1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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
47
48
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
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
99 assertTrue(true);
100 }
101
102
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 }