View Javadoc

1   package org.apache.maven.shared.release.phase;
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.eq;
23  import static org.mockito.Matchers.isA;
24  import static org.mockito.Matchers.startsWith;
25  import static org.mockito.Mockito.mock;
26  import static org.mockito.Mockito.times;
27  import static org.mockito.Mockito.verify;
28  import static org.mockito.Mockito.verifyNoMoreInteractions;
29  import static org.mockito.Mockito.when;
30  
31  import java.util.Collections;
32  import java.util.List;
33  
34  import org.apache.maven.model.Model;
35  import org.apache.maven.project.MavenProject;
36  import org.apache.maven.shared.release.ReleaseExecutionException;
37  import org.apache.maven.shared.release.config.ReleaseDescriptor;
38  import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
39  import org.apache.maven.shared.release.versions.VersionParseException;
40  import org.codehaus.plexus.PlexusTestCase;
41  import org.codehaus.plexus.components.interactivity.Prompter;
42  import org.codehaus.plexus.components.interactivity.PrompterException;
43  
44  /**
45   * Test the version mapping phase.
46   *
47   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
48   */
49  public class MapVersionsPhaseTest
50      extends PlexusTestCase
51  {
52      public void testMapReleaseVersionsInteractive()
53          throws Exception
54      {
55          // prepare
56          MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
57          MavenProject project = createProject( "artifactId", "1.0-SNAPSHOT" );
58  
59          Prompter mockPrompter = mock( Prompter.class );
60          when( mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) ) ).thenReturn( "2.0" );
61          phase.setPrompter( mockPrompter );
62  
63          List<MavenProject> reactorProjects = Collections.singletonList( project );
64  
65          ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
66  
67          // execute
68          phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
69  
70          // verify
71          assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
72                        releaseDescriptor.getReleaseVersions() );
73  
74          // prepare
75          releaseDescriptor = new ReleaseDescriptor();
76  
77          // execute
78          phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
79  
80          // verify
81          assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
82                        releaseDescriptor.getReleaseVersions() );
83          verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) );
84          verifyNoMoreInteractions( mockPrompter );
85      }
86      
87      // MRELEASE-403: Release plugin ignores given version number
88      public void testMapReleaseVersionsInteractiveAddZeroIncremental()
89          throws Exception
90      {
91          // prepare
92          MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
93          MavenProject project = createProject( "artifactId", "1.0-SNAPSHOT" );
94  
95          Prompter mockPrompter = mock( Prompter.class );
96          when(
97                mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
98                                     eq( "1.0" ) ) ).thenReturn( "1.0.0" );
99          phase.setPrompter( mockPrompter );
100 
101         List<MavenProject> reactorProjects = Collections.singletonList( project );
102 
103         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
104 
105         // execute
106         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
107 
108         // verify
109         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ),
110                       releaseDescriptor.getReleaseVersions() );
111 
112         // prepare
113         releaseDescriptor = new ReleaseDescriptor();
114 
115         // execute
116         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
117 
118         // verify
119         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ),
120                       releaseDescriptor.getReleaseVersions() );
121         verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName()
122                                                        + "\"?" ), eq( "1.0" ) );
123         verifyNoMoreInteractions( mockPrompter );
124     }
125 
126     /**
127      * Test to release "SNAPSHOT" version
128      * MRELEASE-90
129      */
130     public void testMapReleaseVersionsInteractiveWithSnaphotVersion()
131         throws Exception
132     {
133         // prepare
134         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
135         MavenProject project = createProject( "artifactId", "SNAPSHOT" );
136 
137         Prompter mockPrompter = mock( Prompter.class );
138         when( mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) ) ).thenReturn( "2.0" );
139         phase.setPrompter( mockPrompter );
140 
141         List<MavenProject> reactorProjects = Collections.singletonList( project );
142 
143         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
144 
145         // execute
146         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
147 
148         // verify
149         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
150                       releaseDescriptor.getReleaseVersions() );
151 
152         // prepare
153         releaseDescriptor = new ReleaseDescriptor();
154 
155         // execute
156         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
157 
158         // verify
159         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
160                       releaseDescriptor.getReleaseVersions() );
161         
162         verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ), eq( "1.0" ) );
163         verifyNoMoreInteractions( mockPrompter );
164     }
165 
166     /**
167      * MRELEASE-524: ignores commandline versions in batch mode
168      */
169     public void testMapReleaseVersionsNonInteractiveWithExplicitVersion()
170         throws Exception
171     {
172         // prepare
173         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "SNAPSHOT" ) );
174 
175         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
176 
177         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
178         releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" );
179 
180         Prompter mockPrompter = mock( Prompter.class );
181         phase.setPrompter( mockPrompter );
182 
183         // execute
184         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
185 
186         // verify
187         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
188                       releaseDescriptor.getReleaseVersions() );
189 
190         // prepare
191         releaseDescriptor = new ReleaseDescriptor();
192         releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" );
193 
194         // execute
195         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
196 
197         // verify
198         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
199                       releaseDescriptor.getReleaseVersions() );
200         
201         // never invoke mockprompter
202         verifyNoMoreInteractions( mockPrompter );
203     }
204 
205     public void testMapReleaseVersionsNonInteractive()
206         throws Exception
207     {
208         // prepare
209         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-release-versions" );
210 
211         Prompter mockPrompter = mock( Prompter.class );
212         phase.setPrompter( mockPrompter );
213 
214         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) );
215 
216         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
217         releaseDescriptor.setInteractive( false );
218 
219         // execute
220         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
221 
222         // verify
223         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
224                       releaseDescriptor.getReleaseVersions() );
225         // prepare
226         releaseDescriptor = new ReleaseDescriptor();
227         releaseDescriptor.setInteractive( false );
228 
229         // execute
230         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
231 
232         // verify
233         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
234                       releaseDescriptor.getReleaseVersions() );
235 
236         // never invoke mockprompter
237         verifyNoMoreInteractions( mockPrompter );
238     }
239 
240     public void testMapDevVersionsInteractive()
241         throws Exception
242     {
243         // prepare
244         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
245         MavenProject project = createProject( "artifactId", "1.0" );
246 
247         Prompter mockPrompter = mock( Prompter.class );
248         when( mockPrompter.prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
249         phase.setPrompter( mockPrompter );
250 
251         List<MavenProject> reactorProjects = Collections.singletonList( project );
252 
253         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
254 
255         // execute
256         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
257 
258         // verify
259         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
260                       releaseDescriptor.getDevelopmentVersions() );
261 
262         // prepare
263         releaseDescriptor = new ReleaseDescriptor();
264 
265         // execute
266         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
267 
268         // verify
269         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
270                       releaseDescriptor.getDevelopmentVersions() );
271         
272         verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) );
273         verifyNoMoreInteractions( mockPrompter );
274     }
275 
276     /**
277      * MRELEASE-760: updateWorkingCopyVersions=false still bumps up pom versions to next development version
278      */
279     public void testMapDevVersionsInteractiveDoNotUpdateWorkingCopy()
280         throws Exception
281     {
282         // prepare
283         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
284         MavenProject project = createProject( "artifactId", "1.0" );
285 
286         Prompter mockPrompter = mock( Prompter.class );
287         phase.setPrompter( mockPrompter );
288 
289         List<MavenProject> reactorProjects = Collections.singletonList( project );
290 
291         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
292         releaseDescriptor.setUpdateWorkingCopyVersions( false );
293 
294         // execute
295         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
296 
297         // verify
298         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
299                       releaseDescriptor.getDevelopmentVersions() );
300 
301         // prepare
302         releaseDescriptor = new ReleaseDescriptor();
303         releaseDescriptor.setUpdateWorkingCopyVersions( false );
304 
305         // execute
306         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
307 
308         // verify
309         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
310                       releaseDescriptor.getDevelopmentVersions() );
311         
312         verifyNoMoreInteractions( mockPrompter );
313     }
314 
315     public void testMapDevVersionsNonInteractive()
316         throws Exception
317     {
318         // prepare
319         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
320 
321         Prompter mockPrompter = mock( Prompter.class );
322         phase.setPrompter( mockPrompter );
323 
324         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
325 
326         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
327         releaseDescriptor.setInteractive( false );
328 
329         // execute
330         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
331 
332         // verify
333         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ),
334                       releaseDescriptor.getDevelopmentVersions() );
335 
336         // prepare
337         releaseDescriptor = new ReleaseDescriptor();
338         releaseDescriptor.setInteractive( false );
339 
340         // execute
341         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
342 
343         // verify
344         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ),
345                       releaseDescriptor.getDevelopmentVersions() );
346         
347         // never invoke mockprompter
348         verifyNoMoreInteractions( mockPrompter );
349     }
350 
351      /**
352      * MRELEASE-524: ignores commandline versions in batch mode
353      */
354     public void testMapDevVersionsNonInteractiveWithExplicitVersion()
355         throws Exception
356     {
357         // prepare
358         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
359         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
360 
361         Prompter mockPrompter = mock( Prompter.class );
362         phase.setPrompter( mockPrompter );
363 
364         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
365         releaseDescriptor.setInteractive( false );
366         releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
367 
368         // execute
369         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
370 
371         // verify
372         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ),
373                       releaseDescriptor.getDevelopmentVersions() );
374 
375         // prepare
376         releaseDescriptor = new ReleaseDescriptor();
377         releaseDescriptor.setInteractive( false );
378         releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
379 
380         // execute
381         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
382 
383         // verify
384         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ),
385                       releaseDescriptor.getDevelopmentVersions() );
386         
387         // never invoke mockprompter
388         verifyNoMoreInteractions( mockPrompter );
389     }
390 
391     public void testPrompterException()
392         throws Exception
393     {
394         // prepare
395         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
396 
397         Prompter mockPrompter = mock( Prompter.class );
398         when( mockPrompter.prompt( isA( String.class ),  isA( String.class ) ) ).thenThrow( new PrompterException( "..." ) );
399         phase.setPrompter( mockPrompter );
400 
401         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
402 
403         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
404 
405         // execute
406         try
407         {
408             phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
409 
410             fail( "Expected an exception" );
411         }
412         catch ( ReleaseExecutionException e )
413         {
414             assertEquals( "check cause", PrompterException.class, e.getCause().getClass() );
415         }
416 
417         // prepare
418         releaseDescriptor = new ReleaseDescriptor();
419 
420         // execute
421         try
422         {
423             phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
424 
425             fail( "Expected an exception" );
426         }
427         catch ( ReleaseExecutionException e )
428         {
429             assertEquals( "check cause", PrompterException.class, e.getCause().getClass() );
430         }
431         
432         //verify
433         verify( mockPrompter, times( 2 ) ).prompt( isA( String.class ),  isA( String.class ) );
434         verifyNoMoreInteractions( mockPrompter );
435     }
436 
437     public void testAdjustVersionInteractive()
438         throws Exception
439     {
440         // prepare
441         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
442         MavenProject project = createProject( "artifactId", "foo" );
443 
444         Prompter mockPrompter = mock( Prompter.class );
445         when( mockPrompter.prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
446         phase.setPrompter( mockPrompter );
447 
448         List<MavenProject> reactorProjects = Collections.singletonList( project );
449 
450         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
451 
452         // execute
453         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
454 
455         // verify
456         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
457                       releaseDescriptor.getDevelopmentVersions() );
458 
459         // prepare
460         releaseDescriptor = new ReleaseDescriptor();
461 
462         // execute
463         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
464 
465         // verify
466         assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
467                       releaseDescriptor.getDevelopmentVersions() );
468         verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) );
469         verifyNoMoreInteractions( mockPrompter );
470     }
471 
472     public void testAdjustVersionNonInteractive()
473         throws Exception
474     {
475         MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, "test-map-development-versions" );
476 
477         List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "foo" ) );
478 
479         ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
480         releaseDescriptor.setInteractive( false );
481 
482         try
483         {
484             phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
485 
486             fail( "Expected an exception" );
487         }
488         catch ( ReleaseExecutionException e )
489         {
490             assertEquals( "check cause", VersionParseException.class, e.getCause().getClass() );
491         }
492 
493         releaseDescriptor = new ReleaseDescriptor();
494         releaseDescriptor.setInteractive( false );
495 
496         try
497         {
498             phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
499 
500             fail( "Expected an exception" );
501         }
502         catch ( ReleaseExecutionException e )
503         {
504             assertEquals( "check cause", VersionParseException.class, e.getCause().getClass() );
505         }
506     }
507 
508     private static MavenProject createProject( String artifactId, String version )
509     {
510         Model model = new Model();
511         model.setGroupId( "groupId" );
512         model.setArtifactId( artifactId );
513         model.setVersion( version );
514         return new MavenProject( model );
515     }
516 
517 }