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.InputStream;
  import java.util.Map;
  
  import org.apache.maven.execution.DefaultMavenExecutionRequest;
  import org.apache.maven.execution.MavenExecutionRequest;
  import org.apache.maven.execution.MavenSession;
  import org.apache.maven.execution.MojoExecutionEvent;
  import org.apache.maven.execution.MojoExecutionListener;
  import org.apache.maven.execution.scope.internal.MojoExecutionScope;
  import org.apache.maven.plugin.Mojo;
  import org.apache.maven.plugin.MojoExecution;
  import org.apache.maven.project.MavenProject;
  import org.apache.maven.project.ProjectBuilder;
  import org.apache.maven.project.ProjectBuildingRequest;
  import org.apache.maven.session.scope.internal.SessionScope;
  import org.codehaus.plexus.ContainerConfiguration;
  import org.codehaus.plexus.PlexusContainer;
  import org.codehaus.plexus.component.configurator.ComponentConfigurationException;
  import org.codehaus.plexus.component.repository.exception.ComponentLookupException;
  import org.codehaus.plexus.configuration.PlexusConfiguration;
  import org.codehaus.plexus.util.xml.Xpp3Dom;
  import org.eclipse.aether.DefaultRepositorySystemSession;
  import org.junit.Assert;
  import org.junit.rules.TestRule;
  import org.junit.runner.Description;
  import org.junit.runners.model.Statement;
  
  /**
   * {@link TestRule} for usage with Junit-4.10ff. This is just a wrapper for an embedded 
   * {@link AbstractMojoTestCase}, so all <tt>protected</tt> methods of the TestCase are 
   * exhibited as <tt>public</tt> in the rule. You may annotate single tests methods with 
   * {@link WithoutMojo} to prevent the rule from firing.
   *
   * @author Mirko Friedenhagen
   * @version $Id$
   * @since 2.2
   */
  public class MojoRule
      implements TestRule
  {
      private final AbstractMojoTestCase testCase;
      
      public MojoRule() 
      {
          this( new AbstractMojoTestCase() {} );
      }
  
      public MojoRule(AbstractMojoTestCase testCase)
      {
          this.testCase = testCase;
      }
  
      /**
       * May be overridden in the implementation to do stuff <em>after</em> the embedded test case 
       * is set up but <em>before</em> the current test is actually run.
       *
       * @throws Throwable
       */
      protected void before() throws Throwable
      {
          
      }
      
      /**
       * May be overridden in the implementation to do stuff after the current test was run.
       */
      protected void after() 
      {
          
      }
  
      public InputStream getPublicDescriptorStream()
          throws Exception
      {
          return testCase.getPublicDescriptorStream();
      }
  
     public String getPluginDescriptorPath()
     {
         return testCase.getPluginDescriptorPath();
     }
 
     public String getPluginDescriptorLocation()
     {
         return testCase.getPluginDescriptorLocation();
     }
 
     public void setupContainer()
     {
         testCase.setupContainer();
     }
 
     public ContainerConfiguration setupContainerConfiguration()
     {
         return testCase.setupContainerConfiguration();
     }
     
     public PlexusContainer getContainer()
     {
         return testCase.getContainer();
     }    
     
     /**
      * Lookup the mojo leveraging the subproject pom
      *
      * @param goal
      * @param pluginPom
      * @return a Mojo instance
      * @throws Exception
      */
     public Mojo lookupMojo( String goal, String pluginPom )
         throws Exception
     {
         return testCase.lookupMojo( goal, pluginPom );
     }
 
     /**
      * Lookup an empty mojo
      *
      * @param goal
      * @param pluginPom
      * @return a Mojo instance
      * @throws Exception
      */
     public Mojo lookupEmptyMojo( String goal, String pluginPom )
         throws Exception
     {
         return testCase.lookupEmptyMojo( goal, new File( pluginPom ) );
     }
 
     /**
      * Lookup the mojo leveraging the actual subprojects pom
      *
      * @param goal
      * @param pom
      * @return a Mojo instance
      * @throws Exception
      */
     public Mojo lookupMojo( String goal, File pom )
         throws Exception
     {
         return testCase.lookupMojo( goal, pom );
     }
 
     /**
      * Lookup the mojo leveraging the actual subprojects pom
      *
      * @param goal
      * @param pom
      * @return a Mojo instance
      * @throws Exception
      */
     public Mojo lookupEmptyMojo( String goal, File pom )
         throws Exception
     {
         return testCase.lookupEmptyMojo( goal, pom );
     }
 
     public Mojo lookupMojo( String groupId, String artifactId, String version, String goal,
                                PlexusConfiguration pluginConfiguration )
         throws Exception
     {
         return testCase.lookupMojo( groupId, artifactId, version, goal, pluginConfiguration );
     }
 
     public Mojo lookupConfiguredMojo( MavenProject project, String goal )
         throws Exception
     {
         return testCase.lookupConfiguredMojo( project, goal );
     }
 
     public Mojo lookupConfiguredMojo( MavenSession session, MojoExecution execution )
         throws Exception, ComponentConfigurationException
     {
         return testCase.lookupConfiguredMojo( session, execution );
     }
 
     public MavenSession newMavenSession( MavenProject project )
     {
         return testCase.newMavenSession( project );
     }
 
     public MojoExecution newMojoExecution( String goal )
     {
         return testCase.newMojoExecution( goal );
     }
 
     public PlexusConfiguration extractPluginConfiguration( String artifactId, File pom )
         throws Exception
     {
         return testCase.extractPluginConfiguration( artifactId, pom );
     }
 
     public PlexusConfiguration extractPluginConfiguration( String artifactId, Xpp3Dom pomDom )
         throws Exception
     {
         return testCase.extractPluginConfiguration( artifactId, pomDom );
     }
 
     public Mojo configureMojo( Mojo mojo, String artifactId, File pom )
         throws Exception
     {
         return testCase.configureMojo( mojo, artifactId, pom );
     }
 
     public Mojo configureMojo( Mojo mojo, PlexusConfiguration pluginConfiguration )
         throws Exception
     {
         return testCase.configureMojo( mojo, pluginConfiguration );
     }
 
     /**
      * Convenience method to obtain the value of a variable on a mojo that might not have a getter.
      *
      * NOTE: the caller is responsible for casting to to what the desired type is.
      *
      * @param object
      * @param variable
      * @return object value of variable
      * @throws IllegalArgumentException
      */
     public Object getVariableValueFromObject( Object object, String variable )
         throws IllegalAccessException
     {
         return testCase.getVariableValueFromObject( object, variable );
     }
 
     /**
      * Convenience method to obtain all variables and values from the mojo (including its superclasses)
      *
      * Note: the values in the map are of type Object so the caller is responsible for casting to desired types.
      *
      * @param object
      * @return map of variable names and values
      */
     public Map<String, Object> getVariablesAndValuesFromObject( Object object )
         throws IllegalAccessException
     {
         return testCase.getVariablesAndValuesFromObject( object );
     }
 
     /**
      * Convenience method to obtain all variables and values from the mojo (including its superclasses)
      *
      * Note: the values in the map are of type Object so the caller is responsible for casting to desired types.
      *
      * @param clazz
      * @param object
      * @return map of variable names and values
      */
     public Map<String, Object> getVariablesAndValuesFromObject( Class<?> clazz, Object object )
         throws IllegalAccessException
     {
         return testCase.getVariablesAndValuesFromObject( clazz, object );
     }
 
     /**
      * Convenience method to set values to variables in objects that don't have setters
      *
      * @param object
      * @param variable
      * @param value
      * @throws IllegalAccessException
      */
     public void setVariableValueToObject( Object object, String variable, Object value )
         throws IllegalAccessException
     {
         testCase.setVariableValueToObject( object, variable, value );
     }
 
     @Override
     public Statement apply(final Statement base, Description description) {
         if (description.getAnnotation(WithoutMojo.class) != null) // skip.
         {
             return base;
         }
         return new Statement() 
         {
             @Override
             public void evaluate() throws Throwable 
             {
                 testCase.setUp();
                 before();
                 try 
                 {
                     base.evaluate();
                 } 
                 finally 
                 {
                     after();
                 }
             }            
         };       
     }
 
     /**
      * @since 3.1.0
      */
     public MavenProject readMavenProject( File basedir )
         throws Exception
     {
         File pom = new File( basedir, "pom.xml" );
         MavenExecutionRequest request = new DefaultMavenExecutionRequest();
         request.setBaseDirectory( basedir );
         ProjectBuildingRequest configuration = request.getProjectBuildingRequest();
         configuration.setRepositorySession( new DefaultRepositorySystemSession() );
         MavenProject project = lookup( ProjectBuilder.class ).build( pom, configuration ).getProject();
         Assert.assertNotNull( project );
         return project;
     }
 
     /**
      * @since 3.1.0
      */
     public void executeMojo( File basedir, String goal )
         throws Exception
     {
         MavenProject project = readMavenProject( basedir );
         MavenSession session = newMavenSession( project );
         MojoExecution execution = newMojoExecution( goal );
         executeMojo( session, project, execution );
     }
 
     /**
      * @since 3.1.0
      */
     public Mojo lookupConfiguredMojo( File basedir, String goal )
         throws Exception, ComponentConfigurationException
     {
         MavenProject project = readMavenProject( basedir );
         MavenSession session = newMavenSession( project );
         MojoExecution execution = newMojoExecution( goal );
         return lookupConfiguredMojo( session, execution );
     }
 
     /**
      * @since 3.1.0
      */
     public final <T> T lookup( final Class<T> role )
         throws ComponentLookupException
     {
         return getContainer().lookup( role );
     }
 
     /**
      * @since 3.2.0
      */
     public void executeMojo( MavenProject project, String goal, Xpp3Dom... parameters )
         throws Exception
     {
         MavenSession session = newMavenSession( project );
         executeMojo( session, project, goal, parameters );
     }
 
     /**
      * @since 3.2.0
      */
     public void executeMojo( MavenSession session, MavenProject project, String goal, Xpp3Dom... parameters )
         throws Exception
     {
         MojoExecution execution = newMojoExecution( goal );
         if ( parameters != null )
         {
             Xpp3Dom configuration = execution.getConfiguration();
             for ( Xpp3Dom parameter : parameters )
             {
                 configuration.addChild( parameter );
             }
         }
         executeMojo( session, project, execution );
     }
 
     /**
      * @since 3.2.0
      */
     public void executeMojo( MavenSession session, MavenProject project, MojoExecution execution )
         throws Exception
     {
         SessionScope sessionScope = lookup( SessionScope.class );
         try
         {
             sessionScope.enter();
             sessionScope.seed( MavenSession.class, session );
 
             MojoExecutionScope executionScope = lookup( MojoExecutionScope.class );
             try
             {
                 executionScope.enter();
 
                 executionScope.seed( MavenProject.class, project );
                 executionScope.seed( MojoExecution.class, execution );
 
                 Mojo mojo = lookupConfiguredMojo( session, execution );
                 mojo.execute();
 
                 MojoExecutionEvent event = new MojoExecutionEvent( session, project, execution, mojo );
                 for ( MojoExecutionListener listener : getContainer().lookupList( MojoExecutionListener.class ) )
                 {
                     listener.afterMojoExecutionSuccess( event );
                 }
             }
             finally
             {
                 executionScope.exit();
             }
         }
         finally
         {
             sessionScope.exit();
         }
     }
 
 }