package org.apache.maven.shared.artifact.filter;
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import java.util.Collections;
import java.util.List;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.DefaultArtifact;
import org.apache.maven.artifact.handler.ArtifactHandler;
import org.apache.maven.artifact.handler.DefaultArtifactHandler;
import org.apache.maven.artifact.versioning.VersionRange;
import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
/**
* Tests subclasses of <code>AbstractStrictPatternArtifactFilter</code>.
*
* @author <a href="mailto:markhobson@gmail.com">Mark Hobson</a>
* @version $Id: AbstractStrictPatternArtifactFilterTest.java 803321 2009-08-11 23:09:24Z aheritier $
* @see AbstractStrictPatternArtifactFilter
*/
public abstract class AbstractStrictPatternArtifactFilterTest extends TestCase
{
// fields -----------------------------------------------------------------
protected Artifact artifact;
// TestCase methods -------------------------------------------------------
/*
* @see junit.framework.TestCase#setUp()
*/
protected void setUp() throws Exception
{
artifact = createArtifact( "groupId", "artifactId", "type", "version" );
}
// tests ------------------------------------------------------------------
public void testExactIncluded()
{
assertIncluded( "groupId:artifactId" );
}
public void testExactExcluded()
{
assertExcluded( "differentGroupId:differentArtifactId" );
}
public void testGroupIdIncluded()
{
assertIncluded( "groupId" );
}
public void testGroupIdExcluded()
{
assertExcluded( "differentGroupId" );
}
public void testGroupIdWildcardIncluded()
{
assertIncluded( "*" );
}
public void testGroupIdImplicitWildcardIncluded()
{
assertIncluded( "" );
}
public void testGroupIdStartsWithWildcardIncluded()
{
assertIncluded( "groupId*" );
}
public void testGroupIdStartsWithPartialWildcardIncluded()
{
assertIncluded( "group*" );
}
public void testGroupIdStartsWithWildcardExcluded()
{
assertExcluded( "different*" );
}
public void testGroupIdEndsWithWildcardIncluded()
{
assertIncluded( "*groupId" );
}
public void testGroupIdEndsWithPartialWildcardIncluded()
{
assertIncluded( "*Id" );
}
public void testGroupIdEndsWithWildcardExcluded()
{
assertExcluded( "*different" );
}
public void testGroupIdContainsWildcardIncluded()
{
assertIncluded( "*oup*" );
}
public void testGroupIdContainsWildcardExcluded()
{
assertExcluded( "*different*" );
}
public void testArtifactIdIncluded()
{
assertIncluded( ":artifactId" );
}
public void testArtifactIdExcluded()
{
assertExcluded( ":differentArtifactId" );
}
public void testArtifactIdWildcardIncluded()
{
assertIncluded( ":*" );
}
public void testArtifactIdImplicitWildcardIncluded()
{
assertIncluded( ":" );
}
public void testArtifactIdStartsWithWildcardIncluded()
{
assertIncluded( ":artifactId*" );
}
public void testArtifactIdStartsWithPartialWildcardIncluded()
{
assertIncluded( ":artifact*" );
}
public void testArtifactIdStartsWithWildcardExcluded()
{
assertExcluded( ":different*" );
}
public void testArtifactIdEndsWithWildcardIncluded()
{
assertIncluded( ":*artifactId" );
}
public void testArtifactIdEndsWithPartialWildcardIncluded()
{
assertIncluded( ":*Id" );
}
public void testArtifactIdEndsWithWildcardExcluded()
{
assertExcluded( ":*different" );
}
public void testArtifactIdContainsWildcardIncluded()
{
assertIncluded( ":*fact*" );
}
public void testArtifactIdContainsWildcardExcluded()
{
assertExcluded( ":*different*" );
}
public void testTypeIncluded()
{
assertIncluded( "::type" );
}
public void testTypeExcluded()
{
assertExcluded( "::differentType" );
}
public void testTypeWildcardIncluded()
{
assertIncluded( "::*" );
}
public void testTypeImplicitWildcardIncluded()
{
assertIncluded( "::" );
}
public void testTypeStartsWithWildcardIncluded()
{
assertIncluded( "::type*" );
}
public void testTypeStartsWithPartialWildcardIncluded()
{
assertIncluded( "::t*" );
}
public void testTypeStartsWithWildcardExcluded()
{
assertExcluded( "::different*" );
}
public void testTypeEndsWithWildcardIncluded()
{
assertIncluded( "::*type" );
}
public void testTypeEndsWithPartialWildcardIncluded()
{
assertIncluded( "::*e" );
}
public void testTypeEndsWithWildcardExcluded()
{
assertExcluded( "::*different" );
}
public void testTypeContainsWildcardIncluded()
{
assertIncluded( "::*yp*" );
}
public void testTypeContainsWildcardExcluded()
{
assertExcluded( "::*different*" );
}
public void testVersionIncluded()
{
assertIncluded( ":::version" );
}
public void testVersionExcluded()
{
assertExcluded( ":::differentVersion" );
}
public void testVersionWildcardIncluded()
{
assertIncluded( ":::*" );
}
public void testVersionImplicitWildcardIncluded()
{
assertIncluded( ":::" );
}
public void testVersionStartsWithWildcardIncluded()
{
assertIncluded( ":::version*" );
}
public void testVersionStartsWithPartialWildcardIncluded()
{
assertIncluded( ":::ver*" );
}
public void testVersionStartsWithWildcardExcluded()
{
assertExcluded( ":::different*" );
}
public void testVersionEndsWithWildcardIncluded()
{
assertIncluded( ":::*version" );
}
public void testVersionEndsWithPartialWildcardIncluded()
{
assertIncluded( ":::*ion" );
}
public void testVersionEndsWithWildcardExcluded()
{
assertExcluded( ":::*different" );
}
public void testVersionContainsWildcardIncluded()
{
assertIncluded( ":::*si*" );
}
public void testVersionContainsWildcardExcluded()
{
assertExcluded( ":::*different*" );
}
public void testComplex()
{
assertIncluded( "group*:*Id:*:version" );
}
public void testSnapshotVersion()
{
artifact = createArtifact( "groupId", "artifactId", "type", "version-12345678.123456-1" );
assertIncluded( ":::*-SNAPSHOT" );
}
public void testRangeVersion()
{
artifact = createArtifact( "groupId", "artifactId", "type", "1.0.1" );
assertIncluded( "groupId:artifactId:type:[1.0.1]");
assertIncluded( "groupId:artifactId:type:[1.0,1.1)");
assertExcluded( "groupId:artifactId:type:[1.5,)");
assertExcluded( "groupId:artifactId:type:(,1.0],[1.2,)");
assertExcluded( "groupId:artifactId:type:(,1.0],[1.2,)");
}
public void testWildcardsWithRangeVersion()
{
artifact = createArtifact( "groupId", "artifactId", "type", "1.0.1" );
assertIncluded( ":::[1.0.1]");
assertIncluded( ":artifact*:*:[1.0,1.1)");
assertExcluded( "*group*:*:t*e:[1.5,)");
artifact = createArtifact( "test", "uf", "jar", "0.2.0" );
assertIncluded( "test:*:*:[0.0.2,)" );
}
// protected methods ------------------------------------------------------
/**
* Creates an artifact with the specified attributes.
*
* @param groupId
* the group id for the new artifact
* @param artifactId
* the artifact id for the new artifact
* @param type
* the type for the new artifact
* @param version
* the version for the new artifact
* @return the artifact
*/
protected Artifact createArtifact( String groupId, String artifactId, String type, String version )
{
VersionRange versionRange = VersionRange.createFromVersion( version );
ArtifactHandler handler = new DefaultArtifactHandler();
return new DefaultArtifact( groupId, artifactId, versionRange, null, type, null, handler );
}
/**
* Asserts that the specified pattern is included by the filter being tested.
*
* @param pattern
* the pattern to test for inclusion
* @throws AssertionFailedError
* if the assertion fails
*/
protected void assertIncluded( String pattern )
{
assertFilter( true, pattern );
}
/**
* Asserts that the specified pattern is excluded by the filter being tested.
*
* @param pattern
* the pattern to test for exclusion
* @throws AssertionFailedError
* if the assertion fails
*/
protected void assertExcluded( String pattern )
{
assertFilter( false, pattern );
}
/**
* Asserts that the filter being tested returns the specified result for the specified pattern.
*
* @param expected
* the result expected from the filter
* @param pattern
* the pattern to test
* @throws AssertionFailedError
* if the assertion fails
*/
protected void assertFilter( boolean expected, String pattern )
{
List patterns = Collections.singletonList( pattern );
AbstractStrictPatternArtifactFilter filter = createFilter( patterns );
assertEquals( expected, filter.include( artifact ) );
}
/**
* Creates the strict pattern artifact filter to test for the specified patterns.
*
* @param patterns
* the list of artifact patterns that the filter should match
* @return the filter to test
*/
protected abstract AbstractStrictPatternArtifactFilter createFilter( List patterns );
}