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 java.io.File;
23  import java.io.IOException;
24  import java.util.Iterator;
25  import java.util.List;
26  
27  import org.apache.maven.project.MavenProject;
28  import org.apache.maven.shared.release.config.ReleaseDescriptor;
29  import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
30  import org.apache.maven.shared.release.util.ReleaseUtil;
31  
32  /**
33   * Test the SCM modification check phase.
34   *
35   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
36   */
37  public class RewritePomsForReleasePhaseTest
38      extends AbstractEditModeRewritingReleasePhaseTestCase
39  {
40      private static final String NEXT_VERSION = "1.0";
41  
42      private static final String ALTERNATIVE_NEXT_VERSION = "2.0";
43  
44      protected void setUp()
45          throws Exception
46      {
47          super.setUp();
48  
49          phase = (ReleasePhase) lookup( ReleasePhase.ROLE, "rewrite-poms-for-release" );
50      }
51  
52      protected List<MavenProject> prepareReactorProjects( String path, boolean copyFiles )
53          throws Exception
54      {
55          return createReactorProjects( "rewrite-for-release/", path );
56      }
57  
58      protected String readTestProjectFile( String fileName )
59          throws IOException
60      {
61          return ReleaseUtil.readXmlFile( getTestFile( "target/test-classes/projects/rewrite-for-release/" + fileName ) );
62      }
63  
64      public void testSimulateRewrite()
65          throws Exception
66      {
67          List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
68          ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
69          config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
70  
71          String expected = readTestProjectFile( "basic-pom/pom.xml" );
72  
73          phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
74  
75          String actual = readTestProjectFile( "basic-pom/pom.xml" );
76          assertEquals( "Check the original POM untouched", expected, actual );
77  
78          expected = readTestProjectFile( "basic-pom/expected-pom.xml" );
79          actual = readTestProjectFile( "basic-pom/pom.xml.tag" );
80          assertEquals( "Check the transformed POM", expected, actual );
81      }
82  
83      public void testRewriteWithDashedComments()
84          throws Exception
85      {
86          List<MavenProject> reactorProjects = createReactorProjects("basic-pom-with-dashes-in-comment");
87          ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
88          config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
89  
90          String expected = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
91  
92          phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
93  
94          String actual = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml" );
95          assertEquals( "Check the original POM is untouched", expected, actual );
96  
97          expected = readTestProjectFile( "basic-pom-with-dashes-in-comment/expected-pom.xml" );
98          actual = readTestProjectFile( "basic-pom-with-dashes-in-comment/pom.xml.tag" );
99          assertEquals( "Check the transformed POM", expected, actual );
100     }
101 
102     public void testClean()
103         throws Exception
104     {
105         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
106         ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
107         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
108 
109         File testFile = getTestFile( "target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag" );
110         testFile.delete();
111         assertFalse( testFile.exists() );
112 
113         phase.simulate( config, new DefaultReleaseEnvironment(), reactorProjects );
114 
115         assertTrue( testFile.exists() );
116 
117         phase.clean( reactorProjects );
118 
119         assertFalse( testFile.exists() );
120     }
121 
122     public void testCleanNotExists()
123         throws Exception
124     {
125         List<MavenProject> reactorProjects = createReactorProjectsFromBasicPom();
126         ReleaseDescriptor config = createDescriptorFromBasicPom( reactorProjects );
127         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
128 
129         File testFile = getTestFile( "target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag" );
130         testFile.delete();
131         assertFalse( testFile.exists() );
132 
133         phase.clean( reactorProjects );
134 
135         assertFalse( testFile.exists() );
136     }
137 
138     //MRELEASE-116
139     public void testScmOverridden()
140         throws Exception
141     {
142         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-overridden-scm" );
143         ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
144         config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
145 
146         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
147 
148         assertTrue( comparePomFiles( reactorProjects ) );
149     }
150 
151     protected void mapAlternateNextVersion( ReleaseDescriptor config, String projectId )
152     {
153         config.mapReleaseVersion( projectId, ALTERNATIVE_NEXT_VERSION );
154     }
155 
156     protected void mapNextVersion( ReleaseDescriptor config, String projectId )
157     {
158         config.mapReleaseVersion( projectId, NEXT_VERSION );
159     }
160 
161     protected ReleaseDescriptor createConfigurationForPomWithParentAlternateNextVersion( List<MavenProject> reactorProjects )
162         throws Exception
163     {
164         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
165 
166         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
167         config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
168         return config;
169     }
170 
171     protected ReleaseDescriptor createConfigurationForWithParentNextVersion( List<MavenProject> reactorProjects )
172         throws Exception
173     {
174         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
175 
176         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
177         config.mapReleaseVersion( "groupId:subproject1", NEXT_VERSION );
178         return config;
179     }
180 
181     protected void unmapNextVersion( ReleaseDescriptor config, String projectId )
182     {
183         // nothing to do
184     }
185 
186     public void testRewriteBasicPomWithCvs()
187         throws Exception
188     {
189 
190         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs" );
191         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
192         mapNextVersion( config, "groupId:artifactId" );
193 
194         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
195 
196         assertTrue( comparePomFiles( reactorProjects ) );
197     }
198 
199     public void testRewriteBasicPomWithScmExpression()
200         throws Exception
201     {
202 
203         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-scm-expression" );
204         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
205         mapNextVersion( config, "groupId:artifactId" );
206 
207         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
208 
209         assertTrue( comparePomFiles( reactorProjects ) );
210     }
211 
212     public void testRewriteBasicPomWithTagBase()
213         throws Exception
214     {
215 
216         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base" );
217         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
218         config.setScmTagBase( "file://localhost/tmp/scm-repo/releases" );
219         mapNextVersion( config, "groupId:artifactId" );
220 
221         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
222 
223         assertTrue( comparePomFiles( reactorProjects ) );
224     }
225 
226     public void testRewriteBasicPomWithTagBaseAndVaryingScmUrls()
227         throws Exception
228     {
229         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-tag-base-and-varying-scm-urls" );
230         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
231         config.setScmTagBase( "file://localhost/tmp/scm-repo/allprojects/releases" );
232         mapNextVersion( config, "groupId:artifactId" );
233 
234         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
235 
236         assertTrue( comparePomFiles( reactorProjects ) );
237     }
238 
239     public void testRewriteBasicPomWithCvsFromTag()
240         throws Exception
241     {
242         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-cvs-from-tag" );
243         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
244         mapNextVersion( config, "groupId:artifactId" );
245 
246         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
247 
248         assertTrue( comparePomFiles( reactorProjects ) );
249     }
250 
251     public void testRewriteBasicPomWithEmptyScm()
252         throws Exception
253     {
254         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-with-empty-scm" );
255         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
256         mapNextVersion( config, "groupId:artifactId" );
257 
258         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
259 
260         assertTrue( comparePomFiles( reactorProjects ) );
261     }
262 
263     public void testRewriteInterpolatedVersions()
264         throws Exception
265     {
266         List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
267         ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
268 
269         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
270 
271         assertTrue( comparePomFiles( reactorProjects ) );
272     }
273 
274     public void testRewriteInterpolatedVersionsDifferentVersion()
275         throws Exception
276     {
277         List<MavenProject> reactorProjects = createReactorProjects( "interpolated-versions" );
278         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
279 
280         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
281         config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
282         config.mapReleaseVersion( "groupId:subproject2", NEXT_VERSION );
283         config.mapReleaseVersion( "groupId:subproject3", NEXT_VERSION );
284 
285         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
286 
287         for ( Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); )
288         {
289             MavenProject project = i.next();
290 
291             // skip subproject1 - we don't need to worry about its version mapping change, it has no deps of any kind
292             if ( !"groupId".equals( project.getGroupId() ) || !"subproject1".equals( project.getArtifactId() ) )
293             {
294                 comparePomFiles( project, "-different-version", true );
295             }
296         }
297     }
298 
299     public void testRewriteBasicPomWithInheritedScm()
300         throws Exception
301     {
302         List<MavenProject> reactorProjects = createReactorProjects( "basic-pom-inherited-scm" );
303         ReleaseDescriptor config = createConfigurationForWithParentNextVersion( reactorProjects );
304         config.mapReleaseVersion( "groupId:subsubproject", NEXT_VERSION );
305 
306         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
307 
308         assertTrue( comparePomFiles( reactorProjects ) );
309     }
310 
311     public void testRewritePomWithParentAndProperties()
312         throws Exception
313     {
314         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-parent-and-properties" );
315 
316         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
317         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
318         config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
319         config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
320 
321         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
322 
323         assertTrue( comparePomFiles( reactorProjects ) );
324     }
325 
326     // MRELEASE-311
327     public void testRewritePomWithDependencyPropertyCoordinate()
328         throws Exception
329     {
330         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-property-dependency-coordinate" );
331 
332         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
333         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
334         config.mapReleaseVersion( "groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION );
335         config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
336 
337         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
338 
339         assertTrue( comparePomFiles( reactorProjects ) );
340     }
341 
342     // MRELEASE-305
343     public void testRewritePomWithScmOfParentEndingWithASlash()
344         throws Exception
345     {
346         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-scm-of-parent-ending-with-a-slash" );
347 
348         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
349         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
350         config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
351 
352         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
353 
354         assertTrue( comparePomFiles( reactorProjects ) );
355     }
356 
357     public void testRewritePomWithDeepSubprojects()
358         throws Exception
359     {
360         List<MavenProject> reactorProjects = createReactorProjects( "multimodule-with-deep-subprojects" );
361 
362         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
363         config.mapReleaseVersion( "groupId:artifactId", NEXT_VERSION );
364         config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
365         config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
366 
367         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
368 
369         assertTrue( comparePomFiles( reactorProjects ) );
370     }
371 
372     public void testRewritePomForFlatMultiModule()
373         throws Exception
374     {
375         List<MavenProject> reactorProjects = createReactorProjects( "rewrite-for-release/pom-with-parent-flat", "/root-project" );
376         ReleaseDescriptor config = createConfigurationForPomWithParentAlternateNextVersion( reactorProjects );
377 
378         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
379 
380         assertTrue( comparePomFiles( reactorProjects ) );
381     }
382 
383     // MRELEASE-383
384     public void testRewritePomWithCDATASectionOnWindows()
385         throws Exception
386     {
387         List<MavenProject> reactorProjects = createReactorProjects( "cdata-section" );
388         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
389         mapNextVersion( config, "groupId:artifactId" );
390 
391         RewritePomsForReleasePhase phase = (RewritePomsForReleasePhase) this.phase;
392         phase.setLs( "\r\n" );
393         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
394 
395         // compare POMS without line ending normalization
396         assertTrue( comparePomFiles( reactorProjects, false ) );
397     }
398 
399     protected ReleaseDescriptor createDescriptorFromProjects( List<MavenProject> reactorProjects )
400     {
401         ReleaseDescriptor descriptor = super.createDescriptorFromProjects( reactorProjects );
402         descriptor.setScmReleaseLabel( "release-label" );
403         return descriptor;
404     }
405     
406     public void testRewritePomWithExternallyReleasedParent()
407     throws Exception
408     {
409         List<MavenProject> reactorProjects = createReactorProjects( "pom-with-externally-released-parent" );
410     
411         ReleaseDescriptor config = createDescriptorFromProjects( reactorProjects );
412         config.mapResolvedSnapshotDependencies( "external:parent-artifactId", "1" , "2-SNAPSHOT" );
413         config.mapReleaseVersion( "groupId:subproject1", ALTERNATIVE_NEXT_VERSION );
414     
415         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
416     
417         assertTrue( comparePomFiles( reactorProjects ) );
418     }
419 
420     // MRELEASE-454
421     public void testRewritePomWithImportedDependencyManagementInReactor()
422         throws Exception
423     {
424         List<MavenProject> reactorProjects = createReactorProjects( "imported-dependency-management-in-reactor" );
425         ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
426 
427         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
428 
429         assertTrue( comparePomFiles( reactorProjects ) );
430     }
431 
432     public void testRewritePomWithDifferentVersionsAcrossModules()
433         throws Exception
434     {
435         List<MavenProject> reactorProjects = createReactorProjects( "modules-with-different-versions" );
436         ReleaseDescriptor config = createMappedConfiguration( reactorProjects );
437         config.mapReleaseVersion( "groupId:subproject2", ALTERNATIVE_NEXT_VERSION );
438 
439         phase.execute( config, new DefaultReleaseEnvironment(), reactorProjects );
440 
441         assertTrue( comparePomFiles( reactorProjects ) );
442     }
443 
444 }