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


The following commit(s) were added to refs/heads/master by this push:
     new 104d62c086 feat: introduce ProjectTransformer SPI for functional model 
transformation at reactor assembly time
104d62c086 is described below

commit 104d62c0869401e46025543333f2c8cc2f7e7e5c
Author: B V HITESH SAI <[email protected]>
AuthorDate: Fri Nov 13 14:07:14 2026 +0530

    feat: introduce ProjectTransformer SPI for functional model transformation 
at reactor assembly time
    
    - Introduces `ProjectTransformer` SPI in `maven-api-spi`: functional `Model 
→ Model` callback
      replaces the v3 `AbstractMavenLifecycleParticipant.afterProjectsRead()` 
hook; transformers are
      chained in sequence per reactor project and the final model is written 
back before topological re-sort
    - Frozen-field validation rejects changes to `groupId`/`artifactId`, 
`<parent>`, `<mixins>`,
      `<modules>`/`<subprojects>`, and `<profiles>` after each transformer, 
with error messages naming
      the offending transformer class
    - Removes `ProjectManager.setDependencies()` (last-writer-wins) in favour 
of the composable
      `model.withDependencies(...)` pattern
    - Removes `LifecycleParticipant`, `LifecycleParticipantException`, and 
`ProjectExecutionEvent`;
      execution callbacks are deferred to #13807
    - Adds `ProjectTransformerDispatcher` to wire multiple transformers and 
wrap `RuntimeException` in
      `MavenExecutionException`
    - Covers `MavenLifecycleParticipantTest` (v3 backward compat + v4 
transformer ordering) and
      `ProjectTransformerDispatcherTest` (chaining, exception wrapping, 
frozen-field rejection)
    
    Closes #13514, implements #13808.
---
 .../apache/maven/api/spi/ProjectTransformer.java   |  79 +++++++++++++
 .../main/java/org/apache/maven/DefaultMaven.java   |   5 +
 .../impl/ProjectTransformerDispatcher.java         | 112 ++++++++++++++++++
 .../lifecycle/internal/LifecycleModuleBuilder.java |   8 +-
 .../internal/concurrent/BuildPlanExecutor.java     |  13 ++-
 .../maven/MavenLifecycleParticipantTest.java       |  83 +++++++++++++
 .../impl/ProjectTransformerDispatcherTest.java     | 130 +++++++++++++++++++++
 7 files changed, 427 insertions(+), 3 deletions(-)

diff --git 
a/api/maven-api-spi/src/main/java/org/apache/maven/api/spi/ProjectTransformer.java
 
