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