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 org.apache.maven.project.MavenProject;
23 import org.apache.maven.shared.release.ReleaseExecutionException;
24 import org.apache.maven.shared.release.ReleaseFailureException;
25 import org.apache.maven.shared.release.config.ReleaseDescriptor;
26 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
27 import org.codehaus.plexus.components.interactivity.Prompter;
28 import org.codehaus.plexus.components.interactivity.PrompterException;
29 import static org.mockito.Mockito.*;
30
31 import java.util.Arrays;
32 import java.util.Collections;
33 import java.util.List;
34 import java.util.Map;
35
36
37
38
39
40
41 public class CheckDependencySnapshotsPhaseTest
42 extends AbstractReleaseTestCase
43 {
44 private static final String NO = "no";
45
46 private static final String YES = "yes";
47
48 private static final List<String> YES_NO_ARRAY = Arrays.asList( YES, NO );
49
50 private static final String DEFAULT_CHOICE = "1";
51
52 private static final List<String> CHOICE_ARRAY = Arrays.asList( "0", DEFAULT_CHOICE, "2", "3" );
53
54 protected void setUp()
55 throws Exception
56 {
57 super.setUp();
58
59 phase = (ReleasePhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
60 }
61
62 public void testNoSnapshotDependencies()
63 throws Exception
64 {
65 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
66 List<MavenProject> reactorProjects = createDescriptorFromProjects( "no-snapshot-dependencies" );
67
68 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
69
70 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
71
72
73 assertTrue( true );
74 }
75
76 public void testNoSnapshotRangeDependencies()
77 throws Exception
78 {
79 CheckDependencySnapshotsPhase phase =
80 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
81
82 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
83 List<MavenProject> reactorProjects = createDescriptorFromProjects( "no-snapshot-range-dependencies" );
84
85 phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.1", "1.2-SNAPSHOT" ) ) );
86
87 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
88
89 phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.1", "1.2-SNAPSHOT" ) ) );
90
91 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
92
93
94 assertTrue( true );
95 }
96
97 public void testSnapshotDependenciesInProjectOnly()
98 throws Exception
99 {
100 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
101 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-snapshot-dependencies" );
102
103 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
104
105 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
106
107
108 assertTrue( true );
109 }
110
111 public void testSnapshotReleasePluginNonInteractive()
112 throws Exception
113 {
114 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
115 List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
116 releaseDescriptor.setInteractive( false );
117
118 try
119 {
120 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
121
122 fail( "Should have failed execution" );
123 }
124 catch ( ReleaseFailureException e )
125 {
126 assertTrue( true );
127 }
128
129 try
130 {
131 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
132
133 fail( "Should have failed execution" );
134 }
135 catch ( ReleaseFailureException e )
136 {
137 assertTrue( true );
138 }
139 }
140
141 public void testSnapshotReleasePluginInteractiveDeclined()
142 throws Exception
143 {
144 CheckDependencySnapshotsPhase phase =
145 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
146
147 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
148 List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
149
150 phase.setPrompter( createMockPrompterWithSnapshotReleasePlugin( NO, NO ) );
151
152 try
153 {
154 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
155
156 fail( "Should have failed execution" );
157 }
158 catch ( ReleaseFailureException e )
159 {
160 assertTrue( true );
161 }
162
163 phase.setPrompter( createMockPrompterWithSnapshotReleasePlugin( NO, NO ) );
164
165 try
166 {
167 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
168
169 fail( "Should have failed execution" );
170 }
171 catch ( ReleaseFailureException e )
172 {
173 assertTrue( true );
174 }
175 }
176
177 public void testSnapshotReleasePluginInteractiveAcceptedForExecution()
178 throws Exception
179 {
180 CheckDependencySnapshotsPhase phase =
181 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
182
183 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
184 List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
185
186 phase.setPrompter( createYesMockPrompter() );
187
188 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
189
190 assertTrue( true );
191 }
192
193 public void testSnapshotReleasePluginInteractiveAcceptedForSimulation()
194 throws Exception
195 {
196 CheckDependencySnapshotsPhase phase =
197 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
198
199 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
200 List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
201
202 phase.setPrompter( createYesMockPrompter() );
203
204 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
205
206 assertTrue( true );
207 }
208
209 public void testSnapshotReleasePluginInteractiveInvalid()
210 throws Exception
211 {
212 CheckDependencySnapshotsPhase phase =
213 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
214
215 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
216 List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
217
218 phase.setPrompter( createMockPrompterWithSnapshotReleasePlugin( "donkey", NO ) );
219
220 try
221 {
222 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
223
224 fail( "Should have failed execution" );
225 }
226 catch ( ReleaseFailureException e )
227 {
228 assertTrue( true );
229 }
230
231 phase.setPrompter( createMockPrompterWithSnapshotReleasePlugin( "donkey", NO ) );
232
233 try
234 {
235 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
236
237 fail( "Should have failed execution" );
238 }
239 catch ( ReleaseFailureException e )
240 {
241 assertTrue( true );
242 }
243 }
244
245 public void testSnapshotReleasePluginInteractiveException()
246 throws Exception
247 {
248 CheckDependencySnapshotsPhase phase =
249 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
250
251 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
252 List<MavenProject> reactorProjects = createDescriptorFromProjects( "snapshot-release-plugin" );
253
254 Prompter mockPrompter = mock( Prompter.class );
255 when( mockPrompter.prompt( anyString(), eq( YES_NO_ARRAY ), eq( NO ) ) ).thenThrow( new PrompterException(
256 "..." ) );
257 phase.setPrompter( mockPrompter );
258
259 try
260 {
261 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
262
263 fail( "Should have failed execution" );
264 }
265 catch ( ReleaseExecutionException e )
266 {
267 assertEquals( "Check cause", PrompterException.class, e.getCause().getClass() );
268 }
269
270 mockPrompter = mock( Prompter.class );
271 when( mockPrompter.prompt( anyString(), eq( YES_NO_ARRAY ), eq( NO ) ) ).thenThrow( new PrompterException(
272 "..." ) );
273
274 try
275 {
276 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
277
278 fail( "Should have failed execution" );
279 }
280 catch ( ReleaseExecutionException e )
281 {
282 assertEquals( "Check cause", PrompterException.class, e.getCause().getClass() );
283 }
284 }
285
286 public void testSnapshotDependenciesInProjectOnlyMismatchedVersion()
287 throws Exception
288 {
289 CheckDependencySnapshotsPhase phase =
290 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
291
292 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
293 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-differing-snapshot-dependencies" );
294
295 phase.setPrompter( createNoMockPrompter() );
296
297 try
298 {
299 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
300
301 fail( "Should have failed execution" );
302 }
303 catch ( ReleaseFailureException e )
304 {
305 assertTrue( true );
306 }
307
308 phase.setPrompter( createNoMockPrompter() );
309
310 try
311 {
312 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
313
314 fail( "Should have failed execution" );
315 }
316 catch ( ReleaseFailureException e )
317 {
318 assertTrue( true );
319 }
320 }
321
322 public void testSnapshotManagedDependenciesInProjectOnly()
323 throws Exception
324 {
325 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
326 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-managed-snapshot-dependency" );
327
328 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
329
330 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
331
332
333 assertTrue( true );
334 }
335
336 public void testSnapshotUnusedInternalManagedDependency()
337 throws Exception
338 {
339 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
340 List<MavenProject> reactorProjects = createDescriptorFromProjects( "unused-internal-managed-snapshot-dependency" );
341
342 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
343
344 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
345
346
347 assertTrue( true );
348 }
349
350 public void testSnapshotUnusedExternalManagedDependency()
351 throws Exception
352 {
353 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
354 List<MavenProject> reactorProjects = createDescriptorFromProjects( "unused-external-managed-snapshot-dependency" );
355
356 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
357
358 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
359
360
361 assertTrue( true );
362 }
363
364 public void testSnapshotExternalManagedDependency()
365 throws Exception
366 {
367 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
368 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-managed-snapshot-dependency" );
369
370 releaseDescriptor.setInteractive( false );
371
372 try
373 {
374 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
375
376 fail( "Should have failed execution" );
377 }
378 catch ( ReleaseFailureException e )
379 {
380 assertTrue( true );
381 }
382
383 try
384 {
385 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
386
387 fail( "Should have failed execution" );
388 }
389 catch ( ReleaseFailureException e )
390 {
391 assertTrue( true );
392 }
393 }
394
395 public void testSnapshotDependenciesOutsideProjectOnlyNonInteractive()
396 throws Exception
397 {
398 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
399 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
400
401 releaseDescriptor.setInteractive( false );
402
403 try
404 {
405 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
406
407 fail( "Should have failed execution" );
408 }
409 catch ( ReleaseFailureException e )
410 {
411 assertTrue( true );
412 }
413
414 try
415 {
416 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
417
418 fail( "Should have failed execution" );
419 }
420 catch ( ReleaseFailureException e )
421 {
422 assertTrue( true );
423 }
424 }
425
426 public void testRangeSnapshotDependenciesOutsideProjectOnlyNonInteractive()
427 throws Exception
428 {
429 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
430 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-range-snapshot-dependencies" );
431
432 releaseDescriptor.setInteractive( false );
433
434 try
435 {
436 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
437
438 fail( "Should have failed execution" );
439 }
440 catch ( ReleaseFailureException e )
441 {
442 assertTrue( true );
443 }
444
445 try
446 {
447 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
448
449 fail( "Should have failed execution" );
450 }
451 catch ( ReleaseFailureException e )
452 {
453 assertTrue( true );
454 }
455 }
456
457 public void testSnapshotDependenciesOutsideProjectOnlyInteractiveWithSnapshotsResolved()
458 throws Exception
459 {
460 CheckDependencySnapshotsPhase phase =
461 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
462
463 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
464 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
465
466 phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.1-SNAPSHOT" ),
467 new VersionPair( "1.0", "1.0" ) ) );
468
469 try
470 {
471 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
472 }
473 catch ( ReleaseFailureException e )
474 {
475 fail( e.getMessage() );
476 }
477
478
479 @SuppressWarnings("rawtypes")
480 Map versionsMap = (Map) releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
481
482 assertNotNull( versionsMap );
483 assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
484 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
485
486 releaseDescriptor = new ReleaseDescriptor();
487
488 phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.1-SNAPSHOT" ) ) );
489
490 try
491 {
492 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
493 }
494 catch ( ReleaseFailureException e )
495 {
496 fail( e.getMessage() );
497 }
498 }
499
500 public void testSnapshotDependenciesSelectOlderRelease()
501 throws Exception
502 {
503 CheckDependencySnapshotsPhase phase =
504 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
505
506 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
507 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
508
509 phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "0.9", "1.0-SNAPSHOT" ),
510 new VersionPair( "1.0", "1.0-SNAPSHOT" ) ) );
511
512 try
513 {
514 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
515 }
516 catch ( ReleaseFailureException e )
517 {
518 fail( e.getMessage() );
519 }
520
521
522 @SuppressWarnings("rawtypes")
523 Map versionsMap = (Map) releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
524
525 assertNotNull( versionsMap );
526 assertEquals( "1.0-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
527 assertEquals( "0.9", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
528 }
529
530 public void testSnapshotDependenciesSelectDefaults()
531 throws Exception
532 {
533 CheckDependencySnapshotsPhase phase =
534 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
535
536 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
537 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
538
539 phase.setPrompter( createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0", "1.0" ) ) );
540
541 try
542 {
543 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
544 }
545 catch ( ReleaseFailureException e )
546 {
547 fail( e.getMessage() );
548 }
549
550
551 @SuppressWarnings("rawtypes")
552 Map versionsMap = (Map) releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
553
554 assertNotNull( versionsMap );
555 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
556 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
557 }
558
559 public void testSnapshotDependenciesUpdateAllOnlyDependenciesNeeded()
560 throws Exception
561 {
562 CheckDependencySnapshotsPhase phase =
563 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
564
565 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
566 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-dependencies" );
567
568 phase.setPrompter( createMockPrompter( YES, "0", new VersionPair( "1.0", "1.0" ) ) );
569
570 try
571 {
572 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
573 }
574 catch ( ReleaseFailureException e )
575 {
576 fail( e.getMessage() );
577 }
578
579
580 @SuppressWarnings("rawtypes")
581 Map versionsMap = (Map) releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
582
583 assertNotNull( versionsMap );
584 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
585 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
586 }
587
588
589 public void testSnapshotDependenciesUpdateAll()
590 throws Exception
591 {
592 CheckDependencySnapshotsPhase phase =
593 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
594
595 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
596 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-all" );
597
598 Prompter mockPrompter = createMockPrompter( YES, "0", Arrays.asList( new VersionPair( "1.0", "1.0" ),
599 new VersionPair( "1.1", "1.1" ),
600 new VersionPair( "1.2", "1.2" ),
601 new VersionPair( "1.3", "1.3" ) ) );
602 phase.setPrompter( mockPrompter );
603
604 try
605 {
606 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
607 }
608 catch ( ReleaseFailureException e )
609 {
610 fail( e.getMessage() );
611 }
612
613
614 @SuppressWarnings("rawtypes")
615 Map versionsMap = (Map) releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
616
617 assertNotNull( versionsMap );
618 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
619 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
620 }
621
622
623 public void testSnapshotDependenciesOutsideMultimoduleProjectOnlyInteractiveWithSnapshotsResolved()
624 throws Exception
625 {
626 CheckDependencySnapshotsPhase phase =
627 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
628
629 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
630 List<MavenProject> reactorProjects = createDescriptorFromProjects( "multimodule-external-snapshot-dependencies" );
631
632 VersionPair pair = new VersionPair( "1.0", "1.1-SNAPSHOT" );
633 VersionPair defaultPair = new VersionPair( "1.0", "1.0" );
634 Prompter mockPrompter = createMockPrompter( "yes", "1", Arrays.asList( pair, pair ), Arrays.asList( defaultPair,
635 defaultPair ) );
636 phase.setPrompter( mockPrompter );
637
638 try
639 {
640 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
641 }
642 catch ( ReleaseFailureException e )
643 {
644 fail( e.getMessage() );
645 }
646
647 @SuppressWarnings("rawtypes")
648 Map resolvedDependencies = releaseDescriptor.getResolvedSnapshotDependencies();
649
650 assertNotNull( resolvedDependencies );
651 assertEquals( 2, resolvedDependencies.size() );
652
653 assertTrue( resolvedDependencies.containsKey( "external:artifactId" ) );
654 assertTrue( resolvedDependencies.containsKey( "external:artifactId2") );
655
656 @SuppressWarnings("rawtypes")
657 Map versionsMap = (Map) releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId" );
658
659 assertNotNull( versionsMap );
660 assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
661 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
662
663 versionsMap = (Map) releaseDescriptor.getResolvedSnapshotDependencies().get( "external:artifactId2" );
664
665 assertNotNull( versionsMap );
666 assertEquals( "1.1-SNAPSHOT", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
667 assertEquals( "1.0", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
668 }
669
670 public void testSnapshotDependenciesInsideAndOutsideProject()
671 throws Exception
672 {
673 CheckDependencySnapshotsPhase phase =
674 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
675
676 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
677 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-and-external-snapshot-dependencies" );
678
679 phase.setPrompter( createNoMockPrompter() );
680
681 try
682 {
683 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
684
685 fail( "Should have failed execution" );
686 }
687 catch ( ReleaseFailureException e )
688 {
689 assertTrue( true );
690 }
691
692 phase.setPrompter( createNoMockPrompter() );
693
694 try
695 {
696 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
697
698 fail( "Should have failed execution" );
699 }
700 catch ( ReleaseFailureException e )
701 {
702 assertTrue( true );
703 }
704 }
705
706 public void testNoSnapshotReportPlugins()
707 throws Exception
708 {
709 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
710 List<MavenProject> reactorProjects = createDescriptorFromProjects( "no-snapshot-report-plugins" );
711
712 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
713
714 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
715
716
717 assertTrue( true );
718 }
719
720 public void testSnapshotReportPluginsInProjectOnly()
721 throws Exception
722 {
723 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
724 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-snapshot-report-plugins" );
725
726 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
727
728 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
729
730
731 assertTrue( true );
732 }
733
734 public void testSnapshotReportPluginsOutsideProjectOnly()
735 throws Exception
736 {
737 CheckDependencySnapshotsPhase phase =
738 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
739
740 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
741 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-report-plugins" );
742
743 phase.setPrompter( createNoMockPrompter() );
744
745 try
746 {
747 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
748
749 fail( "Should have failed execution" );
750 }
751 catch ( ReleaseFailureException e )
752 {
753 assertTrue( true );
754 }
755
756 phase.setPrompter( createNoMockPrompter() );
757
758 try
759 {
760 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
761
762 fail( "Should have failed execution" );
763 }
764 catch ( ReleaseFailureException e )
765 {
766 assertTrue( true );
767 }
768 }
769
770 public void testSnapshotReportPluginsInsideAndOutsideProject()
771 throws Exception
772 {
773 CheckDependencySnapshotsPhase phase =
774 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
775
776 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
777 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-and-external-snapshot-report-plugins" );
778
779 phase.setPrompter( createNoMockPrompter() );
780
781 try
782 {
783 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
784
785 fail( "Should have failed execution" );
786 }
787 catch ( ReleaseFailureException e )
788 {
789 assertTrue( true );
790 }
791
792 phase.setPrompter( createNoMockPrompter() );
793
794 try
795 {
796 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
797
798 fail( "Should have failed execution" );
799 }
800 catch ( ReleaseFailureException e )
801 {
802 assertTrue( true );
803 }
804 }
805
806 public void testNoSnapshotPlugins()
807 throws Exception
808 {
809 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
810 List<MavenProject> reactorProjects = createDescriptorFromProjects( "no-snapshot-plugins" );
811
812 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
813
814 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
815
816
817 assertTrue( true );
818 }
819
820 public void testSnapshotPluginsInProjectOnly()
821 throws Exception
822 {
823 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
824 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-snapshot-plugins" );
825
826 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
827
828 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
829
830
831 assertTrue( true );
832 }
833
834 public void testSnapshotManagedPluginInProjectOnly()
835 throws Exception
836 {
837 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
838 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-managed-snapshot-plugin" );
839
840 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
841
842 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
843
844
845 assertTrue( true );
846 }
847
848 public void testSnapshotUnusedInternalManagedPlugin()
849 throws Exception
850 {
851 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
852 List<MavenProject> reactorProjects = createDescriptorFromProjects( "unused-internal-managed-snapshot-plugin" );
853
854 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
855
856 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
857
858
859 assertTrue( true );
860 }
861
862 public void testSnapshotUnusedExternalManagedPlugin()
863 throws Exception
864 {
865 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
866 List<MavenProject> reactorProjects = createDescriptorFromProjects( "unused-external-managed-snapshot-plugin" );
867
868 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
869
870 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
871
872
873 assertTrue( true );
874 }
875
876 public void testSnapshotExternalManagedPlugin()
877 throws Exception
878 {
879 CheckDependencySnapshotsPhase phase =
880 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
881
882 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
883 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-managed-snapshot-plugin" );
884
885 phase.setPrompter( createNoMockPrompter() );
886
887 try
888 {
889 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
890
891 fail( "Should have failed execution" );
892 }
893 catch ( ReleaseFailureException e )
894 {
895 assertTrue( true );
896 }
897
898 phase.setPrompter( createNoMockPrompter() );
899
900 try
901 {
902 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
903
904 fail( "Should have failed execution" );
905 }
906 catch ( ReleaseFailureException e )
907 {
908 assertTrue( true );
909 }
910 }
911
912 public void testSnapshotPluginsOutsideProjectOnly()
913 throws Exception
914 {
915 CheckDependencySnapshotsPhase phase =
916 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
917
918 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
919 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-plugins" );
920
921 phase.setPrompter( createNoMockPrompter() );
922
923 try
924 {
925 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
926
927 fail( "Should have failed execution" );
928 }
929 catch ( ReleaseFailureException e )
930 {
931 assertTrue( true );
932 }
933
934 phase.setPrompter( createNoMockPrompter() );
935
936 try
937 {
938 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
939
940 fail( "Should have failed execution" );
941 }
942 catch ( ReleaseFailureException e )
943 {
944 assertTrue( true );
945 }
946 }
947
948 public void testSnapshotPluginsInsideAndOutsideProject()
949 throws Exception
950 {
951 CheckDependencySnapshotsPhase phase =
952 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
953
954 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
955 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-and-external-snapshot-plugins" );
956
957 phase.setPrompter( createNoMockPrompter() );
958
959 try
960 {
961 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
962
963 fail( "Should have failed execution" );
964 }
965 catch ( ReleaseFailureException e )
966 {
967 assertTrue( true );
968 }
969
970 phase.setPrompter( createNoMockPrompter() );
971
972 try
973 {
974 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
975
976 fail( "Should have failed execution" );
977 }
978 catch ( ReleaseFailureException e )
979 {
980 assertTrue( true );
981 }
982 }
983
984 public void testSnapshotExternalParent()
985 throws Exception
986 {
987 CheckDependencySnapshotsPhase phase =
988 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
989
990 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
991 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-parent/child" );
992
993 phase.setPrompter( createNoMockPrompter() );
994
995 try
996 {
997 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
998
999 fail( "Should have failed execution" );
1000 }
1001 catch ( ReleaseFailureException e )
1002 {
1003 assertTrue( true );
1004 }
1005
1006 phase.setPrompter( createNoMockPrompter() );
1007
1008 try
1009 {
1010 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1011
1012 fail( "Should have failed execution" );
1013 }
1014 catch ( ReleaseFailureException e )
1015 {
1016 assertTrue( true );
1017 }
1018 }
1019
1020 public void testSnapshotExternalParentAdjusted()
1021 throws Exception
1022 {
1023 CheckDependencySnapshotsPhase phase =
1024 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
1025
1026 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1027 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-parent/child" );
1028
1029 Prompter mockPrompter = createMockPrompter( YES, DEFAULT_CHOICE, new VersionPair( "1.0-test", "1.0-test" ),
1030 new VersionPair( "1.0", "1.0-test" ) );
1031 phase.setPrompter( mockPrompter );
1032
1033 try
1034 {
1035 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1036 }
1037 catch ( ReleaseFailureException e )
1038 {
1039 fail( e.getMessage() );
1040 }
1041
1042
1043 @SuppressWarnings("rawtypes")
1044 Map versionsMap = (Map) releaseDescriptor.getResolvedSnapshotDependencies().get( "groupId:parent-external" );
1045
1046 assertNotNull( versionsMap );
1047 assertEquals( "1.0-test", versionsMap.get( ReleaseDescriptor.DEVELOPMENT_KEY ) );
1048 assertEquals( "1.0-test", versionsMap.get( ReleaseDescriptor.RELEASE_KEY ) );
1049 }
1050
1051 public void testReleaseExternalParent()
1052 throws Exception
1053 {
1054 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1055 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-parent/child" );
1056
1057 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1058
1059 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1060
1061
1062 assertTrue( true );
1063 }
1064
1065 public void testSnapshotExternalExtension()
1066 throws Exception
1067 {
1068 CheckDependencySnapshotsPhase phase =
1069 (CheckDependencySnapshotsPhase) lookup( ReleasePhase.ROLE, "check-dependency-snapshots" );
1070
1071 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1072 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-snapshot-extension" );
1073
1074 phase.setPrompter( createNoMockPrompter() );
1075
1076 try
1077 {
1078 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1079
1080 fail( "Should have failed execution" );
1081 }
1082 catch ( ReleaseFailureException e )
1083 {
1084 assertTrue( true );
1085 }
1086
1087 phase.setPrompter( createNoMockPrompter() );
1088
1089 try
1090 {
1091 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1092
1093 fail( "Should have failed execution" );
1094 }
1095 catch ( ReleaseFailureException e )
1096 {
1097 assertTrue( true );
1098 }
1099 }
1100
1101 public void testSnapshotInternalExtension()
1102 throws Exception
1103 {
1104 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1105 List<MavenProject> reactorProjects = createDescriptorFromProjects( "internal-snapshot-extension" );
1106
1107 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1108
1109 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1110
1111
1112 assertTrue( true );
1113 }
1114
1115 public void testReleaseExternalExtension()
1116 throws Exception
1117 {
1118 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1119 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-extension" );
1120
1121 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1122
1123 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1124
1125
1126 assertTrue( true );
1127 }
1128
1129 public void testAllowTimestampedSnapshots()
1130 throws Exception
1131 {
1132 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
1133 List<MavenProject> reactorProjects = createDescriptorFromProjects( "external-timestamped-snapshot-dependencies" );
1134
1135 releaseDescriptor.setInteractive( false );
1136
1137
1138 try
1139 {
1140 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1141
1142 fail( "Should have failed execution" );
1143 }
1144 catch ( ReleaseFailureException e )
1145 {
1146 assertTrue( true );
1147 }
1148
1149
1150 releaseDescriptor.setAllowTimestampedSnapshots(true);
1151
1152 phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1153
1154 phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1155
1156
1157 assertTrue( true );
1158 }
1159
1160 private List<MavenProject> createDescriptorFromProjects( String path )
1161 throws Exception
1162 {
1163 return createReactorProjects( "check-dependencies/", path );
1164 }
1165
1166 private Prompter createNoMockPrompter()
1167 throws PrompterException
1168 {
1169 return createYesNoMockPrompter( false );
1170 }
1171
1172 private Prompter createYesMockPrompter()
1173 throws PrompterException
1174 {
1175 return createYesNoMockPrompter( true );
1176 }
1177
1178 private Prompter createYesNoMockPrompter( boolean yes )
1179 throws PrompterException
1180 {
1181 Prompter mockPrompter = mock( Prompter.class );
1182
1183 when( mockPrompter.prompt( anyString(), eq( YES_NO_ARRAY ), eq( NO ) ) ).thenReturn( yes ? YES : NO );
1184
1185 return mockPrompter;
1186 }
1187
1188 private Prompter createMockPrompterWithSnapshotReleasePlugin( String useSnapshotReleasePlugin,
1189 String resolveSnapshots )
1190 throws PrompterException
1191 {
1192 Prompter mockPrompter = mock( Prompter.class );
1193
1194 when( mockPrompter.prompt( anyString(), eq( YES_NO_ARRAY ), eq( NO ) ) ).thenReturn( useSnapshotReleasePlugin );
1195 when( mockPrompter.prompt( anyString(), eq( YES_NO_ARRAY ), eq( NO ) ) ).thenReturn( resolveSnapshots );
1196
1197 return mockPrompter;
1198 }
1199
1200 private Prompter createMockPrompter( String resolveSnapshots, String resolutionType, VersionPair resolvedVersions )
1201 throws PrompterException
1202 {
1203 return createMockPrompter( resolveSnapshots, resolutionType, resolvedVersions, resolvedVersions );
1204 }
1205
1206 private Prompter createMockPrompter( String resolveSnapshots, String resolutionType, VersionPair resolvedVersions,
1207 VersionPair defaultVersions )
1208 throws PrompterException
1209 {
1210 return createMockPrompter( resolveSnapshots, resolutionType, Collections.singletonList( resolvedVersions ),
1211 Collections.singletonList( defaultVersions ) );
1212 }
1213
1214 private Prompter createMockPrompter( String resolveSnapshots, String resolutionType,
1215 List<VersionPair> resolvedVersions )
1216 throws PrompterException
1217 {
1218 return createMockPrompter( resolveSnapshots, resolutionType, resolvedVersions, resolvedVersions );
1219 }
1220
1221 private Prompter createMockPrompter( String resolveSnapshots, String resolutionType,
1222 List<VersionPair> resolvedVersions, List<VersionPair> defaultVersions )
1223 throws PrompterException
1224 {
1225 Prompter mockPrompter = mock( Prompter.class );
1226
1227 when( mockPrompter.prompt( anyString(), eq( YES_NO_ARRAY ), eq( NO ) ) ).thenReturn( resolveSnapshots );
1228 when( mockPrompter.prompt( anyString(), eq( CHOICE_ARRAY ), eq( DEFAULT_CHOICE ) ) ).thenReturn(
1229 resolutionType );
1230
1231 for ( int i = 0; i < resolvedVersions.size(); i++ )
1232 {
1233 when( mockPrompter.prompt( "Which release version should it be set to?", defaultVersions.get(
1234 i ).releaseVersion ) ).thenReturn( resolvedVersions.get( i ).releaseVersion );
1235 when( mockPrompter.prompt( "What version should the dependency be reset to for development?",
1236 defaultVersions.get( i ).developmentVersion ) ).thenReturn( resolvedVersions.get(
1237 i ).developmentVersion );
1238 }
1239 return mockPrompter;
1240 }
1241
1242 private static class VersionPair
1243 {
1244 String releaseVersion;
1245
1246 String developmentVersion;
1247
1248 public VersionPair( String releaseVersion, String developmentVersion )
1249 {
1250 this.releaseVersion = releaseVersion;
1251 this.developmentVersion = developmentVersion;
1252 }
1253 }
1254 }