b/api/maven-api-spi/src/main/java/org/apache/maven/api/spi/ProjectTransformer.java
new file mode 100644
index 0000000000..e05d65f763
--- /dev/null
+++ 
b/api/maven-api-spi/src/main/java/org/apache/maven/api/spi/ProjectTransformer.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.api.spi;
+
+import org.apache.maven.api.Project;
+import org.apache.maven.api.Session;
+import org.apache.maven.api.annotations.Consumer;
+import org.apache.maven.api.annotations.Experimental;
+import org.apache.maven.api.annotations.Nonnull;
+import org.apache.maven.api.model.Model;
+import org.apache.maven.api.services.MavenException;
+
+/**
+ * Allows build extensions to transform project models after all reactor 
projects have been read
+ * and before the reactor is sorted for execution. This is the v4 API 
equivalent of
+ * {@code AbstractMavenLifecycleParticipant.afterProjectsRead()}.
+ * <p>
+ * Transformers are called in sequence for each reactor project; the model 
returned by one transformer
+ * is passed as input to the next. The final model is written back into the 
project by the runtime.
+ * <p>
+ * Implementations may return a modified model built via {@code 
Model.newBuilder(model)...build()},
+ * or return the input model unmodified for a no-op. Throwing aborts the build.
+ *
+ * <h2>Allowed modifications</h2>
+ * At this point in the build, no artifacts have been resolved and no plugin 
classloaders have been
+ * created. The following model sections are safe to modify:
+ * <ul>
+ *   <li>{@code <dependencies>} — e.g. injecting resolved platform 
dependencies</li>
+ *   <li>{@code <dependencyManagement>}</li>
+ *   <li>{@code <build>}, {@code <plugins>}, {@code <pluginManagement>} — e.g. 
injecting JVM args
+ *       into Surefire/Failsafe configuration</li>
+ *   <li>{@code <properties>}</li>
+ * </ul>
+ *
+ * <h2>Frozen fields</h2>
+ * The runtime rejects changes to the following fields after each transformer 
runs — modifying
+ * them would break reactor identity, inheritance, or module structure that 
has already been assembled:
+ * <ul>
+ *   <li>{@code groupId}, {@code artifactId} — reactor identity</li>
+ *   <li>{@code <parent>}, {@code <mixins>} — inheritance already resolved</li>
+ *   <li>{@code <modules>}, {@code <subprojects>} — project set is fixed at 
this point</li>
+ *   <li>{@code <profiles>} — already activated</li>
+ * </ul>
+ *
+ * @since 4.2.0
+ */
+@Experimental
+@Consumer
+public interface ProjectTransformer extends SpiService {
+
+    /**
+     * Transforms the model of a single reactor project.
+     *
+     * @param session the build session (provides access to all reactor 
projects)
+     * @param project the project being transformed (reflects the original 
state before any transformer ran)
+     * @param model   the model as modified by preceding transformers in the 
chain
+     * @return the transformed model; must not be {@code null}
+     * @throws MavenException if the transformation fails and the build cannot 
continue
+     */
+    @Nonnull
+    Model transformProject(@Nonnull Session session, @Nonnull Project project, 
@Nonnull Model model)
+            throws MavenException;
+}
diff --git a/impl/maven-core/src/main/java/org/apache/maven/DefaultMaven.java 
b/impl/maven-core/src/main/java/org/apache/maven/DefaultMaven.java
index 9cd32da972..6c8fa91af8 100644
--- a/impl/maven-core/src/main/java/org/apache/maven/DefaultMaven.java
+++ b/impl/maven-core/src/main/java/org/apache/maven/DefaultMaven.java
@@ -46,6 +46,7 @@
 import org.apache.maven.api.model.Profile;
 import org.apache.maven.api.services.Lookup;
 import org.apache.maven.api.services.LookupException;
+import org.apache.maven.api.spi.ProjectTransformer;
 import org.apache.maven.artifact.ArtifactUtils;
 import org.apache.maven.di.Injector;
 import org.apache.maven.di.Key;
@@ -64,6 +65,7 @@
 import org.apache.maven.graph.ProjectSelector;
 import org.apache.maven.internal.impl.DefaultSessionFactory;
 import org.apache.maven.internal.impl.InternalMavenSession;
+import org.apache.maven.internal.impl.ProjectTransformerDispatcher;
 import org.apache.maven.lifecycle.LifecycleExecutionException;
 import org.apache.maven.lifecycle.internal.ExecutionEventCatapult;
 import org.apache.maven.lifecycle.internal.LifecycleStarter;
@@ -419,6 +421,9 @@ private void afterSessionStart(MavenSession session) throws 
MavenExecutionExcept
 
     private void afterProjectsRead(MavenSession session) throws 
MavenExecutionException {
         callListeners(session, 
AbstractMavenLifecycleParticipant::afterProjectsRead);
+        Collection<ProjectTransformer> transformers =
+                getExtensionComponents(session.getProjects(), 
ProjectTransformer.class);
+        ProjectTransformerDispatcher.transformProjects(session, transformers);
     }
 
     private void afterSessionEnd(MavenSession session) throws 
