Use complete artifact keys instead of G:A when checking whether dependency has been visited

aloubyansky · aloubyansky · commit da86c8142568 · 2025-09-24T11:30:40.000+02:00
diff --git a/devtools/gradle/gradle-model/src/main/java/io/quarkus/gradle/tooling/GradleApplicationModelBuilder.java b/devtools/gradle/gradle-model/src/main/java/io/quarkus/gradle/tooling/GradleApplicationModelBuilder.java
@@ -241,18 +241,36 @@ private static void collectDestinationDirs(Collection<SourceDir> sources, final
     private void collectExtensionDependencies(Project project, Configuration deploymentConfiguration,
             ApplicationModelBuilder modelBuilder) {
         final ResolvedConfiguration rc = deploymentConfiguration.getResolvedConfiguration();
+        final Set<ArtifactKey> processedDeps = new HashSet<>();
         for (var dep : rc.getFirstLevelModuleDependencies()) {
-            processDeploymentDependency(project, dep, modelBuilder, false);
+            processDeploymentDependency(project, dep, modelBuilder, false, processedDeps);
         }
     }
 
     private static void processDeploymentDependency(Project project, ResolvedDependency resolvedDep,
-            ApplicationModelBuilder modelBuilder, boolean clearReloadableFlag) {
-        boolean processChildren = false;
-        for (var a : resolvedDep.getModuleArtifacts()) {
-            ResolvedDependencyBuilder dep = modelBuilder.getDependency(getKey(a));
+            ApplicationModelBuilder modelBuilder, boolean clearReloadableFlag, Set<ArtifactKey> processedDeps) {
+        final Set<ResolvedArtifact> resolvedArtifacts = resolvedDep.getModuleArtifacts();
+        boolean processChildren = resolvedArtifacts.isEmpty();
+        for (var a : resolvedArtifacts) {
+            final ArtifactKey artifactKey = getKey(a);
+            if (!processedDeps.add(artifactKey)) {
+                continue;
+            }
+            processChildren = true;
+            ResolvedDependencyBuilder dep = modelBuilder.getDependency(artifactKey);
             if (dep == null) {
-                if (a.getId().getComponentIdentifier() instanceof ProjectComponentIdentifier projectComponentIdentifier) {
+                if (isApplicationRoot(modelBuilder, artifactKey)) {
+                    // An application root artifact may be found among the dependencies in a could of cases:
+                    // test fixtures in an application project and as a deployment module in an extension project
+                    // running deployment module tests.
+                    // In case of test fixtures, the root artifact does not have to be added to the model as a dependency,
+                    // it can simply be skipped.
+                    // In case of a deployment test, it has to be added as a dependency, since otherwise, the deployment
+                    // module will appear to be missing.
+                    // This part here looks like a hack but appears to work for both cases so far.
+                    dep = modelBuilder.getApplicationArtifact();
+                } else if (a.getId()
+                        .getComponentIdentifier() instanceof ProjectComponentIdentifier projectComponentIdentifier) {
                     var includedBuild = ToolingUtils.includedBuild(project,
                             projectComponentIdentifier.getBuild().getBuildPath());
                     final Project projectDep;
@@ -297,22 +315,26 @@ private static void processDeploymentDependency(Project project, ResolvedDepende
                 }
             }
             if (dep != null) {
-                if (!dep.isDeploymentCp()) {
-                    dep.setDeploymentCp();
-                    processChildren = true;
+                if (dep.isRuntimeExtensionArtifact()) {
+                    clearReloadableFlag = true;
                 }
+                dep.setDeploymentCp();
                 if (clearReloadableFlag) {
                     dep.clearFlag(DependencyFlags.RELOADABLE);
                 }
             }
         }
         if (processChildren) {
             for (var child : resolvedDep.getChildren()) {
-                processDeploymentDependency(project, child, modelBuilder, clearReloadableFlag);
+                processDeploymentDependency(project, child, modelBuilder, clearReloadableFlag, processedDeps);
             }
         }
     }
 
+    private static boolean isApplicationRoot(ApplicationModelBuilder modelBuilder, ArtifactKey artifactKey) {
+        return modelBuilder.getApplicationArtifact().getKey().equals(artifactKey);
+    }
+
     private static ResolvedDependencyBuilder addArtifactDependency(Project project, ApplicationModelBuilder modelBuilder,
             ResolvedArtifact a) {
         ResolvedDependencyBuilder dep = modelBuilder.getDependency(getKey(a));
@@ -350,9 +372,7 @@ private void collectDependencies(ResolvedConfiguration configuration, Resolvable
 
         final Set<File> artifactFiles = getArtifactFilesOrNull(configuration, dependencies);
         for (ResolvedDependency d : configuration.getFirstLevelModuleDependencies()) {
-            collectDependencies(d, workspaceDiscovery, project, artifactFiles, new HashSet<>(),
-                    modelBuilder,
-                    wsModule,
+            collectDependencies(d, workspaceDiscovery, project, artifactFiles, modelBuilder, wsModule,
                     (byte) (COLLECT_TOP_EXTENSION_RUNTIME_NODES | COLLECT_DIRECT_DEPS | COLLECT_RELOADABLE_MODULES));
         }
 
@@ -403,86 +423,94 @@ private static Set<File> getArtifactFilesOrNull(ResolvedConfiguration configurat
     }
 
     private void collectDependencies(org.gradle.api.artifacts.ResolvedDependency resolvedDep, boolean workspaceDiscovery,
-            Project project, Set<File> artifactFiles, Set<ArtifactKey> processedModules, ApplicationModelBuilder modelBuilder,
+            Project project, Set<File> artifactFiles, ApplicationModelBuilder modelBuilder,
             WorkspaceModule.Mutable parentModule,
             byte flags) {
         WorkspaceModule.Mutable projectModule = null;
-        for (ResolvedArtifact a : resolvedDep.getModuleArtifacts()) {
+        final Set<ResolvedArtifact> resolvedArtifacts = resolvedDep.getModuleArtifacts();
+        boolean processChildren = resolvedArtifacts.isEmpty();
+        for (ResolvedArtifact a : resolvedArtifacts) {
             if (!isDependency(a)) {
                 continue;
             }
-            var depBuilder = modelBuilder.getDependency(getKey(a));
-            if (depBuilder != null) {
-                if (isFlagOn(flags, COLLECT_DIRECT_DEPS)) {
-                    depBuilder.setDirect(true);
-                }
+            final ArtifactKey artifactKey = getKey(a);
+            if (isApplicationRoot(modelBuilder, artifactKey)) {
                 continue;
             }
-            final ArtifactCoords depCoords = getArtifactCoords(a);
-            depBuilder = ResolvedDependencyBuilder.newInstance()
-                    .setCoords(depCoords)
-                    .setRuntimeCp();
-            if (isFlagOn(flags, COLLECT_DIRECT_DEPS)) {
-                depBuilder.setDirect(true);
-                flags = clearFlag(flags, COLLECT_DIRECT_DEPS);
-            }
-            if (parentModule != null) {
-                parentModule.addDependency(new ArtifactDependency(depCoords));
-            }
-
-            PathCollection paths = null;
-            if (workspaceDiscovery && a.getId().getComponentIdentifier() instanceof ProjectComponentIdentifier compId) {
-                Project projectDep = project.getRootProject().findProject(compId.getProjectPath());
+            var depBuilder = modelBuilder.getDependency(artifactKey);
+            if (depBuilder == null) {
+                processChildren = true;
+                final ArtifactCoords depCoords = getArtifactCoords(a);
+                depBuilder = ResolvedDependencyBuilder.newInstance()
+                        .setCoords(depCoords)
+                        .setRuntimeCp();
+                if (parentModule != null) {
+                    parentModule.addDependency(new ArtifactDependency(depCoords));
+                }
 
-                final String classifier = a.getClassifier();
-                if (classifier == null || classifier.isEmpty()) {
-                    final IncludedBuild includedBuild = ToolingUtils.includedBuild(project.getRootProject(),
-                            compId.getBuild().getBuildPath());
-                    if (includedBuild != null) {
-                        if (includedBuild instanceof IncludedBuildInternal ib) {
-                            projectDep = ToolingUtils.includedBuildProject(ib, compId.getProjectPath());
-                        }
-                        if (projectDep != null) {
-                            initProjectModuleAndBuildPaths(projectDep, a, modelBuilder, depBuilder);
+                PathCollection paths = null;
+                if (workspaceDiscovery && a.getId().getComponentIdentifier() instanceof ProjectComponentIdentifier compId) {
+                    Project projectDep = project.getRootProject().findProject(compId.getProjectPath());
+
+                    final String classifier = a.getClassifier();
+                    if (classifier == null || classifier.isEmpty()) {
+                        final IncludedBuild includedBuild = ToolingUtils.includedBuild(project.getRootProject(),
+                                compId.getBuild().getBuildPath());
+                        if (includedBuild != null) {
+                            if (includedBuild instanceof IncludedBuildInternal ib) {
+                                projectDep = ToolingUtils.includedBuildProject(ib, compId.getProjectPath());
+                            }
+                            if (projectDep != null) {
+                                initProjectModuleAndBuildPaths(projectDep, a, modelBuilder, depBuilder);
+                            } else {
+                                final PathList.Builder pathBuilder = PathList.builder();
+                                addSubstitutedProject(pathBuilder, includedBuild.getProjectDir());
+                                paths = pathBuilder.build();
+                            }
                         } else {
-                            final PathList.Builder pathBuilder = PathList.builder();
-                            addSubstitutedProject(pathBuilder, includedBuild.getProjectDir());
-                            paths = pathBuilder.build();
+                            initProjectModuleAndBuildPaths(projectDep, a, modelBuilder, depBuilder);
                         }
                     } else {
                         initProjectModuleAndBuildPaths(projectDep, a, modelBuilder, depBuilder);
                     }
-                } else {
-                    initProjectModuleAndBuildPaths(projectDep, a, modelBuilder, depBuilder);
                 }
-            }
 
-            depBuilder.setResolvedPaths(paths == null ? PathList.of(a.getFile().toPath()) : paths);
-            if (processQuarkusDependency(depBuilder, modelBuilder)) {
-                if (isFlagOn(flags, COLLECT_TOP_EXTENSION_RUNTIME_NODES)) {
+                depBuilder.setResolvedPaths(paths == null ? PathList.of(a.getFile().toPath()) : paths);
+                if (processQuarkusDependency(depBuilder, modelBuilder)) {
+                    flags = clearFlag(flags, COLLECT_RELOADABLE_MODULES);
+                }
+                modelBuilder.addDependency(depBuilder);
+                if (projectModule == null && depBuilder.getWorkspaceModule() != null) {
+                    projectModule = depBuilder.getWorkspaceModule().mutable();
+                }
+
+                if (artifactFiles != null) {
+                    artifactFiles.add(a.getFile());
+                }
+            }
+            if (isFlagOn(flags, COLLECT_DIRECT_DEPS)) {
+                depBuilder.setDirect(true);
+                flags = clearFlag(flags, COLLECT_DIRECT_DEPS);
+            }
+            if (depBuilder.isRuntimeExtensionArtifact()) {
+                if (isFlagOn(flags, COLLECT_RELOADABLE_MODULES)) {
+                    flags = clearFlag(flags, COLLECT_RELOADABLE_MODULES);
+                    processChildren = true;
+                }
+                if (isFlagOn(flags, COLLECT_TOP_EXTENSION_RUNTIME_NODES)
+                        && !depBuilder.isFlagSet(DependencyFlags.TOP_LEVEL_RUNTIME_EXTENSION_ARTIFACT)) {
                     depBuilder.setFlags(DependencyFlags.TOP_LEVEL_RUNTIME_EXTENSION_ARTIFACT);
                     flags = clearFlag(flags, COLLECT_TOP_EXTENSION_RUNTIME_NODES);
                 }
-                flags = clearFlag(flags, COLLECT_RELOADABLE_MODULES);
             }
             if (!isFlagOn(flags, COLLECT_RELOADABLE_MODULES)) {
                 depBuilder.clearFlag(DependencyFlags.RELOADABLE);
             }
-            modelBuilder.addDependency(depBuilder);
-            if (projectModule == null && depBuilder.getWorkspaceModule() != null) {
-                projectModule = depBuilder.getWorkspaceModule().mutable();
-            }
-
-            if (artifactFiles != null) {
-                artifactFiles.add(a.getFile());
-            }
         }
 
-        processedModules.add(ArtifactKey.ga(resolvedDep.getModuleGroup(), resolvedDep.getModuleName()));
-        for (org.gradle.api.artifacts.ResolvedDependency child : resolvedDep.getChildren()) {
-            if (!processedModules.contains(ArtifactKey.ga(child.getModuleGroup(), child.getModuleName()))) {
-                collectDependencies(child, workspaceDiscovery, project, artifactFiles, processedModules,
-                        modelBuilder, projectModule, flags);
+        if (processChildren) {
+            for (org.gradle.api.artifacts.ResolvedDependency child : resolvedDep.getChildren()) {
+                collectDependencies(child, workspaceDiscovery, project, artifactFiles, modelBuilder, projectModule, flags);
             }
         }
     }
diff --git a/integration-tests/gradle/src/main/resources/basic-composite-build-extension-project/application/build.gradle b/integration-tests/gradle/src/main/resources/basic-composite-build-extension-project/application/build.gradle
@@ -18,10 +18,10 @@ dependencies {
     implementation enforcedPlatform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}")
     testImplementation 'org.junit.jupiter:junit-jupiter-api'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
-    implementation 'io.quarkus:quarkus-resteasy'
-    implementation ('org.acme.libs:libraryB')
-    implementation ('org.acme.libs:libraryA')
-    implementation ('org.acme.extensions:example-extension')
+    implementation 'io.quarkus:quarkus-rest'
+    implementation 'org.acme.libs:libraryB'
+    implementation 'org.acme.libs:libraryA'
+    implementation 'org.acme.extensions:example-extension'
 
 }
 
diff --git a/integration-tests/gradle/src/main/resources/basic-composite-build-extension-project/libraries/libraryA/build.gradle b/integration-tests/gradle/src/main/resources/basic-composite-build-extension-project/libraries/libraryA/build.gradle
@@ -15,7 +15,7 @@ repositories {
 
 dependencies {
     implementation platform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}")
-    implementation ("${quarkusPlatformGroupId}:quarkus-arc:${quarkusPlatformVersion}")
+    implementation 'io.quarkus:quarkus-arc'
     testImplementation 'org.junit.jupiter:junit-jupiter-api'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
 }
diff --git a/integration-tests/gradle/src/main/resources/basic-composite-build-extension-project/libraries/libraryB/build.gradle b/integration-tests/gradle/src/main/resources/basic-composite-build-extension-project/libraries/libraryB/build.gradle
@@ -15,7 +15,7 @@ repositories {
 
 dependencies {
     implementation platform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}")
-    implementation ("${quarkusPlatformGroupId}:quarkus-arc:${quarkusPlatformVersion}")
+    implementation 'io.quarkus:quarkus-arc'
     testImplementation 'org.junit.jupiter:junit-jupiter-api'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
     implementation project(':libraryA')
diff --git a/integration-tests/gradle/src/main/resources/basic-composite-build-project/application/build.gradle b/integration-tests/gradle/src/main/resources/basic-composite-build-project/application/build.gradle
@@ -18,9 +18,9 @@ dependencies {
     implementation enforcedPlatform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}")
     testImplementation 'org.junit.jupiter:junit-jupiter-api'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
-    implementation 'io.quarkus:quarkus-resteasy'
-    implementation ('org.acme.libs:libraryB')
-    implementation ('org.acme.libs:libraryA')
+    implementation 'io.quarkus:quarkus-rest'
+    implementation 'org.acme.libs:libraryB'
+    implementation 'org.acme.libs:libraryA'
 
 }
 
diff --git a/integration-tests/gradle/src/main/resources/basic-composite-build-project/libraries/libraryA/build.gradle b/integration-tests/gradle/src/main/resources/basic-composite-build-project/libraries/libraryA/build.gradle
@@ -15,7 +15,7 @@ repositories {
 
 dependencies {
     implementation platform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}")
-    implementation ("${quarkusPlatformGroupId}:quarkus-arc:${quarkusPlatformVersion}")
+    implementation 'io.quarkus:quarkus-arc'
     testImplementation 'org.junit.jupiter:junit-jupiter-api'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
 }
diff --git a/integration-tests/gradle/src/main/resources/basic-composite-build-project/libraries/libraryB/build.gradle b/integration-tests/gradle/src/main/resources/basic-composite-build-project/libraries/libraryB/build.gradle
@@ -15,7 +15,7 @@ repositories {
 
 dependencies {
     implementation platform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}")
-    implementation ("${quarkusPlatformGroupId}:quarkus-arc:${quarkusPlatformVersion}")
+    implementation 'io.quarkus:quarkus-arc'
     testImplementation 'org.junit.jupiter:junit-jupiter-api'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'
     implementation project(':libraryA')
diff --git a/integration-tests/gradle/src/test/java/io/quarkus/gradle/TestFixtureMultiModuleTest.java b/integration-tests/gradle/src/test/java/io/quarkus/gradle/TestFixtureMultiModuleTest.java
@@ -4,16 +4,61 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.net.URISyntaxException;
+import java.io.ObjectInputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.junit.jupiter.api.Test;
 
+import io.quarkus.bootstrap.model.ApplicationModel;
+import io.quarkus.bootstrap.util.BootstrapUtils;
+import io.quarkus.maven.dependency.ArtifactKey;
+
 public class TestFixtureMultiModuleTest extends QuarkusGradleWrapperTestBase {
 
     @Test
-    public void testTaskShouldUseTestFixtures() throws IOException, URISyntaxException, InterruptedException {
+    public void testTaskShouldUseTestFixtures() throws Exception {
         final File projectDir = getProjectDir("test-fixtures-multi-module");
         final BuildResult result = runGradleWrapper(projectDir, "clean", "test");
         assertThat(BuildResult.isSuccessful(result.getTasks().get(":application:test"))).isTrue();
+
+        final Path testModelDat = projectDir.toPath().resolve("application").resolve("build").resolve("quarkus")
+                .resolve("application-model").resolve("quarkus-app-test-model.dat");
+        assertThat(testModelDat).exists();
+        final ApplicationModel model = deserializeAppModel(testModelDat);
+        final Map<ArtifactKey, String> actualDepFlags = new HashMap<>();
+        for (var dep : model.getDependencies()) {
+            if (dep.getGroupId().equals("my-groupId")) {
+                actualDepFlags.put(dep.getKey(), BootstrapUtils.toTextFlags(dep.getFlags()));
+            }
+        }
+        assertThat(actualDepFlags).containsExactlyInAnyOrderEntriesOf(Map.of(
+                ArtifactKey.fromString("my-groupId:library-1::jar"),
+                "runtime-cp, deployment-cp, workspace-module, reloadable",
+                ArtifactKey.fromString("my-groupId:library-1:test-fixtures:jar"),
+                "runtime-cp, deployment-cp, workspace-module, reloadable",
+                ArtifactKey.fromString("my-groupId:library-2::jar"),
+                "direct, runtime-cp, deployment-cp, workspace-module, reloadable",
+                ArtifactKey.fromString("my-groupId:library-2:test-fixtures:jar"),
+                "direct, runtime-cp, deployment-cp, workspace-module, reloadable",
+                ArtifactKey.fromString("my-groupId:static-init-library::jar"),
+                "runtime-cp, deployment-cp, workspace-module, reloadable"));
+    }
+
+    /**
+     * Copied from ToolingUtils
+     *
+     * @param path application model dat file
+     * @return deserialized ApplicationModel
+     * @throws IOException in case of a failure to read the model
+     */
+    private static ApplicationModel deserializeAppModel(Path path) throws IOException {
+        try (ObjectInputStream out = new ObjectInputStream(Files.newInputStream(path))) {
+            return (ApplicationModel) out.readObject();
+        } catch (ClassNotFoundException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ repositories {`
`15`	`15`
`16`	`16`	`dependencies {`
`17`	`17`	`implementation platform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}")`
`18`		`- implementation ("${quarkusPlatformGroupId}:quarkus-arc:${quarkusPlatformVersion}")`
	`18`	`+ implementation 'io.quarkus:quarkus-arc'`
`19`	`19`	`testImplementation 'org.junit.jupiter:junit-jupiter-api'`
`20`	`20`	`testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine'`
`21`	`21`	`}`