View Javadoc
1   package org.apache.maven.shared.release.phase;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import static org.mockito.Mockito.mock;
23  import static org.mockito.Mockito.verify;
24  import static org.mockito.Mockito.verifyNoMoreInteractions;
25  import static org.mockito.Mockito.when;
26  
27  import java.io.IOException;
28  import java.util.ArrayList;
29  import java.util.Collections;
30  import java.util.List;
31  
32  import org.apache.maven.project.MavenProject;
33  import org.apache.maven.scm.manager.NoSuchScmProviderException;
34  import org.apache.maven.scm.manager.ScmManager;
35  import org.apache.maven.scm.manager.ScmManagerStub;
36  import org.apache.maven.scm.provider.ScmProvider;
37  import org.apache.maven.scm.repository.ScmRepositoryException;
38  import org.apache.maven.shared.release.ReleaseExecutionException;
39  import org.apache.maven.shared.release.ReleaseFailureException;
40  import org.apache.maven.shared.release.config.ReleaseDescriptor;
41  import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
42  import org.apache.maven.shared.release.scm.DefaultScmRepositoryConfigurator;
43  import org.apache.maven.shared.release.scm.ReleaseScmRepositoryException;
44  import org.apache.maven.shared.release.scm.ScmRepositoryConfigurator;
45  import org.apache.maven.shared.release.util.ReleaseUtil;
46  
47  /**
48   * Base class with tests for rewriting POMs.
49   *
50   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
51   */
52  public abstract class AbstractRewritingReleasePhaseTestCase
53      extends AbstractReleaseTestCase
54  {
55      public void testRewriteBasicPom()
56          throws Exception
57      {
58          List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
59          ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
60          mapNextVersion( config, "groupId:artifactId" );
61  
62          phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
63  
64          assertTrue( comparePomFiles( reactorProjects ) );
65      }
66  
67      public void testRewriteBasicPomEntities()
68          throws Exception
69      {
70          List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-entities" );
71          ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
72          mapNextVersion( config, "groupId:artifactId" );
73  
74          phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
75  
76          assertTrue( comparePomFiles( reactorProjects ) );
77      }
78  
79      public void testRewriteBasicPomNamespace()
80          throws Exception
81      {
82          List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-namespace" );
83          ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
84          mapNextVersion( config, "groupId:artifactId" );
85  
86          phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
87  
88          assertTrue( comparePomFiles( reactorProjects ) );
89      }
90  
91      public void testRewriteBasicPomWithEncoding()
92          throws Exception
93      {
94          List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-encoding" );
95          ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
96          mapNextVersion( config, "groupId:artifactId" );
97  
98          phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
99  
100         assertTrue( comparePomFiles( reactorProjects ) );
101     }
102 
103     public void testRewritePomWithParent()
104         throws Exception
105     {
106         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent" );
107         ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
108 
109         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
110 
111         assertTrue( comparePomFiles( reactorProjects ) );
112     }
113 
114     public void testRewritePomWithUnmappedParent()
115         throws Exception
116     {
117 
118         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent" );
119         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
120 
121         // Process the child first
122         reactorProjects = new ArrayList<MavenProject>( reactorProjects );
123         Collections.reverse( reactorProjects );
124 
125         mapAlternateNextVersion( config, "groupId:subproject1" );
126 
127         try
128         {
129             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
130 
131             fail( "Should have thrown an exception" );
132         }
133         catch ( ReleaseFailureException e )
134         {
135             assertTrue( true );
136         }
137     }
138 
139     public void testRewritePomWithReleasedParent()
140         throws Exception
141     {
142 
143         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-released-parent" );
144         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
145 
146         mapAlternateNextVersion( config, "groupId:subproject1" );
147         config.mapReleaseVersion( "groupId:artifactId", "1" );
148         config.mapDevelopmentVersion( "groupId:artifactId", "1" );
149 
150         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
151 
152         assertTrue( comparePomFiles( reactorProjects ) );
153     }
154 
155     protected abstract void mapAlternateNextVersion( ReleaseDescriptor config, String projectId );
156 
157     public void testRewritePomWithInheritedVersion()
158         throws Exception
159     {
160         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-inherited-version" );
161         ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
162 
163         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
164 
165         assertTrue( comparePomFiles( reactorProjects ) );
166     }
167 
168     public void testRewritePomWithChangedInheritedVersion()
169         throws Exception
170     {
171         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-inherited-version" );
172         ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
173 
174         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
175 
176         MavenProject project = (MavenProject) getProjectsAsMap( reactorProjects ).get( "groupId:subproject1" );
177         comparePomFiles( project, "-version-changed" );
178     }
179 
180     protected abstract ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
181         throws Exception;
182 
183     public void testRewritePomDependencies()
184         throws Exception
185     {
186         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-dependencies" );
187         ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
188         mapNextVersion( config, "groupId:subsubproject" );
189 
190         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
191 
192         assertTrue( comparePomFiles( reactorProjects ) );
193     }
194 
195     public void testRewritePomUnmappedDependencies()
196         throws Exception
197     {
198         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-dependencies" );
199         ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
200 
201         try
202         {
203             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
204 
205             fail( "Should have thrown an exception" );
206         }
207         catch ( ReleaseFailureException e )
208         {
209             assertTrue( true );
210         }
211     }
212 
213     public void testRewritePomDependenciesDifferentVersion()
214         throws Exception
215     {
216         List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-dependencies" );
217         ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
218 
219         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
220 
221         assertTrue( comparePomFiles( reactorProjects ) );
222     }
223 
224     public void testRewriteManagedPomDependencies()
225         throws Exception
226     {
227         List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" );
228         ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
229 
230         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
231 
232         assertTrue( comparePomFiles( reactorProjects ) );
233     }
234 
235     public void testRewriteManagedPomUnmappedDependencies()
236         throws Exception
237     {
238         List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-dependency" );
239         ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
240 
241         try
242         {
243             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
244 
245             fail( "Should have thrown an exception" );
246         }
247         catch ( ReleaseFailureException e )
248         {
249             assertTrue( true );
250         }
251     }
252 
253     public void testRewritePomPlugins()
254         throws Exception
255     {
256         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugins" );
257         ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
258 
259         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
260 
261         assertTrue( comparePomFiles( reactorProjects ) );
262     }
263 
264     public void testRewritePomUnmappedPlugins()
265         throws Exception
266     {
267         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-plugins" );
268         ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
269 
270         try
271         {
272             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
273 
274             fail( "Should have thrown an exception" );
275         }
276         catch ( ReleaseFailureException e )
277         {
278             assertTrue( true );
279         }
280     }
281 
282     public void testRewritePomPluginsDifferentVersion()
283         throws Exception
284     {
285         List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-plugins" );
286         ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
287 
288         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
289 
290         assertTrue( comparePomFiles( reactorProjects ) );
291     }
292 
293     public void testRewriteManagedPomPlugins()
294         throws Exception
295     {
296         List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" );
297         ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
298 
299         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
300 
301         assertTrue( comparePomFiles( reactorProjects ) );
302     }
303 
304     public void testRewriteManagedPomUnmappedPlugins()
305         throws Exception
306     {
307         List<MavenProject> reactorProjects = createReactorProjects( "internal-managed-snapshot-plugin" );
308         ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
309 
310         try
311         {
312             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
313 
314             fail( "Should have thrown an exception" );
315         }
316         catch ( ReleaseFailureException e )
317         {
318             assertTrue( true );
319         }
320     }
321 
322     public void testRewritePomReportPlugins()
323         throws Exception
324     {
325         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" );
326         ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
327 
328         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
329 
330         assertTrue( comparePomFiles( reactorProjects ) );
331     }
332 
333     public void testRewritePomUnmappedReportPlugins()
334         throws Exception
335     {
336         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-report-plugins" );
337         ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
338 
339         try
340         {
341             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
342 
343             fail( "Should have thrown an exception" );
344         }
345         catch ( ReleaseFailureException e )
346         {
347             assertTrue( true );
348         }
349     }
350 
351     public void testRewritePomReportPluginsDifferentVersion()
352         throws Exception
353     {
354         List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-report-plugins" );
355         ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
356 
357         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
358 
359         assertTrue( comparePomFiles( reactorProjects ) );
360     }
361 
362     public void testRewritePomExtension()
363         throws Exception
364     {
365         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-extension" );
366         ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
367 
368         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
369 
370         assertTrue( comparePomFiles( reactorProjects ) );
371     }
372 
373     public void testRewritePomUnmappedExtension()
374         throws Exception
375     {
376         List<MavenProject> reactorProjects = createReactorProjects( "internal-snapshot-extension" );
377         ReleaseDescriptor config = createUnmappedConfiguration( reactorProjects );
378 
379         try
380         {
381             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
382 
383             fail( "Should have thrown an exception" );
384         }
385         catch ( ReleaseFailureException e )
386         {
387             assertTrue( true );
388         }
389     }
390 
391     public void testRewritePomExtensionDifferentVersion()
392         throws Exception
393     {
394         List<MavenProject> reactorProjects = createReactorProjects( "internal-differing-snapshot-extension" );
395         ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
396 
397         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
398 
399         assertTrue( comparePomFiles( reactorProjects ) );
400     }
401 
402     public void testRewritePomExtensionUndefinedVersion()
403         throws Exception
404     {
405         List<MavenProject> reactorProjects = createReactorProjects( "pom-without-extension-version" );
406         ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
407 
408         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
409 
410         assertTrue( comparePomFiles( reactorProjects ) );
411     }
412 
413     public void testRewriteAddSchema()
414         throws Exception
415     {
416         boolean copyFiles = true;
417 
418         // Run a second time to check they are not duplicated
419         for ( int i = 0; i < 2; i++ )
420         {
421             String path = "basic-pom";
422             List<MavenProject> reactorProjects = prepareReactorProjects( path, copyFiles );
423             ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
424             mapNextVersion( config, "groupId:artifactId" );
425             config.setAddSchema( true );
426 
427             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
428 
429             comparePomFiles( reactorProjects, "-with-schema" );
430 
431             copyFiles = false;
432             
433             verifyReactorProjects( path, copyFiles );
434         }
435     }
436 
437     public void testSimulateRewriteEditModeSkipped()
438         throws Exception
439     {
440         // prepare
441         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
442         ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
443         config.setScmUseEditMode( true );
444         mapNextVersion( config, "groupId:artifactId" );
445 
446         ScmProvider scmProviderMock = mock( ScmProvider.class );
447 
448         ScmManagerStub scmManager = new ScmManagerStub();
449         DefaultScmRepositoryConfigurator configurator =
450             (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.ROLE );
451         configurator.setScmManager( scmManager );
452         scmManager.setScmProvider( scmProviderMock );
453 
454         // execute
455         phase.simulate( config,  new DefaultReleaseEnvironment(), reactorProjects );
456 
457         // verify
458         verifyNoMoreInteractions( scmProviderMock );
459     }
460 
461     public void testRewriteUnmappedPom()
462         throws Exception
463     {
464         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
465         ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
466 
467         try
468         {
469             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
470 
471             fail( "Should have thrown an exception" );
472         }
473         catch ( ReleaseFailureException e )
474         {
475             assertTrue( true );
476         }
477     }
478 
479     public void testRewriteBasicPomWithScmRepoException()
480         throws Exception
481     {
482         // prepare
483         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
484         ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
485         config.setScmUseEditMode( true );
486         mapNextVersion( config, "groupId:artifactId" );
487 
488         ScmManager scmManagerMock = mock( ScmManager.class );
489         when( scmManagerMock.makeScmRepository( config.getScmSourceUrl() ) ).thenThrow( new ScmRepositoryException( "..." ) );
490 
491         DefaultScmRepositoryConfigurator configurator =
492             (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.ROLE );
493         configurator.setScmManager( scmManagerMock );
494 
495         try
496         {
497             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
498 
499             fail( "Should have thrown an exception" );
500         }
501         catch ( ReleaseScmRepositoryException e )
502         {
503             assertNull( "Check no additional cause", e.getCause() );
504         }
505         
506         verify( scmManagerMock ).makeScmRepository( config.getScmSourceUrl() );
507         verifyNoMoreInteractions( scmManagerMock );
508     }
509 
510     public void testRewriteBasicPomWithNoSuchProviderException()
511         throws Exception
512     {
513         // prepare
514         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
515         ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
516         config.setScmUseEditMode( true );
517         mapNextVersion( config, "groupId:artifactId" );
518 
519         ScmManager scmManagerMock = mock( ScmManager.class );
520         when( scmManagerMock.makeScmRepository( config.getScmSourceUrl() ) ).thenThrow( new NoSuchScmProviderException( "..." ) );
521 
522         DefaultScmRepositoryConfigurator configurator =
523             (DefaultScmRepositoryConfigurator) lookup( ScmRepositoryConfigurator.ROLE );
524         configurator.setScmManager( scmManagerMock );
525 
526         // execute
527         try
528         {
529             phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
530 
531             fail( "Should have thrown an exception" );
532         }
533         catch ( ReleaseExecutionException e )
534         {
535             assertEquals( "Check cause", NoSuchScmProviderException.class, e.getCause().getClass() );
536         }
537         
538         // verify
539         verify( scmManagerMock ).makeScmRepository( config.getScmSourceUrl() );
540         verifyNoMoreInteractions( scmManagerMock );
541     }
542 
543     public void testRewriteWhitespaceAroundValues()
544         throws Exception
545     {
546         List<MavenProject> reactorProjects = createReactorProjects( "whitespace-around-values" );
547         ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
548         mapNextVersion( config, "groupId:subproject2" );
549 
550         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
551 
552         assertTrue( comparePomFiles( reactorProjects ) );
553     }
554 
555     public void testRewriteCommentsAroundValues()
556         throws Exception
557     {
558         List<MavenProject> reactorProjects = createReactorProjects( "comments-around-values" );
559         ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
560         mapNextVersion( config, "groupId:subproject2" );
561 
562         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
563 
564         assertTrue( comparePomFiles( reactorProjects ) );
565     }
566 
567     public void testRewriteCDataAroundValues()
568         throws Exception
569     {
570         List<MavenProject> reactorProjects = createReactorProjects( "cdata-around-values" );
571         ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
572         mapNextVersion( config, "groupId:subproject2" );
573 
574         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
575 
576         assertTrue( comparePomFiles( reactorProjects ) );
577     }
578 
579     public void testCleanNoProjects()
580         throws Exception
581     {
582         // This occurs when it is release:perform run standalone. Just check there are no errors.
583         ReleaseDescriptor config = new ReleaseDescriptor();
584         config.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo" );
585         config.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
586 
587         phase.clean( Collections.<MavenProject>emptyList() );
588 
589         assertTrue( true );
590     }
591 
592     protected ReleaseDescriptor createUnmappedConfiguration( List<MavenProject> reactorProjects )
593         throws Exception
594     {
595         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
596 
597         unmapNextVersion( config, "groupId:subproject1" );
598         mapNextVersion( config, "groupId:subproject2" );
599         mapNextVersion( config, "groupId:subproject3" );
600         mapNextVersion( config, "groupId:artifactId" );
601         return config;
602     }
603 
604     protected List<MavenProject> createReactorProjects( String path )
605         throws Exception
606     {
607         return prepareReactorProjects( path, true );
608     }
609 
610     protected ReleaseDescriptor createDefaultConfiguration( List<MavenProject> reactorProjects )
611         throws Exception
612     {
613         ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
614 
615         mapNextVersion( config, "groupId:subproject4" );
616         return config;
617     }
618 
619     protected ReleaseDescriptor createMappedConfiguration( List<MavenProject> reactorProjects )
620         throws Exception
621     {
622         ReleaseDescriptor config = createDifferingVersionConfiguration( reactorProjects );
623 
624         mapNextVersion( config, "groupId:subproject3" );
625         return config;
626     }
627 
628     private ReleaseDescriptor createDifferingVersionConfiguration( List<MavenProject> reactorProjects )
629         throws Exception
630     {
631         ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
632 
633         mapNextVersion( config, "groupId:subproject2" );
634         return config;
635     }
636 
637     protected List<MavenProject> createReactorProjectsFromBasicPom()
638         throws Exception
639     {
640         return createReactorProjects( "basic-pom" );
641     }
642 
643     protected abstract ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
644         throws Exception;
645 
646     protected abstract void unmapNextVersion( ReleaseDescriptor config, String projectId );
647 
648     protected abstract void mapNextVersion( ReleaseDescriptor config, String projectId );
649 
650     protected ReleaseDescriptor createDescriptorFromBasicPom( List<MavenProject> reactorProjects )
651         throws Exception
652     {
653         return createDescriptorFromProjects( reactorProjects );
654     }
655 
656     protected abstract String readTestProjectFile( String fileName )
657         throws IOException;
658 
659     public void testRewritePomDependenciesWithNamespace()
660         throws Exception
661     {
662         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-namespace" );
663         ReleaseDescriptor config = createDefaultConfiguration( reactorProjects );
664 
665         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
666 
667         assertTrue( comparePomFiles( reactorProjects ) );
668     }
669 
670     protected abstract List<MavenProject> prepareReactorProjects( String path, boolean copyFiles )
671         throws Exception;
672     
673     protected void verifyReactorProjects( String path, boolean copyFiles ) throws Exception
674     {
675     }
676 
677     protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
678     {
679         ReleaseDescriptor descriptor = new ReleaseDescriptor();
680         MavenProject rootProject = ReleaseUtil.getRootProject( reactorProjects );
681         if ( rootProject.getScm() == null )
682         {
683             descriptor.setScmSourceUrl( "scm:svn:file://localhost/tmp/scm-repo/trunk" );
684         }
685         else
686         {
687             descriptor.setScmSourceUrl( rootProject.getScm().getConnection() );
688         }
689 
690         descriptor.setWorkingDirectory( getTestFile( "target/test/checkout" ).getAbsolutePath() );
691 
692         return descriptor;
693     }
694 }