View Javadoc
1   package org.apache.maven.plugins.release;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import static org.mockito.Matchers.isA;
23  import static org.mockito.Mockito.doThrow;
24  import static org.mockito.Mockito.mock;
25  import static org.mockito.Mockito.verify;
26  import static org.mockito.Mockito.verifyNoMoreInteractions;
27  
28  import java.io.File;
29  import java.util.Arrays;
30  import java.util.List;
31  
32  import org.apache.maven.execution.MavenSession;
33  import org.apache.maven.model.DistributionManagement;
34  import org.apache.maven.model.Profile;
35  import org.apache.maven.model.Site;
36  import org.apache.maven.plugin.MojoExecutionException;
37  import org.apache.maven.plugin.MojoFailureException;
38  import org.apache.maven.plugin.testing.AbstractMojoTestCase;
39  import org.apache.maven.project.MavenProject;
40  import org.apache.maven.shared.release.ReleaseExecutionException;
41  import org.apache.maven.shared.release.ReleaseFailureException;
42  import org.apache.maven.shared.release.ReleaseManager;
43  import org.apache.maven.shared.release.ReleasePerformRequest;
44  import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
45  import org.mockito.ArgumentCaptor;
46  
47  /**
48   * Test release:perform.
49   *
50   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
51   */
52  public class PerformReleaseMojoTest
53      extends AbstractMojoTestCase
54  {
55      private File workingDirectory;
56  
57      public void testPerform()
58          throws Exception
59      {
60          PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
61  
62          ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
63          builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
64          File checkoutDirectory = getTestFile( "target/checkout" );
65          builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
66          builder.setPerformGoals( "deploy site-deploy" );
67  
68          ReleaseManager mock = mock( ReleaseManager.class );
69          mojo.setReleaseManager( mock );
70          
71          // execute
72          mojo.execute();
73          
74          // verify
75          ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
76          verify( mock ).perform( argument.capture() );
77          assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
78          assertNotNull( argument.getValue().getReleaseEnvironment()  );
79          assertNotNull( argument.getValue().getReactorProjects() );
80          assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
81          verifyNoMoreInteractions( mock );
82      }
83  
84      public void testPerformWithFlatStructure()
85          throws Exception
86      {
87          PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-flat-structure.xml" );
88  
89          ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
90          builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
91          File checkoutDirectory = getTestFile( "target/checkout" );
92          builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
93          builder.setPerformGoals( "deploy" );
94          builder.setScmSourceUrl( "scm:svn:file://localhost/target/svnroot/flat-multi-module/trunk/root-project" );
95  
96          ReleaseManager mock = mock( ReleaseManager.class );
97          mojo.setReleaseManager( mock );
98  
99          // execute
100         mojo.execute();
101         
102         // verify
103         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
104         verify( mock ).perform( argument.capture() );
105         assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
106         assertNotNull( argument.getValue().getReleaseEnvironment()  );
107         assertNotNull( argument.getValue().getReactorProjects() );
108         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
109         verifyNoMoreInteractions( mock );
110     }
111 
112     
113     public void testPerformWithoutSite()
114         throws Exception
115     {
116         File testFileDirectory = getTestFile( "target/test-classes/mojos/perform/" );
117         PerformReleaseMojo mojo =
118             (PerformReleaseMojo) lookupMojo( "perform", new File( testFileDirectory, "perform-without-site.xml" ) );
119         mojo.setBasedir( testFileDirectory );
120         mojo.setPomFileName( "pom.xml" );
121         
122         MavenProject project = (MavenProject) getVariableValueFromObject( mojo, "project" );
123         setVariableValueToObject( mojo, "session", newMavenSession( project ) );
124 
125         ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
126         builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
127         File checkoutDirectory = getTestFile( "target/checkout" );
128         builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
129         builder.setPerformGoals( "deploy" );
130 
131         ReleaseManager mock = mock( ReleaseManager.class );
132         mojo.setReleaseManager( mock );
133 
134         // execute
135         mojo.execute();
136 
137         // verify
138         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
139         verify( mock ).perform( argument.capture() );
140         assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
141         assertNotNull( argument.getValue().getReleaseEnvironment()  );
142         assertNotNull( argument.getValue().getReactorProjects() );
143         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
144         verifyNoMoreInteractions( mock );
145     }
146 
147     private PerformReleaseMojo getMojoWithProjectSite( String fileName )
148         throws Exception
149     {
150         PerformReleaseMojo mojo = (PerformReleaseMojo) lookupMojo( "perform", new File( workingDirectory, fileName ) );
151         mojo.setBasedir( workingDirectory );
152         mojo.setPomFileName( fileName );
153 
154         MavenProject project = (MavenProject) getVariableValueFromObject( mojo, "project" );
155         DistributionManagement distributionManagement = new DistributionManagement();
156         distributionManagement.setSite( new Site() );
157         project.setDistributionManagement( distributionManagement );
158         
159         setVariableValueToObject( mojo, "session", newMavenSession( project ) );
160 
161         return mojo;
162     }
163 
164     public void testPerformWithExecutionException()
165         throws Exception
166     {
167         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
168 
169         ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
170         builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
171         File checkoutDirectory = getTestFile( "target/checkout" );
172         builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
173         builder.setPerformGoals( "deploy site-deploy" );
174 
175         ReleaseManager mock = mock( ReleaseManager.class );
176         doThrow( new ReleaseExecutionException( "..." ) ).when( mock ).perform( isA( ReleasePerformRequest.class ) );
177         mojo.setReleaseManager( mock );
178 
179         // execute
180         try
181         {
182             mojo.execute();
183 
184             fail( "Should have thrown an exception" );
185         }
186         catch ( MojoExecutionException e )
187         {
188             assertEquals( "Check cause", ReleaseExecutionException.class, e.getCause().getClass() );
189         }
190         
191         // verify
192         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
193         verify( mock ).perform( argument.capture() );
194         assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
195         assertNotNull( argument.getValue().getReleaseEnvironment()  );
196         assertNotNull( argument.getValue().getReactorProjects() );
197         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
198 
199         verifyNoMoreInteractions( mock );
200     }
201 
202     public void testPerformWithExecutionFailure()
203         throws Exception
204     {
205         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
206 
207         ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
208         builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
209         File checkoutDirectory = getTestFile( "target/checkout" );
210         builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
211         builder.setPerformGoals( "deploy site-deploy" );
212 
213         ReleaseManager mock = mock( ReleaseManager.class );
214         ReleaseFailureException cause = new ReleaseFailureException( "..." );
215         doThrow( cause ).when( mock ).perform( isA( ReleasePerformRequest.class ) );
216 
217         mojo.setReleaseManager( mock );
218 
219         // execute
220         try
221         {
222             mojo.execute();
223 
224             fail( "Should have thrown an exception" );
225         }
226         catch ( MojoFailureException e )
227         {
228             assertEquals( "Check cause exists", cause, e.getCause() );
229         }
230         
231         // verify
232         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
233         verify( mock ).perform( argument.capture() );
234         assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
235         assertNotNull( argument.getValue().getReleaseEnvironment()  );
236         assertNotNull( argument.getValue().getReactorProjects() );
237         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
238 
239         verifyNoMoreInteractions( mock );
240     }
241 
242     public void testPerformWithScm()
243         throws Exception
244     {
245         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-scm.xml" );
246 
247         ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
248         builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
249         File checkoutDirectory = getTestFile( "target/checkout" );
250         builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
251         builder.setPerformGoals( "deploy site-deploy" );
252         builder.setScmSourceUrl( "scm-url" );
253 
254         ReleaseManager mock = mock( ReleaseManager.class );
255         mojo.setReleaseManager( mock );
256 
257         // execute
258         mojo.execute();
259         
260         // verify
261         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
262         verify( mock ).perform( argument.capture() );
263         assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
264         assertNotNull( argument.getValue().getReleaseEnvironment()  );
265         assertNotNull( argument.getValue().getReactorProjects() );
266         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
267 
268         verifyNoMoreInteractions( mock );
269     }
270 
271     public void testPerformWithProfiles()
272         throws Exception
273     {
274         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform.xml" );
275 
276         ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
277         builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
278         File checkoutDirectory = getTestFile( "target/checkout" );
279         builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
280         builder.setPerformGoals( "deploy site-deploy" );
281         builder.setAdditionalArguments( "-P prof1,2prof" );
282 
283         MavenSession session = (MavenSession) getVariableValueFromObject( mojo, "session");
284         Profile profile1 = new Profile();
285         profile1.setId( "prof1" );
286         session.getRequest().addProfile( profile1 );
287         Profile profile2 = new Profile();
288         profile2.setId( "2prof" );
289         session.getRequest().addProfile( profile2 );
290         session.getRequest().setActiveProfiles( Arrays.asList( "prof1", "2prof" ) );
291 
292         ReleaseManager mock = mock( ReleaseManager.class );
293         mojo.setReleaseManager( mock );
294 
295         // execute
296         mojo.execute();
297 
298         // verify
299         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
300         verify( mock ).perform( argument.capture() );
301         assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
302         assertNotNull( argument.getValue().getReleaseEnvironment()  );
303         assertNotNull( argument.getValue().getReactorProjects() );
304         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
305 
306         verifyNoMoreInteractions( mock );
307     }
308 
309     public void testPerformWithProfilesAndArguments()
310         throws Exception
311     {
312         PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-args.xml" );
313 
314         ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
315         builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
316         File checkoutDirectory = getTestFile( "target/checkout" );
317         builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
318         builder.setPerformGoals( "deploy site-deploy" );
319         builder.setAdditionalArguments( "-Dmaven.test.skip=true -P prof1,2prof" );
320 
321         MavenSession session = (MavenSession) getVariableValueFromObject( mojo, "session");
322         Profile profile1 = new Profile();
323         profile1.setId( "prof1" );
324         session.getRequest().addProfile( profile1 );
325         Profile profile2 = new Profile();
326         profile2.setId( "2prof" );
327         session.getRequest().addProfile( profile2 );
328         session.getRequest().setActiveProfiles( Arrays.asList( "prof1", "2prof" ) );
329 
330         ReleaseManager mock = mock( ReleaseManager.class );
331         mojo.setReleaseManager( mock );
332 
333         // execute
334         mojo.execute();
335 
336         // verify
337         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
338         verify( mock ).perform( argument.capture() );
339         assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
340         assertNotNull( argument.getValue().getReleaseEnvironment()  );
341         assertNotNull( argument.getValue().getReactorProjects() );
342         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
343 
344         verifyNoMoreInteractions( mock );
345     }
346 
347     public void testPerformWithMultilineGoals()
348         throws Exception
349     {
350 	    PerformReleaseMojo mojo = getMojoWithProjectSite( "perform-with-multiline-goals.xml" );
351 
352         ReleaseDescriptorBuilder builder = createReleaseDescriptorBuilder( mojo );
353         builder.setWorkingDirectory( workingDirectory.getAbsolutePath() );
354         File checkoutDirectory = getTestFile( "target/checkout" );
355         builder.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
356         builder.setPerformGoals( "deploy site-deploy" );
357 
358         ReleaseManager mock = mock( ReleaseManager.class );
359         mojo.setReleaseManager( mock );
360 
361         // execute
362         mojo.execute();
363 
364         // verify
365         ArgumentCaptor<ReleasePerformRequest> argument = ArgumentCaptor.forClass(ReleasePerformRequest.class);
366         verify( mock ).perform( argument.capture() );
367         assertNotNull( argument.getValue().getReleaseDescriptorBuilder() );
368         assertNotNull( argument.getValue().getReleaseEnvironment()  );
369         assertNotNull( argument.getValue().getReactorProjects() );
370         assertEquals( Boolean.FALSE, argument.getValue().getDryRun() );
371 
372         verifyNoMoreInteractions( mock );
373     }
374 
375     private ReleaseDescriptorBuilder createReleaseDescriptorBuilder( PerformReleaseMojo mojo ) throws Exception
376     {
377         ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
378         
379         @SuppressWarnings( "unchecked" )
380         List<MavenProject> reactorProjects = (List<MavenProject>) getVariableValueFromObject( mojo, "reactorProjects" );
381         
382         for ( MavenProject project : reactorProjects )
383         {
384             builder.putOriginalVersion( project.getGroupId() + ':' + project.getArtifactId(), project.getVersion() );
385         }
386         
387         return builder;
388     }
389 
390     protected void setUp()
391         throws Exception
392     {
393         super.setUp();
394         workingDirectory = getTestFile( "target/test-classes/mojos/perform" );
395     }
396 }