Merge pull request quarkusio#44032 from cdsap/avoid_forced_resolution…

…_when_configuring_task

Avoiding forcing resolution when configuring QuarkusApplicationModelTask

devtools/gradle/gradle-application-plugin/src/main/java/io/quarkus/gradle/QuarkusPlugin.java

@@ -519,14 +519,12 @@ private static void configureApplicationModelTask(Project project, QuarkusApplic
         task.getProjectDescriptor().set(projectDescriptor);
         task.getLaunchMode().set(launchMode);
         task.getOriginalClasspath().setFrom(classpath.getOriginalRuntimeClasspathAsInput());
-        task.getAppClasspath().configureFrom(classpath.getRuntimeConfiguration());
+        task.getAppClasspath().configureFrom(classpath.getRuntimeConfigurationWithoutResolvingDeployment());
         task.getPlatformConfiguration().configureFrom(classpath.getPlatformConfiguration());
         task.getDeploymentClasspath().configureFrom(classpath.getDeploymentConfiguration());
-        task.getPlatformImportProperties().set(classpath.getPlatformImports().getPlatformProperties());
-        task.getApplicationModel().set(
-                project.getLayout().getBuildDirectory()
-                        .file(quarkusModelFile));
-
+        task.getDeploymentResolvedWorkaround().from(classpath.getDeploymentConfiguration().getIncoming().getFiles());
+        task.getPlatformImportProperties().set(classpath.getPlatformImportsWithoutResolvingPlatform().getPlatformProperties());
+        task.getApplicationModel().set(project.getLayout().getBuildDirectory().file(quarkusModelFile));
     }
 
     private static void configureQuarkusBuildTask(Project project, QuarkusPluginExtension quarkusExt, QuarkusBuildTask task,

devtools/gradle/gradle-application-plugin/src/main/java/io/quarkus/gradle/tasks/QuarkusApplicationModelTask.java

@@ -48,6 +48,7 @@
 import org.gradle.api.provider.Property;
 import org.gradle.api.tasks.CompileClasspath;
 import org.gradle.api.tasks.Input;
+import org.gradle.api.tasks.InputFiles;
 import org.gradle.api.tasks.Internal;
 import org.gradle.api.tasks.Nested;
 import org.gradle.api.tasks.OutputFile;
@@ -107,6 +108,9 @@ public abstract class QuarkusApplicationModelTask extends DefaultTask {
     @CompileClasspath
     public abstract ConfigurableFileCollection getOriginalClasspath();
 
+    @InputFiles
+    public abstract ConfigurableFileCollection getDeploymentResolvedWorkaround();
+
     @Nested
     public abstract QuarkusResolvedClasspath getPlatformConfiguration();
 

devtools/gradle/gradle-model/src/main/java/io/quarkus/gradle/dependency/ApplicationDeploymentClasspathBuilder.java

@@ -288,6 +288,10 @@ public Configuration getRuntimeConfiguration() {
         return project.getConfigurations().getByName(this.runtimeConfigurationName);
     }
 
+    public Configuration getRuntimeConfigurationWithoutResolvingDeployment() {
+        return project.getConfigurations().getByName(this.runtimeConfigurationName);
+    }
+
     public Configuration getDeploymentConfiguration() {
         return project.getConfigurations().getByName(this.deploymentConfigurationName);
     }
@@ -308,6 +312,10 @@ public PlatformImports getPlatformImports() {
         return platformImports.get(this.platformImportName);
     }
 
+    public PlatformImports getPlatformImportsWithoutResolvingPlatform() {
+        return platformImports.get(this.platformImportName);
+    }
+
     private Set<ExtensionDependency<?>> collectFirstMetQuarkusExtensions(Configuration configuration,
             Collection<ExtensionDependency<?>> knownExtensions) {
 

integration-tests/gradle/src/main/resources/java-platform-with-eager-resolution-project/build.gradle.kts

@@ -0,0 +1,31 @@
+plugins {
+    java
+    id("io.quarkus")
+}
+
+repositories {
+    mavenCentral()
+    mavenLocal()
+}
+
+
+dependencies {
+    implementation("io.quarkus:quarkus-rest")
+    implementation("io.quarkus:quarkus-arc")
+    implementation(enforcedPlatform(project(":library")))
+    testImplementation("io.quarkus:quarkus-junit5")
+    testImplementation("io.rest-assured:rest-assured")
+}
+
+group = "org.acme"
+version = "1.0.0-SNAPSHOT"
+
+tasks.withType<Test> {
+    systemProperty("java.util.logging.manager", "org.jboss.logmanager.LogManager")
+}
+tasks.withType<JavaCompile> {
+    options.encoding = "UTF-8"
+    options.compilerArgs.add("-parameters")
+}
+
+tasks.all{}

integration-tests/gradle/src/main/resources/java-platform-with-eager-resolution-project/gradle.properties

@@ -0,0 +1,3 @@
+quarkusPlatformArtifactId=quarkus-bom
+quarkusPlatformGroupId=io.quarkus
+kotlinVersion=${kotlin.version}

integration-tests/gradle/src/main/resources/java-platform-with-eager-resolution-project/library/build.gradle.kts

@@ -0,0 +1,15 @@
+plugins {
+    `java-platform`
+}
+
+val quarkusPlatformGroupId: String by project
+val quarkusPlatformArtifactId: String by project
+val quarkusPlatformVersion: String by project
+
+javaPlatform.allowDependencies()
+dependencies{
+    api(enforcedPlatform("${quarkusPlatformGroupId}:${quarkusPlatformArtifactId}:${quarkusPlatformVersion}"))
+    constraints{
+        api("org.assertj:assertj-core:3.26.3")
+    }
+}

integration-tests/gradle/src/main/resources/java-platform-with-eager-resolution-project/settings.gradle

@@ -0,0 +1,19 @@
+pluginManagement {
+    repositories {
+        mavenLocal {
+            content {
+                includeGroupByRegex 'io.quarkus.*'
+                includeGroup 'org.hibernate.orm'
+            }
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+    plugins {
+        id 'io.quarkus' version "${quarkusPluginVersion}"
+        id 'org.jetbrains.kotlin.jvm' version "${kotlinVersion}"
+        id 'org.jetbrains.kotlin.plugin.allopen' version "${kotlinVersion}"
+    }
+}
+rootProject.name='java-platform-with-eager-resolution-project'
+include(":library")

integration-tests/gradle/src/main/resources/java-platform-with-eager-resolution-project/src/main/java/org/acme/GreetingResource.java

@@ -0,0 +1,16 @@
+package org.acme;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+
+@Path("/hello")
+public class GreetingResource {
+
+    @GET
+    @Produces(MediaType.TEXT_PLAIN)
+    public String hello() {
+        return "Hello from Quarkus REST";
+    }
+}

integration-tests/gradle/src/main/resources/java-platform-with-eager-resolution-project/src/native-test/java/org/acme/GreetingResourceIT.java

@@ -0,0 +1,8 @@
+package org.acme;
+
+import io.quarkus.test.junit.QuarkusIntegrationTest;
+
+@QuarkusIntegrationTest
+class GreetingResourceIT extends GreetingResourceTest {
+    // Execute the same tests but in packaged mode.
+}

integration-tests/gradle/src/main/resources/java-platform-with-eager-resolution-project/src/test/java/org/acme/GreetingResourceTest.java

@@ -0,0 +1,20 @@
+package org.acme;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.CoreMatchers.is;
+
+@QuarkusTest
+class GreetingResourceTest {
+    @Test
+    void testHelloEndpoint() {
+        given()
+          .when().get("/hello")
+          .then()
+             .statusCode(200)
+             .body(is("Hello from Quarkus REST"));
+    }
+
+}

integration-tests/gradle/src/test/java/io/quarkus/gradle/JavaPlatformWithEagerResolutionTest.java

@@ -0,0 +1,26 @@
+package io.quarkus.gradle;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+
+import org.junit.jupiter.api.Test;
+
+public class JavaPlatformWithEagerResolutionTest extends QuarkusGradleWrapperTestBase {
+
+    @Test
+    public void shouldImportConditionalDependency() throws IOException, URISyntaxException, InterruptedException {
+
+        final File projectDir = getProjectDir("java-platform-with-eager-resolution-project");
+
+        runGradleWrapper(projectDir, "clean", ":quarkusBuild");
+
+        final File buildDir = new File(projectDir, "build");
+
+        final Path quarkusOutput = buildDir.toPath().resolve("quarkus-app");
+        assertThat(quarkusOutput.resolve("quarkus-run.jar")).exists();
+    }
+}