1 package org.apache.maven.shared.release.phase;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.junit.Assert.assertEquals;
23 import static org.junit.Assert.assertNull;
24 import static org.junit.Assert.assertTrue;
25 import static org.junit.Assert.fail;
26 import static org.mockito.Mockito.mock;
27 import static org.mockito.Mockito.verifyNoMoreInteractions;
28
29 import java.io.IOException;
30 import java.util.ArrayList;
31 import java.util.Arrays;
32 import java.util.Collection;
33 import java.util.Collections;
34 import java.util.List;
35
36 import org.apache.maven.project.MavenProject;
37 import org.apache.maven.scm.manager.NoSuchScmProviderException;
38 import org.apache.maven.scm.manager.ScmManager;
39 import org.apache.maven.scm.provider.ScmProvider;
40 import org.apache.maven.scm.repository.ScmRepositoryException;
41 import org.apache.maven.shared.release.ReleaseExecutionException;
42 import org.apache.maven.shared.release.ReleaseFailureException;
43 import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
44 import org.apache.maven.shared.release.config.ReleaseUtils;
45 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
46 import org.apache.maven.shared.release.scm.DefaultScmRepositoryConfigurator;
47 import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
48 import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
49 import org.apache.maven.shared.release.stubs.ScmManagerStub;
50 import org.apache.maven.shared.release.transform.jdom2.JDomModelETLFactory;
51 import org.apache.maven.shared.release.util.ReleaseUtil;
52 import org.junit.Ignore;
53 import org.junit.Test;
54 import org.junit.runner.RunWith;
55 import org.junit.runners.Parameterized;
56 import org.junit.runners.Parameterized.Parameters;
57
58
59
60
61
62
63 @RunWith(Parameterized.class)
64 public abstract class AbstractRewritingReleasePhaseTestCase
65 extends AbstractReleaseTestCase
66 {
67 private String modelETL;
68
69 @Parameters
70 public static Collection<Object[]> data()
71 {
72 return Arrays.asList( new Object[][] { { JDomModelETLFactory.ROLE_HINT } } );
73 }
74
75 public AbstractRewritingReleasePhaseTestCase( String modelETL )
76 {
77 this.modelETL = modelETL;
78 }
79
80 @Override
81 public void setUp()
82 throws Exception
83 {
84 super.setUp();
85 phase = lookup( ReleasePhase.class, getRoleHint() );
86
87 if( phase instanceof AbstractRewritePomsPhase)
88 {
89 ((AbstractRewritePomsPhase) phase).setModelETL( modelETL );
90 ((AbstractRewritePomsPhase) phase).setStartTime( 0 );
91 }
92 }
93
94 protected abstract String getRoleHint();
95
96 @Test
97 public void testRewriteBasicPom()
98 throws Exception
99 {
100 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
101 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom" );
102 mapNextVersion( builder, "groupId:artifactId" );
103
104 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
105
106 assertTrue( comparePomFiles( reactorProjects ) );
107 }
108
109 @Test
110 public void testRewriteBasicPomEntities()
111 throws Exception
112 {
113 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-entities" );
114 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom-entities" );
115 mapNextVersion( builder, "groupId:artifactId" );
116
117 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
118
119 assertTrue( comparePomFiles( reactorProjects ) );
120 }
121
122 @Test
123 public void testRewriteBasicPomNamespace()
124 throws Exception
125 {
126 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-namespace" );
127 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom-namespace" );
128 mapNextVersion( builder, "groupId:artifactId" );
129
130 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
131
132 assertTrue( comparePomFiles( reactorProjects ) );
133 }
134
135 @Test
136 public void testRewriteBasicPomWithEncoding()
137 throws Exception
138 {
139 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-encoding" );
140 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom-with-encoding" );
141 mapNextVersion( builder, "groupId:artifactId" );
142
143 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
144
145 assertTrue( comparePomFiles( reactorProjects ) );
146 }
147
148 @Test
149 public void testRewritePomWithParent()
150 throws Exception
151 {
152 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent" );
153 ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects, "pom-with-parent" );
154
155 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
156
157 assertTrue( comparePomFiles( reactorProjects ) );
158 }
159
160 @Test
161 public void testRewritePomWithUnmappedParent()
162 throws Exception
163 {
164
165 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent" );
166 ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects, "pom-with-parent" );
167
168
169 reactorProjects = new ArrayList<>( reactorProjects );
170 Collections.reverse( reactorProjects );
171
172 mapAlternateNextVersion( builder, "groupId:subproject1" );
173
174 try
175 {
176 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
177
178 fail( "Should have thrown an exception" );
179 }
180 catch ( ReleaseFailureException e )
181 {
182 assertTrue( true );
183 }
184 }
185
186 @Test
187 public void testRewritePomWithReleasedParent()
188 throws Exception
189 {
190
191 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-released-parent" );
192 ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects, "pom-with-released-parent" );
193
194 mapAlternateNextVersion( builder, "groupId:subproject1" );
195 builder.addReleaseVersion( "groupId:artifactId", "1" );
196 builder.addDevelopmentVersion( "groupId:artifactId", "1" );
197
198 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
199
200 assertTrue( comparePomFiles( reactorProjects ) );
201 }
202
203 protected abstract void mapAlternateNextVersion( ReleaseDescriptorBuilder config, String projectId );
204
205 @Test
206 public void testRewritePomWithInheritedVersion()
207 throws Exception
208 {
209 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-inherited-version" );
210 ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects, "pom-with-inherited-version" );
211
212 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
213
214 assertTrue( comparePomFiles( reactorProjects ) );
215 }
216
217 @Test
218 public void testRewritePomWithChangedInheritedVersion()
219 throws Exception
220 {
221 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-inherited-version" );
222 ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects, "pom-with-inherited-version" );
223
224 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
225
226 MavenProject project = getProjectsAsMap( reactorProjects ).get( "groupId:subproject1" );
227 comparePomFiles( project, "-version-changed" );
228 }
229
230 protected abstract ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects, String workingDirectory )
231 throws Exception;
232
233 @Test
234 public void testRewritePomDependencies()
235 throws Exception
236 {
237 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-dependencies" );
238 ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects, "internal-snapshot-dependencies" );
239 mapNextVersion( builder, "groupId:subsubproject" );
240
241 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
242
243 assertTrue( comparePomFiles( reactorProjects ) );
244 }
245
246 @Test
247 public void testRewritePomUnmappedDependencies()
248 throws Exception
249 {
250 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-dependencies" );
251 ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects, "internal-snapshot-dependencies" );
252
253 try
254 {
255 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
256
257 fail( "Should have thrown an exception" );
258 }
259 catch ( ReleaseFailureException e )
260 {
261 assertTrue( true );
262 }
263 }
264
265 @Test
266 public void testRewritePomDependenciesDifferentVersion()
267 throws Exception
268 {
269 List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-dependencies" );
270 ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects, "internal-differing-snapshot-dependencies" );
271
272 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
273
274 assertTrue( comparePomFiles( reactorProjects ) );
275 }
276
277 @Test
278 public void testRewriteManagedPomDependencies()
279 throws Exception
280 {
281 List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" );
282 ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects, "internal-managed-snapshot-dependency" );
283
284 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
285
286 assertTrue( comparePomFiles( reactorProjects ) );
287 }
288
289 @Test
290 public void testRewriteManagedPomUnmappedDependencies()
291 throws Exception
292 {
293 List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" );
294 ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects, "internal-managed-snapshot-dependency" );
295
296 try
297 {
298 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
299
300 fail( "Should have thrown an exception" );
301 }
302 catch ( ReleaseFailureException e )
303 {
304 assertTrue( true );
305 }
306 }
307
308 @Test
309 public void testRewritePomPlugins()
310 throws Exception
311 {
312 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugins" );
313 ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects, "internal-snapshot-plugins" );
314
315 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
316
317 assertTrue( comparePomFiles( reactorProjects ) );
318 }
319
320 @Test
321 public void testRewritePomUnmappedPlugins()
322 throws Exception
323 {
324 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugins" );
325 ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects, "internal-snapshot-plugins" );
326
327 try
328 {
329 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
330
331 fail( "Should have thrown an exception" );
332 }
333 catch ( ReleaseFailureException e )
334 {
335 assertTrue( true );
336 }
337 }
338
339 @Test
340 public void testRewritePomPluginsDifferentVersion()
341 throws Exception
342 {
343 List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-plugins" );
344 ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects, "internal-differing-snapshot-plugins" );
345
346 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
347
348 assertTrue( comparePomFiles( reactorProjects ) );
349 }
350
351 @Test
352 public void testRewriteManagedPomPlugins()
353 throws Exception
354 {
355 List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" );
356 ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects, "internal-managed-snapshot-plugin" );
357
358 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
359
360 assertTrue( comparePomFiles( reactorProjects ) );
361 }
362
363 @Test
364 public void testRewriteManagedPomUnmappedPlugins()
365 throws Exception
366 {
367 List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" );
368 ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects, "internal-managed-snapshot-plugin" );
369
370 try
371 {
372 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
373
374 fail( "Should have thrown an exception" );
375 }
376 catch ( ReleaseFailureException e )
377 {
378 assertTrue( true );
379 }
380 }
381
382 @Test
383 public void testRewritePomReportPlugins()
384 throws Exception
385 {
386 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" );
387 ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects, "internal-snapshot-report-plugins" );
388
389 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
390
391 assertTrue( comparePomFiles( reactorProjects ) );
392 }
393
394 @Test
395 public void testRewritePomUnmappedReportPlugins()
396 throws Exception
397 {
398 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" );
399 ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects, "internal-snapshot-report-plugins" );
400
401 try
402 {
403 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
404
405 fail( "Should have thrown an exception" );
406 }
407 catch ( ReleaseFailureException e )
408 {
409 assertTrue( true );
410 }
411 }
412
413 @Test
414 public void testRewritePomReportPluginsDifferentVersion()
415 throws Exception
416 {
417 List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-report-plugins" );
418 ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects, "internal-differing-snapshot-report-plugins" );
419
420 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
421
422 assertTrue( comparePomFiles( reactorProjects ) );
423 }
424
425 @Test
426 @Ignore( "Extensions being part of reactor is not supported anymore" )
427 public void testRewritePomExtension()
428 throws Exception
429 {
430 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-extension" );
431 ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects, "internal-snapshot-extension" );
432
433 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
434
435 assertTrue( comparePomFiles( reactorProjects ) );
436 }
437
438 @Test
439 @Ignore( "Extensions being part of reactor is not supported anymore" )
440 public void testRewritePomUnmappedExtension()
441 throws Exception
442 {
443 List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-extension" );
444 ReleaseDescriptorBuilder builder = createUnmappedConfiguration( reactorProjects, "internal-snapshot-extension" );
445
446 try
447 {
448 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
449
450 fail( "Should have thrown an exception" );
451 }
452 catch ( ReleaseFailureException e )
453 {
454 assertTrue( true );
455 }
456 }
457
458 @Test
459 @Ignore( "Extensions being part of reactor is not supported anymore" )
460 public void testRewritePomExtensionDifferentVersion()
461 throws Exception
462 {
463 List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-extension" );
464 ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects, "internal-differing-snapshot-extension" );
465
466 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
467
468 assertTrue( comparePomFiles( reactorProjects ) );
469 }
470
471 @Test
472 @Ignore( "Extensions being part of reactor is not supported anymore" )
473 public void testRewritePomExtensionUndefinedVersion()
474 throws Exception
475 {
476 List<MavenProject> reactorProjects = createReactorProjects( "pom-without-extension-version" );
477 ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects, "pom-without-extension-version" );
478
479 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
480
481 assertTrue( comparePomFiles( reactorProjects ) );
482 }
483
484 @Test
485 public void testRewriteAddSchema()
486 throws Exception
487 {
488 boolean copyFiles = true;
489
490
491 for ( int i = 0; i < 2; i++ )
492 {
493 String path = "basic-pom";
494 List<MavenProject> reactorProjects = prepareReactorProjects( path );
495 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom" );
496 mapNextVersion( builder, "groupId:artifactId" );
497 builder.setAddSchema( true );
498
499 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
500
501 comparePomFiles( reactorProjects, "-with-schema" );
502
503 copyFiles = false;
504
505 verifyReactorProjects( path, copyFiles );
506 }
507 }
508
509 @Test
510 public void testSimulateRewriteEditModeSkipped()
511 throws Exception
512 {
513
514 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
515 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom" );
516 builder.setScmUseEditMode( true );
517 mapNextVersion( builder, "groupId:artifactId" );
518
519 ScmProvider scmProviderMock = mock( ScmProvider.class );
520
521 ScmManagerStub scmManager = new ScmManagerStub();
522 DefaultScmRepositoryConfigurator configurator =
523 (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.class );
524 configurator.setScmManager( scmManager );
525 scmManager.setScmProvider( scmProviderMock );
526
527
528 phase.simulate( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
529
530
531 verifyNoMoreInteractions( scmProviderMock );
532 }
533
534 @Test
535 public void testRewriteUnmappedPom()
536 throws Exception
537 {
538 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
539 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom" );
540
541 try
542 {
543 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
544
545 fail( "Should have thrown an exception" );
546 }
547 catch ( ReleaseFailureException e )
548 {
549 assertTrue( true );
550 }
551 }
552
553 @Test
554 public void testRewriteBasicPomWithScmRepoException()
555 throws Exception
556 {
557
558 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
559 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom" );
560 builder.setScmUseEditMode( true );
561 builder.setScmSourceUrl( "scm:svn:fail" );
562 mapNextVersion( builder, "groupId:artifactId" );
563
564 ScmManager scmManager = lookup( ScmManager.class );
565 if ( scmManager instanceof ScmManagerStub )
566 {
567 ((ScmManagerStub) scmManager ).setException( new ScmRepositoryException( "..." ) );
568 }
569
570 try
571 {
572 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
573
574 fail( "Should have thrown an exception" );
575 }
576 catch ( ReleaseScmRepositoryException e )
577 {
578 assertNull( "Check no additional cause", e.getCause() );
579 }
580 }
581
582 @Test
583 public void testRewriteBasicPomWithNoSuchProviderException()
584 throws Exception
585 {
586
587 List<MavenProject> reactorProjects = createReactorProjects( "basic-pom" );
588 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom( reactorProjects, "basic-pom" );
589 builder.setScmUseEditMode( true );
590 builder.setScmSourceUrl( "scm:fail:path" );
591 mapNextVersion( builder, "groupId:artifactId" );
592
593 ScmManager scmManager = (ScmManager) lookup( ScmManager.class );
594 if ( scmManager instanceof ScmManagerStub )
595 {
596 ((ScmManagerStub) scmManager ).setException( new NoSuchScmProviderException( "..." ) );;
597 }
598
599
600 try
601 {
602 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
603
604 fail( "Should have thrown an exception" );
605 }
606 catch ( ReleaseExecutionException e )
607 {
608
609 assertEquals( "Check cause", NoSuchScmProviderException.class, e.getCause().getClass() );
610 }
611 }
612
613 @Test
614 public void testRewriteWhitespaceAroundValues()
615 throws Exception
616 {
617 List<MavenProject> reactorProjects = createReactorProjects( "whitespace-around-values" );
618 ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects, "whitespace-around-values" );
619 mapNextVersion( builder, "groupId:subproject2" );
620
621 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
622
623 assertTrue( comparePomFiles( reactorProjects ) );
624 }
625
626 @Test
627 public void testRewriteCommentsAroundValues()
628 throws Exception
629 {
630 List<MavenProject> reactorProjects = createReactorProjects( "comments-around-values" );
631 ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects, "comments-around-values" );
632 mapNextVersion( builder, "groupId:subproject2" );
633
634 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
635
636 assertTrue( comparePomFiles( reactorProjects ) );
637 }
638
639 @Test
640 public void testRewriteCDataAroundValues()
641 throws Exception
642 {
643 List<MavenProject> reactorProjects = createReactorProjects( "cdata-around-values" );
644 ReleaseDescriptorBuilder builder = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects, "cdata-around-values" );
645 mapNextVersion( builder, "groupId:subproject2" );
646
647 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
648
649 assertTrue( comparePomFiles( reactorProjects ) );
650 }
651
652 @Test
653 public void testCleanNoProjects()
654 throws Exception
655 {
656
657 ( (ResourceGenerator) phase ).clean( Collections.<MavenProject>emptyList() );
658 }
659
660 protected ReleaseDescriptorBuilder createUnmappedConfiguration( List<MavenProject> reactorProjects, String workingDirectory )
661 throws Exception
662 {
663 ReleaseDescriptorBuilder builder = createDescriptorFromProjects( reactorProjects, workingDirectory );
664
665 unmapNextVersion( builder, "groupId:subproject1" );
666 mapNextVersion( builder, "groupId:subproject2" );
667 mapNextVersion( builder, "groupId:subproject3" );
668 mapNextVersion( builder, "groupId:artifactId" );
669 return builder;
670 }
671
672 protected List<MavenProject> createReactorProjects( String path )
673 throws Exception
674 {
675 return prepareReactorProjects( path );
676 }
677
678 protected ReleaseDescriptorBuilder createDefaultConfiguration( List<MavenProject> reactorProjects, String workingDirectory )
679 throws Exception
680 {
681 ReleaseDescriptorBuilder builder = createMappedConfiguration( reactorProjects, workingDirectory );
682
683 mapNextVersion( builder, "groupId:subproject4" );
684 return builder;
685 }
686
687 protected ReleaseDescriptorBuilder createMappedConfiguration( List<MavenProject> reactorProjects, String workingDirectory )
688 throws Exception
689 {
690 ReleaseDescriptorBuilder builder = createDifferingVersionConfiguration( reactorProjects, workingDirectory );
691
692 mapNextVersion( builder, "groupId:subproject3" );
693 return builder;
694 }
695
696 private ReleaseDescriptorBuilder createDifferingVersionConfiguration( List<MavenProject> reactorProjects, String workingDirectory )
697 throws Exception
698 {
699 ReleaseDescriptorBuilder builder = createConfigurationForWithParentNextVersion( reactorProjects, workingDirectory );
700
701 mapNextVersion( builder, "groupId:subproject2" );
702 return builder;
703 }
704
705 protected abstract ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects, String workingDirectory )
706 throws Exception;
707
708 protected abstract void unmapNextVersion( ReleaseDescriptorBuilder config, String projectId );
709
710 protected abstract void mapNextVersion( ReleaseDescriptorBuilder config, String projectId );
711
712 protected ReleaseDescriptorBuilder createDescriptorFromBasicPom( List<MavenProject> reactorProjects, String workingDirectory )
713 throws Exception
714 {
715 return createDescriptorFromProjects( reactorProjects, workingDirectory );
716 }
717
718 protected abstract String readTestProjectFile( String fileName )
719 throws IOException;
720
721 @Test
722 public void testRewritePomDependenciesWithNamespace()
723 throws Exception
724 {
725 List<MavenProject> reactorProjects = createReactorProjects( "pom-with-namespace" );
726 ReleaseDescriptorBuilder builder = createDefaultConfiguration( reactorProjects, "pom-with-namespace" );
727
728 phase.execute( ReleaseUtils.buildReleaseDescriptor( builder ), new DefaultReleaseEnvironment(), reactorProjects );
729
730 assertTrue( comparePomFiles( reactorProjects ) );
731 }
732
733 protected abstract List<MavenProject> prepareReactorProjects( String path )
734 throws Exception;
735
736 protected void verifyReactorProjects( String path, boolean copyFiles )
737 throws Exception
738 {
739 }
740
741 protected ReleaseDescriptorBuilder createDescriptorFromProjects( List<MavenProject> reactorProjects, String workingDirectory )
742 {
743 ReleaseDescriptorBuilder builder = createDescriptorFromProjects( new ReleaseDescriptorBuilder(), reactorProjects );
744 builder.setWorkingDirectory( getWorkingDirectory( workingDirectory ).toString() );
745 return builder;
746 }
747
748 private ReleaseDescriptorBuilder createDescriptorFromProjects( ReleaseDescriptorBuilder builder, List<MavenProject> reactorProjects )
749 {
750 MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
751
752 for ( MavenProject project : reactorProjects )
753 {
754 String key = project.getGroupId() + ':' + project.getArtifactId();
755 builder.putOriginalVersion( key, project.getVersion() );
756 builder.addOriginalScmInfo( key, project.getScm() );
757 }
758
759 if ( rootProject.getScm() == null )
760 {
761 builder.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
762 }
763 else
764 {
765 builder.setScmSourceUrl( rootProject.getScm().getConnection() );
766 }
767
768 return builder;
769 }
770 }