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>&lt;localRepository&gt;</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;
     }
 }