package org.apache.maven.archetype.mojos;
/*
* 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 org.apache.commons.collections.CollectionUtils;
import org.apache.maven.archetype.ArchetypeGenerationRequest;
import org.apache.maven.archetype.ArchetypeGenerationResult;
import org.apache.maven.archetype.common.Constants;
import org.apache.maven.archetype.exception.ArchetypeNotConfigured;
import org.apache.maven.archetype.generator.ArchetypeGenerator;
import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugin.MojoFailureException;
import org.apache.maven.project.MavenProject;
import org.apache.maven.settings.Settings;
import org.apache.maven.shared.invoker.DefaultInvocationRequest;
import org.apache.maven.shared.invoker.InvocationRequest;
import org.apache.maven.shared.invoker.InvocationResult;
import org.apache.maven.shared.invoker.Invoker;
import org.apache.maven.shared.invoker.MavenInvocationException;
import org.apache.maven.shared.scriptinterpreter.RunFailureException;
import org.apache.maven.shared.scriptinterpreter.ScriptRunner;
import org.codehaus.plexus.util.FileUtils;
import org.codehaus.plexus.util.IOUtil;
import org.codehaus.plexus.util.InterpolationFilterReader;
import org.codehaus.plexus.util.ReaderFactory;
import org.codehaus.plexus.util.StringUtils;
import org.codehaus.plexus.util.WriterFactory;
import org.codehaus.plexus.util.introspection.ReflectionValueExtractor;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
/**
* <p>Execute the archetype integration tests, consisting in generating projects from the current archetype and
* optionally comparing generated projects with reference copy.</p>
* <p/>
* <p>Each IT consists of a sub-directory in <code>src/test/resources/projects</code> containing:</p>
* <ul>
* <li>a <code>goal.txt</code> file, containing a list of goals to run against the generated project (can be empty,
* content ignored before maven-archetype-plugin 2.1),</li>
* <li>an <code>archetype.properties</code> file, containing properties for project generation,</li>
* <li>an optional <code>reference/</code> directory containing a reference copy of the expected project created from the IT.</li>
* </ul>
* <p/>
* Notice that it is expected to be run as part as of a build after the <code>package</code> phase and not directly
* as a goal from CLI.
*
* @author rafale
* @requiresProject true
* @goal integration-test
*/
public class IntegrationTestMojo
extends AbstractMojo
{
/**
* @component
*/
private ArchetypeGenerator archetypeGenerator;
/**
* @component
*/
private Invoker invoker;
/**
* The archetype project to execute the integration tests on.
*
* @parameter expression="${project}"
* @required
* @readonly
*/
private MavenProject project;
/**
* Skip the integration test.
*
* @parameter expression="${archetype.test.skip}"
* @readonly
*/
private boolean skip = false;
/**
* Directory of test projects
*
* @parameter expression="${archetype.test.projectsDirectory}" default-value="${project.build.testOutputDirectory}/projects"
* @required
* @since 2.2
*/
private File testProjectsDirectory;
/**
* Relative path of a cleanup/verification hook script to run after executing the build. This script may be written
* with either BeanShell or Groovy. If the file extension is omitted (e.g. <code>verify</code>), the
* plugin searches for the file by trying out the well-known extensions <code>.bsh</code> and <code>.groovy</code>.
* If this script exists for a particular project but returns any non-null value different from <code>true</code> or
* throws an exception, the corresponding build is flagged as a failure.
*
* @parameter expression="${archetype.test.verifyScript}" default-value="verify"
* @since 2.2
*/
private String postBuildHookScript;
/**
* Suppress logging to the <code>build.log</code> file.
*
* @parameter expression="${archetype.test.noLog}" default-value="false"
* @since 2.2
*/
private boolean noLog;
/**
* Flag used to determine whether the build logs should be output to the normal mojo log.
*
* @parameter expression="${archetype.test.streamLogs}" default-value="true"
* @since 2.2
*/
private boolean streamLogs;
/**
* The file encoding for the post-build script.
*
* @parameter expression="${encoding}" default-value="${project.build.sourceEncoding}"
* @since 2.2
*/
private String encoding;
/**
* The local repository to run maven instance.
*
* @parameter expression="${archetype.test.localRepositoryPath}" default-value="${settings.localRepository}"
* @required
* @readonly
* @since 2.2
*/
private File localRepositoryPath;
/**
* flag to enable show mvn version used for running its (cli option : -V,--show-version )
*
* @parameter expression="${archetype.test.showVersion}" default-value="false"
* @since 2.2
*/
private boolean showVersion;
/**
* Whether to show debug statements in the build output.
*
* @parameter expression="${archetype.test.debug}" default-value="false"
* @since 2.2
*/
private boolean debug;
/**
* A list of additional properties which will be used to filter tokens in settings.xml
*
* @parameter
* @since 2.2
*/
private Map<String, String> filterProperties;
/**
* The current user system settings for use in Maven.
*
* @parameter expression="${settings}"
* @required
* @readonly
* @since 2.2
*/
private Settings settings;
/**
* Path to an alternate <code>settings.xml</code> to use for Maven invocation with all ITs. Note that the
* <code><localRepository></code> element of this settings file is always ignored, i.e. the path given by the
* parameter {@link #localRepositoryPath} is dominant.
*
* @parameter expression="${archetype.test.settingsFile}"
* @since 2.2
*/
private File settingsFile;
public void execute()
throws MojoExecutionException, MojoFailureException
{
if ( skip )
{
return;
}
if ( !testProjectsDirectory.exists() )
{
getLog().warn( "No Archetype IT projects: root 'projects' directory not found." );
return;
}
File archetypeFile = project.getArtifact().getFile();
if ( archetypeFile == null )
{
throw new MojoFailureException( "Unable to get the archetypes' artifact which should have just been built:"
+ " you probably launched 'mvn archetype:integration-test' instead of"
+ " 'mvn integration-test'." );
}
try
{
@SuppressWarnings( "unchecked" ) List<File> projectsGoalFiles =
FileUtils.getFiles( testProjectsDirectory, "*/goal.txt", "" );
if ( projectsGoalFiles.size() == 0 )
{
getLog().warn( "No Archetype IT projects: no directory with goal.txt found." );
return;
}
StringWriter errorWriter = new StringWriter();
for ( File goalFile : projectsGoalFiles )
{
try
{
processIntegrationTest( goalFile, archetypeFile );
}
catch ( IntegrationTestFailure ex )
{
errorWriter.write( "\nArchetype IT '" + goalFile.getParentFile().getName() + "' failed: " );
errorWriter.write( ex.getMessage() );
}
}
String errors = errorWriter.toString();
if ( !StringUtils.isEmpty( errors ) )
{
throw new MojoExecutionException( errors );
}
}
catch ( IOException ex )
{
throw new MojoFailureException( ex, ex.getMessage(), ex.getMessage() );
}
}
/**
* Checks that actual directory content is the same as reference.
*
* @param reference the reference directory
* @param actual the actual directory to compare with the reference
* @throws IntegrationTestFailure if content differs
*/
private void assertDirectoryEquals( File reference, File actual )
throws IntegrationTestFailure, IOException
{
@SuppressWarnings( "unchecked" ) List<String> referenceFiles =
FileUtils.getFileAndDirectoryNames( reference, "**", null, false, true, true, true );
getLog().debug( "reference content: " + referenceFiles );
@SuppressWarnings( "unchecked" ) List<String> actualFiles =
FileUtils.getFileAndDirectoryNames( actual, "**", null, false, true, true, true );
getLog().debug( "actual content: " + referenceFiles );
boolean fileNamesEquals = CollectionUtils.isEqualCollection( referenceFiles, actualFiles );
if ( !fileNamesEquals )
{
getLog().debug( "Actual list of files is not the same as reference:" );
int missing = 0;
for ( String ref : referenceFiles )
{
if ( actualFiles.contains( ref ) )
{
actualFiles.remove( ref );
getLog().debug( "Contained " + ref );
}
else
{
missing++;
getLog().error( "Not contained " + ref );
}
}
getLog().error( "Remains " + actualFiles );
throw new IntegrationTestFailure(
"Reference and generated project differs (missing: " + missing + ", unexpected: " + actualFiles.size()
+ ")" );
}
boolean contentEquals = true;
for ( String file : referenceFiles )
{
File referenceFile = new File( reference, file );
File actualFile = new File( actual, file );
if ( referenceFile.isDirectory() )
{
if ( actualFile.isFile() )
{
getLog().warn( "File " + file + " is a directory in the reference but a file in actual" );
contentEquals = false;
}
}
else if ( actualFile.isDirectory() )
{
if ( referenceFile.isFile() )
{
getLog().warn( "File " + file + " is a file in the reference but a directory in actual" );
contentEquals = false;
}
}
else if ( !FileUtils.contentEquals( referenceFile, actualFile ) )
{
getLog().warn( "Contents of file " + file + " are not equal" );
contentEquals = false;
}
}
if ( !contentEquals )
{
throw new IntegrationTestFailure( "Some content are not equals" );
}
}
private Properties loadProperties( final File propertiesFile )
throws IOException, FileNotFoundException
{
Properties properties = new Properties();
InputStream in = null;
try
{
in = new FileInputStream( propertiesFile );
properties.load( in );
}
finally
{
IOUtil.close( in );
}
return properties;
}
private void processIntegrationTest( File goalFile, File archetypeFile )
throws IntegrationTestFailure, MojoExecutionException
{
getLog().info( "Processing Archetype IT project: " + goalFile.getParentFile().getName() );
try
{
Properties properties = getProperties( goalFile );
String basedir = goalFile.getParentFile().getPath() + "/project";
FileUtils.deleteDirectory( basedir );
FileUtils.mkdir( basedir );
ArchetypeGenerationRequest request =
new ArchetypeGenerationRequest().setArchetypeGroupId( project.getGroupId() ).setArchetypeArtifactId(
project.getArtifactId() ).setArchetypeVersion( project.getVersion() ).setGroupId(
properties.getProperty( Constants.GROUP_ID ) ).setArtifactId(
properties.getProperty( Constants.ARTIFACT_ID ) ).setVersion(
properties.getProperty( Constants.VERSION ) ).setPackage(
properties.getProperty( Constants.PACKAGE ) ).setOutputDirectory( basedir ).setProperties(
properties );
ArchetypeGenerationResult result = new ArchetypeGenerationResult();
archetypeGenerator.generateArchetype( request, archetypeFile, result );
if ( result.getCause() != null )
{
if ( result.getCause() instanceof ArchetypeNotConfigured )
{
ArchetypeNotConfigured anc = (ArchetypeNotConfigured) result.getCause();
throw new IntegrationTestFailure(
"Missing required properties in archetype.properties: " + StringUtils.join(
anc.getMissingProperties().iterator(), ", " ), anc );
}
throw new IntegrationTestFailure( result.getCause().getMessage(), result.getCause() );
}
File reference = new File( goalFile.getParentFile(), "reference" );
if ( reference.exists() )
{
// compare generated project with reference
getLog().info( "Comparing generated project with reference content: " + reference );
assertDirectoryEquals( reference, new File( basedir, request.getArtifactId() ) );
}
String goals = FileUtils.fileRead( goalFile );
invokePostArchetypeGenerationGoals( goals, new File( basedir, request.getArtifactId() ), goalFile );
}
catch ( IOException ioe )
{
throw new IntegrationTestFailure( ioe );
}
}
private Properties getProperties( File goalFile )
throws IOException
{
File propertiesFile = new File( goalFile.getParentFile(), "archetype.properties" );
return loadProperties( propertiesFile );
}
private void invokePostArchetypeGenerationGoals( String goals, File basedir, File goalFile )
throws IntegrationTestFailure, IOException, MojoExecutionException
{
FileLogger logger = setupLogger( basedir );
if ( !StringUtils.isBlank( goals ) )
{
getLog().info( "Invoking post-archetype-generation goals: " + goals );
if ( !localRepositoryPath.exists() )
{
localRepositoryPath.mkdirs();
}
InvocationRequest request = new DefaultInvocationRequest().setBaseDirectory( basedir ).setGoals(
Arrays.asList( StringUtils.split( goals, "," ) ) ).setLocalRepositoryDirectory(
localRepositoryPath ).setInteractive( false ).setShowErrors( true );
request.setDebug( debug );
request.setShowVersion( showVersion );
if ( logger != null )
{
request.setErrorHandler( logger );
request.setOutputHandler( logger );
}
File interpolatedSettingsFile = null;
if ( settingsFile != null )
{
File interpolatedSettingsDirectory =
new File( project.getBuild().getOutputDirectory(), "archetype-it" );
if ( interpolatedSettingsDirectory.exists() )
{
FileUtils.deleteDirectory( interpolatedSettingsDirectory );
}
interpolatedSettingsDirectory.mkdir();
interpolatedSettingsFile =
new File( interpolatedSettingsDirectory, "interpolated-" + settingsFile.getName() );
buildInterpolatedFile( settingsFile, interpolatedSettingsFile );
request.setUserSettingsFile( interpolatedSettingsFile );
}
try
{
InvocationResult result = invoker.execute( request );
getLog().info( "Post-archetype-generation invoker exit code: " + result.getExitCode() );
if ( result.getExitCode() != 0 )
{
throw new IntegrationTestFailure( "Execution failure: exit code = " + result.getExitCode(),
result.getExecutionException() );
}
}
catch ( MavenInvocationException e )
{
throw new IntegrationTestFailure( "Cannot run additions goals.", e );
}
}
else
{
getLog().info( "No post-archetype-generation goals to invoke." );
}
// verify result
ScriptRunner scriptRunner = new ScriptRunner( getLog() );
scriptRunner.setScriptEncoding( encoding );
Map<String, Object> context = new LinkedHashMap<String, Object>();
context.put( "projectDir", basedir );
try
{
scriptRunner.run( "post-build script", goalFile.getParentFile(), postBuildHookScript, context, logger,
"failure post script", true );
}
catch ( RunFailureException e )
{
throw new IntegrationTestFailure( "post build script failure failure: " + e.getMessage(), e );
}
}
private FileLogger setupLogger( File basedir )
throws IOException
{
FileLogger logger = null;
if ( !noLog )
{
File outputLog = new File( basedir, "build.log" );
if ( streamLogs )
{
logger = new FileLogger( outputLog, getLog() );
}
else
{
logger = new FileLogger( outputLog );
}
getLog().debug( "build log initialized in: " + outputLog );
}
return logger;
}
class IntegrationTestFailure
extends Exception
{
IntegrationTestFailure()
{
super();
}
IntegrationTestFailure( String message )
{
super( message );
}
IntegrationTestFailure( Throwable cause )
{
super( cause );
}
IntegrationTestFailure( String message, Throwable cause )
{
super( message, cause );
}
}
/**
* Returns the map-based value source used to interpolate settings and other stuff.
*
* @return The map-based value source for interpolation, never <code>null</code>.
*/
private Map<String, Object> getInterpolationValueSource()
{
Map<String, Object> props = new HashMap<String, Object>();
if ( filterProperties != null )
{
props.putAll( filterProperties );
}
if ( filterProperties != null )
{
props.putAll( filterProperties );
}
props.put( "basedir", this.project.getBasedir().getAbsolutePath() );
props.put( "baseurl", toUrl( this.project.getBasedir().getAbsolutePath() ) );
if ( settings.getLocalRepository() != null )
{
props.put( "localRepository", settings.getLocalRepository() );
props.put( "localRepositoryUrl", toUrl( settings.getLocalRepository() ) );
}
return new CompositeMap( this.project, props );
}
protected void buildInterpolatedFile( File originalFile, File interpolatedFile )
throws MojoExecutionException
{
getLog().debug( "Interpolate " + originalFile.getPath() + " to " + interpolatedFile.getPath() );
try
{
String xml;
Reader reader = null;
try
{
// interpolation with token @...@
Map<String, Object> composite = getInterpolationValueSource();
reader = ReaderFactory.newXmlReader( originalFile );
reader = new InterpolationFilterReader( reader, composite, "@", "@" );
xml = IOUtil.toString( reader );
}
finally
{
IOUtil.close( reader );
}
Writer writer = null;
try
{
interpolatedFile.getParentFile().mkdirs();
writer = WriterFactory.newXmlWriter( interpolatedFile );
writer.write( xml );
writer.flush();
}
finally
{
IOUtil.close( writer );
}
}
catch ( IOException e )
{
throw new MojoExecutionException( "Failed to interpolate file " + originalFile.getPath(), e );
}
}
private static class CompositeMap
implements Map<String, Object>
{
/**
* The Maven project from which to extract interpolated values, never <code>null</code>.
*/
private MavenProject mavenProject;
/**
* The set of additional properties from which to extract interpolated values, never <code>null</code>.
*/
private Map<String, Object> properties;
/**
* Creates a new interpolation source backed by the specified Maven project and some user-specified properties.
*
* @param mavenProject The Maven project from which to extract interpolated values, must not be <code>null</code>.
* @param properties The set of additional properties from which to extract interpolated values, may be
* <code>null</code>.
*/
protected CompositeMap( MavenProject mavenProject, Map<String, Object> properties )
{
if ( mavenProject == null )
{
throw new IllegalArgumentException( "no project specified" );
}
this.mavenProject = mavenProject;
this.properties = properties == null ? (Map) new Properties() : properties;
}
/**
* {@inheritDoc}
*
* @see java.util.Map#clear()
*/
public void clear()
{
// nothing here
}
/**
* {@inheritDoc}
*
* @see java.util.Map#containsKey(java.lang.Object)
*/
public boolean containsKey( Object key )
{
if ( !( key instanceof String ) )
{
return false;
}
String expression = (String) key;
if ( expression.startsWith( "project." ) || expression.startsWith( "pom." ) )
{
try
{
Object evaluated = ReflectionValueExtractor.evaluate( expression, this.mavenProject );
if ( evaluated != null )
{
return true;
}
}
catch ( Exception e )
{
// uhm do we have to throw a RuntimeException here ?
}
}
return properties.containsKey( key ) || mavenProject.getProperties().containsKey( key );
}
/**
* {@inheritDoc}
*
* @see java.util.Map#containsValue(java.lang.Object)
*/
public boolean containsValue( Object value )
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#entrySet()
*/
public Set<Entry<String, Object>> entrySet()
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#get(java.lang.Object)
*/
public Object get( Object key )
{
if ( !( key instanceof String ) )
{
return null;
}
String expression = (String) key;
if ( expression.startsWith( "project." ) || expression.startsWith( "pom." ) )
{
try
{
Object evaluated = ReflectionValueExtractor.evaluate( expression, this.mavenProject );
if ( evaluated != null )
{
return evaluated;
}
}
catch ( Exception e )
{
// uhm do we have to throw a RuntimeException here ?
}
}
Object value = properties.get( key );
return ( value != null ? value : this.mavenProject.getProperties().get( key ) );
}
/**
* {@inheritDoc}
*
* @see java.util.Map#isEmpty()
*/
public boolean isEmpty()
{
return this.mavenProject == null && this.mavenProject.getProperties().isEmpty()
&& this.properties.isEmpty();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#keySet()
*/
public Set<String> keySet()
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#put(java.lang.Object, java.lang.Object)
*/
public Object put( String key, Object value )
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#putAll(java.util.Map)
*/
public void putAll( Map<? extends String, ? extends Object> t )
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#remove(java.lang.Object)
*/
public Object remove( Object key )
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#size()
*/
public int size()
{
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*
* @see java.util.Map#values()
*/
public Collection<Object> values()
{
throw new UnsupportedOperationException();
}
}
/**
* Converts the specified filesystem path to a URL. The resulting URL has no trailing slash regardless whether the
* path denotes a file or a directory.
*
* @param filename The filesystem path to convert, must not be <code>null</code>.
* @return The <code>file:</code> URL for the specified path, never <code>null</code>.
*/
private static String toUrl( String filename )
{
/*
* NOTE: Maven fails to properly handle percent-encoded "file:" URLs (WAGON-111) so don't use File.toURI() here
* as-is but use the decoded path component in the URL.
*/
String url = "file://" + new File( filename ).toURI().getPath();
if ( url.endsWith( "/" ) )
{
url = url.substring( 0, url.length() - 1 );
}
return url;
}
}