Use compilations instead of multiple mpp targets for java codegen tests (#5164)

* use compilations instead of multiple mpp targets for java codegen tests

* fix tests

* remove warning

Author: martinbonnin

build-logic/src/main/kotlin/Mpp.kt

@@ -1,8 +1,15 @@
+
+import com.android.build.gradle.internal.tasks.factory.dependsOn
 import org.gradle.api.Action
 import org.gradle.api.Project
+import org.gradle.api.tasks.testing.Test
 import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.kotlinExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrLink
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinNativeLink
+import org.jetbrains.kotlin.konan.target.Family
 
 private val allAppleTargets = setOf(
     "macosX64",
@@ -19,23 +26,23 @@ private val allAppleTargets = setOf(
 )
 
 // Try to guess the dev machine to make sure the tests are running smoothly
-val hostTarget: String
+internal val hostTarget: String
   get() = if (System.getProperty("os.arch") == "aarch64") {
     "macosArm64"
   } else {
     "macosX64"
   }
 
-val enabledAppleTargets = allAppleTargets
-val enabledLinux = true
-val enabledJs = true
+private val enableLinux = true
+private val enableJs = true
 
 fun Project.configureMppDefaults(withJs: Boolean, withLinux: Boolean, withAndroid: Boolean) {
   configureMpp(
       withJvm = true,
       withJs = withJs,
+      browserTest = false,
       withLinux = withLinux,
-      appleTargets = enabledAppleTargets,
+      appleTargets = allAppleTargets,
       withAndroid = withAndroid,
   )
 }
@@ -67,7 +74,7 @@ fun Project.configureMpp(
     withLinux: Boolean,
     withAndroid: Boolean,
     appleTargets: Collection<String>,
-    browserTest: Boolean = false,
+    browserTest: Boolean,
 ) {
   val kotlinExtension = extensions.findByName("kotlin") as? KotlinMultiplatformExtension
   check(kotlinExtension != null) {
@@ -78,7 +85,7 @@ fun Project.configureMpp(
       jvm()
     }
 
-    if (enabledJs && withJs) {
+    if (enableJs && withJs) {
       js(IR) {
         if (browserTest) {
           browser {
@@ -101,7 +108,7 @@ fun Project.configureMpp(
       }
     }
 
-    if (enabledLinux && withLinux) {
+    if (enableLinux && withLinux) {
       linuxX64("linux")
     }
 
@@ -111,8 +118,14 @@ fun Project.configureMpp(
       }
     }
 
-    createAndConfigureAppleTargets(appleTargets.toSet().intersect(enabledAppleTargets))
+    appleTargets.toSet().intersect(allAppleTargets).forEach { presetName ->
+      targetFromPreset(
+          presets.getByName(presetName),
+          presetName,
+      )
+    }
 
+    configureSourceSetGraph()
     addTestDependencies()
 
     tasks.withType(KotlinJsIrLink::class.java).configureEach {
@@ -124,31 +137,65 @@ fun Project.configureMpp(
   }
 }
 
-private fun KotlinMultiplatformExtension.createAndConfigureAppleTargets(presetNames: Collection<String>) {
-  if (presetNames.isEmpty()) {
-    return
+/**
+ * Current Graph is something like so
+ *
+ * graph TB
+ * commonMain --> jvmMain
+ * commonMain --> appleMain
+ * commonMain --> linuxMain
+ * commonMain --> jsMain
+ * appleMain --> macosX64
+ * appleMain --> macosArm64
+ * appleMain --> iosArm64
+ * appleMain --> iosX64
+ * appleMain --> iosSimulatorArm64
+ * appleMain --> watchosArm32
+ * appleMain --> watchosArm64
+ * appleMain --> watchosSimulatorArm64
+ * appleMain --> tvosArm64
+ * appleMain --> tvosX64
+ * appleMain --> tvosSimulatorArm64
+ *
+ *
+ * commonTest --> kotlinCodegenTest
+ * commonTest --> jvmJavaCodeGen
+ * kotlinCodegenTest --> macOsArm64Test
+ * kotlinCodegenTest --> jvmTest
+ * kotlinCodegenTest --> jsTest
+ *
+ *
+ *
+ * classDef kotlinPurple fill:#A97BFF,stroke:#333,stroke-width:2px,color:#333
+ * classDef javaOrange fill:#b07289,stroke:#333,stroke-width:2px,color:#333
+ * classDef gray fill:#AAA,stroke:#333,stroke-width:2px,color:#333
+ * class kotlinCodegenTest gray
+ * class jvmJavaCodeGen,macOsArm64Test,jvmTest,jsTest kotlinPurple
+ * class commonTest javaOrange
+ */
+private fun KotlinMultiplatformExtension.configureSourceSetGraph() {
+  val hasAppleTarget = targets.any {
+    it is KotlinNativeTarget && it.konanTarget.family in setOf(Family.IOS, Family.OSX, Family.WATCHOS, Family.TVOS)
   }
+  if (hasAppleTarget) {
+    val appleMain = sourceSets.create("appleMain")
+    val appleTest = sourceSets.create("appleTest")
 
-  if (System.getProperty("idea.sync.active") != null) {
-    // Early return. Inside intelliJ, only configure one target
-    targetFromPreset(presets.getByName(hostTarget), "apple")
-    return
-  }
+    appleMain.dependsOn(sourceSets.getByName("commonMain"))
+    appleTest.dependsOn(sourceSets.getByName("commonTest"))
 
-  val appleMain = sourceSets.create("appleMain")
-  val appleTest = sourceSets.create("appleTest")
+    allAppleTargets.forEach {
+      sourceSets.findByName("${it}Main")?.dependsOn(appleMain)
+      sourceSets.findByName("${it}Test")?.dependsOn(appleTest)
+    }
+  }
 
-  appleMain.dependsOn(sourceSets.getByName("commonMain"))
-  appleTest.dependsOn(sourceSets.getByName("commonTest"))
+  val kotlinCodegentTest = sourceSets.create("kotlinCodegenTest")
 
-  presetNames.forEach { presetName ->
-    targetFromPreset(
-        presets.getByName(presetName),
-        presetName,
-    )
+  kotlinCodegentTest.dependsOn(sourceSets.getByName("commonTest"))
 
-    sourceSets.getByName("${presetName}Main").dependsOn(appleMain)
-    sourceSets.getByName("${presetName}Test").dependsOn(appleTest)
+  targets.forEach {
+    sourceSets.findByName("${it.name}Test")?.dependsOn(kotlinCodegentTest)
   }
 }
 
@@ -159,3 +206,38 @@ private fun KotlinMultiplatformExtension.addTestDependencies() {
     }
   }
 }
+
+fun Project.registerJavaCodegenTestTask() {
+  val kotlin = kotlinExtension
+  check(kotlin is KotlinMultiplatformExtension) {
+    "Only multiplatform projects can register a javaCodegenTest task"
+  }
+  val jvmTarget = kotlin.targets.getByName("jvm") as KotlinJvmTarget
+  jvmTarget.withJava()
+
+  val javaCodegenCompilation = jvmTarget.compilations.create("javaCodegen")
+  javaCodegenCompilation.compileJavaTaskProvider?.configure {
+    classpath += configurations.getByName("jvmTestCompileClasspath")
+  }
+  javaCodegenCompilation.configurations.compileDependencyConfiguration.extendsFrom(configurations.getByName("jvmTestCompileClasspath"))
+  javaCodegenCompilation.defaultSourceSet.dependsOn(kotlin.sourceSets.getByName("commonTest"))
+  javaCodegenCompilation.defaultSourceSet.kotlin.apply {
+    srcDir("src/kotlinCodegenTest/kotlin")
+  }
+
+  val task = tasks.register("javaCodegenTest", Test::class.java) {
+    description = "Runs Java codegen tests."
+    group = "verification"
+
+    testClassesDirs = javaCodegenCompilation.output.classesDirs
+    classpath = configurations.getByName("jvmTestRuntimeClasspath") + javaCodegenCompilation.output.classesDirs
+
+    useJUnit()
+
+    testLogging {
+      events("passed")
+    }
+  }
+
+  tasks.named("build").dependsOn(task)
+}

build-logic/src/main/kotlin/com/apollographql/apollo3/buildlogic/plugin/TestConventionPlugin.kt

@@ -4,6 +4,7 @@ import commonSetup
 import configureJavaAndKotlinCompilers
 import configureMppTestsDefaults
 import configureTesting
+import hostTarget
 import optIn
 import org.gradle.api.Action
 import org.gradle.api.Plugin
@@ -49,7 +50,7 @@ class TestConventionPlugin : Plugin<Project> {
           withJs = mppConfiguration.withJs.getOrElse(true),
           withJvm = mppConfiguration.withJvm.getOrElse(true),
           browserTest = mppConfiguration.browserTest.getOrElse(false),
-          appleTargets = mppConfiguration.appleTargets.orElse(setOf("macosArm64", "macosX64")).get()
+          appleTargets = mppConfiguration.appleTargets.getOrElse(setOf(hostTarget))
       )
     }
   }

tests/defer/build.gradle.kts

@@ -9,13 +9,6 @@ apolloTest {
 }
 
 kotlin {
-  /**
-   * Extra target to test the java codegen
-   */
-  jvm("javaCodegen") {
-    withJava()
-  }
-
   sourceSets {
     findByName("commonMain")?.apply {
       dependencies {
@@ -26,6 +19,7 @@ kotlin {
 
     findByName("commonTest")?.apply {
       dependencies {
+        implementation(libs.apollo.normalizedcache)
         implementation(libs.apollo.mockserver)
         implementation(libs.apollo.testingsupport)
       }
@@ -51,47 +45,44 @@ kotlin {
   }
 }
 
-apollo {
-  service("kotlin") {
-    packageName.set("defer")
-    generateKotlinModels.set(true)
-    sourceFolder.set("base")
-    configureConnection(true)
-  }
-  service("java") {
-    packageName.set("defer")
-    generateKotlinModels.set(false)
-    sourceFolder.set("base")
-    configureConnection(false)
-  }
-  service("supergraph") {
-    packageName.set("supergraph")
-    sourceFolder.set("supergraph")
-    this.addTypename.set("ifAbstract")
+fun configureApollo(generateKotlinModels: Boolean) {
+  val extra = if (generateKotlinModels) "kotlin" else "java"
 
-    configureConnection(true)
+  apollo {
+    service("base-$extra") {
+      packageName.set("defer")
+      this.generateKotlinModels.set(generateKotlinModels)
+      sourceFolder.set("base")
+      configureConnection(generateKotlinModels)
+    }
+    service("supergraph-$extra") {
+      packageName.set("supergraph")
+      sourceFolder.set("supergraph")
+      this.addTypename.set("ifAbstract")
+      this.generateKotlinModels.set(generateKotlinModels)
+      configureConnection(generateKotlinModels)
+    }
   }
 }
 
+configureApollo(true)
+if (System.getProperty("idea.sync.active") == null) {
+  registerJavaCodegenTestTask()
+  configureApollo(false)
+}
+
 fun com.apollographql.apollo3.gradle.api.Service.configureConnection(generateKotlinModels: Boolean) {
   outputDirConnection {
-    if (System.getProperty("idea.sync.active") == null) {
-      if (generateKotlinModels) {
-        connectToKotlinSourceSet("jvmTest")
-        connectToKotlinSourceSet("jsTest")
-        connectToKotlinSourceSet("appleTest")
-      } else {
-        connectToJavaSourceSet("main")
-      }
+    if (generateKotlinModels) {
+      connectToKotlinSourceSet("kotlinCodegenTest")
     } else {
-      // For autocomplete to work
-      connectToKotlinSourceSet("commonTest")
+      connectToJavaSourceSet("javaCodegen")
     }
   }
 }
 
 tasks.withType(AbstractTestTask::class.java) {
-  // Run the defer with Router tests only from a a specific CI job
+  // Run the defer with Router tests only from a specific CI job
   val runDeferWithRouterTests = System.getenv("COM_APOLLOGRAPHQL_DEFER_WITH_ROUTER_TESTS").toBoolean()
   if (runDeferWithRouterTests) {
     filter.setIncludePatterns("test.DeferWithRouterTest")
@@ -100,41 +91,3 @@ tasks.withType(AbstractTestTask::class.java) {
   }
 }
 
-// See https://youtrack.jetbrains.com/issue/KT-56019
-val myAttribute = Attribute.of("com.apollographql.test", String::class.java)
-
-configurations.named("jvmApiElements").configure {
-  attributes {
-    attribute(myAttribute, "jvm")
-  }
-}
-
-configurations.named("javaCodegenApiElements").configure {
-  attributes {
-    attribute(myAttribute, "java")
-  }
-}
-
-configurations.named("jvmRuntimeElements").configure {
-  attributes {
-    attribute(myAttribute, "jvm-runtime")
-  }
-}
-
-configurations.named("javaCodegenRuntimeElements").configure {
-  attributes {
-    attribute(myAttribute, "java-runtime")
-  }
-}
-
-configurations.named("jvmSourcesElements").configure {
-  attributes {
-    attribute(myAttribute, "jvm")
-  }
-}
-
-configurations.named("javaCodegenSourcesElements").configure {
-  attributes {
-    attribute(myAttribute, "java")
-  }
-}