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.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.codehaus.plexus.util.FileUtils;
  import org.codehaus.plexus.util.IOUtil;
  import org.codehaus.plexus.util.StringUtils;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.StringWriter;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Properties;
  
  /**
   * <p>Execute the archetype integration tests, consisting in generating projects from the current archetype and
   * optionally comparing generated projects with reference copy.</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>
   *
   * 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;
  
      public void execute()
          throws MojoExecutionException, MojoFailureException
      {
          if ( skip )
         {
             return;
         }
 
         File projectsDirectory = new File( project.getBasedir(), "target/test-classes/projects" );
 
         if ( !projectsDirectory.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( projectsDirectory, "*/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
     {
         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() ) );
         }
         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 )
         throws IntegrationTestFailure
     {
         if ( StringUtils.isBlank( goals ) )
         {
             getLog().info( "No post-archetype-generation goals to invoke." );
 
             return;
         }
 
         getLog().info( "Invoking post-archetype-generation goals: " + goals );
 
         InvocationRequest request = new DefaultInvocationRequest()
             .setBaseDirectory( basedir )
             .setGoals( Arrays.asList( StringUtils.split( goals, "," ) ) );
 
         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 );
         }
     }
 
     class IntegrationTestFailure
         extends Exception
     {
         IntegrationTestFailure()
         {
             super();
         }
 
         IntegrationTestFailure( String message )
         {
             super( message );
         }
 
         IntegrationTestFailure( Throwable cause )
         {
             super( cause );
         }
 
         IntegrationTestFailure( String message, Throwable cause )
         {
             super( message, cause );
         }
     }
 }