You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by gn...@apache.org on 2025/10/08 21:10:28 UTC
(maven) branch master updated (02de10f88e -> 1376aa9ea4)
This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git
from 02de10f88e Fix CI-friendly version processing with profile properties (fix #11196)
new 3660924fc2 Add phase upgrade support for Maven 4.1.0 model upgrades
new 1376aa9ea4 Use Maven API constants for phase names instead of hardcoded strings
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../invoker/mvnup/goals/ModelUpgradeStrategy.java | 122 ++++++
.../invoker/mvnup/goals/UpgradeConstants.java | 2 +
.../mvnup/goals/ModelUpgradeStrategyTest.java | 461 +++++++++++++++++++++
3 files changed, 585 insertions(+)
(maven) 02/02: Use Maven API constants for phase names instead of hardcoded strings
Posted by gn...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git
commit 1376aa9ea4e199eaee54f79b55ca01992c4ba1ef
Author: Guillaume Nodet <gn...@gmail.com>
AuthorDate: Wed Oct 8 06:53:12 2025 +0000
Use Maven API constants for phase names instead of hardcoded strings
Replace hardcoded phase name strings with proper Maven API constants:
- Use Lifecycle.BEFORE and Lifecycle.AFTER for phase prefixes
- Use Lifecycle.Phase.CLEAN and Lifecycle.Phase.INTEGRATION_TEST for phase names
- Use Lifecycle.SITE for site lifecycle phase
This ensures consistency with Maven's lifecycle definitions and makes
the code more maintainable by using the official API constants.
---
.../cling/invoker/mvnup/goals/ModelUpgradeStrategy.java | 14 ++++++++------
1 file changed, 8 insertions(+), 6 deletions(-)
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategy.java
index d6e3d8f331..6a6d18bbe0 100644
--- a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategy.java
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategy.java
@@ -25,6 +25,7 @@
import java.util.Map;
import java.util.Set;
+import org.apache.maven.api.Lifecycle;
import org.apache.maven.api.cli.mvnup.UpgradeOptions;
import org.apache.maven.api.di.Named;
import org.apache.maven.api.di.Priority;
@@ -299,21 +300,22 @@ private void upgradeDeprecatedPhases(Document pomDocument, UpgradeContext contex
/**
* Creates the mapping of deprecated phase names to their Maven 4 equivalents.
+ * Uses Maven API constants to ensure consistency with the lifecycle definitions.
*/
private Map<String, String> createPhaseUpgradeMap() {
Map<String, String> phaseUpgrades = new HashMap<>();
// Clean lifecycle aliases
- phaseUpgrades.put("pre-clean", "before:clean");
- phaseUpgrades.put("post-clean", "after:clean");
+ phaseUpgrades.put("pre-clean", Lifecycle.BEFORE + Lifecycle.Phase.CLEAN);
+ phaseUpgrades.put("post-clean", Lifecycle.AFTER + Lifecycle.Phase.CLEAN);
// Default lifecycle aliases
- phaseUpgrades.put("pre-integration-test", "before:integration-test");
- phaseUpgrades.put("post-integration-test", "after:integration-test");
+ phaseUpgrades.put("pre-integration-test", Lifecycle.BEFORE + Lifecycle.Phase.INTEGRATION_TEST);
+ phaseUpgrades.put("post-integration-test", Lifecycle.AFTER + Lifecycle.Phase.INTEGRATION_TEST);
// Site lifecycle aliases
- phaseUpgrades.put("pre-site", "before:site");
- phaseUpgrades.put("post-site", "after:site");
+ phaseUpgrades.put("pre-site", Lifecycle.BEFORE + Lifecycle.SITE);
+ phaseUpgrades.put("post-site", Lifecycle.AFTER + Lifecycle.SITE);
return phaseUpgrades;
}
(maven) 01/02: Add phase upgrade support for Maven 4.1.0 model upgrades
Posted by gn...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
gnodet pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/maven.git
commit 3660924fc22efa13a006eb6977be9010063cdc61
Author: Guillaume Nodet <gn...@gmail.com>
AuthorDate: Wed Oct 8 06:36:19 2025 +0000
Add phase upgrade support for Maven 4.1.0 model upgrades
This commit implements automatic phase name upgrades when upgrading
Maven projects from model version 4.0.0 to 4.1.0. The deprecated
Maven 3 phase names are automatically converted to their Maven 4
equivalents:
- pre-clean → before:clean
- post-clean → after:clean
- pre-integration-test → before:integration-test
- post-integration-test → after:integration-test
- pre-site → before:site
- post-site → after:site
The upgrade functionality:
- Only applies when upgrading to model version 4.1.0 or higher
- Processes all plugin executions in build/plugins, build/pluginManagement,
and profile/build/plugins sections
- Preserves non-deprecated phase names unchanged
- Includes comprehensive test coverage for all scenarios
This enhancement ensures that Maven projects upgrading to 4.1.0 will
automatically have their deprecated phase references updated to use
the new Maven 4 phase naming convention.
---
.../invoker/mvnup/goals/ModelUpgradeStrategy.java | 120 ++++++
.../invoker/mvnup/goals/UpgradeConstants.java | 2 +
.../mvnup/goals/ModelUpgradeStrategyTest.java | 461 +++++++++++++++++++++
3 files changed, 583 insertions(+)
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategy.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategy.java
index 3a1392c43e..d6e3d8f331 100644
--- a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategy.java
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategy.java
@@ -19,6 +19,7 @@
package org.apache.maven.cling.invoker.mvnup.goals;
import java.nio.file.Path;
+import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
@@ -44,8 +45,15 @@
import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlAttributes.SCHEMA_LOCATION;
import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlAttributes.XSI_NAMESPACE_PREFIX;
import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlAttributes.XSI_NAMESPACE_URI;
+import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.BUILD;
+import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.EXECUTION;
+import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.EXECUTIONS;
import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.MODULE;
import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.MODULES;
+import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.PHASE;
+import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.PLUGIN;
+import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.PLUGINS;
+import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.PLUGIN_MANAGEMENT;
import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.PROFILE;
import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.PROFILES;
import static org.apache.maven.cling.invoker.mvnup.goals.UpgradeConstants.XmlElements.SUBPROJECT;
@@ -143,6 +151,7 @@ private void performModelUpgrade(
// Convert modules to subprojects (for 4.1.0 and higher)
if (ModelVersionUtils.isVersionGreaterOrEqual(targetModelVersion, MODEL_VERSION_4_1_0)) {
convertModulesToSubprojects(pomDocument, context);
+ upgradeDeprecatedPhases(pomDocument, context);
}
// Update modelVersion to target version (perhaps removed later during inference step)
@@ -256,4 +265,115 @@ private String getNamespaceForModelVersion(String modelVersion) {
return MAVEN_4_0_0_NAMESPACE;
}
}
+
+ /**
+ * Upgrades deprecated Maven 3 phase names to Maven 4 equivalents.
+ * This replaces pre-/post- phases with before:/after: phases.
+ */
+ private void upgradeDeprecatedPhases(Document pomDocument, UpgradeContext context) {
+ // Create mapping of deprecated phases to their Maven 4 equivalents
+ Map<String, String> phaseUpgrades = createPhaseUpgradeMap();
+
+ Element root = pomDocument.getRootElement();
+ Namespace namespace = root.getNamespace();
+
+ int totalUpgrades = 0;
+
+ // Upgrade phases in main build section
+ totalUpgrades += upgradePhaseElements(root.getChild(BUILD, namespace), namespace, phaseUpgrades, context);
+
+ // Upgrade phases in profiles
+ Element profilesElement = root.getChild(PROFILES, namespace);
+ if (profilesElement != null) {
+ List<Element> profileElements = profilesElement.getChildren(PROFILE, namespace);
+ for (Element profileElement : profileElements) {
+ Element profileBuildElement = profileElement.getChild(BUILD, namespace);
+ totalUpgrades += upgradePhaseElements(profileBuildElement, namespace, phaseUpgrades, context);
+ }
+ }
+
+ if (totalUpgrades > 0) {
+ context.detail("Upgraded " + totalUpgrades + " deprecated phase name(s) to Maven 4 equivalents");
+ }
+ }
+
+ /**
+ * Creates the mapping of deprecated phase names to their Maven 4 equivalents.
+ */
+ private Map<String, String> createPhaseUpgradeMap() {
+ Map<String, String> phaseUpgrades = new HashMap<>();
+
+ // Clean lifecycle aliases
+ phaseUpgrades.put("pre-clean", "before:clean");
+ phaseUpgrades.put("post-clean", "after:clean");
+
+ // Default lifecycle aliases
+ phaseUpgrades.put("pre-integration-test", "before:integration-test");
+ phaseUpgrades.put("post-integration-test", "after:integration-test");
+
+ // Site lifecycle aliases
+ phaseUpgrades.put("pre-site", "before:site");
+ phaseUpgrades.put("post-site", "after:site");
+
+ return phaseUpgrades;
+ }
+
+ /**
+ * Upgrades phase elements within a build section.
+ */
+ private int upgradePhaseElements(
+ Element buildElement, Namespace namespace, Map<String, String> phaseUpgrades, UpgradeContext context) {
+ if (buildElement == null) {
+ return 0;
+ }
+
+ int upgrades = 0;
+
+ // Check plugins section
+ Element pluginsElement = buildElement.getChild(PLUGINS, namespace);
+ if (pluginsElement != null) {
+ upgrades += upgradePhaseElementsInPlugins(pluginsElement, namespace, phaseUpgrades, context);
+ }
+
+ // Check pluginManagement section
+ Element pluginManagementElement = buildElement.getChild(PLUGIN_MANAGEMENT, namespace);
+ if (pluginManagementElement != null) {
+ Element managedPluginsElement = pluginManagementElement.getChild(PLUGINS, namespace);
+ if (managedPluginsElement != null) {
+ upgrades += upgradePhaseElementsInPlugins(managedPluginsElement, namespace, phaseUpgrades, context);
+ }
+ }
+
+ return upgrades;
+ }
+
+ /**
+ * Upgrades phase elements within a plugins section.
+ */
+ private int upgradePhaseElementsInPlugins(
+ Element pluginsElement, Namespace namespace, Map<String, String> phaseUpgrades, UpgradeContext context) {
+ int upgrades = 0;
+
+ List<Element> pluginElements = pluginsElement.getChildren(PLUGIN, namespace);
+ for (Element pluginElement : pluginElements) {
+ Element executionsElement = pluginElement.getChild(EXECUTIONS, namespace);
+ if (executionsElement != null) {
+ List<Element> executionElements = executionsElement.getChildren(EXECUTION, namespace);
+ for (Element executionElement : executionElements) {
+ Element phaseElement = executionElement.getChild(PHASE, namespace);
+ if (phaseElement != null) {
+ String currentPhase = phaseElement.getTextTrim();
+ String newPhase = phaseUpgrades.get(currentPhase);
+ if (newPhase != null) {
+ phaseElement.setText(newPhase);
+ context.detail("Upgraded phase: " + currentPhase + " → " + newPhase);
+ upgrades++;
+ }
+ }
+ }
+ }
+ }
+
+ return upgrades;
+ }
}
diff --git a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/UpgradeConstants.java b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/UpgradeConstants.java
index 253728c508..f8fd5494bc 100644
--- a/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/UpgradeConstants.java
+++ b/impl/maven-cli/src/main/java/org/apache/maven/cling/invoker/mvnup/goals/UpgradeConstants.java
@@ -77,9 +77,11 @@ public static final class XmlElements {
public static final String TEST_OUTPUT_DIRECTORY = "testOutputDirectory";
public static final String EXTENSIONS = "extensions";
public static final String EXECUTIONS = "executions";
+ public static final String EXECUTION = "execution";
public static final String GOALS = "goals";
public static final String INHERITED = "inherited";
public static final String CONFIGURATION = "configuration";
+ public static final String PHASE = "phase";
// Module elements
public static final String MODULES = "modules";
diff --git a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategyTest.java b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategyTest.java
index 2a0c3c1719..ab20e4c132 100644
--- a/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategyTest.java
+++ b/impl/maven-cli/src/test/java/org/apache/maven/cling/invoker/mvnup/goals/ModelUpgradeStrategyTest.java
@@ -324,6 +324,467 @@ void shouldProvideMeaningfulDescription() {
}
}
+ @Nested
+ @DisplayName("Phase Upgrades")
+ class PhaseUpgradeTests {
+
+ @Test
+ @DisplayName("should upgrade deprecated phases to Maven 4 equivalents in 4.1.0")
+ void shouldUpgradeDeprecatedPhasesIn410() throws Exception {
+ Document document = createDocumentWithDeprecatedPhases();
+ Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+ // Create context with --model-version=4.1.0 option to trigger phase upgrade
+ UpgradeOptions options = mock(UpgradeOptions.class);
+ when(options.modelVersion()).thenReturn(Optional.of("4.1.0"));
+ when(options.all()).thenReturn(Optional.empty());
+ UpgradeContext context = createMockContext(options);
+
+ UpgradeResult result = strategy.apply(context, pomMap);
+
+ assertTrue(result.success(), "Model upgrade should succeed");
+ assertTrue(result.modifiedCount() > 0, "Should have upgraded phases");
+
+ // Verify phases were upgraded
+ verifyCleanPluginPhases(document);
+ verifyFailsafePluginPhases(document);
+ verifySitePluginPhases(document);
+ verifyPluginManagementPhases(document);
+ verifyProfilePhases(document);
+ }
+
+ private Document createDocumentWithDeprecatedPhases() throws Exception {
+ String pomXml =
+ """
+ <?xml version="1.0" encoding="UTF-8"?>
+ <project xmlns="http://maven.apache.org/POM/4.0.0">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>com.example</groupId>
+ <artifactId>test-project</artifactId>
+ <version>1.0.0</version>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-clean-plugin</artifactId>
+ <version>3.2.0</version>
+ <executions>
+ <execution>
+ <id>pre-clean-test</id>
+ <phase>pre-clean</phase>
+ <goals>
+ <goal>clean</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>post-clean-test</id>
+ <phase>post-clean</phase>
+ <goals>
+ <goal>clean</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-failsafe-plugin</artifactId>
+ <version>3.0.0-M7</version>
+ <executions>
+ <execution>
+ <id>pre-integration-test-setup</id>
+ <phase>pre-integration-test</phase>
+ <goals>
+ <goal>integration-test</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>post-integration-test-cleanup</id>
+ <phase>post-integration-test</phase>
+ <goals>
+ <goal>verify</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-site-plugin</artifactId>
+ <version>3.12.1</version>
+ <executions>
+ <execution>
+ <id>pre-site-setup</id>
+ <phase>pre-site</phase>
+ <goals>
+ <goal>site</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>post-site-cleanup</id>
+ <phase>post-site</phase>
+ <goals>
+ <goal>deploy</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ <pluginManagement>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>3.11.0</version>
+ <executions>
+ <execution>
+ <id>pre-clean-compile</id>
+ <phase>pre-clean</phase>
+ <goals>
+ <goal>compile</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </pluginManagement>
+ </build>
+ <profiles>
+ <profile>
+ <id>test-profile</id>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-antrun-plugin</artifactId>
+ <version>3.1.0</version>
+ <executions>
+ <execution>
+ <id>profile-pre-integration-test</id>
+ <phase>pre-integration-test</phase>
+ <goals>
+ <goal>run</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ </profiles>
+ </project>
+ """;
+
+ return saxBuilder.build(new StringReader(pomXml));
+ }
+
+ private void verifyCleanPluginPhases(Document document) {
+ Element root = document.getRootElement();
+ Namespace namespace = root.getNamespace();
+ Element build = root.getChild("build", namespace);
+ Element plugins = build.getChild("plugins", namespace);
+
+ Element cleanPlugin = plugins.getChildren("plugin", namespace).stream()
+ .filter(p -> "maven-clean-plugin"
+ .equals(p.getChild("artifactId", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(cleanPlugin);
+
+ Element cleanExecutions = cleanPlugin.getChild("executions", namespace);
+ Element preCleanExecution = cleanExecutions.getChildren("execution", namespace).stream()
+ .filter(e ->
+ "pre-clean-test".equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(preCleanExecution);
+ assertEquals(
+ "before:clean",
+ preCleanExecution.getChild("phase", namespace).getText());
+
+ Element postCleanExecution = cleanExecutions.getChildren("execution", namespace).stream()
+ .filter(e ->
+ "post-clean-test".equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(postCleanExecution);
+ assertEquals(
+ "after:clean",
+ postCleanExecution.getChild("phase", namespace).getText());
+ }
+
+ private void verifyFailsafePluginPhases(Document document) {
+ Element root = document.getRootElement();
+ Namespace namespace = root.getNamespace();
+ Element build = root.getChild("build", namespace);
+ Element plugins = build.getChild("plugins", namespace);
+
+ Element failsafePlugin = plugins.getChildren("plugin", namespace).stream()
+ .filter(p -> "maven-failsafe-plugin"
+ .equals(p.getChild("artifactId", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(failsafePlugin);
+
+ Element failsafeExecutions = failsafePlugin.getChild("executions", namespace);
+ Element preIntegrationExecution = failsafeExecutions.getChildren("execution", namespace).stream()
+ .filter(e -> "pre-integration-test-setup"
+ .equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(preIntegrationExecution);
+ assertEquals(
+ "before:integration-test",
+ preIntegrationExecution.getChild("phase", namespace).getText());
+
+ Element postIntegrationExecution = failsafeExecutions.getChildren("execution", namespace).stream()
+ .filter(e -> "post-integration-test-cleanup"
+ .equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(postIntegrationExecution);
+ assertEquals(
+ "after:integration-test",
+ postIntegrationExecution.getChild("phase", namespace).getText());
+ }
+
+ private void verifySitePluginPhases(Document document) {
+ Element root = document.getRootElement();
+ Namespace namespace = root.getNamespace();
+ Element build = root.getChild("build", namespace);
+ Element plugins = build.getChild("plugins", namespace);
+
+ Element sitePlugin = plugins.getChildren("plugin", namespace).stream()
+ .filter(p -> "maven-site-plugin"
+ .equals(p.getChild("artifactId", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(sitePlugin);
+
+ Element siteExecutions = sitePlugin.getChild("executions", namespace);
+ Element preSiteExecution = siteExecutions.getChildren("execution", namespace).stream()
+ .filter(e ->
+ "pre-site-setup".equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(preSiteExecution);
+ assertEquals(
+ "before:site", preSiteExecution.getChild("phase", namespace).getText());
+
+ Element postSiteExecution = siteExecutions.getChildren("execution", namespace).stream()
+ .filter(e -> "post-site-cleanup"
+ .equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(postSiteExecution);
+ assertEquals(
+ "after:site", postSiteExecution.getChild("phase", namespace).getText());
+ }
+
+ private void verifyPluginManagementPhases(Document document) {
+ Element root = document.getRootElement();
+ Namespace namespace = root.getNamespace();
+ Element build = root.getChild("build", namespace);
+ Element pluginManagement = build.getChild("pluginManagement", namespace);
+ Element managedPlugins = pluginManagement.getChild("plugins", namespace);
+ Element compilerPlugin = managedPlugins.getChildren("plugin", namespace).stream()
+ .filter(p -> "maven-compiler-plugin"
+ .equals(p.getChild("artifactId", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(compilerPlugin);
+
+ Element compilerExecutions = compilerPlugin.getChild("executions", namespace);
+ Element preCleanCompileExecution = compilerExecutions.getChildren("execution", namespace).stream()
+ .filter(e -> "pre-clean-compile"
+ .equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(preCleanCompileExecution);
+ assertEquals(
+ "before:clean",
+ preCleanCompileExecution.getChild("phase", namespace).getText());
+ }
+
+ private void verifyProfilePhases(Document document) {
+ Element root = document.getRootElement();
+ Namespace namespace = root.getNamespace();
+ Element profiles = root.getChild("profiles", namespace);
+ Element profile = profiles.getChild("profile", namespace);
+ Element profileBuild = profile.getChild("build", namespace);
+ Element profilePlugins = profileBuild.getChild("plugins", namespace);
+ Element antrunPlugin = profilePlugins.getChildren("plugin", namespace).stream()
+ .filter(p -> "maven-antrun-plugin"
+ .equals(p.getChild("artifactId", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(antrunPlugin);
+
+ Element antrunExecutions = antrunPlugin.getChild("executions", namespace);
+ Element profilePreIntegrationExecution = antrunExecutions.getChildren("execution", namespace).stream()
+ .filter(e -> "profile-pre-integration-test"
+ .equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(profilePreIntegrationExecution);
+ assertEquals(
+ "before:integration-test",
+ profilePreIntegrationExecution.getChild("phase", namespace).getText());
+ }
+
+ @Test
+ @DisplayName("should not upgrade phases when upgrading to 4.0.0")
+ void shouldNotUpgradePhasesWhenUpgradingTo400() throws Exception {
+ String pomXml =
+ """
+ <?xml version="1.0" encoding="UTF-8"?>
+ <project xmlns="http://maven.apache.org/POM/4.0.0">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>com.example</groupId>
+ <artifactId>test-project</artifactId>
+ <version>1.0.0</version>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-clean-plugin</artifactId>
+ <version>3.2.0</version>
+ <executions>
+ <execution>
+ <id>pre-clean-test</id>
+ <phase>pre-clean</phase>
+ <goals>
+ <goal>clean</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ </project>
+ """;
+
+ Document document = saxBuilder.build(new StringReader(pomXml));
+ Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+ // Create context with --model-version=4.0.0 option (no phase upgrade)
+ UpgradeOptions options = mock(UpgradeOptions.class);
+ when(options.modelVersion()).thenReturn(Optional.of("4.0.0"));
+ when(options.all()).thenReturn(Optional.empty());
+ UpgradeContext context = createMockContext(options);
+
+ UpgradeResult result = strategy.apply(context, pomMap);
+
+ assertTrue(result.success(), "Model upgrade should succeed");
+
+ // Verify phases were NOT upgraded (should remain as pre-clean)
+ Element root = document.getRootElement();
+ Namespace namespace = root.getNamespace();
+ Element build = root.getChild("build", namespace);
+ Element plugins = build.getChild("plugins", namespace);
+ Element cleanPlugin = plugins.getChild("plugin", namespace);
+ Element executions = cleanPlugin.getChild("executions", namespace);
+ Element execution = executions.getChild("execution", namespace);
+ Element phase = execution.getChild("phase", namespace);
+
+ assertEquals("pre-clean", phase.getText(), "Phase should remain as pre-clean for 4.0.0");
+ }
+
+ @Test
+ @DisplayName("should preserve non-deprecated phases")
+ void shouldPreserveNonDeprecatedPhases() throws Exception {
+ String pomXml =
+ """
+ <?xml version="1.0" encoding="UTF-8"?>
+ <project xmlns="http://maven.apache.org/POM/4.0.0">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>com.example</groupId>
+ <artifactId>test-project</artifactId>
+ <version>1.0.0</version>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <version>3.11.0</version>
+ <executions>
+ <execution>
+ <id>compile-test</id>
+ <phase>compile</phase>
+ <goals>
+ <goal>compile</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>test-compile-test</id>
+ <phase>test-compile</phase>
+ <goals>
+ <goal>testCompile</goal>
+ </goals>
+ </execution>
+ <execution>
+ <id>package-test</id>
+ <phase>package</phase>
+ <goals>
+ <goal>compile</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ </project>
+ """;
+
+ Document document = saxBuilder.build(new StringReader(pomXml));
+ Map<Path, Document> pomMap = Map.of(Paths.get("pom.xml"), document);
+
+ // Create context with --model-version=4.1.0 option
+ UpgradeOptions options = mock(UpgradeOptions.class);
+ when(options.modelVersion()).thenReturn(Optional.of("4.1.0"));
+ when(options.all()).thenReturn(Optional.empty());
+ UpgradeContext context = createMockContext(options);
+
+ UpgradeResult result = strategy.apply(context, pomMap);
+
+ assertTrue(result.success(), "Model upgrade should succeed");
+
+ // Verify non-deprecated phases were preserved
+ Element root = document.getRootElement();
+ Namespace namespace = root.getNamespace();
+ Element build = root.getChild("build", namespace);
+ Element plugins = build.getChild("plugins", namespace);
+ Element compilerPlugin = plugins.getChild("plugin", namespace);
+ Element executions = compilerPlugin.getChild("executions", namespace);
+
+ Element compileExecution = executions.getChildren("execution", namespace).stream()
+ .filter(e ->
+ "compile-test".equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(compileExecution);
+ assertEquals(
+ "compile", compileExecution.getChild("phase", namespace).getText());
+
+ Element testCompileExecution = executions.getChildren("execution", namespace).stream()
+ .filter(e -> "test-compile-test"
+ .equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(testCompileExecution);
+ assertEquals(
+ "test-compile",
+ testCompileExecution.getChild("phase", namespace).getText());
+
+ Element packageExecution = executions.getChildren("execution", namespace).stream()
+ .filter(e ->
+ "package-test".equals(e.getChild("id", namespace).getText()))
+ .findFirst()
+ .orElse(null);
+ assertNotNull(packageExecution);
+ assertEquals(
+ "package", packageExecution.getChild("phase", namespace).getText());
+ }
+ }
+
@Nested
@DisplayName("Downgrade Handling")
class DowngradeHandlingTests {