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

Reply via email to