1 package org.apache.maven.shared.release.phase;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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.times;
26 import static org.mockito.Mockito.verify;
27 import static org.mockito.Mockito.verifyNoMoreInteractions;
28 import static org.mockito.Mockito.when;
29
30 import java.util.ArrayList;
31 import java.util.Collections;
32 import java.util.HashMap;
33 import java.util.List;
34 import java.util.Map;
35
36 import org.apache.maven.model.Model;
37 import org.apache.maven.project.MavenProject;
38 import org.apache.maven.shared.release.ReleaseExecutionException;
39 import org.apache.maven.shared.release.config.ReleaseDescriptor;
40 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
41 import org.apache.maven.shared.release.versions.VersionParseException;
42 import org.codehaus.plexus.PlexusTestCase;
43 import org.codehaus.plexus.components.interactivity.Prompter;
44 import org.codehaus.plexus.components.interactivity.PrompterException;
45 import org.mockito.Mock;
46 import org.mockito.MockitoAnnotations;
47
48
49
50
51
52
53 public class MapVersionsPhaseTest
54 extends PlexusTestCase
55 {
56 private static final String TEST_MAP_BRANCH_VERSIONS = "test-map-branch-versions";
57 private static final String TEST_MAP_DEVELOPMENT_VERSIONS = "test-map-development-versions";
58 private static final String TEST_MAP_RELEASE_VERSIONS = "test-map-release-versions";
59 @Mock
60 private Prompter mockPrompter;
61
62 public void setUp()
63 throws Exception
64 {
65 super.setUp();
66 MockitoAnnotations.initMocks( this );
67 }
68
69 @Override
70 protected void tearDown()
71 throws Exception
72 {
73 super.tearDown();
74 verifyNoMoreInteractions( mockPrompter );
75 }
76
77 public void testExecuteSnapshot_MapRelease()
78 throws Exception
79 {
80
81 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
82 MavenProject project = createProject( "artifactId", "1.0-SNAPSHOT" );
83
84 when(
85 mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
86 eq( "1.0" ) ) ).thenReturn( "2.0" );
87 phase.setPrompter( mockPrompter );
88
89 List<MavenProject> reactorProjects = Collections.singletonList( project );
90
91 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
92
93
94 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
95
96
97 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
98 releaseDescriptor.getReleaseVersions() );
99
100 verify( mockPrompter ).prompt( startsWith( "What is the release version for \"" + project.getName()
101 + "\"?" ), eq( "1.0" ) );
102 }
103
104 public void testSimulateSnapshot_MapReleaseVersions()
105 throws Exception
106 {
107
108 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
109 MavenProject project = createProject( "artifactId", "1.0-SNAPSHOT" );
110
111 when(
112 mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
113 eq( "1.0" ) ) ).thenReturn( "2.0" );
114 phase.setPrompter( mockPrompter );
115
116 List<MavenProject> reactorProjects = Collections.singletonList( project );
117
118 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
119
120
121 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
122
123
124 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
125 releaseDescriptor.getReleaseVersions() );
126 verify( mockPrompter ).prompt( startsWith( "What is the release version for \"" + project.getName()
127 + "\"?" ), eq( "1.0" ) );
128 }
129
130
131 public void testMapReleaseVersionsInteractiveAddZeroIncremental()
132 throws Exception
133 {
134
135 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
136 MavenProject project = createProject( "artifactId", "1.0-SNAPSHOT" );
137
138 when(
139 mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
140 eq( "1.0" ) ) ).thenReturn( "1.0.0" );
141 phase.setPrompter( mockPrompter );
142
143 List<MavenProject> reactorProjects = Collections.singletonList( project );
144
145 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
146
147
148 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
149
150
151 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ),
152 releaseDescriptor.getReleaseVersions() );
153
154
155 releaseDescriptor = new ReleaseDescriptor();
156
157
158 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
159
160
161 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0.0" ),
162 releaseDescriptor.getReleaseVersions() );
163 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName()
164 + "\"?" ), eq( "1.0" ) );
165 }
166
167
168
169
170 public void testMapReleaseVersionsInteractiveWithSnaphotVersion()
171 throws Exception
172 {
173
174 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
175 MavenProject project = createProject( "artifactId", "SNAPSHOT" );
176
177 when(
178 mockPrompter.prompt( startsWith( "What is the release version for \"" + project.getName() + "\"?" ),
179 eq( "1.0" ) ) ).thenReturn( "2.0" );
180 phase.setPrompter( mockPrompter );
181
182 List<MavenProject> reactorProjects = Collections.singletonList( project );
183
184 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
185
186
187 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
188
189
190 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
191 releaseDescriptor.getReleaseVersions() );
192
193
194 releaseDescriptor = new ReleaseDescriptor();
195
196
197 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
198
199
200 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
201 releaseDescriptor.getReleaseVersions() );
202
203 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the release version for \"" + project.getName()
204 + "\"?" ), eq( "1.0" ) );
205 }
206
207
208
209
210 public void testMapReleaseVersionsNonInteractiveWithExplicitVersion()
211 throws Exception
212 {
213
214 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "SNAPSHOT" ) );
215
216 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
217
218 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
219 releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" );
220
221 phase.setPrompter( mockPrompter );
222
223
224 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
225
226
227 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
228 releaseDescriptor.getReleaseVersions() );
229
230
231 releaseDescriptor = new ReleaseDescriptor();
232 releaseDescriptor.addReleaseVersion( "groupId:artifactId", "2.0" );
233
234
235 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
236
237
238 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0" ),
239 releaseDescriptor.getReleaseVersions() );
240 }
241
242 public void testExecuteSnapshotNonInteractive_MapRelease()
243 throws Exception
244 {
245
246 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
247
248 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) );
249
250 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
251 releaseDescriptor.setInteractive( false );
252
253
254 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
255
256
257 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
258 releaseDescriptor.getReleaseVersions() );
259 }
260
261 public void testSimulateSnapshotNonInteractive_MapReleaseVersions()
262 throws Exception
263 {
264
265 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
266
267 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0-SNAPSHOT" ) );
268
269 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
270 releaseDescriptor.setInteractive( false );
271
272
273 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
274
275
276 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
277 releaseDescriptor.getReleaseVersions() );
278 }
279
280 public void testMapDevVersionsInteractive()
281 throws Exception
282 {
283
284 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
285 MavenProject project = createProject( "artifactId", "1.0" );
286
287 when(
288 mockPrompter.prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ),
289 eq( "1.1-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
290 phase.setPrompter( mockPrompter );
291
292 List<MavenProject> reactorProjects = Collections.singletonList( project );
293
294 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
295
296
297 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
298
299
300 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
301 releaseDescriptor.getDevelopmentVersions() );
302
303
304 releaseDescriptor = new ReleaseDescriptor();
305
306
307 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
308
309
310 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
311 releaseDescriptor.getDevelopmentVersions() );
312
313 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \""
314 + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) );
315 }
316
317
318
319
320 public void testMapDevVersionsInteractiveDoNotUpdateWorkingCopy()
321 throws Exception
322 {
323
324 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
325 MavenProject project = createProject( "artifactId", "1.0" );
326
327 phase.setPrompter( mockPrompter );
328
329 List<MavenProject> reactorProjects = Collections.singletonList( project );
330
331 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
332 releaseDescriptor.setUpdateWorkingCopyVersions( false );
333
334
335 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
336
337
338 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
339 releaseDescriptor.getDevelopmentVersions() );
340
341
342 releaseDescriptor = new ReleaseDescriptor();
343 releaseDescriptor.setUpdateWorkingCopyVersions( false );
344
345
346 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
347
348
349 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.0" ),
350 releaseDescriptor.getDevelopmentVersions() );
351 }
352
353 public void testMapDevVersionsNonInteractive()
354 throws Exception
355 {
356
357 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
358
359 phase.setPrompter( mockPrompter );
360
361 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
362
363 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
364 releaseDescriptor.setInteractive( false );
365
366
367 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
368
369
370 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ),
371 releaseDescriptor.getDevelopmentVersions() );
372
373
374 releaseDescriptor = new ReleaseDescriptor();
375 releaseDescriptor.setInteractive( false );
376
377
378 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
379
380
381 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "1.1-SNAPSHOT" ),
382 releaseDescriptor.getDevelopmentVersions() );
383 }
384
385
386
387
388 public void testMapDevVersionsNonInteractiveWithExplicitVersion()
389 throws Exception
390 {
391
392 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
393 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
394
395 phase.setPrompter( mockPrompter );
396
397 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
398 releaseDescriptor.setInteractive( false );
399 releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
400
401
402 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
403
404
405 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ),
406 releaseDescriptor.getDevelopmentVersions() );
407
408
409 releaseDescriptor = new ReleaseDescriptor();
410 releaseDescriptor.setInteractive( false );
411 releaseDescriptor.addDevelopmentVersion( "groupId:artifactId", "2-SNAPSHOT" );
412
413
414 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
415
416
417 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2-SNAPSHOT" ),
418 releaseDescriptor.getDevelopmentVersions() );
419 }
420
421 public void testPrompterException()
422 throws Exception
423 {
424
425 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
426
427 when( mockPrompter.prompt( isA( String.class ), isA( String.class ) ) ).thenThrow( new PrompterException( "..." ) );
428 phase.setPrompter( mockPrompter );
429
430 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.0" ) );
431
432 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
433
434
435 try
436 {
437 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
438
439 fail( "Expected an exception" );
440 }
441 catch ( ReleaseExecutionException e )
442 {
443 assertEquals( "check cause", PrompterException.class, e.getCause().getClass() );
444 }
445
446
447 releaseDescriptor = new ReleaseDescriptor();
448
449
450 try
451 {
452 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
453
454 fail( "Expected an exception" );
455 }
456 catch ( ReleaseExecutionException e )
457 {
458 assertEquals( "check cause", PrompterException.class, e.getCause().getClass() );
459 }
460
461
462 verify( mockPrompter, times( 2 ) ).prompt( isA( String.class ), isA( String.class ) );
463 }
464
465 public void testAdjustVersionInteractive()
466 throws Exception
467 {
468
469 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
470 MavenProject project = createProject( "artifactId", "foo" );
471
472 when(
473 mockPrompter.prompt( startsWith( "What is the new development version for \"" + project.getName() + "\"?" ),
474 eq( "1.1-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
475 phase.setPrompter( mockPrompter );
476
477 List<MavenProject> reactorProjects = Collections.singletonList( project );
478
479 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
480
481
482 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
483
484
485 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
486 releaseDescriptor.getDevelopmentVersions() );
487
488
489 releaseDescriptor = new ReleaseDescriptor();
490
491
492 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
493
494
495 assertEquals( "Check mapped versions", Collections.singletonMap( "groupId:artifactId", "2.0-SNAPSHOT" ),
496 releaseDescriptor.getDevelopmentVersions() );
497
498 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for \""
499 + project.getName() + "\"?" ), eq( "1.1-SNAPSHOT" ) );
500 }
501
502 public void testAdjustVersionNonInteractive()
503 throws Exception
504 {
505 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
506
507 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "foo" ) );
508
509 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
510 releaseDescriptor.setInteractive( false );
511
512 try
513 {
514 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
515
516 fail( "Expected an exception" );
517 }
518 catch ( ReleaseExecutionException e )
519 {
520 assertEquals( "check cause", VersionParseException.class, e.getCause().getClass() );
521 }
522
523 releaseDescriptor = new ReleaseDescriptor();
524 releaseDescriptor.setInteractive( false );
525
526 try
527 {
528 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
529
530 fail( "Expected an exception" );
531 }
532 catch ( ReleaseExecutionException e )
533 {
534 assertEquals( "check cause", VersionParseException.class, e.getCause().getClass() );
535 }
536 }
537
538 public void testExecuteSnapshotBranchCreation_DefaultDevelopmentVersion_MapDevelopment()
539 throws Exception
540 {
541
542 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
543
544 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
545
546 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
547 releaseDescriptor.setBranchCreation( true );
548 releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
549
550
551 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
552
553
554 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
555 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), releaseDescriptor.getDevelopmentVersions() );
556 }
557
558 public void testSimulateSnapshotBranchCreation_DefaultDevelopmentVersion_MapDevelopment()
559 throws Exception
560 {
561
562 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
563
564 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
565
566 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
567 releaseDescriptor.setBranchCreation( true );
568 releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
569
570
571 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
572
573
574 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
575 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), releaseDescriptor.getDevelopmentVersions() );
576 }
577
578 public void testExecuteSnapshotBranchCreation_DefaultDevelopmentVersion_NonInteractive_MapDevelopment()
579 throws Exception
580 {
581
582 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
583
584 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
585
586 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
587 releaseDescriptor.setBranchCreation( true );
588 releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
589 releaseDescriptor.setInteractive( false );
590
591
592 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
593
594
595 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
596 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
597 releaseDescriptor.getDevelopmentVersions() );
598 }
599
600 public void testSimulateSnapshotBranchCreation_DefaultDevelopmentVersion_NonInteractive_MapDevelopment()
601 throws Exception
602 {
603
604 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
605
606 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
607
608 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
609 releaseDescriptor.setBranchCreation( true );
610 releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
611 releaseDescriptor.setInteractive( false );
612
613
614 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
615
616
617 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
618 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
619 releaseDescriptor.getDevelopmentVersions() );
620 }
621
622 public void testExecuteSnapshotBranchCreation_NonInteractive_MapDevelopment()
623 throws Exception
624 {
625
626 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
627
628 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
629
630 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
631 releaseDescriptor.setBranchCreation( true );
632 releaseDescriptor.setInteractive( false );
633
634
635 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
636
637
638 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
639 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
640 releaseDescriptor.getDevelopmentVersions() );
641 }
642
643 public void testSimulateSnapshotBranchCreation_NonInteractive_MapDevelopment()
644 throws Exception
645 {
646
647 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
648
649 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
650
651 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
652 releaseDescriptor.setBranchCreation( true );
653 releaseDescriptor.setInteractive( false );
654
655
656 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
657
658
659 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
660 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
661 releaseDescriptor.getDevelopmentVersions() );
662 }
663
664
665 public void testExecuteSnapshotDefaultDevelopmentVersion_MapDevelopment()
666 throws Exception
667 {
668
669 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
670
671 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
672
673 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
674 releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
675
676
677 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
678
679
680 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
681 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), releaseDescriptor.getDevelopmentVersions() );
682 }
683
684 public void testSimulateSnapshotDefaultDevelopmentVersion_MapDevelopment()
685 throws Exception
686 {
687
688 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
689
690 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
691
692 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
693 releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
694
695
696 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
697
698
699 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
700 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ), releaseDescriptor.getDevelopmentVersions() );
701 }
702
703 public void testExecuteSnapshotDefaultDevelopmentVersion_NonInteractive_MapDevelopment()
704 throws Exception
705 {
706
707 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
708
709 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
710
711 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
712 releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
713 releaseDescriptor.setInteractive( false );
714
715
716 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
717
718
719 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
720 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
721 releaseDescriptor.getDevelopmentVersions() );
722 }
723
724 public void testSimulateSnapshotDefaultDevelopmentVersion_NonInteractive_MapDevelopment()
725 throws Exception
726 {
727
728 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
729
730 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
731
732 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
733 releaseDescriptor.setDefaultDevelopmentVersion( "1.1.1-SNAPSHOT" );
734 releaseDescriptor.setInteractive( false );
735
736
737 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
738
739
740 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
741 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.1.1-SNAPSHOT" ),
742 releaseDescriptor.getDevelopmentVersions() );
743 }
744
745 public void testExecuteSnapshotNonInteractive_MapDevelopment()
746 throws Exception
747 {
748
749 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
750
751 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
752
753 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
754 releaseDescriptor.setInteractive( false );
755
756
757 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
758
759
760 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
761 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
762 releaseDescriptor.getDevelopmentVersions() );
763 }
764
765 public void testSimulateSnapshotNonInteractive_MapDevelopment()
766 throws Exception
767 {
768
769 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
770
771 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
772
773 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
774 releaseDescriptor.setInteractive( false );
775
776
777 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
778
779
780 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
781 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
782 releaseDescriptor.getDevelopmentVersions() );
783 }
784
785 public void testExecuteSnapshotAutoVersionSubmodules_NotInteractive_MapDevelopment()
786 throws Exception
787 {
788
789 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
790
791 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
792
793 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
794 releaseDescriptor.setAutoVersionSubmodules( true );
795 releaseDescriptor.setInteractive( false );
796
797
798 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
799
800
801 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
802 releaseDescriptor.getDevelopmentVersions() );
803 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
804 }
805
806 public void testSimulateSnapshotAutoVersionSubmodules_NotInteractive_MapDevelopment()
807 throws Exception
808 {
809
810 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
811
812 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
813
814 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
815 releaseDescriptor.setAutoVersionSubmodules( true );
816 releaseDescriptor.setInteractive( false );
817
818
819 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
820
821
822 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
823 releaseDescriptor.getDevelopmentVersions() );
824 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
825 }
826
827 public void testExecuteReleaseAutoVersionSubmodules_NotInteractive_MapDevelopment()
828 throws Exception
829 {
830
831 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
832
833 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
834
835 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
836 releaseDescriptor.setAutoVersionSubmodules( true );
837 releaseDescriptor.setInteractive( false );
838
839
840 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
841
842
843 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
844 releaseDescriptor.getDevelopmentVersions() );
845 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
846 }
847
848 public void testSimulateReleaseAutoVersionSubmodules_NotInteractive_MapDevelopment()
849 throws Exception
850 {
851
852 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
853
854 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
855
856 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
857 releaseDescriptor.setAutoVersionSubmodules( true );
858 releaseDescriptor.setInteractive( false );
859
860
861 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
862
863
864 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
865 releaseDescriptor.getDevelopmentVersions() );
866 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
867 }
868
869 public void testExecuteSnapshotAutoVersionSubmodules_NotInteractive_MapRelease()
870 throws Exception
871 {
872
873 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
874
875 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
876
877 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
878 releaseDescriptor.setAutoVersionSubmodules( true );
879 releaseDescriptor.setInteractive( false );
880
881
882 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
883
884
885 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
886 releaseDescriptor.getReleaseVersions() );
887 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
888 }
889
890 public void testSimulateSnapshotAutoVersionSubmodules_NotInteractive_MapRelease()
891 throws Exception
892 {
893
894 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
895
896 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
897
898 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
899 releaseDescriptor.setAutoVersionSubmodules( true );
900 releaseDescriptor.setInteractive( false );
901
902
903 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
904
905
906 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
907 releaseDescriptor.getReleaseVersions() );
908 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
909 }
910
911 public void testExecuteReleaseAutoVersionSubmodules_NotInteractive_MapRelease()
912 throws Exception
913 {
914
915 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
916
917 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
918
919 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
920 releaseDescriptor.setAutoVersionSubmodules( true );
921 releaseDescriptor.setInteractive( false );
922
923
924 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
925
926
927 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
928 releaseDescriptor.getReleaseVersions() );
929 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
930 }
931
932 public void testSimulateReleaseAutoVersionSubmodules_NotInteractive_MapRelease()
933 throws Exception
934 {
935
936 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
937
938 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
939
940 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
941 releaseDescriptor.setAutoVersionSubmodules( true );
942 releaseDescriptor.setInteractive( false );
943
944
945 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
946
947
948 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
949 releaseDescriptor.getReleaseVersions() );
950 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
951 }
952
953 public void testExecuteSnapshotAutoVersionSubmodules_BranchCreation_NotInteractive_MapDevelopment()
954 throws Exception
955 {
956
957 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
958
959 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
960
961 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
962 releaseDescriptor.setAutoVersionSubmodules( true );
963 releaseDescriptor.setBranchCreation( true );
964 releaseDescriptor.setInteractive( false );
965
966
967 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
968
969
970 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
971 releaseDescriptor.getDevelopmentVersions() );
972 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
973 }
974
975 public void testSimulateSnapshotAutoVersionSubmodules_BranchCreation_NotInteractive_MapDevelopment()
976 throws Exception
977 {
978
979 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
980
981 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
982
983 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
984 releaseDescriptor.setAutoVersionSubmodules( true );
985 releaseDescriptor.setBranchCreation( true );
986 releaseDescriptor.setInteractive( false );
987
988
989 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
990
991
992 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
993 releaseDescriptor.getDevelopmentVersions() );
994 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
995 }
996
997 public void testExecuteReleaseAutoVersionSubmodules_BranchCreation_NotInteractive_MapDevelopment()
998 throws Exception
999 {
1000
1001 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1002
1003 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1004
1005 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1006 releaseDescriptor.setAutoVersionSubmodules( true );
1007 releaseDescriptor.setBranchCreation( true );
1008 releaseDescriptor.setInteractive( false );
1009
1010
1011 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1012
1013
1014 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
1015 releaseDescriptor.getDevelopmentVersions() );
1016 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1017 }
1018
1019 public void testSimulateReleaseAutoVersionSubmodules_BranchCreation_NotInteractive_MapDevelopment()
1020 throws Exception
1021 {
1022
1023 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1024
1025 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1026
1027 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1028 releaseDescriptor.setAutoVersionSubmodules( true );
1029 releaseDescriptor.setBranchCreation( true );
1030 releaseDescriptor.setInteractive( false );
1031
1032
1033 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1034
1035
1036 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
1037 releaseDescriptor.getDevelopmentVersions() );
1038 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1039 }
1040
1041 public void testExecuteSnapshotAutoVersionSubmodules_BranchCreation_NotInteractive_MapBranch()
1042 throws Exception
1043 {
1044
1045 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1046
1047 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1048
1049 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1050 releaseDescriptor.setAutoVersionSubmodules( true );
1051 releaseDescriptor.setBranchCreation( true );
1052 releaseDescriptor.setInteractive( false );
1053
1054
1055 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1056
1057
1058 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
1059 releaseDescriptor.getReleaseVersions() );
1060 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1061 }
1062
1063 public void testSimulateSnapshotAutoVersionSubmodules_BranchCreation_NotInteractive_MapBranch()
1064 throws Exception
1065 {
1066
1067 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1068
1069 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1070
1071 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1072 releaseDescriptor.setAutoVersionSubmodules( true );
1073 releaseDescriptor.setBranchCreation( true );
1074 releaseDescriptor.setInteractive( false );
1075
1076
1077 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1078
1079
1080 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
1081 releaseDescriptor.getReleaseVersions() );
1082 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1083 }
1084
1085 public void testExecuteReleaseAutoVersionSubmodules_BranchCreation_NotInteractive_MapBranch()
1086 throws Exception
1087 {
1088
1089 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1090
1091 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1092
1093 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1094 releaseDescriptor.setAutoVersionSubmodules( true );
1095 releaseDescriptor.setBranchCreation( true );
1096 releaseDescriptor.setInteractive( false );
1097
1098
1099 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1100
1101
1102
1103
1104
1105
1106
1107 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
1108 releaseDescriptor.getReleaseVersions() );
1109 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1110 }
1111
1112 public void testSimulateReleaseAutoVersionSubmodules_BranchCreation_NotInteractive_MapBranch()
1113 throws Exception
1114 {
1115
1116 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1117
1118 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1119
1120 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1121 releaseDescriptor.setAutoVersionSubmodules( true );
1122 releaseDescriptor.setBranchCreation( true );
1123 releaseDescriptor.setInteractive( false );
1124
1125
1126 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1127
1128
1129
1130
1131
1132
1133
1134 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
1135 releaseDescriptor.getReleaseVersions() );
1136 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1137 }
1138
1139 public void testExecuteSnapshotBranchCreation_NonInteractive_UpdateBranchVersions_MapBranch()
1140 throws Exception
1141 {
1142
1143 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1144
1145 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1146
1147 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1148 releaseDescriptor.setBranchCreation( true );
1149 releaseDescriptor.setInteractive( false );
1150 releaseDescriptor.setUpdateBranchVersions( true );
1151
1152
1153 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1154
1155
1156
1157
1158
1159 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
1160 releaseDescriptor.getReleaseVersions() );
1161 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1162 }
1163
1164 public void testSimulateSnapshotBranchCreation_NonInteractive_UpdateBranchVersions_MapBranch()
1165 throws Exception
1166 {
1167
1168 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1169
1170 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1171
1172 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1173 releaseDescriptor.setBranchCreation( true );
1174 releaseDescriptor.setInteractive( false );
1175 releaseDescriptor.setUpdateBranchVersions( true );
1176
1177
1178 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1179
1180
1181
1182
1183
1184 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.3-SNAPSHOT" ),
1185 releaseDescriptor.getReleaseVersions() );
1186 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1187 }
1188
1189 public void testExecuteSnapshotBranchCreation_DefaultReleaseVersion_NonInteractive_UpdateBranchVersions_MapBranch()
1190 throws Exception
1191 {
1192
1193 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1194
1195 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1196
1197 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1198 releaseDescriptor.setBranchCreation( true );
1199 releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
1200 releaseDescriptor.setInteractive( false );
1201 releaseDescriptor.setUpdateBranchVersions( true );
1202
1203
1204 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1205
1206
1207 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
1208 releaseDescriptor.getReleaseVersions() );
1209 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1210 }
1211
1212 public void testSimulateSnapshotBranchCreation_DefaultReleaseVersion_NonInteractive_UpdateBranchVersions_MapBranch()
1213 throws Exception
1214 {
1215
1216 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1217
1218 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1219
1220 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1221 releaseDescriptor.setBranchCreation( true );
1222 releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
1223 releaseDescriptor.setInteractive( false );
1224 releaseDescriptor.setUpdateBranchVersions( true );
1225
1226
1227 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1228
1229
1230 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
1231 releaseDescriptor.getReleaseVersions() );
1232 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1233 }
1234
1235 public void testExecuteSnapshotBranchCreation_DefaultReleaseVersion_UpdateBranchVersions_MapBranch()
1236 throws Exception
1237 {
1238
1239 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1240
1241 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1242
1243 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1244 releaseDescriptor.setBranchCreation( true );
1245 releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
1246 releaseDescriptor.setUpdateBranchVersions( true );
1247
1248
1249 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1250
1251
1252 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
1253 releaseDescriptor.getReleaseVersions() );
1254 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1255 }
1256
1257 public void testSimulateSnapshotBranchCreation_DefaultReleaseVersion_UpdateBranchVersions_MapBranch()
1258 throws Exception
1259 {
1260
1261 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1262
1263 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1264
1265 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1266 releaseDescriptor.setBranchCreation( true );
1267 releaseDescriptor.setDefaultReleaseVersion( "2.1-SNAPSHOT" );
1268 releaseDescriptor.setUpdateBranchVersions( true );
1269
1270
1271 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1272
1273
1274 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
1275 releaseDescriptor.getReleaseVersions() );
1276 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1277 }
1278
1279 public void testExecuteSnapshotBranchCreation_UpdateBranchVersions_MapBranch()
1280 throws Exception
1281 {
1282
1283 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1284
1285 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1286
1287 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1288 releaseDescriptor.setBranchCreation( true );
1289 releaseDescriptor.setUpdateBranchVersions( true );
1290
1291
1292
1293
1294 when( mockPrompter.prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
1295 phase.setPrompter( mockPrompter );
1296
1297
1298 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1299
1300
1301
1302
1303 verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) );
1304 }
1305
1306 public void testSimulateSnapshotBranchCreation_UpdateBranchVersions_MapBranch()
1307 throws Exception
1308 {
1309
1310 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1311
1312 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1313
1314 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1315 releaseDescriptor.setBranchCreation( true );
1316 releaseDescriptor.setUpdateBranchVersions( true );
1317
1318
1319
1320
1321 when( mockPrompter.prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
1322 phase.setPrompter( mockPrompter );
1323
1324
1325 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1326
1327
1328
1329
1330 verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) );
1331 }
1332
1333 public void testExecuteReleaseBranchCreation_UpdateBranchVersions_UpdateVersionsToSnapshot_MapBranch()
1334 throws Exception
1335 {
1336
1337 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1338
1339 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1340
1341 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1342 releaseDescriptor.setBranchCreation( true );
1343 releaseDescriptor.setUpdateBranchVersions( true );
1344 releaseDescriptor.setUpdateVersionsToSnapshot( true );
1345
1346
1347
1348
1349 when( mockPrompter.prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.1-SNAPSHOT" );
1350 phase.setPrompter( mockPrompter );
1351
1352
1353 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1354
1355
1356
1357
1358 verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) );
1359 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
1360 releaseDescriptor.getReleaseVersions() );
1361 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1362 }
1363
1364 public void testSimulateReleaseBranchCreation_UpdateBranchVersions_UpdateVersionsToSnapshot_MapBranch()
1365 throws Exception
1366 {
1367
1368 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1369
1370 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1371
1372 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1373 releaseDescriptor.setBranchCreation( true );
1374 releaseDescriptor.setUpdateBranchVersions( true );
1375 releaseDescriptor.setUpdateVersionsToSnapshot( true );
1376
1377
1378
1379
1380 when( mockPrompter.prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.1-SNAPSHOT" );
1381 phase.setPrompter( mockPrompter );
1382
1383
1384 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1385
1386
1387
1388
1389 verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) );
1390 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "2.1-SNAPSHOT" ),
1391 releaseDescriptor.getReleaseVersions() );
1392 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1393 }
1394
1395 public void testExecuteSnapshotBranchCreation_UpdateBranchVersions_UpdateVersionsToSnapshot_MapBranch()
1396 throws Exception
1397 {
1398
1399 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1400
1401 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1402
1403 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1404 releaseDescriptor.setBranchCreation( true );
1405 releaseDescriptor.setUpdateBranchVersions( true );
1406 releaseDescriptor.setUpdateVersionsToSnapshot( true );
1407
1408
1409
1410
1411 when( mockPrompter.prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
1412 phase.setPrompter( mockPrompter );
1413
1414
1415 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1416
1417
1418
1419
1420 verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) );
1421 }
1422
1423 public void testSimulateSnapshotBranchCreation_UpdateBranchVersions_UpdateVersionsToSnapshot_MapBranch()
1424 throws Exception
1425 {
1426
1427 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1428
1429 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1430
1431 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1432 releaseDescriptor.setBranchCreation( true );
1433 releaseDescriptor.setUpdateBranchVersions( true );
1434 releaseDescriptor.setUpdateVersionsToSnapshot( true );
1435
1436
1437
1438
1439 when( mockPrompter.prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
1440 phase.setPrompter( mockPrompter );
1441
1442
1443 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1444
1445
1446
1447
1448 verify( mockPrompter ).prompt( startsWith( "What is the branch version for" ), eq( "1.3-SNAPSHOT" ) );
1449 }
1450
1451 public void testExecuteReleaseBranchCreation_MapBranch()
1452 throws Exception
1453 {
1454
1455 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1456
1457 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1458
1459 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1460 releaseDescriptor.setBranchCreation( true );
1461
1462
1463 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1464
1465
1466
1467
1468
1469
1470
1471 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
1472 releaseDescriptor.getReleaseVersions() );
1473 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1474 }
1475
1476 public void testSimulateReleaseBranchCreation_MapBranch()
1477 throws Exception
1478 {
1479
1480 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1481
1482 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1483
1484 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1485 releaseDescriptor.setBranchCreation( true );
1486
1487
1488 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1489
1490
1491
1492
1493
1494
1495
1496 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
1497 releaseDescriptor.getReleaseVersions() );
1498 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1499 }
1500
1501 public void testExecuteReleaseBranchCreation_NonUpdateWorkingCopyVersions_MapDevelopment()
1502 throws Exception
1503 {
1504
1505 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1506
1507 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1508
1509 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1510 releaseDescriptor.setBranchCreation( true );
1511 releaseDescriptor.setUpdateWorkingCopyVersions( false );
1512
1513
1514 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1515
1516
1517 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1518 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), releaseDescriptor.getDevelopmentVersions() );
1519 }
1520
1521 public void testSimulateReleaseBranchCreation_NonUpdateWorkingCopyVersions_MapDevelopment()
1522 throws Exception
1523 {
1524
1525 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1526
1527 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1528
1529 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1530 releaseDescriptor.setBranchCreation( true );
1531 releaseDescriptor.setUpdateWorkingCopyVersions( false );
1532
1533
1534 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1535
1536
1537 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1538 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), releaseDescriptor.getDevelopmentVersions() );
1539 }
1540
1541 public void testExecuteReleaseBranchCreation_MapDevelopment()
1542 throws Exception
1543 {
1544
1545 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1546
1547 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1548
1549 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1550 releaseDescriptor.setBranchCreation( true );
1551
1552
1553 releaseDescriptor.setInteractive( false );
1554 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1555
1556
1557
1558 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1559 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), releaseDescriptor.getDevelopmentVersions() );
1560 }
1561
1562 public void testSimulateReleaseBranchCreation_MapDevelopment()
1563 throws Exception
1564 {
1565
1566 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1567
1568 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1569
1570 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1571 releaseDescriptor.setBranchCreation( true );
1572
1573
1574 releaseDescriptor.setInteractive( false );
1575
1576
1577 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1578
1579
1580 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1581 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2" ), releaseDescriptor.getDevelopmentVersions() );
1582 }
1583
1584 public void testExecuteSnapshotBranchCreation_MapBranch()
1585 throws Exception
1586 {
1587
1588 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1589
1590 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1591
1592 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1593 releaseDescriptor.setBranchCreation( true );
1594
1595
1596 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1597
1598
1599 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
1600 releaseDescriptor.getReleaseVersions() );
1601 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1602 }
1603
1604 public void testSimulateSnapshotBranchCreation_MapBranch()
1605 throws Exception
1606 {
1607
1608 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1609
1610 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1611
1612 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1613 releaseDescriptor.setBranchCreation( true );
1614
1615
1616 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1617
1618
1619 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ),
1620 releaseDescriptor.getReleaseVersions() );
1621 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1622 }
1623
1624 public void testExecuteSnapshotBranchCreation_NonUpdateWorkingCopyVersions_MapDevelopment()
1625 throws Exception
1626 {
1627
1628 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1629
1630 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1631
1632 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1633 releaseDescriptor.setBranchCreation( true );
1634 releaseDescriptor.setUpdateWorkingCopyVersions( false );
1635
1636
1637 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1638
1639
1640 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1641 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ), releaseDescriptor.getDevelopmentVersions() );
1642 }
1643
1644 public void testSimulateSnapshotBranchCreation_NonUpdateWorkingCopyVersions_MapDevelopment()
1645 throws Exception
1646 {
1647
1648 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1649
1650 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1651
1652 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1653 releaseDescriptor.setBranchCreation( true );
1654 releaseDescriptor.setUpdateWorkingCopyVersions( false );
1655
1656
1657 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1658
1659
1660 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1661 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "1.2-SNAPSHOT" ), releaseDescriptor.getDevelopmentVersions() );
1662 }
1663
1664 public void testExecuteReleaseBranchCreation_UpdateBranchVersions_MapBranch()
1665 throws Exception
1666 {
1667
1668 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1669
1670 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1671
1672 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1673 releaseDescriptor.setBranchCreation( true );
1674 releaseDescriptor.setUpdateBranchVersions( true );
1675
1676
1677 releaseDescriptor.setInteractive( false );
1678
1679
1680 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1681
1682
1683 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
1684 releaseDescriptor.getReleaseVersions() );
1685 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1686 }
1687
1688 public void testSimulateReleaseBranchCreation_UpdateBranchVersions_MapBranch()
1689 throws Exception
1690 {
1691
1692 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_BRANCH_VERSIONS );
1693
1694 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2" ) );
1695
1696 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1697 releaseDescriptor.setBranchCreation( true );
1698 releaseDescriptor.setUpdateBranchVersions( true );
1699
1700
1701 releaseDescriptor.setInteractive( false );
1702
1703
1704 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1705
1706
1707 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "1.2" ),
1708 releaseDescriptor.getReleaseVersions() );
1709 assertNull( "Check development versions", releaseDescriptor.getDevelopmentVersions().get( "groupId:artifactId" ) );
1710 }
1711
1712 public void testExecuteSnapshotBranchCreation_UpdateWorkingCopyVersions_MapDevelopment()
1713 throws Exception
1714 {
1715
1716 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1717
1718 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1719
1720 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1721 releaseDescriptor.setBranchCreation( true );
1722 releaseDescriptor.setUpdateWorkingCopyVersions( true );
1723
1724 when( mockPrompter.prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
1725 phase.setPrompter( mockPrompter );
1726
1727
1728 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1729
1730
1731 verify( mockPrompter ).prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) );
1732 }
1733
1734 public void testSimulateSnapshotBranchCreation_UpdateWorkingCopyVersions_MapDevelopment()
1735 throws Exception
1736 {
1737
1738 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1739
1740 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "artifactId", "1.2-SNAPSHOT" ) );
1741
1742 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1743 releaseDescriptor.setBranchCreation( true );
1744 releaseDescriptor.setUpdateWorkingCopyVersions( true );
1745
1746 when( mockPrompter.prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) ) ).thenReturn( "2.0-SNAPSHOT" );
1747 phase.setPrompter( mockPrompter );
1748
1749
1750 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1751
1752
1753 verify( mockPrompter ).prompt( startsWith( "What is the new working copy version for" ), eq( "1.3-SNAPSHOT" ) );
1754 }
1755
1756 public void testExecuteMultiModuleAutoVersionSubmodules__MapDevelopment()
1757 throws Exception
1758 {
1759
1760 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1761
1762 List<MavenProject> reactorProjects = new ArrayList<MavenProject>();
1763 Collections.addAll( reactorProjects, createProject( "artifactId", "1.2-SNAPSHOT" ),
1764 createProject( "module1", "2.0" ) );
1765
1766 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1767 releaseDescriptor.setAutoVersionSubmodules( true );
1768 releaseDescriptor.setInteractive( false );
1769
1770
1771 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1772
1773
1774 Map<String, String> developmentVersions = new HashMap<String, String>();
1775 developmentVersions.put( "groupId:artifactId", "1.3-SNAPSHOT" );
1776 developmentVersions.put( "groupId:module1", "2.0" );
1777 assertEquals( "Check development versions", developmentVersions, releaseDescriptor.getDevelopmentVersions() );
1778 assertEquals( "Check release versions", 0, releaseDescriptor.getReleaseVersions().size() );
1779 }
1780
1781 public void testSimulateMultiModuleAutoVersionSubmodules__MapDevelopment()
1782 throws Exception
1783 {
1784
1785 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1786
1787 List<MavenProject> reactorProjects = new ArrayList<MavenProject>();
1788 Collections.addAll( reactorProjects, createProject( "artifactId", "1.2-SNAPSHOT" ),
1789 createProject( "module1", "2.0" ) );
1790
1791 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1792 releaseDescriptor.setAutoVersionSubmodules( true );
1793 releaseDescriptor.setInteractive( false );
1794
1795
1796 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1797
1798
1799 Map<String, String> developmentVersions = new HashMap<String, String>();
1800 developmentVersions.put( "groupId:artifactId", "1.3-SNAPSHOT" );
1801 developmentVersions.put( "groupId:module1", "2.0" );
1802 assertEquals( "Check development versions", developmentVersions, releaseDescriptor.getDevelopmentVersions() );
1803 assertEquals( "Check release versions", 0, releaseDescriptor.getReleaseVersions().size() );
1804 }
1805
1806 public void testExecuteSnapshotAutoVersionSubmodules_DefaultReleaseVersion_NonInteractive_MapDevelopment()
1807 throws Exception
1808 {
1809
1810 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1811
1812 List<MavenProject> reactorProjects =
1813 Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
1814
1815 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1816 releaseDescriptor.setAutoVersionSubmodules( true );
1817 releaseDescriptor.setDefaultReleaseVersion( "3.0" );
1818 releaseDescriptor.setInteractive( false );
1819
1820
1821 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1822
1823
1824 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.1-SNAPSHOT" ),
1825 releaseDescriptor.getDevelopmentVersions() );
1826 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1827 }
1828
1829 public void testSimulateSnapshotAutoVersionSubmodules_DefaultReleaseVersion_NonInteractive_MapDevelopment()
1830 throws Exception
1831 {
1832
1833 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1834
1835 List<MavenProject> reactorProjects =
1836 Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
1837
1838 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1839 releaseDescriptor.setAutoVersionSubmodules( true );
1840 releaseDescriptor.setDefaultReleaseVersion( "3.0" );
1841 releaseDescriptor.setInteractive( false );
1842
1843
1844 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1845
1846
1847 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.1-SNAPSHOT" ),
1848 releaseDescriptor.getDevelopmentVersions() );
1849 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1850 }
1851
1852 public void testExecuteSnapshotAutoVersionSubmodules_DefaultDevelopmentVersion_NonInteractive_MapDevelopment()
1853 throws Exception
1854 {
1855
1856 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1857
1858 List<MavenProject> reactorProjects =
1859 Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
1860
1861 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1862 releaseDescriptor.setAutoVersionSubmodules( true );
1863 releaseDescriptor.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
1864 releaseDescriptor.setInteractive( false );
1865
1866
1867 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1868
1869
1870 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.0-SNAPSHOT" ),
1871 releaseDescriptor.getDevelopmentVersions() );
1872 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1873 }
1874
1875 public void testSimulateSnapshotAutoVersionSubmodules_DefaultDevelopmentVersion_NonInteractive_MapDevelopment()
1876 throws Exception
1877 {
1878
1879 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1880
1881 List<MavenProject> reactorProjects =
1882 Collections.singletonList( createProject( "artifactId", "1.2.1-SNAPSHOT" ) );
1883
1884 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1885 releaseDescriptor.setAutoVersionSubmodules( true );
1886 releaseDescriptor.setDefaultDevelopmentVersion( "3.0-SNAPSHOT" );
1887 releaseDescriptor.setInteractive( false );
1888
1889
1890 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1891
1892
1893 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "3.0-SNAPSHOT" ),
1894 releaseDescriptor.getDevelopmentVersions() );
1895 assertNull( "Check release versions", releaseDescriptor.getReleaseVersions().get( "groupId:artifactId" ) );
1896 }
1897
1898
1899 public void testUnusualVersions1() throws Exception
1900 {
1901 MapVersionsPhase mapReleasephase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
1902 MapVersionsPhase mapDevelopmentphase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1903
1904 List<MavenProject> reactorProjects =
1905 Collections.singletonList( createProject( "artifactId", "MYB_200909-SNAPSHOT" ) );
1906
1907 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1908 releaseDescriptor.setDefaultReleaseVersion( "PPX" );
1909 releaseDescriptor.setDefaultDevelopmentVersion( "MYB_200909-SNAPSHOT" );
1910
1911
1912 mapReleasephase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1913 mapDevelopmentphase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1914
1915
1916 assertEquals( "Check development versions", Collections.singletonMap( "groupId:artifactId", "MYB_200909-SNAPSHOT" ),
1917 releaseDescriptor.getDevelopmentVersions() );
1918 assertEquals( "Check release versions", Collections.singletonMap( "groupId:artifactId", "PPX" ),
1919 releaseDescriptor.getReleaseVersions() );
1920 }
1921
1922
1923 public void testContinuousSnapshotCheck() throws Exception
1924 {
1925
1926 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1927
1928 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
1929
1930 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1931
1932 when( mockPrompter.prompt( startsWith( "What is the new development version for " ), eq( "1.12-SNAPSHOT" ) ) )
1933 .thenReturn( "2.0" )
1934 .thenReturn( "2.0-SNAPSHOT" );
1935 phase.setPrompter( mockPrompter );
1936
1937
1938 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1939
1940
1941 verify( mockPrompter, times( 2 ) ).prompt( startsWith( "What is the new development version for " ), eq( "1.12-SNAPSHOT" ) );
1942 }
1943
1944
1945 public void testEmptyDefaultDevelopmentVersion() throws Exception
1946 {
1947
1948 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_DEVELOPMENT_VERSIONS );
1949
1950 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
1951
1952 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1953 releaseDescriptor.setDefaultDevelopmentVersion( "" );
1954
1955 when( mockPrompter.prompt( startsWith( "What is the new development version for " ), eq( "1.12-SNAPSHOT" ) ) )
1956 .thenReturn( "2.0-SNAPSHOT" );
1957 phase.setPrompter( mockPrompter );
1958
1959
1960 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1961
1962
1963 verify( mockPrompter ).prompt( startsWith( "What is the new development version for " ), eq( "1.12-SNAPSHOT" ) );
1964 }
1965
1966 public void testEmptyDefaultReleaseVersion() throws Exception
1967 {
1968
1969 MapVersionsPhase phase = (MapVersionsPhase) lookup( ReleasePhase.ROLE, TEST_MAP_RELEASE_VERSIONS );
1970
1971 List<MavenProject> reactorProjects = Collections.singletonList( createProject( "bar", "1.11-SNAPSHOT" ) );
1972
1973 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1974 releaseDescriptor.setDefaultReleaseVersion( "" );
1975
1976 when( mockPrompter.prompt( startsWith( "What is the release version for " ), eq( "1.11" ) ) )
1977 .thenReturn( "2.0" );
1978 phase.setPrompter( mockPrompter );
1979
1980
1981 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1982
1983
1984 verify( mockPrompter ).prompt( startsWith( "What is the release version for " ), eq( "1.11" ) );
1985 }
1986
1987
1988 private static MavenProject createProject( String artifactId, String version )
1989 {
1990 Model model = new Model();
1991 model.setGroupId( "groupId" );
1992 model.setArtifactId( artifactId );
1993 model.setVersion( version );
1994 return new MavenProject( model );
1995 }
1996
1997 }