1 package org.apache.maven.shared.release;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 import static org.mockito.Mockito.*;
22
23 import java.io.File;
24 import java.io.IOException;
25 import java.util.Collections;
26 import java.util.List;
27 import java.util.Map;
28
29 import org.apache.maven.project.MavenProject;
30 import org.apache.maven.scm.ScmException;
31 import org.apache.maven.scm.ScmFile;
32 import org.apache.maven.scm.ScmFileSet;
33 import org.apache.maven.scm.ScmTag;
34 import org.apache.maven.scm.command.checkout.CheckOutScmResult;
35 import org.apache.maven.scm.manager.NoSuchScmProviderException;
36 import org.apache.maven.scm.manager.ScmManager;
37 import org.apache.maven.scm.manager.ScmManagerStub;
38 import org.apache.maven.scm.provider.ScmProvider;
39 import org.apache.maven.scm.provider.ScmProviderStub;
40 import org.apache.maven.scm.repository.ScmRepository;
41 import org.apache.maven.scm.repository.ScmRepositoryException;
42 import org.apache.maven.shared.release.config.ReleaseDescriptor;
43 import org.apache.maven.shared.release.config.ReleaseDescriptorStore;
44 import org.apache.maven.shared.release.config.ReleaseDescriptorStoreException;
45 import org.apache.maven.shared.release.config.ReleaseDescriptorStoreStub;
46 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
47 import org.apache.maven.shared.release.env.ReleaseEnvironment;
48 import org.apache.maven.shared.release.exec.MavenExecutor;
49 import org.apache.maven.shared.release.phase.IsScmFileSetEquals;
50 import org.apache.maven.shared.release.phase.ReleasePhase;
51 import org.apache.maven.shared.release.phase.ReleasePhaseStub;
52 import org.apache.maven.shared.release.phase.RunPerformGoalsPhase;
53 import org.apache.maven.shared.release.scm.DefaultScmRepositoryConfigurator;
54 import org.apache.maven.shared.release.scm.ReleaseScmCommandException;
55 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
56 import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
57 import org.codehaus.plexus.PlexusTestCase;
58 import org.codehaus.plexus.util.FileUtils;
59 import org.codehaus.plexus.util.ReflectionUtils;
60
61
62
63
64
65
66 public class DefaultReleaseManagerTest
67 extends PlexusTestCase
68 {
69 private ReleaseDescriptorStoreStub configStore;
70
71
72 protected void setUp()
73 throws Exception
74 {
75 super.setUp();
76
77 configStore = (ReleaseDescriptorStoreStub) lookup( ReleaseDescriptorStore.ROLE, "stub" );
78 }
79
80 public void testPrepareNoCompletedPhase()
81 throws Exception
82 {
83 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
84
85 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
86 releaseDescriptor.setCompletedPhase( null );
87
88 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null );
89
90 @SuppressWarnings("unchecked")
91 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
92
93 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
94 assertTrue( "step1 executed", phase.isExecuted() );
95 assertFalse( "step1 not simulated", phase.isSimulated() );
96 phase = (ReleasePhaseStub) phases.get( "step2" );
97 assertTrue( "step2 executed", phase.isExecuted() );
98 assertFalse( "step2 not simulated", phase.isSimulated() );
99 phase = (ReleasePhaseStub) phases.get( "step3" );
100 assertTrue( "step3 executed", phase.isExecuted() );
101 assertFalse( "step3 not simulated", phase.isSimulated() );
102 }
103
104 public void testPrepareCompletedPhase()
105 throws Exception
106 {
107 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
108
109 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
110 releaseDescriptor.setCompletedPhase( "step1" );
111
112 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null );
113
114 @SuppressWarnings("unchecked")
115 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
116
117 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
118 assertFalse( "step1 not executed", phase.isExecuted() );
119 assertFalse( "step1 not simulated", phase.isSimulated() );
120 phase = (ReleasePhaseStub) phases.get( "step2" );
121 assertTrue( "step2 executed", phase.isExecuted() );
122 assertFalse( "step2 not simulated", phase.isSimulated() );
123 phase = (ReleasePhaseStub) phases.get( "step3" );
124 assertTrue( "step3 executed", phase.isExecuted() );
125 assertFalse( "step3 not simulated", phase.isSimulated() );
126 }
127
128 public void testPrepareCompletedPhaseNoResume()
129 throws Exception
130 {
131 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
132
133 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
134 releaseDescriptor.setCompletedPhase( "step1" );
135
136 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null, false, false );
137
138 @SuppressWarnings("unchecked")
139 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
140
141 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
142 assertTrue( "step1 executed", phase.isExecuted() );
143 assertFalse( "step1 not simulated", phase.isSimulated() );
144 phase = (ReleasePhaseStub) phases.get( "step2" );
145 assertTrue( "step2 executed", phase.isExecuted() );
146 assertFalse( "step2 not simulated", phase.isSimulated() );
147 phase = (ReleasePhaseStub) phases.get( "step3" );
148 assertTrue( "step3 executed", phase.isExecuted() );
149 assertFalse( "step3 not simulated", phase.isSimulated() );
150 }
151
152 public void testPrepareCompletedAllPhases()
153 throws Exception
154 {
155 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
156
157 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
158 releaseDescriptor.setCompletedPhase( "step3" );
159
160 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null );
161
162 @SuppressWarnings("unchecked")
163 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
164
165 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
166 assertFalse( "step1 not executed", phase.isExecuted() );
167 assertFalse( "step1 not simulated", phase.isSimulated() );
168 phase = (ReleasePhaseStub) phases.get( "step2" );
169 assertFalse( "step2 not executed", phase.isExecuted() );
170 assertFalse( "step2 not simulated", phase.isSimulated() );
171 phase = (ReleasePhaseStub) phases.get( "step3" );
172 assertFalse( "step3 not executed", phase.isExecuted() );
173 assertFalse( "step3 not simulated", phase.isSimulated() );
174 }
175
176 public void testPrepareInvalidCompletedPhase()
177 throws Exception
178 {
179 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
180
181 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
182 releaseDescriptor.setCompletedPhase( "foo" );
183
184 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null );
185
186 @SuppressWarnings("unchecked")
187 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
188
189 ReleasePhaseStub phase = phases.get( "step1" );
190 assertTrue( "step1 executed", phase.isExecuted() );
191 assertFalse( "step1 not simulated", phase.isSimulated() );
192 phase = phases.get( "step2" );
193 assertTrue( "step2 executed", phase.isExecuted() );
194 assertFalse( "step2 not simulated", phase.isSimulated() );
195 phase = phases.get( "step3" );
196 assertTrue( "step3 executed", phase.isExecuted() );
197 assertFalse( "step3 not simulated", phase.isSimulated() );
198 }
199
200 public void testPrepareSimulateNoCompletedPhase()
201 throws Exception
202 {
203 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
204
205 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
206 releaseDescriptor.setCompletedPhase( null );
207
208 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null, true, true );
209
210 @SuppressWarnings("unchecked")
211 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
212
213 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
214 assertTrue( "step1 simulated", phase.isSimulated() );
215 assertFalse( "step1 not executed", phase.isExecuted() );
216 phase = (ReleasePhaseStub) phases.get( "step2" );
217 assertTrue( "step2 simulated", phase.isSimulated() );
218 assertFalse( "step2 not executed", phase.isExecuted() );
219 phase = (ReleasePhaseStub) phases.get( "step3" );
220 assertTrue( "step3 simulated", phase.isSimulated() );
221 assertFalse( "step3 not executed", phase.isExecuted() );
222 }
223
224 public void testPrepareSimulateCompletedPhase()
225 throws Exception
226 {
227 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
228
229 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
230 releaseDescriptor.setCompletedPhase( "step1" );
231
232 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null, true, true );
233
234 @SuppressWarnings("unchecked")
235 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
236
237 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
238 assertFalse( "step1 not simulated", phase.isSimulated() );
239 assertFalse( "step1 not executed", phase.isExecuted() );
240 phase = (ReleasePhaseStub) phases.get( "step2" );
241 assertTrue( "step2 simulated", phase.isSimulated() );
242 assertFalse( "step2 not executed", phase.isExecuted() );
243 phase = (ReleasePhaseStub) phases.get( "step3" );
244 assertTrue( "step3 simulated", phase.isSimulated() );
245 assertFalse( "step3 not executed", phase.isExecuted() );
246 }
247
248 public void testPrepareSimulateCompletedAllPhases()
249 throws Exception
250 {
251 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
252
253 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
254 releaseDescriptor.setCompletedPhase( "step3" );
255
256 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null, true, true );
257
258 @SuppressWarnings("unchecked")
259 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
260
261 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
262 assertFalse( "step1 not simulated", phase.isSimulated() );
263 assertFalse( "step1 not executed", phase.isExecuted() );
264 phase = (ReleasePhaseStub) phases.get( "step2" );
265 assertFalse( "step2 not simulated", phase.isSimulated() );
266 assertFalse( "step2 not executed", phase.isExecuted() );
267 phase = (ReleasePhaseStub) phases.get( "step3" );
268 assertFalse( "step3 not simulated", phase.isSimulated() );
269 assertFalse( "step3 not executed", phase.isExecuted() );
270 }
271
272 public void testPrepareSimulateInvalidCompletedPhase()
273 throws Exception
274 {
275 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "test" );
276
277 ReleaseDescriptor releaseDescriptor = configStore.getReleaseConfiguration();
278 releaseDescriptor.setCompletedPhase( "foo" );
279
280 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null, true, true );
281
282 @SuppressWarnings("unchecked")
283 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
284
285 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
286 assertTrue( "step1 simulated", phase.isSimulated() );
287 assertFalse( "step1 not executed", phase.isExecuted() );
288 phase = (ReleasePhaseStub) phases.get( "step2" );
289 assertTrue( "step2 simulated", phase.isSimulated() );
290 assertFalse( "step2 not executed", phase.isExecuted() );
291 phase = (ReleasePhaseStub) phases.get( "step3" );
292 assertTrue( "step3 simulated", phase.isSimulated() );
293 assertFalse( "step3 not executed", phase.isExecuted() );
294 }
295
296 public void testPrepareUnknownPhaseConfigured()
297 throws Exception
298 {
299 ReleaseManager releaseManager = (ReleaseManager) lookup( ReleaseManager.ROLE, "bad-phase-configured" );
300
301 try
302 {
303 releaseManager.prepare( new ReleaseDescriptor(), new DefaultReleaseEnvironment(), null );
304 fail( "Should have failed to find a phase" );
305 }
306 catch ( ReleaseExecutionException e )
307 {
308
309 }
310 }
311
312 public void testReleaseConfigurationStoreReadFailure()
313 throws Exception
314 {
315
316 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
317 releaseDescriptor.setScmSourceUrl( "scm-url" );
318 releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
319
320 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
321
322 ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class );
323 when( configStoreMock.read( releaseDescriptor ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) );
324
325 releaseManager.setConfigStore( configStoreMock );
326
327
328 try
329 {
330 releaseManager.prepare( releaseDescriptor, new DefaultReleaseEnvironment(), null );
331 fail( "Should have failed to read configuration" );
332 }
333 catch ( ReleaseExecutionException e )
334 {
335
336 assertEquals( "check cause", ReleaseDescriptorStoreException.class, e.getCause().getClass() );
337 }
338
339
340 verify( configStoreMock ).read( releaseDescriptor );
341 verifyNoMoreInteractions( configStoreMock );
342 }
343
344 public void testReleaseConfigurationStoreWriteFailure()
345 throws Exception
346 {
347
348 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
349 releaseDescriptor.setScmSourceUrl( "scm-url" );
350 releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
351
352 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
353
354 ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class );
355 doThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) ).when( configStoreMock ).write( releaseDescriptor );
356
357 releaseManager.setConfigStore( configStoreMock );
358
359
360 try
361 {
362 releaseManager.prepare( releaseDescriptor, new DefaultReleaseEnvironment(), null, false, false );
363 fail( "Should have failed to read configuration" );
364 }
365 catch ( ReleaseExecutionException e )
366 {
367
368 assertEquals( "check cause", ReleaseDescriptorStoreException.class, e.getCause().getClass() );
369 }
370
371
372 verify( configStoreMock ).write( releaseDescriptor ) ;
373 verifyNoMoreInteractions( configStoreMock );
374 }
375
376 public void testReleaseConfigurationStoreClean()
377 throws Exception
378 {
379
380 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
381 releaseDescriptor.setScmSourceUrl( "scm-url" );
382 releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
383
384 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
385
386 ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class );
387
388 releaseManager.setConfigStore( configStoreMock );
389
390
391 releaseManager.clean( releaseDescriptor, null, null );
392
393
394 @SuppressWarnings("unchecked")
395 Map<String,ReleasePhaseStub> phases = container.lookupMap( ReleasePhase.ROLE );
396
397 ReleasePhaseStub phase = (ReleasePhaseStub) phases.get( "step1" );
398 assertTrue( "step1 not cleaned", phase.isCleaned() );
399
400 phase = (ReleasePhaseStub) phases.get( "step2" );
401 assertTrue( "step2 not cleaned", phase.isCleaned() );
402
403 phase = (ReleasePhaseStub) phases.get( "step3" );
404 assertTrue( "step3 not cleaned", phase.isCleaned() );
405
406 phase = (ReleasePhaseStub) phases.get( "branch1" );
407 assertTrue( "branch1 not cleaned", phase.isCleaned() );
408
409 verify( configStoreMock ).delete( releaseDescriptor );
410 verifyNoMoreInteractions( configStoreMock );
411 }
412
413 public void testReleasePerform()
414 throws Exception
415 {
416
417 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
418
419 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
420 releaseDescriptor.setScmSourceUrl( "scm-url" );
421 releaseDescriptor.setPerformGoals( "goal1 goal2" );
422 File checkoutDirectory = getTestFile( "target/checkout-directory" );
423 releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
424
425 MavenExecutor mock = mock( MavenExecutor.class );
426 RunPerformGoalsPhase phase = (RunPerformGoalsPhase) lookup( ReleasePhase.ROLE, "run-perform-goals" );
427 phase.setMavenExecutor( mock );
428
429 ScmProvider scmProviderMock = mock( ScmProvider.class );
430 when( scmProviderMock.checkOut( isA( ScmRepository.class ),
431 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
432 isA( ScmTag.class ) ) ).thenReturn( new CheckOutScmResult( "...", Collections.<ScmFile>emptyList() ) );
433
434 ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.ROLE );
435 stub.setScmProvider( scmProviderMock );
436
437
438 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), createReactorProjects() );
439
440
441 verify( mock ).executeGoals( eq( checkoutDirectory ),
442 eq( "goal1 goal2" ),
443 isA( ReleaseEnvironment.class ),
444 eq( true ),
445 eq( "-DperformRelease=true -f pom.xml" ),
446 isNull( String.class ),
447 isA( ReleaseResult.class ) );
448 verify( scmProviderMock ).checkOut( isA( ScmRepository.class ),
449 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
450 isA( ScmTag.class ) );
451 verifyNoMoreInteractions( mock, scmProviderMock );
452 }
453
454 private static List<MavenProject> createReactorProjects()
455 {
456 MavenProject project = new MavenProject();
457 project.setFile( getTestFile( "target/dummy-project/pom.xml" ) );
458 return Collections.singletonList( project );
459 }
460
461 public void testReleasePerformWithResult()
462 throws Exception
463 {
464 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
465
466 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
467 releaseDescriptor.setScmSourceUrl( "scm-url" );
468 File checkoutDirectory = getTestFile( "target/checkout-directory" );
469 releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
470
471 ReleaseResult result = releaseManager.performWithResult( releaseDescriptor, new DefaultReleaseEnvironment(),
472 createReactorProjects(), null );
473 assertTrue( result.getOutput().length() > 0 );
474 }
475
476 public void testReleasePerformNoReleaseProfile()
477 throws Exception
478 {
479
480 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
481
482 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
483 releaseDescriptor.setScmSourceUrl( "scm-url" );
484 releaseDescriptor.setPerformGoals( "goal1 goal2" );
485 File checkoutDirectory = getTestFile( "target/checkout-directory" );
486 releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
487
488 MavenExecutor mock = mock( MavenExecutor.class );
489 RunPerformGoalsPhase phase = (RunPerformGoalsPhase) lookup( ReleasePhase.ROLE, "run-perform-goals" );
490 phase.setMavenExecutor( mock );
491
492 ScmProvider scmProviderMock = mock( ScmProvider.class );
493 when( scmProviderMock.checkOut( isA( ScmRepository.class ),
494 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
495 isA( ScmTag.class ) ) ).thenReturn( new CheckOutScmResult( "...", Collections.<ScmFile>emptyList() ) );
496
497 ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.ROLE );
498 stub.setScmProvider( scmProviderMock );
499
500 releaseDescriptor.setUseReleaseProfile( false );
501
502
503 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), createReactorProjects() );
504
505
506 verify( mock ).executeGoals( eq( checkoutDirectory ),
507 eq( "goal1 goal2" ),
508 isA( ReleaseEnvironment.class ),
509 eq( true ),
510 eq( "-f pom.xml" ),
511 isNull( String.class ),
512 isA( ReleaseResult.class ) );
513 verify( scmProviderMock ).checkOut( isA( ScmRepository.class ),
514 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
515 isA( ScmTag.class ) );
516 verifyNoMoreInteractions( mock, scmProviderMock );
517 }
518
519 public void testReleasePerformWithArguments()
520 throws Exception
521 {
522
523 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
524
525 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
526 releaseDescriptor.setScmSourceUrl( "scm-url" );
527 releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true" );
528 releaseDescriptor.setPerformGoals( "goal1 goal2" );
529 File checkoutDirectory = getTestFile( "target/checkout-directory" );
530 releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
531
532 MavenExecutor mock = mock( MavenExecutor.class );
533 RunPerformGoalsPhase phase = (RunPerformGoalsPhase) lookup( ReleasePhase.ROLE, "run-perform-goals" );
534 phase.setMavenExecutor( mock );
535
536 ScmProvider scmProviderMock = mock( ScmProvider.class );
537 when( scmProviderMock.checkOut( isA( ScmRepository.class ),
538 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
539 isA( ScmTag.class ) ) ).thenReturn( new CheckOutScmResult( "...", Collections.<ScmFile>emptyList() ) );
540
541 ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.ROLE );
542 stub.setScmProvider( scmProviderMock );
543
544
545 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), createReactorProjects() );
546
547
548 verify( mock ).executeGoals( eq( checkoutDirectory ),
549 eq( "goal1 goal2" ),
550 isA( ReleaseEnvironment.class),
551 eq( true),
552 eq( "-Dmaven.test.skip=true -DperformRelease=true -f pom.xml" ),
553 isNull( String.class ),
554 isA( ReleaseResult.class ) );
555 verify( scmProviderMock ).checkOut( isA( ScmRepository.class ),
556 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
557 isA( ScmTag.class ) );
558 verifyNoMoreInteractions( mock, scmProviderMock );
559 }
560
561 public void testReleasePerformWithArgumentsNoReleaseProfile()
562 throws Exception
563 {
564
565 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
566
567 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
568 releaseDescriptor.setScmSourceUrl( "scm-url" );
569 releaseDescriptor.setAdditionalArguments( "-Dmaven.test.skip=true" );
570 releaseDescriptor.setPerformGoals( "goal1 goal2" );
571 File checkoutDirectory = getTestFile( "target/checkout-directory" );
572 releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
573
574 MavenExecutor mock = mock( MavenExecutor.class );
575 RunPerformGoalsPhase phase = (RunPerformGoalsPhase) lookup( ReleasePhase.ROLE, "run-perform-goals" );
576 phase.setMavenExecutor( mock );
577
578 ScmProvider scmProviderMock = mock( ScmProvider.class );
579 when( scmProviderMock.checkOut( isA( ScmRepository.class ),
580 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
581 isA( ScmTag.class ) ) ).thenReturn( new CheckOutScmResult( "...", Collections.<ScmFile>emptyList() ) );
582
583 ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.ROLE );
584 stub.setScmProvider( scmProviderMock );
585
586 releaseDescriptor.setUseReleaseProfile( false );
587
588
589 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), createReactorProjects() );
590
591
592 verify( mock ).executeGoals( eq( checkoutDirectory ),
593 eq( "goal1 goal2" ),
594 isA( ReleaseEnvironment.class ),
595 eq( true ),
596 eq( "-Dmaven.test.skip=true -f pom.xml" ),
597 isNull( String.class ),
598 isA( ReleaseResult.class ) );
599 verify( scmProviderMock ).checkOut( isA( ScmRepository.class ),
600 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
601 isA( ScmTag.class ) );
602 verifyNoMoreInteractions( mock, scmProviderMock );
603 }
604
605 public void testReleasePerformWithReleasePropertiesCompleted()
606 throws Exception
607 {
608
609 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
610
611 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
612 releaseDescriptor.setScmSourceUrl( "scm-url" );
613 releaseDescriptor.setPerformGoals( "goal1 goal2" );
614 File checkoutDirectory = getTestFile( "target/checkout-directory" );
615 releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
616
617 MavenExecutor mock = mock( MavenExecutor.class );
618 RunPerformGoalsPhase phase = (RunPerformGoalsPhase) lookup( ReleasePhase.ROLE, "run-perform-goals" );
619 phase.setMavenExecutor( mock );
620
621 ScmProvider scmProviderMock = mock( ScmProvider.class );
622 when( scmProviderMock.checkOut( isA( ScmRepository.class ),
623 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
624 isA( ScmTag.class ) ) ).thenReturn( new CheckOutScmResult( "...", Collections.<ScmFile>emptyList() ) );
625
626 ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.ROLE );
627 stub.setScmProvider( scmProviderMock );
628
629 ReleaseDescriptorStoreStub configStore = new ReleaseDescriptorStoreStub();
630 configStore.getReleaseConfiguration().setCompletedPhase( "end-release" );
631 releaseManager.setConfigStore( configStore );
632
633
634 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), createReactorProjects() );
635
636
637 verify( mock ).executeGoals( eq( checkoutDirectory ),
638 eq( "goal1 goal2" ),
639 isA( ReleaseEnvironment.class ),
640 eq( true ),
641 eq( "-DperformRelease=true -f pom.xml" ),
642 isNull( String.class ),
643 isA( ReleaseResult.class ) );
644 verify( scmProviderMock ).checkOut( isA( ScmRepository.class ),
645 argThat( new IsScmFileSetEquals( new ScmFileSet( checkoutDirectory ) ) ),
646 isA( ScmTag.class ) );
647 verifyNoMoreInteractions( mock, scmProviderMock );
648 }
649
650 public void testReleaseConfigurationStoreReadFailureOnPerform()
651 throws Exception
652 {
653
654 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
655 releaseDescriptor.setScmSourceUrl( "scm-url" );
656 releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
657
658 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
659
660 ReleaseDescriptorStore configStoreMock = mock( ReleaseDescriptorStore.class );
661 when( configStoreMock.read( releaseDescriptor ) ).thenThrow( new ReleaseDescriptorStoreException( "message", new IOException( "ioExceptionMsg" ) ) );
662
663 releaseManager.setConfigStore( configStoreMock );
664
665
666 try
667 {
668 releaseDescriptor.setUseReleaseProfile( false );
669
670 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), null );
671 fail( "Should have failed to read configuration" );
672 }
673 catch ( ReleaseExecutionException e )
674 {
675
676 assertEquals( "check cause", ReleaseDescriptorStoreException.class, e.getCause().getClass() );
677 }
678
679
680 verify( configStoreMock ).read( releaseDescriptor );
681 verifyNoMoreInteractions( configStoreMock );
682 }
683
684 public void testReleasePerformWithIncompletePrepare()
685 throws Exception
686 {
687 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
688 releaseDescriptor.setScmSourceUrl( "scm-url" );
689 releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
690
691 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
692
693 ReleaseDescriptorStoreStub configStore = new ReleaseDescriptorStoreStub();
694 releaseDescriptor.setCompletedPhase( "scm-tag" );
695 releaseManager.setConfigStore( configStore );
696
697 try
698 {
699 releaseDescriptor.setUseReleaseProfile( false );
700
701 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), null );
702 fail( "Should have failed to perform" );
703 }
704 catch ( ReleaseFailureException e )
705 {
706
707 assertTrue( true );
708 }
709 }
710
711
712 @SuppressWarnings( "unchecked" )
713 public void testPerformWithDefaultClean()
714 throws Exception
715 {
716
717 ReleasePerformRequest performRequest = new ReleasePerformRequest();
718 performRequest.setDryRun( true );
719
720 ReleaseManagerListener managerListener = mock( ReleaseManagerListener.class );
721 performRequest.setReleaseManagerListener( managerListener );
722
723 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
724 releaseDescriptor.setScmSourceUrl( "scm-url" );
725 releaseDescriptor.setWorkingDirectory( getTestFile( "target/working-directory" ).getAbsolutePath() );
726 performRequest.setReleaseDescriptor( releaseDescriptor );
727
728 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
729
730
731 releaseManager.perform( performRequest );
732
733
734 verify( managerListener ).phaseStart( "verify-release-configuration" );
735 verify( managerListener ).phaseStart( "verify-completed-prepare-phases" );
736 verify( managerListener ).phaseStart( "checkout-project-from-scm" );
737 verify( managerListener ).phaseStart( "run-perform-goals" );
738 verify( managerListener ).phaseStart( "cleanup" );
739 verify( managerListener, times( 5 ) ).phaseEnd();
740
741
742 verify( managerListener ).goalStart( anyString(), any( List.class ) );
743 verify( managerListener ).goalEnd();
744
745 verifyNoMoreInteractions( managerListener );
746 }
747
748 public void testNoScmUrlPerform()
749 throws Exception
750 {
751 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
752 releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
753
754 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
755
756 try
757 {
758 releaseDescriptor.setUseReleaseProfile( false );
759
760 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), null );
761
762 fail( "perform should have failed" );
763 }
764 catch ( ReleaseFailureException e )
765 {
766 assertNull( "check no cause", e.getCause() );
767 }
768 }
769
770 public void testNoSuchScmProviderExceptionThrown()
771 throws Exception
772 {
773
774 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
775 releaseDescriptor.setScmSourceUrl( "scm-url" );
776 releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
777
778 ScmManager scmManagerMock = mock( ScmManager.class );
779 when( scmManagerMock.makeScmRepository( "scm-url" ) ).thenThrow( new NoSuchScmProviderException( "..." ) );
780
781 DefaultScmRepositoryConfigurator configurator =
782 (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.ROLE );
783 configurator.setScmManager( scmManagerMock );
784
785 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
786
787
788 try
789 {
790 releaseDescriptor.setUseReleaseProfile( false );
791
792 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), null );
793
794 fail( "commit should have failed" );
795 }
796 catch ( ReleaseExecutionException e )
797 {
798 assertEquals( "check cause", NoSuchScmProviderException.class, e.getCause().getClass() );
799 }
800
801
802 verify( scmManagerMock ).makeScmRepository( "scm-url" );
803 verifyNoMoreInteractions( scmManagerMock );
804 }
805
806 public void testScmRepositoryExceptionThrown()
807 throws Exception
808 {
809
810 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
811 releaseDescriptor.setScmSourceUrl( "scm-url" );
812 releaseDescriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
813
814 ScmManager scmManagerMock = mock( ScmManager.class );
815 when( scmManagerMock.makeScmRepository( "scm-url" ) ).thenThrow( new ScmRepositoryException( "..." ) );
816
817 DefaultScmRepositoryConfigurator configurator =
818 (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.ROLE );
819 configurator.setScmManager( scmManagerMock );
820
821 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
822
823
824 try
825 {
826 releaseDescriptor.setUseReleaseProfile( false );
827
828 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), null );
829
830 fail( "commit should have failed" );
831 }
832 catch ( ReleaseScmRepositoryException e )
833 {
834 assertNull( "Check no additional cause", e.getCause() );
835 }
836
837
838 verify( scmManagerMock ).makeScmRepository( "scm-url" );
839 verifyNoMoreInteractions( scmManagerMock );
840 }
841
842 public void testScmExceptionThrown()
843 throws Exception
844 {
845
846 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
847
848 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
849 releaseDescriptor.setScmSourceUrl( "scm-url" );
850 File checkoutDirectory = getTestFile( "target/checkout-directory" );
851 releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
852
853 ScmProvider scmProviderMock = mock( ScmProvider.class );
854 when( scmProviderMock.checkOut( any( ScmRepository.class ), any( ScmFileSet.class ), any ( ScmTag.class ) ) ).thenThrow( new ScmException( "..." ) );
855
856 ScmManagerStub stub = (ScmManagerStub) lookup( ScmManager.ROLE );
857 stub.setScmProvider( scmProviderMock );
858
859
860 try
861 {
862 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), createReactorProjects() );
863
864 fail( "commit should have failed" );
865 }
866 catch ( ReleaseExecutionException e )
867 {
868 assertEquals( "check cause", ScmException.class, e.getCause().getClass() );
869 }
870
871
872 verify( scmProviderMock ).checkOut( any( ScmRepository.class ), any( ScmFileSet.class ), any ( ScmTag.class ) );
873 verifyNoMoreInteractions( scmProviderMock );
874 }
875
876 public void testScmResultFailure()
877 throws Exception
878 {
879 DefaultReleaseManager releaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
880
881 ReleaseDescriptor releaseDescriptor = new ReleaseDescriptor();
882 releaseDescriptor.setScmSourceUrl( "scm-url" );
883 File checkoutDirectory = getTestFile( "target/checkout-directory" );
884 releaseDescriptor.setCheckoutDirectory( checkoutDirectory.getAbsolutePath() );
885
886 ScmManager scmManager = (ScmManager) lookup( ScmManager.ROLE );
887 ScmProviderStub providerStub =
888 (ScmProviderStub) scmManager.getProviderByUrl( releaseDescriptor.getScmSourceUrl() );
889
890 providerStub.setCheckOutScmResult( new CheckOutScmResult( "", "", "", false ) );
891
892 try
893 {
894 releaseManager.perform( releaseDescriptor, new DefaultReleaseEnvironment(), createReactorProjects() );
895
896 fail( "commit should have failed" );
897 }
898 catch ( ReleaseScmCommandException e )
899 {
900 assertNull( "check no other cause", e.getCause() );
901 }
902 }
903
904 public void testDetermineWorkingDirectory()
905 throws Exception
906 {
907 DefaultReleaseManager defaultReleaseManager = new DefaultReleaseManager();
908
909 File checkoutDir = getTestFile( "target/checkout" );
910 FileUtils.forceDelete( checkoutDir );
911 checkoutDir.mkdirs();
912
913 File projectDir = getTestFile( "target/checkout/my/project" );
914 projectDir.mkdirs();
915
916
917 assertEquals( checkoutDir, defaultReleaseManager.determineWorkingDirectory( checkoutDir, "" ) );
918 assertEquals( checkoutDir, defaultReleaseManager.determineWorkingDirectory( checkoutDir, null ) );
919
920
921 assertEquals( projectDir, defaultReleaseManager.determineWorkingDirectory( checkoutDir, "my/project" ) );
922 assertEquals( projectDir, defaultReleaseManager.determineWorkingDirectory( checkoutDir, "my/project/" ) );
923 assertEquals( projectDir, defaultReleaseManager.determineWorkingDirectory( checkoutDir, "my" + File.separator +
924 "project" ) );
925
926 FileUtils.forceDelete( checkoutDir );
927 }
928
929
930 @SuppressWarnings( "unchecked" )
931 public void testRollbackCall()
932 throws Exception
933 {
934 DefaultReleaseManager defaultReleaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
935
936 ReleasePhase rollbackPhase1 = mock( ReleasePhase.class );
937 ReflectionUtils.setVariableValueInObject( defaultReleaseManager, "rollbackPhases",
938 Collections.singletonList( "rollbackPhase1" ) );
939 Map<String, ReleasePhase> releasePhases =
940 (Map<String, ReleasePhase>) ReflectionUtils.getValueIncludingSuperclasses( "releasePhases",
941 defaultReleaseManager );
942 releasePhases.put( "rollbackPhase1", rollbackPhase1 );
943
944 defaultReleaseManager.rollback( configStore.getReleaseConfiguration(), (ReleaseEnvironment) null, null );
945
946 verify( rollbackPhase1 ).execute( any( ReleaseDescriptor.class ), any( ReleaseEnvironment.class ),
947 any( List.class ) );
948 verifyNoMoreInteractions( rollbackPhase1 );
949 }
950
951
952
953 @SuppressWarnings( "unchecked" )
954 public void testUpdateVersionsCall()
955 throws Exception
956 {
957 DefaultReleaseManager defaultReleaseManager = (DefaultReleaseManager) lookup( ReleaseManager.ROLE, "test" );
958
959 ReleasePhase updateVersionsPhase1 = mock( ReleasePhase.class );
960 ReflectionUtils.setVariableValueInObject( defaultReleaseManager, "updateVersionsPhases",
961 Collections.singletonList( "updateVersionsPhase1" ) );
962 Map<String, ReleasePhase> releasePhases =
963 (Map<String, ReleasePhase>) ReflectionUtils.getValueIncludingSuperclasses( "releasePhases",
964 defaultReleaseManager );
965 releasePhases.put( "updateVersionsPhase1", updateVersionsPhase1 );
966
967 defaultReleaseManager.updateVersions( configStore.getReleaseConfiguration(), null, null );
968
969 verify( updateVersionsPhase1 ).execute( any( ReleaseDescriptor.class ), any( ReleaseEnvironment.class ),
970 any( List.class ) );
971 verifyNoMoreInteractions( updateVersionsPhase1 );
972 }
973 }