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"));
+ }
+}