1   package org.apache.maven.lifecycle;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
5    * agreements. See the NOTICE file distributed with this work for additional information regarding
6    * copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance with the License. You may obtain a
8    * copy of the License at
9    *
10   * http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software distributed under the License
13   * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
14   * or implied. See the License for the specific language governing permissions and limitations under
15   * the License.
16   */
17  
18  import org.apache.maven.AbstractCoreMavenComponentTestCase;
19  import org.apache.maven.artifact.Artifact;
20  import org.apache.maven.exception.ExceptionHandler;
21  import org.apache.maven.execution.MavenSession;
22  import org.apache.maven.lifecycle.internal.ExecutionPlanItem;
23  import org.apache.maven.lifecycle.internal.LifecycleExecutionPlanCalculator;
24  import org.apache.maven.lifecycle.internal.LifecycleTaskSegmentCalculator;
25  import org.apache.maven.lifecycle.internal.DefaultLifecycleTaskSegmentCalculator;
26  import org.apache.maven.lifecycle.internal.MojoDescriptorCreator;
27  import org.apache.maven.lifecycle.internal.TaskSegment;
28  import org.apache.maven.model.Plugin;
29  import org.apache.maven.plugin.MojoExecution;
30  import org.apache.maven.plugin.descriptor.MojoDescriptor;
31  import org.codehaus.plexus.component.annotations.Requirement;
32  import org.codehaus.plexus.util.xml.Xpp3Dom;
33  
34  import java.io.File;
35  import java.util.ArrayList;
36  import java.util.Arrays;
37  import java.util.List;
38  
39  public class LifecycleExecutorTest
40      extends AbstractCoreMavenComponentTestCase
41  {
42      @Requirement
43      private DefaultLifecycleExecutor lifecycleExecutor;
44  
45      @Requirement
46      private DefaultLifecycleTaskSegmentCalculator lifeCycleTaskSegmentCalculator;
47  
48      @Requirement
49      private LifecycleExecutionPlanCalculator lifeCycleExecutionPlanCalculator;
50  
51      @Requirement
52      private MojoDescriptorCreator mojoDescriptorCreator;
53  
54  
55      protected void setUp()
56          throws Exception
57      {
58          super.setUp();
59          lifecycleExecutor = (DefaultLifecycleExecutor) lookup( LifecycleExecutor.class );
60          lifeCycleTaskSegmentCalculator =
61              (DefaultLifecycleTaskSegmentCalculator) lookup( LifecycleTaskSegmentCalculator.class );
62          lifeCycleExecutionPlanCalculator = lookup( LifecycleExecutionPlanCalculator.class );
63          mojoDescriptorCreator = lookup( MojoDescriptorCreator.class );
64          lookup( ExceptionHandler.class );
65      }
66  
67      @Override
68      protected void tearDown()
69          throws Exception
70      {
71          lifecycleExecutor = null;
72          super.tearDown();
73      }
74  
75      protected String getProjectsDirectory()
76      {
77          return "src/test/projects/lifecycle-executor";
78      }
79  
80      // -----------------------------------------------------------------------------------------------
81      // Tests which exercise the lifecycle executor when it is dealing with default lifecycle phases.
82      // -----------------------------------------------------------------------------------------------
83  
84      public void testCalculationOfBuildPlanWithIndividualTaskWherePluginIsSpecifiedInThePom()
85          throws Exception
86      {
87          // We are doing something like "mvn resources:resources" where no version is specified but this
88          // project we are working on has the version specified in the POM so the version should come from there.
89          File pom = getProject( "project-basic" );
90          MavenSession session = createMavenSession( pom );
91          assertEquals( "project-basic", session.getCurrentProject().getArtifactId() );
92          assertEquals( "1.0", session.getCurrentProject().getVersion() );
93          List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "resources:resources" ) );
94          assertEquals( 1, executionPlan.size() );
95          MojoExecution mojoExecution = executionPlan.get( 0 );
96          assertNotNull( mojoExecution );
97          assertEquals( "org.apache.maven.plugins",
98                        mojoExecution.getMojoDescriptor().getPluginDescriptor().getGroupId() );
99          assertEquals( "maven-resources-plugin",
100                       mojoExecution.getMojoDescriptor().getPluginDescriptor().getArtifactId() );
101         assertEquals( "0.1", mojoExecution.getMojoDescriptor().getPluginDescriptor().getVersion() );
102     }
103 
104     public void testCalculationOfBuildPlanWithIndividualTaskOfTheCleanLifecycle()
105         throws Exception
106     {
107         // We are doing something like "mvn clean:clean" where no version is specified but this
108         // project we are working on has the version specified in the POM so the version should come from there.
109         File pom = getProject( "project-basic" );
110         MavenSession session = createMavenSession( pom );
111         assertEquals( "project-basic", session.getCurrentProject().getArtifactId() );
112         assertEquals( "1.0", session.getCurrentProject().getVersion() );
113         List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "clean" ) );
114         assertEquals( 1, executionPlan.size() );
115         MojoExecution mojoExecution = executionPlan.get( 0 );
116         assertNotNull( mojoExecution );
117         assertEquals( "org.apache.maven.plugins",
118                       mojoExecution.getMojoDescriptor().getPluginDescriptor().getGroupId() );
119         assertEquals( "maven-clean-plugin", mojoExecution.getMojoDescriptor().getPluginDescriptor().getArtifactId() );
120         assertEquals( "0.1", mojoExecution.getMojoDescriptor().getPluginDescriptor().getVersion() );
121     }
122 
123     public void testCalculationOfBuildPlanWithIndividualTaskOfTheCleanCleanGoal()
124         throws Exception
125     {
126         // We are doing something like "mvn clean:clean" where no version is specified but this
127         // project we are working on has the version specified in the POM so the version should come from there.
128         File pom = getProject( "project-basic" );
129         MavenSession session = createMavenSession( pom );
130         assertEquals( "project-basic", session.getCurrentProject().getArtifactId() );
131         assertEquals( "1.0", session.getCurrentProject().getVersion() );
132         List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "clean:clean" ) );
133         assertEquals( 1, executionPlan.size() );
134         MojoExecution mojoExecution = executionPlan.get( 0 );
135         assertNotNull( mojoExecution );
136         assertEquals( "org.apache.maven.plugins",
137                       mojoExecution.getMojoDescriptor().getPluginDescriptor().getGroupId() );
138         assertEquals( "maven-clean-plugin", mojoExecution.getMojoDescriptor().getPluginDescriptor().getArtifactId() );
139         assertEquals( "0.1", mojoExecution.getMojoDescriptor().getPluginDescriptor().getVersion() );
140     }
141 
142     List<MojoExecution> getExecutions( MavenExecutionPlan mavenExecutionPlan )
143     {
144         List<MojoExecution> result = new ArrayList<MojoExecution>();
145         for ( ExecutionPlanItem executionPlanItem : mavenExecutionPlan )
146         {
147             result.add( executionPlanItem.getMojoExecution() );
148         }
149         return result;
150     }
151 
152     // We need to take in multiple lifecycles
153     public void testCalculationOfBuildPlanTasksOfTheCleanLifecycleAndTheInstallLifecycle()
154         throws Exception
155     {
156         File pom = getProject( "project-with-additional-lifecycle-elements" );
157         MavenSession session = createMavenSession( pom );
158         assertEquals( "project-with-additional-lifecycle-elements", session.getCurrentProject().getArtifactId() );
159         assertEquals( "1.0", session.getCurrentProject().getVersion() );
160         List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "clean", "install" ) );
161 
162         //[01] clean:clean
163         //[02] resources:resources
164         //[03] compiler:compile
165         //[04] it:generate-metadata
166         //[05] resources:testResources
167         //[06] compiler:testCompile
168         //[07] it:generate-test-metadata
169         //[08] surefire:test
170         //[09] jar:jar
171         //[10] install:install
172         //
173         assertEquals( 10, executionPlan.size() );
174 
175         assertEquals( "clean:clean", executionPlan.get( 0 ).getMojoDescriptor().getFullGoalName() );
176         assertEquals( "resources:resources", executionPlan.get( 1 ).getMojoDescriptor().getFullGoalName() );
177         assertEquals( "compiler:compile", executionPlan.get( 2 ).getMojoDescriptor().getFullGoalName() );
178         assertEquals( "it:generate-metadata", executionPlan.get( 3 ).getMojoDescriptor().getFullGoalName() );
179         assertEquals( "resources:testResources", executionPlan.get( 4 ).getMojoDescriptor().getFullGoalName() );
180         assertEquals( "compiler:testCompile", executionPlan.get( 5 ).getMojoDescriptor().getFullGoalName() );
181         assertEquals( "it:generate-test-metadata", executionPlan.get( 6 ).getMojoDescriptor().getFullGoalName() );
182         assertEquals( "surefire:test", executionPlan.get( 7 ).getMojoDescriptor().getFullGoalName() );
183         assertEquals( "jar:jar", executionPlan.get( 8 ).getMojoDescriptor().getFullGoalName() );
184         assertEquals( "install:install", executionPlan.get( 9 ).getMojoDescriptor().getFullGoalName() );
185     }
186 
187     // We need to take in multiple lifecycles
188     public void testCalculationOfBuildPlanWithMultipleExecutionsOfModello()
189         throws Exception
190     {
191         File pom = getProject( "project-with-multiple-executions" );
192         MavenSession session = createMavenSession( pom );
193         assertEquals( "project-with-multiple-executions", session.getCurrentProject().getArtifactId() );
194         assertEquals( "1.0.1", session.getCurrentProject().getVersion() );
195 
196         MavenExecutionPlan plan = calculateExecutionPlan( session, "clean", "install" );
197 
198         List<MojoExecution> executions = getExecutions( plan );
199 
200         //[01] clean:clean
201         //[02] modello:xpp3-writer
202         //[03] modello:java
203         //[04] modello:xpp3-reader
204         //[05] modello:xpp3-writer
205         //[06] modello:java
206         //[07] modello:xpp3-reader
207         //[08] plugin:descriptor        
208         //[09] resources:resources
209         //[10] compiler:compile
210         //[11] resources:testResources
211         //[12] compiler:testCompile
212         //[13] surefire:test
213         //[14] jar:jar
214         //[15] plugin:addPluginArtifactMetadata        
215         //[16] install:install
216         //
217 
218         assertEquals( 16, executions.size() );
219 
220         assertEquals( "clean:clean", executions.get( 0 ).getMojoDescriptor().getFullGoalName() );
221         assertEquals( "it:xpp3-writer", executions.get( 1 ).getMojoDescriptor().getFullGoalName() );
222         assertEquals( "it:java", executions.get( 2 ).getMojoDescriptor().getFullGoalName() );
223         assertEquals( "it:xpp3-reader", executions.get( 3 ).getMojoDescriptor().getFullGoalName() );
224         assertEquals( "it:xpp3-writer", executions.get( 4 ).getMojoDescriptor().getFullGoalName() );
225         assertEquals( "it:java", executions.get( 5 ).getMojoDescriptor().getFullGoalName() );
226         assertEquals( "it:xpp3-reader", executions.get( 6 ).getMojoDescriptor().getFullGoalName() );
227         assertEquals( "plugin:descriptor", executions.get( 7 ).getMojoDescriptor().getFullGoalName() );
228         assertEquals( "resources:resources", executions.get( 8 ).getMojoDescriptor().getFullGoalName() );
229         assertEquals( "compiler:compile", executions.get( 9 ).getMojoDescriptor().getFullGoalName() );
230         assertEquals( "resources:testResources", executions.get( 10 ).getMojoDescriptor().getFullGoalName() );
231         assertEquals( "compiler:testCompile", executions.get( 11 ).getMojoDescriptor().getFullGoalName() );
232         assertEquals( "surefire:test", executions.get( 12 ).getMojoDescriptor().getFullGoalName() );
233         assertEquals( "jar:jar", executions.get( 13 ).getMojoDescriptor().getFullGoalName() );
234         assertEquals( "plugin:addPluginArtifactMetadata", executions.get( 14 ).getMojoDescriptor().getFullGoalName() );
235         assertEquals( "install:install", executions.get( 15 ).getMojoDescriptor().getFullGoalName() );
236 
237         assertEquals( "src/main/mdo/remote-resources.mdo",
238                       new MojoExecutionXPathContainer( executions.get( 1 ) ).getValue(
239                           "configuration/models[1]/model" ) );
240         assertEquals( "src/main/mdo/supplemental-model.mdo",
241                       new MojoExecutionXPathContainer( executions.get( 4 ) ).getValue(
242                           "configuration/models[1]/model" ) );
243     }
244 
245     public void testLifecycleQueryingUsingADefaultLifecyclePhase()
246         throws Exception
247     {
248         File pom = getProject( "project-with-additional-lifecycle-elements" );
249         MavenSession session = createMavenSession( pom );
250         assertEquals( "project-with-additional-lifecycle-elements", session.getCurrentProject().getArtifactId() );
251         assertEquals( "1.0", session.getCurrentProject().getVersion() );
252         List<MojoExecution> executionPlan = getExecutions( calculateExecutionPlan( session, "package" ) );
253 
254         //[01] resources:resources
255         //[02] compiler:compile
256         //[03] it:generate-metadata
257         //[04] resources:testResources
258         //[05] compiler:testCompile
259         //[06] plexus-component-metadata:generate-test-metadata
260         //[07] surefire:test
261         //[08] jar:jar
262         //
263         assertEquals( 8, executionPlan.size() );
264 
265         assertEquals( "resources:resources", executionPlan.get( 0 ).getMojoDescriptor().getFullGoalName() );
266         assertEquals( "compiler:compile", executionPlan.get( 1 ).getMojoDescriptor().getFullGoalName() );
267         assertEquals( "it:generate-metadata", executionPlan.get( 2 ).getMojoDescriptor().getFullGoalName() );
268         assertEquals( "resources:testResources", executionPlan.get( 3 ).getMojoDescriptor().getFullGoalName() );
269         assertEquals( "compiler:testCompile", executionPlan.get( 4 ).getMojoDescriptor().getFullGoalName() );
270         assertEquals( "it:generate-test-metadata", executionPlan.get( 5 ).getMojoDescriptor().getFullGoalName() );
271         assertEquals( "surefire:test", executionPlan.get( 6 ).getMojoDescriptor().getFullGoalName() );
272         assertEquals( "jar:jar", executionPlan.get( 7 ).getMojoDescriptor().getFullGoalName() );
273     }
274 
275     public void testLifecyclePluginsRetrievalForDefaultLifecycle()
276         throws Exception
277     {
278         List<Plugin> plugins =
279             new ArrayList<Plugin>( lifecycleExecutor.getPluginsBoundByDefaultToAllLifecycles( "jar" ) );
280 
281         assertEquals( 8, plugins.size() );
282     }
283 
284     public void testPluginConfigurationCreation()
285         throws Exception
286     {
287         File pom = getProject( "project-with-additional-lifecycle-elements" );
288         MavenSession session = createMavenSession( pom );
289         MojoDescriptor mojoDescriptor =
290             mojoDescriptorCreator.getMojoDescriptor( "org.apache.maven.its.plugins:maven-it-plugin:0.1:java", session,
291                                                      session.getCurrentProject() );
292         Xpp3Dom dom = MojoDescriptorCreator.convert( mojoDescriptor );
293         System.out.println( dom );
294     }
295 
296     MavenExecutionPlan calculateExecutionPlan( MavenSession session, String... tasks )
297         throws Exception
298     {
299         List<TaskSegment> taskSegments =
300             lifeCycleTaskSegmentCalculator.calculateTaskSegments( session, Arrays.asList( tasks ) );
301 
302         TaskSegment mergedSegment = new TaskSegment( false );
303 
304         for ( TaskSegment taskSegment : taskSegments )
305         {
306             mergedSegment.getTasks().addAll( taskSegment.getTasks() );
307         }
308 
309         return lifeCycleExecutionPlanCalculator.calculateExecutionPlan( session, session.getCurrentProject(),
310                                                                         mergedSegment.getTasks() );
311     }
312 
313 
314     public void testPluginPrefixRetrieval()
315         throws Exception
316     {
317         File pom = getProject( "project-basic" );
318         MavenSession session = createMavenSession( pom );
319         Plugin plugin = mojoDescriptorCreator.findPluginForPrefix( "resources", session );
320         assertEquals( "org.apache.maven.plugins", plugin.getGroupId() );
321         assertEquals( "maven-resources-plugin", plugin.getArtifactId() );
322     }
323 
324     // Prefixes
325 
326     public void testFindingPluginPrefixforCleanClean()
327         throws Exception
328     {
329         File pom = getProject( "project-basic" );
330         MavenSession session = createMavenSession( pom );
331         Plugin plugin = mojoDescriptorCreator.findPluginForPrefix( "clean", session );
332         assertNotNull( plugin );
333     }
334 
335 }