package org.apache.maven.plugin.testing;
/*
* 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.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Set;
import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.DefaultArtifact;
import org.apache.maven.artifact.handler.ArtifactHandler;
import org.apache.maven.artifact.versioning.VersionRange;
import org.apache.maven.plugin.testing.stubs.DefaultArtifactHandlerStub;
import org.codehaus.plexus.archiver.Archiver;
import org.codehaus.plexus.archiver.ArchiverException;
import org.codehaus.plexus.archiver.manager.ArchiverManager;
import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
import org.codehaus.plexus.archiver.war.WarArchiver;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.ReflectionUtils;
import org.codehaus.plexus.util.StringUtils;
/**
* This class creates artifacts to be used for testing purposes. It can optionally create actual files on the local disk
* for things like copying. It can create these files as archives with named files inside to be used for testing things
* like unpack. Also provided are some utility methods to quickly get a set of artifacts distinguished by various things
* like group,artifact,type,scope, etc It was originally developed for the dependency plugin, but can be useful in other
* plugins that need to simulate artifacts for unit tests.
*
* @author <a href="mailto:brianf@apache.org">Brian Fox</a>
* @version $Id$
*/
public class ArtifactStubFactory
{
private File workingDir;
private boolean createFiles;
private File srcFile;
private boolean createUnpackableFile;
private ArchiverManager archiverManager;
/**
* Default constructor. This should be used only if real files aren't needed...just the artifact objects
*/
public ArtifactStubFactory()
{
this.workingDir = null;
this.createFiles = false;
}
/**
* This constructor is to be used if files are needed and to set a working dir
*
* @param workingDir
* @param createFiles
*/
public ArtifactStubFactory( File workingDir, boolean createFiles )
{
this.workingDir = new File( workingDir, "localTestRepo" );
this.createFiles = createFiles;
}
/**
* If set, the file will be created as a zip/jar/war with a file inside that can be checked to exist after
* unpacking.
*
* @param archiverManager
*/
public void setUnpackableFile( ArchiverManager archiverManager )
{
this.createUnpackableFile = true;
this.archiverManager = archiverManager;
}
/**
* @param groupId
* @param artifactId
* @param version
* @return a <code>DefaultArtifact</code> instance for the given parameters
* @throws IOException if any
* @see #createArtifact(String, String, String, String, String, String)
*/
public Artifact createArtifact( String groupId, String artifactId, String version )
throws IOException
{
return createArtifact( groupId, artifactId, version, Artifact.SCOPE_COMPILE, "jar", "" );
}
/**
* @param groupId
* @param artifactId
* @param version
* @param scope
* @return a <code>DefaultArtifact</code> instance for the given parameters
* @throws IOException if any
* @see #createArtifact(String, String, String, String, String, String)
*/
public Artifact createArtifact( String groupId, String artifactId, String version, String scope )
throws IOException
{
return createArtifact( groupId, artifactId, version, scope, "jar", "" );
}
/**
* @param groupId
* @param artifactId
* @param version
* @param scope
* @param type
* @param classifier
* @return a <code>DefaultArtifact</code> instance for the given parameters
* @throws IOException if any
* @see #createArtifact(String, String, VersionRange, String, String, String, boolean)
*/
public Artifact createArtifact( String groupId, String artifactId, String version, String scope, String type,
String classifier )
throws IOException
{
VersionRange vr = VersionRange.createFromVersion( version );
return createArtifact( groupId, artifactId, vr, scope, type, classifier, false );
}
/**
* @param groupId not null
* @param artifactId not null
* @param versionRange not null
* @param scope not null
* @param type not null
* @param classifier
* @param optional not null
* @return a <code>DefaultArtifact</code> instance
* @throws IOException if any
*/
public Artifact createArtifact( String groupId, String artifactId, VersionRange versionRange, String scope,
String type, String classifier, boolean optional )
throws IOException
{
ArtifactHandler ah = new DefaultArtifactHandlerStub( type, classifier );
Artifact artifact =
new DefaultArtifact( groupId, artifactId, versionRange, scope, type, classifier, ah, optional );
// i have no idea why this needs to be done manually when isSnapshot is able to figure it out.
artifact.setRelease( !artifact.isSnapshot() );
if ( createFiles )
{
setArtifactFile( artifact, this.workingDir, this.srcFile, this.createUnpackableFile );
}
return artifact;
}
/**
* Creates a new empty file and attaches it to the artifact.
*
* @param artifact to attach the file to.
* @param workingDir where to locate the new file
* @throws IOException
*/
public void setArtifactFile( Artifact artifact, File workingDir )
throws IOException
{
setArtifactFile( artifact, workingDir, null, false );
}
/**
* Copyies the srcFile to the workingDir and then attaches it to the artifact. If srcFile is null, a new empty file
* will be created.
*
* @param artifact to attach
* @param workingDir where to copy the srcFile.
* @param srcFile file to be attached.
* @throws IOException
*/
public void setArtifactFile( Artifact artifact, File workingDir, File srcFile )
throws IOException
{
setArtifactFile( artifact, workingDir, srcFile, false );
}
/**
* Creates an unpackable file (zip,jar etc) containing an empty file.
*
* @param artifact to attach
* @param workingDir where to create the file.
* @throws IOException
*/
public void setUnpackableArtifactFile( Artifact artifact, File workingDir )
throws IOException
{
setArtifactFile( artifact, workingDir, null, true );
}
/**
* Creates an unpackable file (zip,jar etc) containing the srcFile. If srcFile is null, a new empty file will be
* created.
*
* @param artifact to attach
* @param workingDir where to create the file.
* @param srcFile
* @throws IOException if any
*/
public void setUnpackableArtifactFile( Artifact artifact, File workingDir, File srcFile )
throws IOException
{
setArtifactFile( artifact, workingDir, srcFile, true );
}
/**
* Creates a file that can be copied or unpacked based on the passed in artifact
*
* @param artifact
* @param workingDir
* @param srcFile
* @param createUnpackableFile
* @throws IOException if any
*/
private void setArtifactFile( Artifact artifact, File workingDir, File srcFile, boolean createUnpackableFile )
throws IOException
{
if ( workingDir == null )
{
throw new IllegalArgumentException(
"The workingDir must be set." );
}
String fileName = getFormattedFileName( artifact, false );
File theFile = new File( workingDir, fileName );
theFile.getParentFile().mkdirs();
if ( srcFile == null )
{
theFile.createNewFile();
}
else if ( createUnpackableFile )
{
try
{
createUnpackableFile( artifact, theFile );
}
catch ( NoSuchArchiverException e )
{
throw new IOException( "NoSuchArchiverException: " + e.getMessage() );
}
catch ( ArchiverException e )
{
throw new IOException( "ArchiverException: " + e.getMessage() );
}
}
else
{
FileUtils.copyFile( srcFile, theFile );
}
artifact.setFile( theFile );
}
/**
* @param artifact
* @return
*/
public static String getUnpackableFileName( Artifact artifact )
{
return "" + artifact.getGroupId() + "-" + artifact.getArtifactId() + "-" + artifact.getVersion() + "-"
+ artifact.getClassifier() + "-" + artifact.getType() + ".txt";
}
/**
* @param artifact
* @param destFile
* @throws NoSuchArchiverException
* @throws ArchiverException if any
* @throws IOException if any
*/
public void createUnpackableFile( Artifact artifact, File destFile )
throws NoSuchArchiverException, ArchiverException, IOException
{
Archiver archiver = archiverManager.getArchiver( destFile );
archiver.setDestFile( destFile );
archiver.addFile( srcFile, getUnpackableFileName( artifact ) );
try
{
setVariableValueToObject( archiver, "logger", new SilentLog() );
}
catch ( IllegalAccessException e )
{
System.out.println( "Unable to override logger with silent log." );
e.printStackTrace();
}
if ( archiver instanceof WarArchiver )
{
WarArchiver war = (WarArchiver) archiver;
// the use of this is counter-intuitive:
// http://jira.codehaus.org/browse/PLX-286
war.setIgnoreWebxml( false );
}
archiver.createArchive();
}
/**
* @return a <code>DefaultArtifact</code> instance for <code>testGroupId:release:jar:1.0</code>
* @throws IOException if any
*/
public Artifact getReleaseArtifact()
throws IOException
{
return createArtifact( "testGroupId", "release", "1.0" );
}
/**
* @return a default <code>DefaultArtifact</code> instance for <code>testGroupId:snapshot:jar:2.0-SNAPSHOT</code>
* @throws IOException if any
*/
public Artifact getSnapshotArtifact()
throws IOException
{
return createArtifact( "testGroupId", "snapshot", "2.0-SNAPSHOT" );
}
/**
* @return a default set of release and snapshot <code>DefaultArtifact</code>, i.e.:
* <code>testGroupId:snapshot:jar:2.0-SNAPSHOT, testGroupId:release:jar:1.0</code>
* @throws IOException if any
* @see #getReleaseArtifact()
* @see #getSnapshotArtifact()
*/
public Set<Artifact> getReleaseAndSnapshotArtifacts()
throws IOException
{
Set<Artifact> set = new HashSet<Artifact>();
set.add( getReleaseArtifact() );
set.add( getSnapshotArtifact() );
return set;
}
/**
* @return a default set of <code>DefaultArtifact</code>, i.e.:
* <code>g:provided:jar:1.0, g:compile:jar:1.0, g:system:jar:1.0, g:test:jar:1.0, g:runtime:jar:1.0</code>
* @throws IOException if any
*/
public Set<Artifact> getScopedArtifacts()
throws IOException
{
Set<Artifact> set = new HashSet<Artifact>();
set.add( createArtifact( "g", "compile", "1.0", Artifact.SCOPE_COMPILE ) );
set.add( createArtifact( "g", "provided", "1.0", Artifact.SCOPE_PROVIDED ) );
set.add( createArtifact( "g", "test", "1.0", Artifact.SCOPE_TEST ) );
set.add( createArtifact( "g", "runtime", "1.0", Artifact.SCOPE_RUNTIME ) );
set.add( createArtifact( "g", "system", "1.0", Artifact.SCOPE_SYSTEM ) );
return set;
}
/**
* @return a set of <code>DefaultArtifact</code>, i.e.:
* <code>g:d:zip:1.0, g:a:war:1.0, g:b:jar:1.0, g:c:sources:1.0, g:e:rar:1.0</code>
* @throws IOException if any
*/
public Set<Artifact> getTypedArtifacts()
throws IOException
{
Set<Artifact> set = new HashSet<Artifact>();
set.add( createArtifact( "g", "a", "1.0", Artifact.SCOPE_COMPILE, "war", null ) );
set.add( createArtifact( "g", "b", "1.0", Artifact.SCOPE_COMPILE, "jar", null ) );
set.add( createArtifact( "g", "c", "1.0", Artifact.SCOPE_COMPILE, "sources", null ) );
set.add( createArtifact( "g", "d", "1.0", Artifact.SCOPE_COMPILE, "zip", null ) );
set.add( createArtifact( "g", "e", "1.0", Artifact.SCOPE_COMPILE, "rar", null ) );
return set;
}
/**
* @return a set of <code>DefaultArtifact</code>, i.e.:
* <code>g:c:jar:three:1.0, g:b:jar:two:1.0, g:d:jar:four:1.0, g:a:jar:one:1.0</code>
* @throws IOException if any
*/
public Set<Artifact> getClassifiedArtifacts()
throws IOException
{
Set<Artifact> set = new HashSet<Artifact>();
set.add( createArtifact( "g", "a", "1.0", Artifact.SCOPE_COMPILE, "jar", "one" ) );
set.add( createArtifact( "g", "b", "1.0", Artifact.SCOPE_COMPILE, "jar", "two" ) );
set.add( createArtifact( "g", "c", "1.0", Artifact.SCOPE_COMPILE, "jar", "three" ) );
set.add( createArtifact( "g", "d", "1.0", Artifact.SCOPE_COMPILE, "jar", "four" ) );
return set;
}
/**
* @return a set of <code>DefaultArtifact</code>, i.e.:
* <code>g:d:zip:1.0, g:a:war:1.0, g:b:jar:1.0, g:e:rar:1.0</code>
* @throws IOException if any
*/
public Set<Artifact> getTypedArchiveArtifacts()
throws IOException
{
Set<Artifact> set = new HashSet<Artifact>();
set.add( createArtifact( "g", "a", "1.0", Artifact.SCOPE_COMPILE, "war", null ) );
set.add( createArtifact( "g", "b", "1.0", Artifact.SCOPE_COMPILE, "jar", null ) );
set.add( createArtifact( "g", "d", "1.0", Artifact.SCOPE_COMPILE, "zip", null ) );
set.add( createArtifact( "g", "e", "1.0", Artifact.SCOPE_COMPILE, "rar", null ) );
return set;
}
/**
* @return a set of <code>DefaultArtifact</code>, i.e.:
* <code>g:one:jar:a:1.0, g:two:jar:a:1.0, g:four:jar:a:1.0, g:three:jar:a:1.0</code>
* @throws IOException if any
*/
public Set<Artifact> getArtifactArtifacts()
throws IOException
{
Set<Artifact> set = new HashSet<Artifact>();
set.add( createArtifact( "g", "one", "1.0", Artifact.SCOPE_COMPILE, "jar", "a" ) );
set.add( createArtifact( "g", "two", "1.0", Artifact.SCOPE_COMPILE, "jar", "a" ) );
set.add( createArtifact( "g", "three", "1.0", Artifact.SCOPE_COMPILE, "jar", "a" ) );
set.add( createArtifact( "g", "four", "1.0", Artifact.SCOPE_COMPILE, "jar", "a" ) );
return set;
}
/**
* @return a set of <code>DefaultArtifact</code>, i.e.:
* <code>one:group-one:jar:a:1.0, three:group-three:jar:a:1.0, four:group-four:jar:a:1.0,
* two:group-two:jar:a:1.0</code>
* @throws IOException if any
*/
public Set<Artifact> getGroupIdArtifacts()
throws IOException
{
Set<Artifact> set = new HashSet<Artifact>();
set.add( createArtifact( "one", "group-one", "1.0", Artifact.SCOPE_COMPILE, "jar", "a" ) );
set.add( createArtifact( "two", "group-two", "1.0", Artifact.SCOPE_COMPILE, "jar", "a" ) );
set.add( createArtifact( "three", "group-three", "1.0", Artifact.SCOPE_COMPILE, "jar", "a" ) );
set.add( createArtifact( "four", "group-four", "1.0", Artifact.SCOPE_COMPILE, "jar", "a" ) );
return set;
}
/**
* @return a set of <code>DefaultArtifact</code>
* @throws IOException if any
* @see #getTypedArtifacts()
* @see #getScopedArtifacts()
* @see #getReleaseAndSnapshotArtifacts()
*/
public Set<Artifact> getMixedArtifacts()
throws IOException
{
Set<Artifact> set = new HashSet<Artifact>();
set.addAll( getTypedArtifacts() );
set.addAll( getScopedArtifacts() );
set.addAll( getReleaseAndSnapshotArtifacts() );
return set;
}
/**
* @return Returns the createFiles.
*/
public boolean isCreateFiles()
{
return this.createFiles;
}
/**
* @param createFiles The createFiles to set.
*/
public void setCreateFiles( boolean createFiles )
{
this.createFiles = createFiles;
}
/**
* @return Returns the workingDir.
*/
public File getWorkingDir()
{
return this.workingDir;
}
/**
* @param workingDir The workingDir to set.
*/
public void setWorkingDir( File workingDir )
{
this.workingDir = workingDir;
}
/**
* @return Returns the srcFile.
*/
public File getSrcFile()
{
return this.srcFile;
}
/**
* @param srcFile The srcFile to set.
*/
public void setSrcFile( File srcFile )
{
this.srcFile = srcFile;
}
/**
* Convenience method to set values to variables in objects that don't have setters
*
* @param object
* @param variable
* @param value
* @throws IllegalAccessException
*/
public static void setVariableValueToObject( Object object, String variable, Object value )
throws IllegalAccessException
{
Field field = ReflectionUtils.getFieldByNameIncludingSuperclasses( variable, object.getClass() );
field.setAccessible( true );
field.set( object, value );
}
/**
* Builds the file name. If removeVersion is set, then the file name must be reconstructed from the artifactId,
* Classifier (if used) and Type. Otherwise, this method returns the artifact file name.
*
* @param artifact File to be formatted.
* @param removeVersion Specifies if the version should be removed from the file name.
* @return Formatted file name in the format artifactId-[version]-[classifier].[type]
*/
public static String getFormattedFileName( Artifact artifact, boolean removeVersion )
{
String destFileName = null;
// if there is a file and we aren't stripping the version, just get the
// name directly
if ( artifact.getFile() != null && !removeVersion )
{
destFileName = artifact.getFile().getName();
}
else
// if offline
{
String versionString = null;
if ( !removeVersion )
{
versionString = "-" + artifact.getVersion();
}
else
{
versionString = "";
}
String classifierString = "";
if ( StringUtils.isNotEmpty( artifact.getClassifier() ) )
{
classifierString = "-" + artifact.getClassifier();
}
destFileName = artifact.getArtifactId() + versionString + classifierString + "."
+ artifact.getArtifactHandler().getExtension();
}
return destFileName;
}
}