1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.apache.maven.shared.release.phase;
20
21 import javax.inject.Inject;
22 import javax.inject.Named;
23
24 import java.io.File;
25 import java.io.IOException;
26 import java.nio.file.Path;
27 import java.util.Collections;
28 import java.util.Iterator;
29 import java.util.List;
30 import java.util.Objects;
31
32 import org.apache.maven.project.MavenProject;
33 import org.apache.maven.scm.provider.svn.repository.SvnScmProviderRepository;
34 import org.apache.maven.scm.repository.ScmRepository;
35 import org.apache.maven.shared.release.config.ReleaseDescriptorBuilder;
36 import org.apache.maven.shared.release.config.ReleaseUtils;
37 import org.apache.maven.shared.release.env.DefaultReleaseEnvironment;
38 import org.apache.maven.shared.release.util.ReleaseUtil;
39 import org.codehaus.plexus.testing.PlexusTest;
40 import org.junit.jupiter.api.Test;
41
42 import static org.codehaus.plexus.testing.PlexusExtension.getTestFile;
43 import static org.junit.jupiter.api.Assertions.assertEquals;
44 import static org.junit.jupiter.api.Assertions.assertFalse;
45 import static org.junit.jupiter.api.Assertions.assertTrue;
46
47
48
49
50
51
52 @PlexusTest
53 class RewritePomsForReleasePhaseTest extends AbstractEditModeRewritingReleasePhaseTestCase {
54 private static final String NEXT_VERSION = "1.0";
55
56 private static final String ALTERNATIVE_NEXT_VERSION = "2.0";
57
58 @Inject
59 @Named("rewrite-poms-for-release")
60 private ReleasePhase phase;
61
62 @Override
63 protected ReleasePhase getTestedPhase() {
64 return phase;
65 }
66
67 @Override
68 protected Path getWorkingDirectory(String workingDir) {
69 return super.getWorkingDirectory("rewrite-for-release/" + workingDir);
70 }
71
72 @Override
73 protected List<MavenProject> prepareReactorProjects(String path) throws Exception {
74 String dir = "rewrite-for-release/" + Objects.toString(path, "");
75 return createReactorProjects(dir, path, null);
76 }
77
78 @Override
79 protected String readTestProjectFile(String fileName) throws IOException {
80 return ReleaseUtil.readXmlFile(getTestFile("target/test-classes/projects/rewrite-for-release/" + fileName));
81 }
82
83 @Test
84 void testSimulateRewrite() throws Exception {
85 List<MavenProject> reactorProjects = createReactorProjects("basic-pom");
86 ReleaseDescriptorBuilder builder = createDescriptorFromBasicPom(reactorProjects, "basic-pom");
87 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
88
89 String expected = readTestProjectFile("basic-pom/pom.xml");
90
91 phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
92
93 String actual = readTestProjectFile("basic-pom/pom.xml");
94 assertEquals(expected, actual, "Check the original POM untouched");
95
96 expected = readTestProjectFile("basic-pom/expected-pom.xml");
97 actual = readTestProjectFile("basic-pom/pom.xml.tag");
98 assertEquals(expected, actual, "Check the transformed POM");
99 }
100
101 @Test
102 void testRewriteWithDashedComments() throws Exception {
103 List<MavenProject> reactorProjects = createReactorProjects("basic-pom-with-dashes-in-comment");
104 ReleaseDescriptorBuilder builder =
105 createDescriptorFromBasicPom(reactorProjects, "basic-pom-with-dashes-in-comment");
106 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
107
108 String expected = readTestProjectFile("basic-pom-with-dashes-in-comment/pom.xml");
109
110 phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
111
112 String actual = readTestProjectFile("basic-pom-with-dashes-in-comment/pom.xml");
113 assertEquals(expected, actual, "Check the original POM is untouched");
114
115 expected = readTestProjectFile("basic-pom-with-dashes-in-comment/expected-pom.xml");
116 actual = readTestProjectFile("basic-pom-with-dashes-in-comment/pom.xml.tag");
117 assertEquals(expected, actual, "Check the transformed POM");
118 }
119
120 @Test
121 void testClean() throws Exception {
122 List<MavenProject> reactorProjects = createReactorProjects("basic-pom");
123 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, "basic-pom");
124 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
125
126 File testFile = getTestFile("target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag");
127 testFile.delete();
128 assertFalse(testFile.exists());
129
130 phase.simulate(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
131
132 assertTrue(testFile.exists());
133
134 ((ResourceGenerator) phase).clean(reactorProjects);
135
136 assertFalse(testFile.exists());
137 }
138
139 @Test
140 void testCleanNotExists() throws Exception {
141 List<MavenProject> reactorProjects = createReactorProjects("basic-pom");
142
143 File testFile = getTestFile("target/test-classes/projects/rewrite-for-release/basic-pom/pom.xml.tag");
144 testFile.delete();
145 assertFalse(testFile.exists());
146
147 ((ResourceGenerator) phase).clean(reactorProjects);
148
149 assertFalse(testFile.exists());
150 }
151
152
153 @Test
154 void testScmOverridden() throws Exception {
155 List<MavenProject> reactorProjects = createReactorProjects("pom-with-overridden-scm");
156 ReleaseDescriptorBuilder builder =
157 createConfigurationForWithParentNextVersion(reactorProjects, "pom-with-overridden-scm");
158 builder.addReleaseVersion("groupId:subsubproject", NEXT_VERSION);
159
160 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
161
162 comparePomFiles(reactorProjects);
163 }
164
165 @Override
166 protected void mapAlternateNextVersion(ReleaseDescriptorBuilder config, String projectId) {
167 config.addReleaseVersion(projectId, ALTERNATIVE_NEXT_VERSION);
168 }
169
170 @Override
171 protected void mapNextVersion(ReleaseDescriptorBuilder config, String projectId) {
172 config.addReleaseVersion(projectId, NEXT_VERSION);
173 }
174
175 @Override
176 protected ReleaseDescriptorBuilder createConfigurationForPomWithParentAlternateNextVersion(
177 List<MavenProject> reactorProjects, String workingDirectory) throws Exception {
178 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, workingDirectory);
179
180 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
181 builder.addReleaseVersion("groupId:subproject1", ALTERNATIVE_NEXT_VERSION);
182 return builder;
183 }
184
185 @Override
186 protected ReleaseDescriptorBuilder createConfigurationForWithParentNextVersion(
187 List<MavenProject> reactorProjects, String workingDirectory) throws Exception {
188 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, workingDirectory);
189
190 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
191 builder.addReleaseVersion("groupId:subproject1", NEXT_VERSION);
192 return builder;
193 }
194
195 @Override
196 protected void unmapNextVersion(ReleaseDescriptorBuilder config, String projectId) {
197
198 }
199
200 @Test
201 void testRewriteBasicPomWithGit() throws Exception {
202
203 List<MavenProject> reactorProjects = createReactorProjects("basic-pom-with-git");
204 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, "basic-pom-with-git");
205 mapNextVersion(builder, "groupId:artifactId");
206
207 String sourceUrl = "scm:git:git://localhost/repo";
208 SvnScmProviderRepository scmProviderRepository = new SvnScmProviderRepository(sourceUrl);
209 ScmRepository repository = new ScmRepository("git", scmProviderRepository);
210 scmManager.addScmRepositoryForUrl("scm:git:git://localhost/repo", repository);
211
212 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
213
214 comparePomFiles(reactorProjects);
215 }
216
217 @Test
218 void testRewriteBasicPomWithScmExpression() throws Exception {
219
220 List<MavenProject> reactorProjects = createReactorProjects("basic-pom-with-scm-expression");
221 ReleaseDescriptorBuilder builder =
222 createDescriptorFromProjects(reactorProjects, "basic-pom-with-scm-expression");
223 mapNextVersion(builder, "groupId:artifactId");
224
225 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
226
227 comparePomFiles(reactorProjects);
228 }
229
230 @Test
231 void testRewriteBasicPomWithTagBase() throws Exception {
232
233 List<MavenProject> reactorProjects = createReactorProjects("basic-pom-with-tag-base");
234 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, "basic-pom-with-tag-base");
235 builder.setScmTagBase("file://localhost/tmp/scm-repo/releases");
236 mapNextVersion(builder, "groupId:artifactId");
237
238 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
239
240 comparePomFiles(reactorProjects);
241 }
242
243 @Test
244 void testRewriteBasicPomWithTagBaseAndVaryingScmUrls() throws Exception {
245 List<MavenProject> reactorProjects = createReactorProjects("basic-pom-with-tag-base-and-varying-scm-urls");
246 ReleaseDescriptorBuilder builder =
247 createDescriptorFromProjects(reactorProjects, "basic-pom-with-tag-base-and-varying-scm-urls");
248 builder.setScmTagBase("file://localhost/tmp/scm-repo/allprojects/releases");
249 mapNextVersion(builder, "groupId:artifactId");
250
251 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
252
253 comparePomFiles(reactorProjects);
254 }
255
256 @Test
257 void testRewriteBasicPomWithGitFromTag() throws Exception {
258 List<MavenProject> reactorProjects = createReactorProjects("basic-pom-with-git-from-tag");
259 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, "basic-pom-with-git-from-tag");
260 mapNextVersion(builder, "groupId:artifactId");
261
262 String sourceUrl = "scm:git:git://localhost/repo";
263 SvnScmProviderRepository scmProviderRepository = new SvnScmProviderRepository(sourceUrl);
264 ScmRepository repository = new ScmRepository("git", scmProviderRepository);
265 scmManager.addScmRepositoryForUrl("scm:git:git://localhost/repo", repository);
266
267 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
268
269 comparePomFiles(reactorProjects);
270 }
271
272 @Test
273 void testRewriteBasicPomWithEmptyScm() throws Exception {
274 List<MavenProject> reactorProjects = createReactorProjects("basic-pom-with-empty-scm");
275 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, "basic-pom-with-empty-scm");
276 mapNextVersion(builder, "groupId:artifactId");
277
278 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
279
280 comparePomFiles(reactorProjects);
281 }
282
283 @Test
284 void testRewriteInterpolatedVersions() throws Exception {
285 List<MavenProject> reactorProjects = createReactorProjects("interpolated-versions");
286 ReleaseDescriptorBuilder builder = createMappedConfiguration(reactorProjects, "interpolated-versions");
287
288 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
289
290 comparePomFiles(reactorProjects);
291 }
292
293 @Test
294 void testRewriteInterpolatedVersionsDifferentVersion() throws Exception {
295 List<MavenProject> reactorProjects = createReactorProjects("interpolated-versions");
296 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, "interpolated-versions");
297
298 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
299 builder.addReleaseVersion("groupId:subproject1", ALTERNATIVE_NEXT_VERSION);
300 builder.addReleaseVersion("groupId:subproject2", NEXT_VERSION);
301 builder.addReleaseVersion("groupId:subproject3", NEXT_VERSION);
302
303 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
304
305 for (Iterator<MavenProject> i = reactorProjects.iterator(); i.hasNext(); ) {
306 MavenProject project = i.next();
307
308
309 if (!"groupId".equals(project.getGroupId()) || !"subproject1".equals(project.getArtifactId())) {
310 comparePomFiles(project, "-different-version", true);
311 }
312 }
313 }
314
315 @Test
316 void testRewriteBasicPomWithInheritedScm() throws Exception {
317 List<MavenProject> reactorProjects = createReactorProjects("basic-pom-inherited-scm");
318 ReleaseDescriptorBuilder builder =
319 createConfigurationForWithParentNextVersion(reactorProjects, "basic-pom-inherited-scm");
320 builder.addReleaseVersion("groupId:subsubproject", NEXT_VERSION);
321
322 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
323
324 comparePomFiles(reactorProjects);
325 }
326
327 @Test
328 void testRewritePomWithParentAndProperties() throws Exception {
329 List<MavenProject> reactorProjects = createReactorProjects("pom-with-parent-and-properties");
330
331 ReleaseDescriptorBuilder builder =
332 createDescriptorFromProjects(reactorProjects, "pom-with-parent-and-properties");
333 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
334 builder.addReleaseVersion("groupId:subproject1", ALTERNATIVE_NEXT_VERSION);
335 builder.addReleaseVersion("groupId:subproject2", ALTERNATIVE_NEXT_VERSION);
336
337 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
338
339 comparePomFiles(reactorProjects);
340 }
341
342
343 @Test
344 void testRewritePomWithCiFriendlyReactor() throws Exception {
345 List<MavenProject> reactorProjects = createReactorProjects("pom-with-parent-and-cifriendly-expressions");
346
347 ReleaseDescriptorBuilder builder =
348 createDescriptorFromProjects(reactorProjects, "pom-with-parent-and-cifriendly-expressions");
349 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
350 builder.addReleaseVersion("groupId:subproject1", NEXT_VERSION);
351 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
352
353 comparePomFiles(reactorProjects);
354 }
355
356 @Test
357 void testRewritePomWithCiFriendlyReactorWithOnlyRevision() throws Exception {
358 List<MavenProject> reactorProjects = createReactorProjects("pom-with-parent-and-cifriendly-revision");
359
360 ReleaseDescriptorBuilder builder =
361 createDescriptorFromProjects(reactorProjects, "pom-with-parent-and-cifriendly-revision");
362 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
363 builder.addReleaseVersion("groupId:subproject1", NEXT_VERSION);
364 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
365
366 comparePomFiles(reactorProjects);
367 }
368
369
370 @Test
371 void testRewritePomWithDependencyPropertyCoordinate() throws Exception {
372 List<MavenProject> reactorProjects = createReactorProjects("pom-with-property-dependency-coordinate");
373
374 ReleaseDescriptorBuilder builder =
375 createDescriptorFromProjects(reactorProjects, "pom-with-property-dependency-coordinate");
376 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
377 builder.addReleaseVersion("groupId:subproject1-3.4", ALTERNATIVE_NEXT_VERSION);
378 builder.addReleaseVersion("groupId:subproject2", ALTERNATIVE_NEXT_VERSION);
379
380 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
381
382 comparePomFiles(reactorProjects);
383 }
384
385
386 @Test
387 void testRewritePomWithScmOfParentEndingWithASlash() throws Exception {
388 List<MavenProject> reactorProjects = createReactorProjects("pom-with-scm-of-parent-ending-with-a-slash");
389
390 ReleaseDescriptorBuilder builder =
391 createDescriptorFromProjects(reactorProjects, "pom-with-scm-of-parent-ending-with-a-slash");
392 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
393 builder.addReleaseVersion("groupId:subproject1", ALTERNATIVE_NEXT_VERSION);
394
395 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
396
397 comparePomFiles(reactorProjects);
398 }
399
400 @Test
401 void testRewritePomWithDeepSubprojects() throws Exception {
402 List<MavenProject> reactorProjects = createReactorProjects("multimodule-with-deep-subprojects");
403
404 ReleaseDescriptorBuilder builder =
405 createDescriptorFromProjects(reactorProjects, "multimodule-with-deep-subprojects");
406 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
407 builder.addReleaseVersion("groupId:subproject1", ALTERNATIVE_NEXT_VERSION);
408 builder.addReleaseVersion("groupId:subproject2", ALTERNATIVE_NEXT_VERSION);
409
410 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
411
412 comparePomFiles(reactorProjects);
413 }
414
415 @Test
416 void testRewritePomForFlatMultiModule() throws Exception {
417 List<MavenProject> reactorProjects = createReactorProjects(
418 "rewrite-for-release/pom-with-parent-flat", "pom-with-parent-flat", "root-project");
419 ReleaseDescriptorBuilder builder =
420 createConfigurationForPomWithParentAlternateNextVersion(reactorProjects, "pom-with-parent-flat");
421
422 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
423
424 comparePomFiles(reactorProjects);
425 }
426
427
428 @Test
429 void testRewritePomWithCDATASectionOnWindows() throws Exception {
430 List<MavenProject> reactorProjects = createReactorProjects("cdata-section");
431 ReleaseDescriptorBuilder builder = createDescriptorFromProjects(reactorProjects, "cdata-section");
432 mapNextVersion(builder, "groupId:artifactId");
433
434 RewritePomsForReleasePhase phase = (RewritePomsForReleasePhase) this.phase;
435 ReleaseDescriptorBuilder.BuilderReleaseDescriptor builderReleaseDescriptor =
436 ReleaseUtils.buildReleaseDescriptor(builder);
437 builderReleaseDescriptor.setLineSeparator("\r\n");
438 phase.execute(builderReleaseDescriptor, new DefaultReleaseEnvironment(), reactorProjects);
439
440
441 comparePomFiles(reactorProjects, false);
442 }
443
444 protected ReleaseDescriptorBuilder createDescriptorFromProjects(
445 List<MavenProject> reactorProjects, String workingDirectory) {
446 ReleaseDescriptorBuilder builder = super.createDescriptorFromProjects(reactorProjects, workingDirectory);
447 builder.setScmReleaseLabel("release-label");
448 return builder;
449 }
450
451 @Test
452 void testRewritePomWithExternallyReleasedParent() throws Exception {
453 List<MavenProject> reactorProjects = createReactorProjects("pom-with-externally-released-parent");
454
455 ReleaseDescriptorBuilder builder =
456 createDescriptorFromProjects(reactorProjects, "pom-with-externally-released-parent");
457 builder.addDependencyReleaseVersion("external:parent-artifactId", "1");
458 builder.addDependencyDevelopmentVersion("external:parent-artifactId", "2-SNAPSHOT");
459 builder.addReleaseVersion("groupId:subproject1", ALTERNATIVE_NEXT_VERSION);
460
461 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
462
463 comparePomFiles(reactorProjects);
464 }
465
466
467 @Test
468 void testRewritePomWithImportedDependencyManagementInReactor() throws Exception {
469 List<MavenProject> reactorProjects = createReactorProjects("imported-dependency-management-in-reactor");
470 ReleaseDescriptorBuilder builder =
471 createMappedConfiguration(reactorProjects, "imported-dependency-management-in-reactor");
472
473 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
474
475 comparePomFiles(reactorProjects);
476 }
477
478 @Test
479 void testRewritePomWithDifferentVersionsAcrossModules() throws Exception {
480 List<MavenProject> reactorProjects = createReactorProjects("modules-with-different-versions");
481 ReleaseDescriptorBuilder builder =
482 createMappedConfiguration(reactorProjects, "modules-with-different-versions");
483 builder.addReleaseVersion("groupId:subproject2", ALTERNATIVE_NEXT_VERSION);
484
485 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
486
487 comparePomFiles(reactorProjects);
488 }
489
490 @Test
491 void testRewritePomWithCheckModificationExcludes() throws Exception {
492 List<MavenProject> reactorProjects = createReactorProjects("multimodule-with-check-modification-excludes");
493
494 ReleaseDescriptorBuilder builder =
495 createDescriptorFromProjects(reactorProjects, "multimodule-with-check-modification-excludes");
496 builder.addReleaseVersion("groupId:artifactId", NEXT_VERSION);
497 builder.addReleaseVersion("groupId:subproject1", ALTERNATIVE_NEXT_VERSION);
498 builder.setCheckModificationExcludes(Collections.singletonList("**/subproject2/*"));
499
500 phase.execute(ReleaseUtils.buildReleaseDescriptor(builder), new DefaultReleaseEnvironment(), reactorProjects);
501
502 comparePomFiles(reactorProjects);
503 }
504 }