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 0ba3c07b72 [MNG-7993] Resolve dependencies in project context (#13649)
0ba3c07b72 is described below
commit 0ba3c07b7290affa35d7b8b49f14f6ab29942288
Author: B V HITESH SAI <[email protected]>
AuthorDate: Thu Nov 5 13:35:53 2026 +0530
[MNG-7993] Resolve dependencies in project context (#13649)
* [MNG-7993] Resolve dependencies in project context
Add DependencyResolver overloads that combine plugin-supplied coordinates
with a project context.
Apply the project's repositories and dependency management to direct and
transitive dependencies while preserving explicitly configured values.
* [MNG-7993] Address dependency resolver review
Document project-context routing and default scope behavior.
Cover collect routing, empty dependencies, and partial dependency
management while removing an unreachable scope null check.
* test: add negative test for applyDependencyManagement guard with empty
caller deps
Verify that when a Project is present but request.getDependencies() is
empty, applyDependencyManagement is NOT called. The project's own
dependencies must pass through to the resolver unchanged, with no
managed version/scope/exclusion merge applied.
This covers the guard condition:
request.getProject().isPresent() && !request.getDependencies().isEmpty()
* javadoc: add @since 4.2.0 to new project-context API methods
---------
Co-authored-by: Guillaume Nodet <[email protected]>
---
.../maven/api/services/DependencyResolver.java | 60 ++++++
.../api/services/DependencyResolverRequest.java | 68 ++++++-
.../api/services/RequestImplementationTest.java | 17 ++
.../maven/impl/DefaultDependencyResolver.java | 62 ++++++-
.../maven/impl/DefaultDependencyResolverTest.java | 203 +++++++++++++++++++++
5 files changed, 402 insertions(+), 8 deletions(-)
diff --git
a/api/maven-api-core/src/main/java/org/apache/maven/api/services/DependencyResolver.java
b/api/maven-api-core/src/main/java/org/apache/maven/api/services/DependencyResolver.java
index 24c1c15be5..02b664dfbe 100644
---
a/api/maven-api-core/src/main/java/org/apache/maven/api/services/DependencyResolver.java
+++
b/api/maven-api-core/src/main/java/org/apache/maven/api/services/DependencyResolver.java
@@ -195,6 +195,66 @@ default DependencyResolverResult resolve(
session, DependencyResolverRequest.RequestType.RESOLVE,
project, scope));
}
+ /**
+ * Resolves a dependency in the context of a project. The project's
dependency management and repositories are
+ * applied to the dependency and its transitive dependencies. The path
scope defaults to
+ * {@link PathScope#MAIN_RUNTIME}; use the scope-taking overload to select
another scope.
+ *
+ * @since 4.2.0
+ */
+ @Nonnull
+ default DependencyResolverResult resolve(
+ @Nonnull Session session, @Nonnull Project project, @Nonnull
DependencyCoordinates dependency) {
+ return resolve(DependencyResolverRequest.build(
+ session, DependencyResolverRequest.RequestType.RESOLVE,
project, dependency));
+ }
+
+ /**
+ * Resolves a dependency in the context of a project for the given path
scope. The project's dependency management
+ * and repositories are applied to the dependency and its transitive
dependencies.
+ *
+ * @since 4.2.0
+ */
+ @Nonnull
+ default DependencyResolverResult resolve(
+ @Nonnull Session session,
+ @Nonnull Project project,
+ @Nonnull DependencyCoordinates dependency,
+ @Nonnull PathScope scope) {
+ return resolve(DependencyResolverRequest.build(
+ session, DependencyResolverRequest.RequestType.RESOLVE,
project, dependency, scope));
+ }
+
+ /**
+ * Resolves dependencies in the context of a project. The project's
dependency management and repositories are
+ * applied to the dependencies and their transitive dependencies. The path
scope defaults to
+ * {@link PathScope#MAIN_RUNTIME}; use the scope-taking overload to select
another scope.
+ *
+ * @since 4.2.0
+ */
+ @Nonnull
+ default DependencyResolverResult resolve(
+ @Nonnull Session session, @Nonnull Project project, @Nonnull
List<DependencyCoordinates> dependencies) {
+ return resolve(DependencyResolverRequest.build(
+ session, DependencyResolverRequest.RequestType.RESOLVE,
project, dependencies));
+ }
+
+ /**
+ * Resolves dependencies in the context of a project for the given path
scope. The project's dependency management
+ * and repositories are applied to the dependencies and their transitive
dependencies.
+ *
+ * @since 4.2.0
+ */
+ @Nonnull
+ default DependencyResolverResult resolve(
+ @Nonnull Session session,
+ @Nonnull Project project,
+ @Nonnull List<DependencyCoordinates> dependencies,
+ @Nonnull PathScope scope) {
+ return resolve(DependencyResolverRequest.build(
+ session, DependencyResolverRequest.RequestType.RESOLVE,
project, dependencies, scope));
+ }
+
/**
* Resolves a single dependency for the default runtime scope.
*
diff --git
a/api/maven-api-core/src/main/java/org/apache/maven/api/services/DependencyResolverRequest.java
b/api/maven-api-core/src/main/java/org/apache/maven/api/services/DependencyResolverRequest.java
index f84327763b..f3d7d1eb5e 100644
---
a/api/maven-api-core/src/main/java/org/apache/maven/api/services/DependencyResolverRequest.java
+++
b/api/maven-api-core/src/main/java/org/apache/maven/api/services/DependencyResolverRequest.java
@@ -199,13 +199,71 @@ static DependencyResolverRequest build(Session session,
RequestType requestType,
}
/**
- * Builds a request for the given dependency using the default runtime
scope.
+ * Builds a project-context request for one dependency using {@link
PathScope#MAIN_RUNTIME}.
+ * Use the scope-taking overload to select another scope.
*
- * @param session the session
- * @param requestType the request type
- * @param dependency the root dependency coordinates
- * @return a new request, never {@code null}
+ * @since 4.2.0
+ */
+ @Nonnull
+ static DependencyResolverRequest build(
+ Session session, RequestType requestType, Project project,
DependencyCoordinates dependency) {
+ return build(session, requestType, project, dependency,
PathScope.MAIN_RUNTIME);
+ }
+
+ /**
+ * Builds a project-context request for one dependency and path scope.
+ *
+ * @since 4.2.0
*/
+ @Nonnull
+ static DependencyResolverRequest build(
+ Session session,
+ RequestType requestType,
+ Project project,
+ DependencyCoordinates dependency,
+ PathScope scope) {
+ return new DependencyResolverRequestBuilder()
+ .session(session)
+ .requestType(requestType)
+ .project(project)
+ .dependency(dependency)
+ .pathScope(scope)
+ .build();
+ }
+
+ /**
+ * Builds a project-context request for dependencies using {@link
PathScope#MAIN_RUNTIME}.
+ * Use the scope-taking overload to select another scope.
+ *
+ * @since 4.2.0
+ */
+ @Nonnull
+ static DependencyResolverRequest build(
+ Session session, RequestType requestType, Project project,
List<DependencyCoordinates> dependencies) {
+ return build(session, requestType, project, dependencies,
PathScope.MAIN_RUNTIME);
+ }
+
+ /**
+ * Builds a project-context request for dependencies and path scope.
+ *
+ * @since 4.2.0
+ */
+ @Nonnull
+ static DependencyResolverRequest build(
+ Session session,
+ RequestType requestType,
+ Project project,
+ List<DependencyCoordinates> dependencies,
+ PathScope scope) {
+ return new DependencyResolverRequestBuilder()
+ .session(session)
+ .requestType(requestType)
+ .project(project)
+ .dependencies(dependencies)
+ .pathScope(scope)
+ .build();
+ }
+
@Nonnull
static DependencyResolverRequest build(Session session, RequestType
requestType, DependencyCoordinates dependency) {
return build(session, requestType, dependency, PathScope.MAIN_RUNTIME);
diff --git
a/api/maven-api-core/src/test/java/org/apache/maven/api/services/RequestImplementationTest.java
b/api/maven-api-core/src/test/java/org/apache/maven/api/services/RequestImplementationTest.java
index 694956063e..ff1d855035 100644
---
a/api/maven-api-core/src/test/java/org/apache/maven/api/services/RequestImplementationTest.java
+++
b/api/maven-api-core/src/test/java/org/apache/maven/api/services/RequestImplementationTest.java
@@ -22,13 +22,16 @@
import java.util.List;
import org.apache.maven.api.ArtifactCoordinates;
+import org.apache.maven.api.DependencyCoordinates;
import org.apache.maven.api.PathScope;
+import org.apache.maven.api.Project;
import org.apache.maven.api.RemoteRepository;
import org.apache.maven.api.Session;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.mock;
@@ -113,4 +116,18 @@ void testDependencyResolverRequestEquality() {
assertTrue(toString.contains("requestType="), "Expected " + toString +
" to contain " + "requestType=");
assertTrue(toString.contains("pathScope="), "Expected " + toString + "
to contain " + "pathScope=");
}
+
+ @Test
+ void testDependencyResolverRequestInProjectContext() {
+ Session session = mock(Session.class);
+ Project project = mock(Project.class);
+ DependencyCoordinates dependency = mock(DependencyCoordinates.class);
+
+ DependencyResolverRequest request = DependencyResolverRequest.build(
+ session, DependencyResolverRequest.RequestType.RESOLVE,
project, dependency);
+
+ assertSame(project, request.getProject().orElseThrow());
+ assertEquals(List.of(dependency), request.getDependencies());
+ assertEquals(PathScope.MAIN_RUNTIME, request.getPathScope());
+ }
}
diff --git
a/impl/maven-impl/src/main/java/org/apache/maven/impl/DefaultDependencyResolver.java
b/impl/maven-impl/src/main/java/org/apache/maven/impl/DefaultDependencyResolver.java
index bd7cf5cd6f..d1f02be00f 100644
---
a/impl/maven-impl/src/main/java/org/apache/maven/impl/DefaultDependencyResolver.java
+++
b/impl/maven-impl/src/main/java/org/apache/maven/impl/DefaultDependencyResolver.java
@@ -20,7 +20,9 @@
import java.io.IOException;
import java.nio.file.Path;
+import java.util.ArrayList;
import java.util.Collection;
+import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@@ -127,7 +129,9 @@ public DependencyResolverResult collect(@Nonnull
DependencyResolverRequest reque
Project project = request.getProject().get();
rootArtifact = project.getPomArtifact();
root = null;
- dependencies = project.getDependencies();
+ // Caller-supplied dependencies take precedence to allow
plugin-specific resolution in project context.
+ dependencies =
+ request.getDependencies().isEmpty() ?
project.getDependencies() : request.getDependencies();
managedDependencies = project.getManagedDependencies();
remoteRepositories = request.getRepositories() != null
? request.getRepositories()
@@ -147,11 +151,18 @@ public DependencyResolverResult collect(@Nonnull
DependencyResolverRequest reque
.getResolutionScope(request.getPathScope().id())
.orElseThrow();
}
+ List<org.eclipse.aether.graph.Dependency> resolverDependencies =
+ session.toDependencies(dependencies, false);
+ List<org.eclipse.aether.graph.Dependency>
resolverManagedDependencies =
+ session.toDependencies(managedDependencies, true);
+ if (request.getProject().isPresent() &&
!request.getDependencies().isEmpty()) {
+ resolverDependencies =
applyDependencyManagement(resolverDependencies, resolverManagedDependencies);
+ }
CollectRequest collectRequest = new CollectRequest()
.setRootArtifact(rootArtifact != null ?
session.toArtifact(rootArtifact) : null)
.setRoot(root != null ? session.toDependency(root, false)
: null)
- .setDependencies(session.toDependencies(dependencies,
false))
-
.setManagedDependencies(session.toDependencies(managedDependencies, true))
+ .setDependencies(resolverDependencies)
+ .setManagedDependencies(resolverManagedDependencies)
.setRepositories(session.toResolvingRepositories(remoteRepositories))
.setRequestContext(trace.context())
.setTrace(trace.trace());
@@ -182,6 +193,51 @@ public DependencyResolverResult collect(@Nonnull
DependencyResolverRequest reque
}
}
+ /**
+ * Applies dependency management to dependencies supplied outside the
project model. Resolver applies managed
+ * dependencies only below the root's direct dependencies, while project
model building normally performs this
+ * merge before resolution. Dependencies supplied by a plugin therefore
need the same merge here.
+ */
+ static List<org.eclipse.aether.graph.Dependency> applyDependencyManagement(
+ Collection<org.eclipse.aether.graph.Dependency> dependencies,
+ Collection<org.eclipse.aether.graph.Dependency>
managedDependencies) {
+ Map<String, org.eclipse.aether.graph.Dependency> managed = new
HashMap<>();
+ for (org.eclipse.aether.graph.Dependency dependency :
managedDependencies) {
+ managed.put(dependencyKey(dependency), dependency);
+ }
+
+ List<org.eclipse.aether.graph.Dependency> result = new
ArrayList<>(dependencies.size());
+ for (org.eclipse.aether.graph.Dependency dependency : dependencies) {
+ org.eclipse.aether.graph.Dependency management =
managed.get(dependencyKey(dependency));
+ if (management == null) {
+ result.add(dependency);
+ continue;
+ }
+
+ org.eclipse.aether.artifact.Artifact artifact =
dependency.getArtifact();
+ if (artifact.getVersion().isEmpty()) {
+ artifact =
artifact.setVersion(management.getArtifact().getVersion());
+ }
+ String scope = dependency.getScope();
+ if (scope.isEmpty()) {
+ scope = management.getScope();
+ }
+ Collection<org.eclipse.aether.graph.Exclusion> exclusions =
dependency.getExclusions();
+ if (exclusions.isEmpty()) {
+ exclusions = management.getExclusions();
+ }
+ result.add(new org.eclipse.aether.graph.Dependency(artifact,
scope, dependency.getOptional(), exclusions));
+ }
+ return result;
+ }
+
+ private static String dependencyKey(org.eclipse.aether.graph.Dependency
dependency) {
+ org.eclipse.aether.artifact.Artifact artifact =
dependency.getArtifact();
+ String type =
+
artifact.getProperty(org.eclipse.aether.artifact.ArtifactProperties.TYPE,
artifact.getExtension());
+ return artifact.getGroupId() + ':' + artifact.getArtifactId() + ':' +
type + ':' + artifact.getClassifier();
+ }
+
@Nonnull
@Override
public List<Node> flatten(@Nonnull Session s, @Nonnull Node node,
@Nullable PathScope scope)
diff --git
a/impl/maven-impl/src/test/java/org/apache/maven/impl/DefaultDependencyResolverTest.java
b/impl/maven-impl/src/test/java/org/apache/maven/impl/DefaultDependencyResolverTest.java
new file mode 100644
index 0000000000..b96a961ec4
--- /dev/null
+++
b/impl/maven-impl/src/test/java/org/apache/maven/impl/DefaultDependencyResolverTest.java
@@ -0,0 +1,203 @@
+/*
+ * 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.impl;
+
+import java.util.List;
+import java.util.Optional;
+
+import org.apache.maven.api.DependencyCoordinates;
+import org.apache.maven.api.Node;
+import org.apache.maven.api.Project;
+import org.apache.maven.api.services.DependencyResolverRequest;
+import org.eclipse.aether.RepositorySystem;
+import org.eclipse.aether.RepositorySystemSession;
+import org.eclipse.aether.artifact.DefaultArtifact;
+import org.eclipse.aether.collection.CollectRequest;
+import org.eclipse.aether.collection.CollectResult;
+import org.eclipse.aether.graph.DefaultDependencyNode;
+import org.eclipse.aether.graph.Dependency;
+import org.eclipse.aether.graph.Exclusion;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+class DefaultDependencyResolverTest {
+
+ @Test
+ void collectAppliesProjectManagementToCallerSuppliedDependencies() throws
Exception {
+ InternalSession session = mock(InternalSession.class);
+ RepositorySystem repositorySystem = mock(RepositorySystem.class);
+ RepositorySystemSession repositorySession =
mock(RepositorySystemSession.class);
+ DependencyResolverRequest request =
mock(DependencyResolverRequest.class);
+ Project project = mock(Project.class);
+ DependencyCoordinates projectDependency =
mock(DependencyCoordinates.class);
+ DependencyCoordinates callerDependency =
mock(DependencyCoordinates.class);
+ DependencyCoordinates managedDependency =
mock(DependencyCoordinates.class);
+ List<DependencyCoordinates> projectDependencies =
List.of(projectDependency);
+ List<DependencyCoordinates> callerDependencies =
List.of(callerDependency);
+ List<DependencyCoordinates> managedDependencies =
List.of(managedDependency);
+ Dependency resolverDependency =
+ new Dependency(new DefaultArtifact("org.example", "processor",
"", "jar", ""), "", false);
+ Exclusion exclusion = new Exclusion("org.example", "excluded", "*",
"*");
+ Dependency resolverManagedDependency = new Dependency(
+ new DefaultArtifact("org.example:processor:jar:1.2.3"),
"runtime", false, List.of(exclusion));
+
+ when(request.getSession()).thenReturn(session);
+ when(request.getProject()).thenReturn(Optional.of(project));
+ when(request.getDependencies()).thenReturn(callerDependencies);
+ when(request.getRepositories()).thenReturn(List.of());
+ when(project.getDependencies()).thenReturn(projectDependencies);
+ when(project.getManagedDependencies()).thenReturn(managedDependencies);
+ when(session.toDependencies(callerDependencies,
false)).thenReturn(List.of(resolverDependency));
+ when(session.toDependencies(managedDependencies,
true)).thenReturn(List.of(resolverManagedDependency));
+ when(session.toResolvingRepositories(List.of())).thenReturn(List.of());
+ when(session.getRepositorySystem()).thenReturn(repositorySystem);
+ when(session.getSession()).thenReturn(repositorySession);
+ when(repositorySystem.collectDependencies(eq(repositorySession),
any(CollectRequest.class)))
+ .thenAnswer(invocation -> new
CollectResult(invocation.getArgument(1))
+ .setRoot(new
DefaultDependencyNode(resolverDependency)));
+ when(session.getNode(any(), eq(false))).thenReturn(mock(Node.class));
+
+ new DefaultDependencyResolver().collect(request);
+
+ ArgumentCaptor<CollectRequest> requestCaptor =
ArgumentCaptor.forClass(CollectRequest.class);
+ verify(repositorySystem).collectDependencies(eq(repositorySession),
requestCaptor.capture());
+ Dependency collectedDependency =
+ requestCaptor.getValue().getDependencies().get(0);
+ assertEquals("1.2.3", collectedDependency.getArtifact().getVersion());
+ assertEquals("runtime", collectedDependency.getScope());
+ assertIterableEquals(List.of(exclusion),
collectedDependency.getExclusions());
+ verify(session).toDependencies(callerDependencies, false);
+ verify(session, never()).toDependencies(projectDependencies, false);
+ }
+
+ @Test
+ void collectWithProjectButNoCallerDepsSkipsManagementApplication() throws
Exception {
+ // When a Project is present but request.getDependencies() is empty,
the guard
+ // `request.getProject().isPresent() &&
!request.getDependencies().isEmpty()` is false,
+ // so applyDependencyManagement must NOT be called: the project's own
deps go through
+ // as-is (no managed version/scope/exclusion merge).
+ InternalSession session = mock(InternalSession.class);
+ RepositorySystem repositorySystem = mock(RepositorySystem.class);
+ RepositorySystemSession repositorySession =
mock(RepositorySystemSession.class);
+ DependencyResolverRequest request =
mock(DependencyResolverRequest.class);
+ Project project = mock(Project.class);
+ DependencyCoordinates projectDependency =
mock(DependencyCoordinates.class);
+ DependencyCoordinates managedDependency =
mock(DependencyCoordinates.class);
+ List<DependencyCoordinates> projectDependencies =
List.of(projectDependency);
+ List<DependencyCoordinates> managedDependencies =
List.of(managedDependency);
+ // The resolver-level dependency has no version — management would set
"1.2.3", but must NOT
+ Dependency resolverProjectDependency =
+ new Dependency(new DefaultArtifact("org.example", "processor",
"", "jar", ""), "", false);
+ Dependency resolverManagedDependency =
+ new Dependency(new
DefaultArtifact("org.example:processor:jar:1.2.3"), "runtime");
+
+ when(request.getSession()).thenReturn(session);
+ when(request.getProject()).thenReturn(Optional.of(project));
+ when(request.getDependencies()).thenReturn(List.of()); // no
caller-supplied deps
+ when(request.getRepositories()).thenReturn(List.of());
+ when(project.getDependencies()).thenReturn(projectDependencies);
+ when(project.getManagedDependencies()).thenReturn(managedDependencies);
+ when(session.toDependencies(projectDependencies,
false)).thenReturn(List.of(resolverProjectDependency));
+ when(session.toDependencies(managedDependencies,
true)).thenReturn(List.of(resolverManagedDependency));
+ when(session.toResolvingRepositories(List.of())).thenReturn(List.of());
+ when(session.getRepositorySystem()).thenReturn(repositorySystem);
+ when(session.getSession()).thenReturn(repositorySession);
+ when(repositorySystem.collectDependencies(eq(repositorySession),
any(CollectRequest.class)))
+ .thenAnswer(invocation -> new
CollectResult(invocation.getArgument(1))
+ .setRoot(new
DefaultDependencyNode(resolverProjectDependency)));
+ when(session.getNode(any(), eq(false))).thenReturn(mock(Node.class));
+
+ new DefaultDependencyResolver().collect(request);
+
+ ArgumentCaptor<CollectRequest> requestCaptor =
ArgumentCaptor.forClass(CollectRequest.class);
+ verify(repositorySystem).collectDependencies(eq(repositorySession),
requestCaptor.capture());
+ Dependency collectedDependency =
+ requestCaptor.getValue().getDependencies().get(0);
+ // version must remain empty — management was NOT applied
+ assertEquals("", collectedDependency.getArtifact().getVersion());
+ assertEquals("", collectedDependency.getScope());
+ // project's own dependencies were used (not caller-supplied, since
there were none)
+ verify(session).toDependencies(projectDependencies, false);
+ }
+
+ @Test
+ void appliesProjectManagementToPluginDependency() {
+ Dependency dependency =
+ new Dependency(new DefaultArtifact("org.example", "processor",
"", "jar", ""), "", false);
+ Exclusion exclusion = new Exclusion("org.example", "excluded", "*",
"*");
+ Dependency managed = new Dependency(
+ new DefaultArtifact("org.example:processor:jar:1.2.3"),
"runtime", false, List.of(exclusion));
+
+ Dependency result =
DefaultDependencyResolver.applyDependencyManagement(List.of(dependency),
List.of(managed))
+ .get(0);
+
+ assertEquals("1.2.3", result.getArtifact().getVersion());
+ assertEquals("runtime", result.getScope());
+ assertIterableEquals(List.of(exclusion), result.getExclusions());
+ }
+
+ @Test
+ void keepsValuesDeclaredByPluginDependency() {
+ Exclusion declaredExclusion = new Exclusion("org.example", "declared",
"*", "*");
+ Dependency dependency = new Dependency(
+ new DefaultArtifact("org.example:processor:jar:2.0.0"),
"test", false, List.of(declaredExclusion));
+ Exclusion managedExclusion = new Exclusion("org.example", "managed",
"*", "*");
+ Dependency managed = new Dependency(
+ new DefaultArtifact("org.example:processor:jar:1.2.3"),
"runtime", false, List.of(managedExclusion));
+
+ Dependency result =
DefaultDependencyResolver.applyDependencyManagement(List.of(dependency),
List.of(managed))
+ .get(0);
+
+ assertEquals("2.0.0", result.getArtifact().getVersion());
+ assertEquals("test", result.getScope());
+ assertIterableEquals(List.of(declaredExclusion),
result.getExclusions());
+ }
+
+ @Test
+ void applyingDependencyManagementToEmptyDependenciesIsNoOp() {
+ Dependency managed = new Dependency(new
DefaultArtifact("org.example:processor:jar:1.2.3"), "runtime");
+
+
assertTrue(DefaultDependencyResolver.applyDependencyManagement(List.of(),
List.of(managed))
+ .isEmpty());
+ }
+
+ @Test
+ void appliesDependencyManagementOnlyToMatchingDependencies() {
+ Dependency matching = new Dependency(new
DefaultArtifact("org.example", "processor", "", "jar", ""), "", false);
+ Dependency unmatched = new Dependency(new
DefaultArtifact("org.example:standalone:jar:2.0.0"), "compile");
+ Dependency managed = new Dependency(new
DefaultArtifact("org.example:processor:jar:1.2.3"), "runtime");
+
+ List<Dependency> result =
+
DefaultDependencyResolver.applyDependencyManagement(List.of(matching,
unmatched), List.of(managed));
+
+ assertEquals("1.2.3", result.get(0).getArtifact().getVersion());
+ assertSame(unmatched, result.get(1));
+ }
+}