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;
20
21 import java.io.File;
22 import java.io.IOException;
23 import java.util.Arrays;
24 import java.util.Collections;
25 import java.util.List;
26 import java.util.Properties;
27
28 import com.google.inject.AbstractModule;
29 import com.google.inject.Module;
30 import org.apache.maven.project.MavenProject;
31 import org.apache.maven.scm.CommandParameters;
32 import org.apache.maven.scm.ScmException;
33 import org.apache.maven.scm.ScmFileSet;
34 import org.apache.maven.scm.ScmTag;
35 import org.apache.maven.scm.command.checkout.CheckOutScmResult;
36 import org.apache.maven.scm.manager.ScmManager;
37 import org.apache.maven.scm.provider.ScmProvider;
38 import org.apache.maven.scm.provider.ScmProviderStub;
39 import org.apache.maven.scm.repository.ScmRepository;
40 import org.apache.maven.shared.release.config.ReleaseDescriptor;
41 import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
42 import org.apache.maven.shared.release.config.ReleaseDescriptorStore;
43 import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException;
44 import org.apache.maven.shared.release.config.ReleaseDescriptorStoreStub;
45 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
46 import org.apache.maven.shared.release.phase.ReleasePhase;
47 import org.apache.maven.shared.release.phase.ReleasePhaseStub;
48 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
49 import org.apache.maven.shared.release.stubs.ScmManagerStub;
50 import org.codehaus.plexus.util.FileUtils;
51 import org.junit.Ignore;
52 import org.junit.Test;
53
54 import static org.junit.Assert.assertEquals;
55 import static org.junit.Assert.assertFalse;
56 import static org.junit.Assert.assertNull;
57 import static org.junit.Assert.assertTrue;
58 import static org.junit.Assert.fail;
59 import static org.mockito.ArgumentMatchers.any;
60 import static org.mockito.ArgumentMatchers.anyString;
61 import static org.mockito.Mockito.doThrow;
62 import static org.mockito.Mockito.mock;
63 import static org.mockito.Mockito.times;
64 import static org.mockito.Mockito.verify;
65 import static org.mockito.Mockito.verifyNoMoreInteractions;
66 import static org.mockito.Mockito.when;
67
68
69
70
71
72
73 public class DefaultReleaseManagerTest extends PlexusJUnit4TestCase {
74 private ReleaseDescriptorStoreStub configStore;
75
76 @Override
77 public void setUp() throws Exception {
78 super.setUp();
79
80 configStore = (ReleaseDescriptorStoreStub) lookup(ReleaseDescriptorStore.class, "stub");
81 }
82
83 @Override
84 protected Module[] getCustomModules() {
85 return new Module[] {
86 new AbstractModule() {
87 @Override
88 protected void configure() {
89 bind(ScmManager.class).toInstance(new ScmManagerStub());
90 bind(ReleaseDescriptorStore.class).toInstance(new ReleaseDescriptorStoreStub());
91 }
92 }
93 };
94 }
95
96 @Test
97 public void testPrepareNoCompletedPhase() throws Exception {
98 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
99
100 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
101 builder.setCompletedPhase(null);
102
103 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
104 prepareRequest.setReleaseDescriptorBuilder(builder);
105 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
106 prepareRequest.setUserProperties(new Properties());
107
108 releaseManager.prepare(prepareRequest);
109
110 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
111 assertTrue("step1 executed", phase.isExecuted());
112 assertFalse("step1 not simulated", phase.isSimulated());
113 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
114 assertTrue("step2 executed", phase.isExecuted());
115 assertFalse("step2 not simulated", phase.isSimulated());
116 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
117 assertTrue("step3 executed", phase.isExecuted());
118 assertFalse("step3 not simulated", phase.isSimulated());
119 }
120
121 @Test
122 public void testPrepareCompletedPhase() throws Exception {
123 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
124
125 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
126 builder.setCompletedPhase("step1");
127
128 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
129 prepareRequest.setReleaseDescriptorBuilder(builder);
130 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
131 prepareRequest.setUserProperties(new Properties());
132
133 releaseManager.prepare(prepareRequest);
134
135 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
136 assertFalse("step1 not executed", phase.isExecuted());
137 assertFalse("step1 not simulated", phase.isSimulated());
138 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
139 assertTrue("step2 executed", phase.isExecuted());
140 assertFalse("step2 not simulated", phase.isSimulated());
141 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
142 assertTrue("step3 executed", phase.isExecuted());
143 assertFalse("step3 not simulated", phase.isSimulated());
144 }
145
146 @Test
147 public void testPrepareCompletedPhaseNoResume() throws Exception {
148 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
149
150 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
151 builder.setCompletedPhase("step1");
152
153 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
154 prepareRequest.setReleaseDescriptorBuilder(builder);
155 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
156 prepareRequest.setDryRun(false);
157 prepareRequest.setResume(false);
158 prepareRequest.setUserProperties(new Properties());
159
160 releaseManager.prepare(prepareRequest);
161
162 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
163 assertFalse("step1 executed", phase.isExecuted());
164 assertFalse("step1 not simulated", phase.isSimulated());
165 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
166 assertTrue("step2 executed", phase.isExecuted());
167 assertFalse("step2 not simulated", phase.isSimulated());
168 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
169 assertTrue("step3 executed", phase.isExecuted());
170 assertFalse("step3 not simulated", phase.isSimulated());
171 }
172
173 @Test
174 public void testPrepareCompletedAllPhases() throws Exception {
175 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
176
177 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
178 builder.setCompletedPhase("step3");
179
180 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
181 prepareRequest.setReleaseDescriptorBuilder(builder);
182 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
183 prepareRequest.setUserProperties(new Properties());
184
185 releaseManager.prepare(prepareRequest);
186
187 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
188 assertFalse("step1 not executed", phase.isExecuted());
189 assertFalse("step1 not simulated", phase.isSimulated());
190 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
191 assertFalse("step2 not executed", phase.isExecuted());
192 assertFalse("step2 not simulated", phase.isSimulated());
193 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
194 assertFalse("step3 not executed", phase.isExecuted());
195 assertFalse("step3 not simulated", phase.isSimulated());
196 }
197
198 @Test
199 public void testPrepareInvalidCompletedPhase() throws Exception {
200 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
201
202 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
203 builder.setCompletedPhase("foo");
204
205 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
206 prepareRequest.setReleaseDescriptorBuilder(builder);
207 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
208 prepareRequest.setUserProperties(new Properties());
209
210 releaseManager.prepare(prepareRequest);
211
212 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
213 assertTrue("step1 executed", phase.isExecuted());
214 assertFalse("step1 not simulated", phase.isSimulated());
215 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
216 assertTrue("step2 executed", phase.isExecuted());
217 assertFalse("step2 not simulated", phase.isSimulated());
218 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
219 assertTrue("step3 executed", phase.isExecuted());
220 assertFalse("step3 not simulated", phase.isSimulated());
221 }
222
223 @Test
224 public void testPrepareSimulateNoCompletedPhase() throws Exception {
225 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
226
227 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
228 builder.setCompletedPhase(null);
229
230 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
231 prepareRequest.setReleaseDescriptorBuilder(builder);
232 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
233 prepareRequest.setDryRun(true);
234 prepareRequest.setResume(true);
235 prepareRequest.setUserProperties(new Properties());
236
237 releaseManager.prepare(prepareRequest);
238
239 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
240 assertTrue("step1 simulated", phase.isSimulated());
241 assertFalse("step1 not executed", phase.isExecuted());
242 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
243 assertTrue("step2 simulated", phase.isSimulated());
244 assertFalse("step2 not executed", phase.isExecuted());
245 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
246 assertTrue("step3 simulated", phase.isSimulated());
247 assertFalse("step3 not executed", phase.isExecuted());
248 }
249
250 @Test
251 public void testPrepareSimulateCompletedPhase() throws Exception {
252 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
253
254 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
255 builder.setCompletedPhase("step1");
256
257 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
258 prepareRequest.setReleaseDescriptorBuilder(builder);
259 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
260 prepareRequest.setDryRun(true);
261 prepareRequest.setResume(true);
262 prepareRequest.setUserProperties(new Properties());
263
264 releaseManager.prepare(prepareRequest);
265
266 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
267 assertFalse("step1 not simulated", phase.isSimulated());
268 assertFalse("step1 not executed", phase.isExecuted());
269 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
270 assertTrue("step2 simulated", phase.isSimulated());
271 assertFalse("step2 not executed", phase.isExecuted());
272 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
273 assertTrue("step3 simulated", phase.isSimulated());
274 assertFalse("step3 not executed", phase.isExecuted());
275 }
276
277 @Test
278 public void testPrepareSimulateCompletedAllPhases() throws Exception {
279 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
280
281 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
282 builder.setCompletedPhase("step3");
283
284 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
285 prepareRequest.setReleaseDescriptorBuilder(builder);
286 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
287 prepareRequest.setDryRun(true);
288 prepareRequest.setResume(true);
289 prepareRequest.setUserProperties(new Properties());
290
291 releaseManager.prepare(prepareRequest);
292
293 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
294 assertFalse("step1 not simulated", phase.isSimulated());
295 assertFalse("step1 not executed", phase.isExecuted());
296 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
297 assertFalse("step2 not simulated", phase.isSimulated());
298 assertFalse("step2 not executed", phase.isExecuted());
299 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
300 assertFalse("step3 not simulated", phase.isSimulated());
301 assertFalse("step3 not executed", phase.isExecuted());
302 }
303
304 @Test
305 public void testPrepareSimulateInvalidCompletedPhase() throws Exception {
306 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
307
308 ReleaseDescriptorBuilder builder = configStore.getReleaseConfiguration();
309 builder.setCompletedPhase("foo");
310
311 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
312 prepareRequest.setReleaseDescriptorBuilder(builder);
313 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
314 prepareRequest.setDryRun(true);
315 prepareRequest.setResume(true);
316 prepareRequest.setUserProperties(new Properties());
317
318 releaseManager.prepare(prepareRequest);
319
320 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
321 assertTrue("step1 simulated", phase.isSimulated());
322 assertFalse("step1 not executed", phase.isExecuted());
323 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
324 assertTrue("step2 simulated", phase.isSimulated());
325 assertFalse("step2 not executed", phase.isExecuted());
326 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
327 assertTrue("step3 simulated", phase.isSimulated());
328 assertFalse("step3 not executed", phase.isExecuted());
329 }
330
331 @Ignore("This is testing messed up XML?")
332 @Test
333 public void testPrepareUnknownPhaseConfigured() throws Exception {
334 ReleaseManager releaseManager = lookup(ReleaseManager.class, "bad-phase-configured");
335
336 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
337 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
338 builder.setReleaseStrategyId("foo");
339 prepareRequest.setReleaseDescriptorBuilder(builder);
340 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
341 prepareRequest.setUserProperties(new Properties());
342
343 try {
344 releaseManager.prepare(prepareRequest);
345 fail("Should have failed to find a phase");
346 } catch (ReleaseExecutionException e) {
347
348 }
349 }
350
351 @Test
352 public void testReleaseConfigurationStoreReadFailure() throws Exception {
353
354 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
355 builder.setScmSourceUrl("scm-url");
356 builder.setWorkingDirectory(getTestFile("target/working-directory").getAbsolutePath());
357
358 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup(ReleaseManager.class, "test");
359
360 ReleaseDescriptorStore configStoreMock = mock(ReleaseDescriptorStore.class);
361 when(configStoreMock.read(builder))
362 .thenThrow(new ReleaseDescriptorStoreException("message", new IOException("ioExceptionMsg")));
363
364 releaseManager.setConfigStore(configStoreMock);
365
366 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
367 prepareRequest.setReleaseDescriptorBuilder(builder);
368 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
369 prepareRequest.setUserProperties(new Properties());
370
371
372 try {
373 releaseManager.prepare(prepareRequest);
374 fail("Should have failed to read configuration");
375 } catch (ReleaseExecutionException e) {
376
377 assertEquals(
378 "check cause",
379 ReleaseDescriptorStoreException.class,
380 e.getCause().getClass());
381 }
382
383
384 verify(configStoreMock).read(builder);
385 verifyNoMoreInteractions(configStoreMock);
386 }
387
388 @Test
389 public void testReleaseConfigurationStoreWriteFailure() throws Exception {
390
391 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
392 builder.setScmSourceUrl("scm-url");
393 builder.setWorkingDirectory(getTestFile("target/working-directory").getAbsolutePath());
394
395 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup(ReleaseManager.class, "test");
396
397 ReleaseDescriptorStore configStoreMock = mock(ReleaseDescriptorStore.class);
398 doThrow(new ReleaseDescriptorStoreException("message", new IOException("ioExceptionMsg")))
399 .when(configStoreMock)
400 .write(any(ReleaseDescriptor.class));
401
402 releaseManager.setConfigStore(configStoreMock);
403
404 ReleasePrepareRequest prepareRequest = new ReleasePrepareRequest();
405 prepareRequest.setReleaseDescriptorBuilder(builder);
406 prepareRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
407 prepareRequest.setDryRun(false);
408 prepareRequest.setResume(false);
409 prepareRequest.setUserProperties(new Properties());
410
411
412 try {
413 releaseManager.prepare(prepareRequest);
414 fail("Should have failed to read configuration");
415 } catch (ReleaseExecutionException e) {
416
417 assertEquals(
418 "check cause",
419 ReleaseDescriptorStoreException.class,
420 e.getCause().getClass());
421 }
422
423
424 verify(configStoreMock).write(any(ReleaseDescriptor.class));
425 verifyNoMoreInteractions(configStoreMock);
426 }
427
428 @Test
429 public void testReleaseConfigurationStoreClean() throws Exception {
430
431 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
432 builder.setScmSourceUrl("scm-url");
433 builder.setWorkingDirectory(getTestFile("target/working-directory").getAbsolutePath());
434
435 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup(ReleaseManager.class, "test");
436
437 ReleaseDescriptorStore configStoreMock = mock(ReleaseDescriptorStore.class);
438
439 releaseManager.setConfigStore(configStoreMock);
440
441 ReleaseCleanRequest cleanRequest = new ReleaseCleanRequest();
442 cleanRequest.setReleaseDescriptorBuilder(builder);
443
444
445 releaseManager.clean(cleanRequest);
446
447
448 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step1");
449 assertTrue("step1 not cleaned", phase.isCleaned());
450
451 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step2");
452 assertTrue("step2 not cleaned", phase.isCleaned());
453
454 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "step3");
455 assertTrue("step3 not cleaned", phase.isCleaned());
456
457 phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "branch1");
458 assertTrue("branch1 not cleaned", phase.isCleaned());
459
460 verify(configStoreMock).delete(any(ReleaseDescriptor.class));
461 verifyNoMoreInteractions(configStoreMock);
462 }
463
464 private static List<MavenProject> createReactorProjects() throws IOException {
465 MavenProject project = new MavenProject();
466
467 File projectFile = getTestFile("target/dummy-project/pom.xml");
468 if (!projectFile.exists()) {
469 projectFile.getParentFile().mkdirs();
470 projectFile.createNewFile();
471 }
472 project.setFile(projectFile);
473 return Collections.singletonList(project);
474 }
475
476 @Test
477 public void testReleasePerformWithResult() throws Exception {
478 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
479
480 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
481 builder.setScmSourceUrl("scm-url");
482 File checkoutDirectory = getTestFile("target/checkout-directory");
483 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
484 builder.setWorkingDirectory(getTestPath("target/dummy-project"));
485
486 ReleasePerformRequest performRequest = new ReleasePerformRequest();
487 performRequest.setReleaseDescriptorBuilder(builder);
488 performRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
489 performRequest.setReactorProjects(createReactorProjects());
490
491 ReleaseResult result = releaseManager.performWithResult(performRequest);
492
493 assertTrue(result.getOutput().length() > 0);
494 }
495
496 @Test
497 public void testReleaseConfigurationStoreReadFailureOnPerform() throws Exception {
498
499 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
500 builder.setScmSourceUrl("scm-url");
501 builder.setWorkingDirectory(getTestFile("target/working-directory").getAbsolutePath());
502
503 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup(ReleaseManager.class, "test");
504
505 ReleaseDescriptorStore configStoreMock = mock(ReleaseDescriptorStore.class);
506 when(configStoreMock.read(builder))
507 .thenThrow(new ReleaseDescriptorStoreException("message", new IOException("ioExceptionMsg")));
508
509 releaseManager.setConfigStore(configStoreMock);
510
511 ReleasePerformRequest performRequest = new ReleasePerformRequest();
512 performRequest.setReleaseDescriptorBuilder(builder);
513 performRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
514
515
516 try {
517 builder.setUseReleaseProfile(false);
518
519 releaseManager.perform(performRequest);
520 fail("Should have failed to read configuration");
521 } catch (ReleaseExecutionException e) {
522
523 assertEquals(
524 "check cause",
525 ReleaseDescriptorStoreException.class,
526 e.getCause().getClass());
527 }
528
529
530 verify(configStoreMock).read(builder);
531 verifyNoMoreInteractions(configStoreMock);
532 }
533
534 @Test
535 public void testReleasePerformWithIncompletePrepare() throws Exception {
536 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
537 builder.setScmSourceUrl("scm-url");
538 builder.setWorkingDirectory(getTestFile("target/working-directory").getAbsolutePath());
539
540 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup(ReleaseManager.class, "test");
541
542 ReleaseDescriptorStoreStub configStore = new ReleaseDescriptorStoreStub();
543 builder.setCompletedPhase("scm-tag");
544 releaseManager.setConfigStore(configStore);
545
546 ReleasePerformRequest performRequest = new ReleasePerformRequest();
547 performRequest.setReleaseDescriptorBuilder(builder);
548 performRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
549
550 try {
551 builder.setUseReleaseProfile(false);
552
553 releaseManager.perform(performRequest);
554 fail("Should have failed to perform");
555 } catch (ReleaseFailureException e) {
556
557 assertTrue(true);
558 }
559 }
560
561
562 @Test
563 public void testPerformWithDefaultClean() throws Exception {
564
565 ReleasePerformRequest performRequest = new ReleasePerformRequest();
566 performRequest.setDryRun(true);
567 performRequest.setReactorProjects(createReactorProjects());
568
569 ReleaseManagerListener managerListener = mock(ReleaseManagerListener.class);
570 performRequest.setReleaseManagerListener(managerListener);
571
572 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
573 builder.setScmSourceUrl("scm-url");
574 builder.setWorkingDirectory(getTestFile("target/working-directory").getAbsolutePath());
575 performRequest.setReleaseDescriptorBuilder(builder);
576
577 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
578
579
580 releaseManager.perform(performRequest);
581
582
583 verify(managerListener).phaseStart("verify-completed-prepare-phases");
584 verify(managerListener).phaseStart("checkout-project-from-scm");
585 verify(managerListener).phaseStart("run-perform-goals");
586 verify(managerListener, times(3)).phaseEnd();
587
588
589 verify(managerListener).goalStart(anyString(), any());
590 verify(managerListener).goalEnd();
591
592 verifyNoMoreInteractions(managerListener);
593 }
594
595 @Test
596 public void testNoScmUrlPerform() throws Exception {
597 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
598 builder.setWorkingDirectory(getTestFile("target/test/checkout").getAbsolutePath());
599
600 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
601
602 ReleasePerformRequest performRequest = new ReleasePerformRequest();
603 performRequest.setReleaseDescriptorBuilder(builder);
604 performRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
605
606 try {
607 builder.setUseReleaseProfile(false);
608
609 releaseManager.perform(performRequest);
610
611 fail("perform should have failed");
612 } catch (ReleaseFailureException e) {
613 assertNull("check no cause", e.getCause());
614 }
615 }
616
617 @Test
618 public void testScmExceptionThrown() throws Exception {
619
620 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
621
622 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
623 builder.setScmSourceUrl("scm-url");
624 File checkoutDirectory = getTestFile("target/checkout-directory");
625 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
626
627 ScmProvider scmProviderMock = mock(ScmProvider.class);
628 when(scmProviderMock.checkOut(
629 any(ScmRepository.class),
630 any(ScmFileSet.class),
631 any(ScmTag.class),
632 any(CommandParameters.class)))
633 .thenThrow(new ScmException("..."));
634
635 ScmManagerStub stub = (ScmManagerStub) lookup(ScmManager.class);
636 stub.setScmProvider(scmProviderMock);
637
638 ReleasePerformRequest performRequest = new ReleasePerformRequest();
639 performRequest.setReleaseDescriptorBuilder(builder);
640 performRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
641 performRequest.setReactorProjects(createReactorProjects());
642
643
644 try {
645 releaseManager.perform(performRequest);
646
647 fail("commit should have failed");
648 } catch (ReleaseExecutionException e) {
649 assertEquals("check cause", ScmException.class, e.getCause().getClass());
650 }
651
652
653 verify(scmProviderMock)
654 .checkOut(
655 any(ScmRepository.class), any(ScmFileSet.class),
656 any(ScmTag.class), any(CommandParameters.class));
657 verifyNoMoreInteractions(scmProviderMock);
658 }
659
660 @Test
661 public void testScmResultFailure() throws Exception {
662 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
663
664 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
665 builder.setScmSourceUrl("scm-url");
666 File checkoutDirectory = getTestFile("target/checkout-directory");
667 builder.setCheckoutDirectory(checkoutDirectory.getAbsolutePath());
668 builder.setWorkingDirectory(getTestPath("target/dummy-project"));
669
670 ScmManager scmManager = (ScmManager) lookup(ScmManager.class);
671 ScmProviderStub providerStub = (ScmProviderStub) scmManager.getProviderByUrl("scm-url");
672
673 providerStub.setCheckOutScmResult(new CheckOutScmResult("", "", "", false));
674
675 ReleasePerformRequest performRequest = new ReleasePerformRequest();
676 performRequest.setReleaseDescriptorBuilder(builder);
677 performRequest.setReleaseEnvironment(new DefaultReleaseEnvironment());
678 performRequest.setReactorProjects(createReactorProjects());
679
680 try {
681 releaseManager.perform(performRequest);
682
683 fail("commit should have failed");
684 } catch (ReleaseScmCommandException e) {
685 assertNull("check no other cause", e.getCause());
686 }
687 }
688
689
690 @Test
691 public void testKeepProfilesOnPerform() throws Exception {
692
693 ReleasePerformRequest performRequest = new ReleasePerformRequest();
694 performRequest.setDryRun(true);
695 performRequest.setReactorProjects(createReactorProjects());
696
697 ReleaseManagerListener managerListener = mock(ReleaseManagerListener.class);
698 performRequest.setReleaseManagerListener(managerListener);
699
700 ReleaseDescriptorBuilder builder = new ReleaseDescriptorBuilder();
701 builder.setActivateProfiles(Arrays.asList("aProfile", "anotherOne"));
702 builder.setWorkingDirectory(getTestFile("target/working-directory").getAbsolutePath());
703 performRequest.setReleaseDescriptorBuilder(builder);
704
705 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup(ReleaseManager.class, "test");
706
707 ReleaseDescriptorBuilder secondBuilder = new ReleaseDescriptorBuilder();
708 secondBuilder.setActivateProfiles(Arrays.asList("aProfile", "bProfile"));
709 secondBuilder.setScmSourceUrl("scm-url");
710 ReleaseDescriptorStore configStoreMock = mock(ReleaseDescriptorStore.class);
711 when(configStoreMock.read(any(ReleaseDescriptorBuilder.class))).thenReturn(secondBuilder);
712 releaseManager.setConfigStore(configStoreMock);
713
714
715 ReleaseResult result = releaseManager.performWithResult(performRequest);
716
717
718 assertTrue(result.getOutput().contains("-P aProfile,bProfile,anotherOne"));
719 }
720
721 @Test
722 public void testDetermineWorkingDirectory() throws Exception {
723 DefaultReleaseManager defaultReleaseManager = new DefaultReleaseManager(
724 Collections.emptyMap(), Collections.emptyMap(), mock(ReleaseDescriptorStore.class));
725
726 File checkoutDir = getTestFile("target/checkout");
727 FileUtils.forceDelete(checkoutDir);
728 checkoutDir.mkdirs();
729
730 File projectDir = getTestFile("target/checkout/my/project");
731 projectDir.mkdirs();
732
733
734 assertEquals(checkoutDir, defaultReleaseManager.determineWorkingDirectory(checkoutDir, ""));
735 assertEquals(checkoutDir, defaultReleaseManager.determineWorkingDirectory(checkoutDir, null));
736
737
738 assertEquals(projectDir, defaultReleaseManager.determineWorkingDirectory(checkoutDir, "my/project"));
739 assertEquals(projectDir, defaultReleaseManager.determineWorkingDirectory(checkoutDir, "my/project/"));
740 assertEquals(
741 projectDir,
742 defaultReleaseManager.determineWorkingDirectory(checkoutDir, "my" + File.separator + "project"));
743
744 FileUtils.forceDelete(checkoutDir);
745 }
746
747
748 @Test
749 public void testRollbackCall() throws Exception {
750 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
751
752 ReleaseRollbackRequest rollbackRequest = new ReleaseRollbackRequest();
753 rollbackRequest.setReleaseDescriptorBuilder(configStore.getReleaseConfiguration());
754
755 releaseManager.rollback(rollbackRequest);
756
757 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "rollbackPhase1");
758
759 assertTrue("rollbackPhase1 executed", phase.isExecuted());
760 }
761
762
763 @Test
764 public void testUpdateVersionsCall() throws Exception {
765 ReleaseManager releaseManager = lookup(ReleaseManager.class, "test");
766
767 ReleaseUpdateVersionsRequest updateVersionsRequest = new ReleaseUpdateVersionsRequest();
768 updateVersionsRequest.setReleaseDescriptorBuilder(configStore.getReleaseConfiguration());
769 updateVersionsRequest.setUserProperties(new Properties());
770
771 releaseManager.updateVersions(updateVersionsRequest);
772
773 ReleasePhaseStub phase = (ReleasePhaseStub) lookup(ReleasePhase.class, "updateVersionsPhase1");
774
775 assertTrue("updateVersionsPhase1 executed", phase.isExecuted());
776 }
777 }