View Javadoc

1   package org.apache.maven.shared.release.phase;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import 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   * Test the dependency snapshot check phase.
38   *
39   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
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          // successful execution is verification enough
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          // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // validate
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         // validate
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         // validate
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         // validate
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         // validate
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     // MRELEASE-589
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // validate
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // successful execution is verification enough
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         // confirm POM fails without allowTimestampedSnapshots
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         // check whether flag allows
1150         releaseDescriptor.setAllowTimestampedSnapshots(true);
1151 
1152         phase.execute( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1153 
1154         phase.simulate( releaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects );
1155 
1156         // successful execution is verification enough
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 }