MavenExecutionException {
diff --git 
a/impl/maven-core/src/main/java/org/apache/maven/internal/impl/ProjectTransformerDispatcher.java
 
b/impl/maven-core/src/main/java/org/apache/maven/internal/impl/ProjectTransformerDispatcher.java
new file mode 100644
index 0000000000..9efbec268f
--- /dev/null
+++ 
b/impl/maven-core/src/main/java/org/apache/maven/internal/impl/ProjectTransformerDispatcher.java
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+
+import org.apache.maven.MavenExecutionException;
+import org.apache.maven.api.Project;
+import org.apache.maven.api.model.Model;
+import org.apache.maven.api.spi.ProjectTransformer;
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.project.MavenProject;
+
+/**
+ * Dispatches {@link ProjectTransformer} instances over all reactor projects,
+ * chaining each transformer's output model as the next transformer's input.
+ */
+public final class ProjectTransformerDispatcher {
+
+    private ProjectTransformerDispatcher() {}
+
+    public static void transformProjects(MavenSession session, 
Collection<ProjectTransformer> transformers)
+            throws MavenExecutionException {
+        if (transformers.isEmpty()) {
+            return;
+        }
+        List<ProjectTransformer> chain = List.copyOf(transformers);
+        InternalMavenSession apiSession = 
InternalMavenSession.from(session.getSession());
+        Thread thread = Thread.currentThread();
+        ClassLoader originalClassLoader = thread.getContextClassLoader();
+        try {
+            for (MavenProject mavenProject : session.getProjects()) {
+                Project project = apiSession.getProject(mavenProject);
+                Model model = project.model();
+
+                for (ProjectTransformer transformer : chain) {
+                    
thread.setContextClassLoader(transformer.getClass().getClassLoader());
+                    try {
+                        model = transformer.transformProject(apiSession, 
project, model);
+                    } catch (RuntimeException e) {
+                        throw new MavenExecutionException("Project transformer 
failed for " + mavenProject.getId(), e);
+                    }
+                    if (model == null) {
+                        throw new MavenExecutionException(
+                                "Project transformer "
+                                        + transformer.getClass().getName() + " 
returned null model for "
+                                        + mavenProject.getId(),
+                                (Throwable) null);
+                    }
+                    validateFrozenFields(
+                            project.model(), model, 
transformer.getClass().getName(), mavenProject.getId());
+                }
+
+                if (model != project.model()) {
+                    mavenProject.setModel(new 
org.apache.maven.model.Model(model));
+                }
+            }
+        } finally {
+            thread.setContextClassLoader(originalClassLoader);
+        }
+    }
+
+    private static void validateFrozenFields(
+            Model original, Model transformed, String transformerName, String 
projectId)
+            throws MavenExecutionException {
+        List<String> violations = new ArrayList<>();
+        if (!Objects.equals(original.getGroupId(), transformed.getGroupId())
+                || !Objects.equals(original.getArtifactId(), 
transformed.getArtifactId())) {
+            violations.add("groupId/artifactId");
+        }
+        if (!Objects.equals(original.getParent(), transformed.getParent())) {
+            violations.add("<parent>");
+        }
+        if (!Objects.equals(original.getMixins(), transformed.getMixins())) {
+            violations.add("<mixins>");
+        }
+        if (!Objects.equals(original.getModules(), transformed.getModules())) {
+            violations.add("<modules>");
+        }
+        if (!Objects.equals(original.getSubprojects(), 
transformed.getSubprojects())) {
+            violations.add("<subprojects>");
+        }
+        if (!Objects.equals(original.getProfiles(), 
transformed.getProfiles())) {
+            violations.add("<profiles>");
+        }
+        if (!violations.isEmpty()) {
+            throw new MavenExecutionException(
+                    "The ProjectTransformer " + transformerName + " must not 
change " + String.join(", ", violations)
+                            + " of " + projectId,
+                    (Throwable) null);
+        }
+    }
+}
diff --git 
a/impl/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java
 
b/impl/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java
index 5877a66df1..bc4c0c2ffc 100644
--- 
a/impl/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java
+++ 
b/impl/maven-core/src/main/java/org/apache/maven/lifecycle/internal/LifecycleModuleBuilder.java
@@ -85,6 +85,7 @@ public void buildProject(
         session.setCurrentProject(currentProject);
 
         Instant buildStartTime = MonotonicClock.now();
+        boolean successReported = false;
 
         try {
 
@@ -111,6 +112,7 @@ public void buildProject(
 
             Instant buildEndTime = MonotonicClock.now();
 
+            successReported = true;
             projectExecutionListener.afterProjectExecutionSuccess(
                     new ProjectExecutionEvent(session, currentProject, 
mojoExecutions));
 
@@ -122,8 +124,10 @@ public void buildProject(
         } catch (Throwable t) {
             builderCommon.handleBuildError(reactorContext, rootSession, 
session, currentProject, t, buildStartTime);
 
-            projectExecutionListener.afterProjectExecutionFailure(
-                    new ProjectExecutionEvent(session, currentProject, t));
+            if (!successReported) {
+                projectExecutionListener.afterProjectExecutionFailure(
+                        new ProjectExecutionEvent(session, currentProject, t));
+            }
 
             // rethrow original errors and runtime exceptions
             if (t instanceof RuntimeException runtimeException) {
diff --git 
a/impl/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanExecutor.java
 
b/impl/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanExecutor.java
index b950f9e1b2..dd7371a56c 100644
--- 
a/impl/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanExecutor.java
+++ 
b/impl/maven-core/src/main/java/org/apache/maven/lifecycle/internal/concurrent/BuildPlanExecutor.java
@@ -677,6 +677,9 @@ private void executeStep(BuildStep step) throws 
IOException, LifecycleExecutionE
                     attachToThread(step);
                     
transformerManager.injectTransformedArtifacts(session.getRepositorySession(), 
step.project);
                     projectExecutionListener.beforeProjectExecution(new 
ProjectExecutionEvent(session, step.project));
+                    List<MojoExecution> executionPlan = 
executionPlan(step.project);
+                    projectExecutionListener.beforeProjectLifecycleExecution(
+                            new ProjectExecutionEvent(session, step.project, 
executionPlan));
                     eventCatapult.fire(ExecutionEvent.Type.ProjectStarted, 
session, null);
                     break;
                 case TEARDOWN:
@@ -721,11 +724,15 @@ private void executeStep(BuildStep step) throws 
IOException, LifecycleExecutionE
                             failure = new LifecycleExecutionException("Error 
building project");
                             failures.forEach(failure::addSuppressed);
                         }
+                        List<MojoExecution> failedPlan = 
executionPlan(step.project);
                         handleBuildError(reactorContext, session, 
step.project, failure, isFatal(failures));
+                        projectExecutionListener.afterProjectExecutionFailure(
+                                new ProjectExecutionEvent(session, 
step.project, failedPlan, failure));
                     } else if (projectStarted && allWorkExecuted) {
                         // If there were no failures, report success
+                        List<MojoExecution> successfulPlan = 
executionPlan(step.project);
                         projectExecutionListener.afterProjectExecutionSuccess(
-                                new ProjectExecutionEvent(session, 
step.project, Collections.emptyList()));
+                                new ProjectExecutionEvent(session, 
step.project, successfulPlan));
                         reactorContext
                                 .getResult()
                                 .addBuildSummary(new 
BuildSuccess(step.project, clock.wallTime(), clock.execTime()));
@@ -829,6 +836,10 @@ private void plan() {
             }
         }
 
+        private List<MojoExecution> executionPlan(MavenProject project) {
+            return plan.steps(project).flatMap(BuildStep::executions).toList();
+        }
+
         void bindProjectMojos(MavenProject project) {
             for (Plugin plugin : project.getBuild().getPlugins()) {
                 for (PluginExecution execution : plugin.getExecutions()) {
diff --git 
a/impl/maven-core/src/test/java/org/apache/maven/MavenLifecycleParticipantTest.java
 
b/impl/maven-core/src/test/java/org/apache/maven/MavenLifecycleParticipantTest.java
index 8a8b9c21f0..16cb3947e3 100644
--- 
a/impl/maven-core/src/test/java/org/apache/maven/MavenLifecycleParticipantTest.java
+++ 
b/impl/maven-core/src/test/java/org/apache/maven/MavenLifecycleParticipantTest.java
@@ -23,7 +23,12 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
 
+import org.apache.maven.api.Project;
+import org.apache.maven.api.Session;
+import org.apache.maven.api.model.Model;
+import org.apache.maven.api.spi.ProjectTransformer;
 import org.apache.maven.artifact.Artifact;
 import org.apache.maven.execution.MavenExecutionRequest;
 import org.apache.maven.execution.MavenExecutionResult;
@@ -100,6 +105,38 @@ public void afterProjectsRead(MavenSession session) {
         }
     }
 
+    public static class InjectReactorDependencyV4 implements 
ProjectTransformer {
+        @Override
+        public Model transformProject(Session session, Project project, Model 
model) {
+            if (!"module-a".equals(project.artifactId())) {
+                return model;
+            }
+            Project dependency = session.getProjects().stream()
+                    .filter(p -> "module-b".equals(p.artifactId()))
+                    .findFirst()
+                    .orElseThrow();
+
+            List<org.apache.maven.api.model.Dependency> dependencies = new 
ArrayList<>(model.getDependencies());
+            dependencies.add(org.apache.maven.api.model.Dependency.newBuilder()
+                    .groupId(dependency.groupId())
+                    .artifactId(dependency.artifactId())
+                    .version(dependency.version())
+                    .type("jar")
+                    .build());
+            return model.withDependencies(dependencies);
+        }
+    }
+
+    public static class RecordingProjectTransformer implements 
ProjectTransformer {
+        private static final List<String> CALLBACKS = new 
CopyOnWriteArrayList<>();
+
+        @Override
+        public Model transformProject(Session session, Project project, Model 
model) {
+            CALLBACKS.add("transformProject:" + project.artifactId());
+            return model;
+        }
+    }
+
     @Override
     protected String getProjectsDirectory() {
         return "src/test/projects/lifecycle-listener";
@@ -145,6 +182,32 @@ void testCurrentProjectSelection() throws Exception {
         assertEquals(List.of("root"), reactorOrder);
     }
 
+    @Test
+    void testV4ReactorDependencyInjection() throws Exception {
+        List<String> reactorOrder = getV4ReactorOrder(
+                "lifecycle-participant-reactor-dependency-injection", 
InjectReactorDependencyV4.class);
+        assertEquals(Arrays.asList("parent", "module-b", "module-a"), 
reactorOrder);
+    }
+
+    @Test
+    void testV4ProjectTransformer() throws Exception {
+        RecordingProjectTransformer.CALLBACKS.clear();
+        PlexusContainer container = getContainer();
+        ComponentDescriptor<RecordingProjectTransformer> cd =
+                new ComponentDescriptor<>(RecordingProjectTransformer.class, 
container.getContainerRealm());
+        cd.setRoleClass(ProjectTransformer.class);
+        container.addComponentDescriptor(cd);
+
+        Maven maven = container.lookup(Maven.class);
+        MavenExecutionRequest request =
+                
createMavenExecutionRequest(getProject("lifecycle-listener-dependency-injection"));
+        request.setGoals(List.of("validate"));
+        MavenExecutionResult result = maven.execute(request);
+
+        assertFalse(result.hasExceptions(), result.getExceptions().toString());
+        assertEquals(List.of("transformProject:simple"), 
RecordingProjectTransformer.CALLBACKS);
+    }
+
     private <T> List<String> getReactorOrder(String testProject, Class<T> 
participant) throws Exception {
         PlexusContainer container = getContainer();
 
@@ -166,4 +229,24 @@ private <T> List<String> getReactorOrder(String 
testProject, Class<T> participan
         }
         return order;
     }
+
+    private <T extends ProjectTransformer> List<String> 
getV4ReactorOrder(String testProject, Class<T> transformer)
+            throws Exception {
+        PlexusContainer container = getContainer();
+
+        ComponentDescriptor<T> cd = new ComponentDescriptor<>(transformer, 
container.getContainerRealm());
+        cd.setRoleClass(ProjectTransformer.class);
+        container.addComponentDescriptor(cd);
+
+        Maven maven = container.lookup(Maven.class);
+        File pom = getProject(testProject);
+        MavenExecutionRequest request = createMavenExecutionRequest(pom);
+        request.setGoals(List.of("validate"));
+        MavenExecutionResult result = maven.execute(request);
+
+        assertFalse(result.hasExceptions(), result.getExceptions().toString());
+        return result.getTopologicallySortedProjects().stream()
+                .map(MavenProject::getArtifactId)
+                .toList();
+    }
 }
diff --git 
a/impl/maven-core/src/test/java/org/apache/maven/internal/impl/ProjectTransformerDispatcherTest.java
 
b/impl/maven-core/src/test/java/org/apache/maven/internal/impl/ProjectTransformerDispatcherTest.java
new file mode 100644
index 0000000000..148ee4b33f
--- /dev/null
+++ 
b/impl/maven-core/src/test/java/org/apache/maven/internal/impl/ProjectTransformerDispatcherTest.java
@@ -0,0 +1,130 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.maven.internal.impl;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.maven.MavenExecutionException;
+import org.apache.maven.api.Project;
+import org.apache.maven.api.model.Model;
+import org.apache.maven.api.spi.ProjectTransformer;
+import org.apache.maven.execution.MavenSession;
+import org.apache.maven.project.MavenProject;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class ProjectTransformerDispatcherTest {
+
+    @Test
+    void chainsTransformersAndWritesModelBack() throws Exception {
+        MavenProject mavenProject = new MavenProject();
+        mavenProject.setGroupId("org.test");
+        mavenProject.setArtifactId("test");
+        mavenProject.setVersion("1.0");
+
+        MavenSession mavenSession = mock(MavenSession.class);
+        InternalMavenSession apiSession = mock(InternalMavenSession.class);
+        when(mavenSession.getSession()).thenReturn(apiSession);
+        when(mavenSession.getProjects()).thenReturn(List.of(mavenProject));
+
+        Project apiProject = mock(Project.class);
+        Model originalModel = mavenProject.getModel().getDelegate();
+        when(apiSession.getProject(mavenProject)).thenReturn(apiProject);
+        when(apiProject.model()).thenReturn(originalModel);
+
+        List<String> calls = new ArrayList<>();
+        ProjectTransformer addProperty = (session, project, model) -> {
+            calls.add("addProperty");
+            return model.withProperties(java.util.Map.of("injected", "true"));
+        };
+        ProjectTransformer addProperty2 = (session, project, model) -> {
+            calls.add("addProperty2");
+            assertEquals("true", model.getProperties().get("injected"));
+            return model.withProperties(java.util.Map.of("injected", "true", 
"second", "yes"));
+        };
+
+        ProjectTransformerDispatcher.transformProjects(mavenSession, 
List.of(addProperty, addProperty2));
+
+        assertEquals(List.of("addProperty", "addProperty2"), calls);
+        assertEquals(
+                "yes", 
mavenProject.getModel().getDelegate().getProperties().get("second"));
+    }
+
+    @Test
+    void runtimeExceptionWrappedInMavenExecutionException() {
+        MavenProject mavenProject = new MavenProject();
+        mavenProject.setGroupId("org.test");
+        mavenProject.setArtifactId("test");
+        mavenProject.setVersion("1.0");
+
+        MavenSession mavenSession = mock(MavenSession.class);
+        InternalMavenSession apiSession = mock(InternalMavenSession.class);
+        when(mavenSession.getSession()).thenReturn(apiSession);
+        when(mavenSession.getProjects()).thenReturn(List.of(mavenProject));
+
+        Project apiProject = mock(Project.class);
+        when(apiSession.getProject(mavenProject)).thenReturn(apiProject);
+        
when(apiProject.model()).thenReturn(mavenProject.getModel().getDelegate());
+
+        RuntimeException cause = new RuntimeException("buggy extension");
+        ProjectTransformer failing = (session, project, model) -> {
+            throw cause;
+        };
+
+        MavenExecutionException ex = assertThrows(
+                MavenExecutionException.class,
+                () -> 
ProjectTransformerDispatcher.transformProjects(mavenSession, List.of(failing)));
+
+        assertInstanceOf(RuntimeException.class, ex.getCause());
+        assertEquals("buggy extension", ex.getCause().getMessage());
+    }
+
+    @Test
+    void frozenFieldViolationThrowsMavenExecutionException() {
+        MavenProject mavenProject = new MavenProject();
+        mavenProject.setGroupId("org.test");
+        mavenProject.setArtifactId("test");
+        mavenProject.setVersion("1.0");
+
+        MavenSession mavenSession = mock(MavenSession.class);
+        InternalMavenSession apiSession = mock(InternalMavenSession.class);
+        when(mavenSession.getSession()).thenReturn(apiSession);
+        when(mavenSession.getProjects()).thenReturn(List.of(mavenProject));
+
+        Project apiProject = mock(Project.class);
+        when(apiSession.getProject(mavenProject)).thenReturn(apiProject);
+        
when(apiProject.model()).thenReturn(mavenProject.getModel().getDelegate());
+
+        ProjectTransformer changesGroupId = (session, project, model) -> 
model.withGroupId("hacked");
+
+        MavenExecutionException ex = assertThrows(
+                MavenExecutionException.class,
+                () -> 
ProjectTransformerDispatcher.transformProjects(mavenSession, 
List.of(changesGroupId)));
+
+        assertTrue(ex.getMessage().contains("groupId/artifactId"));
+        assertTrue(ex.getMessage().contains("must not change"));
+    }
+}

Reply via email to