Add instrumentation test APIs to unit test configurations as well

Same logic as with androidTest: Add Compose only if it's detected

Author: mannodermaus

plugin/CHANGELOG.md

@@ -8,7 +8,7 @@ Change Log
 - Update Jacoco & instrumentation test DSLs of the plugin to use Gradle Providers for their input parameters (e.g. `instrumentationTests.enabled.set(true)` instead of `instrumentationTests.enabled = true`)
 - Removed deprecated `integrityCheckEnabled` flag from the plugin DSL's instrumentation test options
 - Allow opt-in usage of extension library via the plugin's DSL
-- Allow autoconfiguration of compose library if Compose is used in the androidTest dependency list 
+- Allow autoconfiguration of instrumentation libraries if Compose or JUnit 5 are found among the test/androidTest dependency lists 
 - Decouple discovery of instrumentation tests from Jupiter, allowing non-Jupiter test engines to be discovered as well
 - Update lifecycle of instrumentation runner params to only be set once, instead of once per test
 - Properly reported disabled dynamic tests to Android instrumentation

plugin/android-junit5/src/main/kotlin/de/mannodermaus/gradle/plugins/junit5/dsl/AndroidJUnitPlatformExtension.kt

@@ -98,6 +98,7 @@ public abstract class AndroidJUnitPlatformExtension @Inject constructor(
             enabled.convention(true)
             version.convention(Libraries.instrumentationVersion)
             includeExtensions.convention(false)
+            useConfigurationParameters.convention(true)
         }
 
     public fun instrumentationTests(action: Action<InstrumentationTestOptions>) {

plugin/android-junit5/src/main/kotlin/de/mannodermaus/gradle/plugins/junit5/dsl/InstrumentationTestOptions.kt

@@ -27,4 +27,11 @@ public abstract class InstrumentationTestOptions {
      */
     @get:Input
     public abstract val includeExtensions: Property<Boolean>
+
+    /**
+     * Whether to use configuration parameters configured via the plugin DSL
+     * for instrumentation tests, too.
+     */
+    @get:Input
+    public abstract val useConfigurationParameters: Property<Boolean>
 }

plugin/android-junit5/src/main/kotlin/de/mannodermaus/gradle/plugins/junit5/internal/configureJUnit5.kt

@@ -92,7 +92,7 @@ private fun AndroidJUnitPlatformExtension.prepareVariantDsl(variant: Variant) {
     }
 }
 
-private fun prepareUnitTests(project: Project, android: AndroidExtension) {
+private fun AndroidJUnitPlatformExtension.prepareUnitTests(project: Project, android: AndroidExtension) {
     // Add default ignore rules for JUnit 5 metadata files to the packaging options of the plugin,
     // so that consumers don't need to do this explicitly
     val options = excludedPackagingOptions()
@@ -106,6 +106,8 @@ private fun prepareUnitTests(project: Project, android: AndroidExtension) {
         //  Fall back to the old DSL when this happens
         options.forEach(project.android.packagingOptions::exclude)
     }
+
+    attachDependencies(project, "testImplementation", includeRunner = false)
 }
 
 private fun AndroidJUnitPlatformExtension.prepareInstrumentationTests(project: Project, android: AndroidExtension) {
@@ -123,29 +125,47 @@ private fun AndroidJUnitPlatformExtension.prepareInstrumentationTests(project: P
             .joinToString(",")
     }
 
-    val version = instrumentationTests.version.get()
-
-    project.dependencies.add(
-        "androidTestImplementation",
-        "${Libraries.instrumentationCore}:$version"
-    )
-    project.dependencies.add(
-        "androidTestRuntimeOnly",
-        "${Libraries.instrumentationRunner}:$version"
-    )
-
-    if (instrumentationTests.includeExtensions.get()) {
-        project.dependencies.add(
-            "androidTestImplementation",
-            "${Libraries.instrumentationExtensions}:$version"
-        )
+    // Copy over configuration parameters to instrumentation tests
+    if (instrumentationTests.useConfigurationParameters.get()) {
+        val instrumentationParams = android.defaultConfig.testInstrumentationRunnerArguments
+            .getAsList("configurationParameters")
+            .toMutableList()
+
+        this.configurationParameters.get().forEach { (key, value) ->
+            instrumentationParams.add("$key=$value")
+        }
+
+        android.defaultConfig.testInstrumentationRunnerArguments["configurationParameters"] =
+            instrumentationParams.joinToString(",")
     }
 
-    if (project.usesComposeIn("androidTestImplementation")) {
-        project.dependencies.add(
-            "androidTestImplementation",
-            "${Libraries.instrumentationCompose}:$version"
-        )
+    attachDependencies(project, "androidTestImplementation", includeRunner = true)
+}
+
+private fun AndroidJUnitPlatformExtension.attachDependencies(
+    project: Project,
+    configurationName: String,
+    includeRunner: Boolean,
+) {
+    if (project.usesJUnitJupiterIn(configurationName)) {
+        val version = instrumentationTests.version.get()
+
+        project.dependencies.add(configurationName, "${Libraries.instrumentationCore}:$version")
+
+        if (includeRunner) {
+            project.dependencies.add(
+                configurationName.replace("Implementation", "RuntimeOnly"),
+                "${Libraries.instrumentationRunner}:$version",
+            )
+        }
+
+        if (instrumentationTests.includeExtensions.get()) {
+            project.dependencies.add(configurationName, "${Libraries.instrumentationExtensions}:$version")
+        }
+
+        if (project.usesComposeIn(configurationName)) {
+            project.dependencies.add(configurationName, "${Libraries.instrumentationCompose}:$version")
+        }
     }
 }
 

plugin/android-junit5/src/test/kotlin/de/mannodermaus/gradle/plugins/junit5/plugin/InstrumentationSupportTests.kt

@@ -32,7 +32,7 @@ class InstrumentationSupportTests {
 
     @Test
     fun `add the RunnerBuilder`() {
-        project.addJUnitJupiterApi()
+        project.addJUnitJupiterApi("androidTest")
         project.evaluate()
 
         assertThat(project.android.defaultConfig.testInstrumentationRunnerArguments["runnerBuilder"])
@@ -41,7 +41,7 @@ class InstrumentationSupportTests {
 
     @Test
     fun `maintain any existing RunnerBuilder`() {
-        project.addJUnitJupiterApi()
+        project.addJUnitJupiterApi("androidTest")
         project.android.defaultConfig.testInstrumentationRunnerArguments["runnerBuilder"] = "something.else"
         project.evaluate()
 
@@ -51,7 +51,7 @@ class InstrumentationSupportTests {
 
     @Test
     fun `do not add the RunnerBuilder when disabled`() {
-        project.addJUnitJupiterApi()
+        project.addJUnitJupiterApi("androidTest")
         project.junitPlatform.instrumentationTests.enabled.set(false)
         project.evaluate()
 
@@ -65,11 +65,52 @@ class InstrumentationSupportTests {
         assertThat(project.android.defaultConfig.testInstrumentationRunnerArguments["runnerBuilder"]).isNull()
     }
 
+    /* Configuration parameters */
+
+    @Test
+    fun `copy configuration parameters to test runner arguments`() {
+        project.addJUnitJupiterApi("androidTest")
+        with (project.junitPlatform) {
+            configurationParameter("my.parameter1", "true")
+            configurationParameter("my.parameter2", "1234")
+        }
+        project.evaluate()
+
+        assertThat(project.android.defaultConfig.testInstrumentationRunnerArguments["configurationParameters"])
+            .isEqualTo("my.parameter1=true,my.parameter2=1234")
+    }
+
+    @Test
+    fun `do not copy configuration parameters if disabled via dsl`() {
+        project.addJUnitJupiterApi("androidTest")
+        with (project.junitPlatform) {
+            configurationParameter("my.parameter1", "true")
+            configurationParameter("my.parameter2", "1234")
+            instrumentationTests.useConfigurationParameters.set(false)
+        }
+        project.evaluate()
+
+        assertThat(project.android.defaultConfig.testInstrumentationRunnerArguments["configurationParameters"])
+            .isNull()
+    }
+
     /* Dependencies */
 
     @Test
-    fun `add only the main dependencies`() {
-        project.addJUnitJupiterApi()
+    fun `add only the main dependencies (test)`() {
+        project.addJUnitJupiterApi("test")
+        project.evaluate()
+
+        assertThat(project).configuration("testImplementation").hasDependency(coreLibrary())
+        assertThat(project).configuration("testRuntimeOnly").doesNotHaveDependency(runnerLibrary())
+
+        assertThat(project).configuration("testImplementation").doesNotHaveDependency(extensionsLibrary())
+        assertThat(project).configuration("testImplementation").doesNotHaveDependency(composeLibrary())
+    }
+
+    @Test
+    fun `add only the main dependencies (androidTest)`() {
+        project.addJUnitJupiterApi("androidTest")
         project.evaluate()
 
         assertThat(project).configuration("androidTestImplementation").hasDependency(coreLibrary())
@@ -81,7 +122,7 @@ class InstrumentationSupportTests {
 
     @Test
     fun `allow overriding the version`() {
-        project.addJUnitJupiterApi()
+        project.addJUnitJupiterApi("androidTest")
         project.junitPlatform.instrumentationTests.version.set("1.3.3.7")
         project.evaluate()
 
@@ -91,7 +132,7 @@ class InstrumentationSupportTests {
 
     @Test
     fun `allow overriding the dependencies`() {
-        project.addJUnitJupiterApi()
+        project.addJUnitJupiterApi("androidTest")
         val addedCore = "de.mannodermaus.junit5:android-test-core:0.1.3.3.7"
         val addedRunner = "de.mannodermaus.junit5:android-test-runner:0.1.3.3.7"
         project.dependencies.add("androidTestImplementation", addedCore)
@@ -104,7 +145,7 @@ class InstrumentationSupportTests {
 
     @Test
     fun `do not add the dependencies when disabled`() {
-        project.addJUnitJupiterApi()
+        project.addJUnitJupiterApi("androidTest")
         project.junitPlatform.instrumentationTests.enabled.set(false)
         project.evaluate()
 
@@ -132,7 +173,7 @@ class InstrumentationSupportTests {
 
     @Test
     fun `add the extension library if configured`() {
-        project.addJUnitJupiterApi()
+        project.addJUnitJupiterApi("androidTest")
         project.junitPlatform.instrumentationTests.includeExtensions.set(true)
         project.evaluate()
 
@@ -143,22 +184,31 @@ class InstrumentationSupportTests {
 
     @Test
     fun `add the compose library if configured`() {
-        project.addJUnitJupiterApi()
-        project.addCompose()
+        project.addJUnitJupiterApi("test")
+        project.addJUnitJupiterApi("androidTest")
+        project.addCompose("test")
+        project.addCompose("androidTest")
         project.evaluate()
 
+        assertThat(project).configuration("testImplementation").hasDependency(coreLibrary())
+        assertThat(project).configuration("testImplementation").hasDependency(composeLibrary())
         assertThat(project).configuration("androidTestImplementation").hasDependency(coreLibrary())
         assertThat(project).configuration("androidTestImplementation").hasDependency(composeLibrary())
         assertThat(project).configuration("androidTestRuntimeOnly").hasDependency(runnerLibrary())
     }
 
     @Test
     fun `add the extensions and compose libraries if configured`() {
-        project.addJUnitJupiterApi()
-        project.addCompose()
+        project.addJUnitJupiterApi("test")
+        project.addJUnitJupiterApi("androidTest")
+        project.addCompose("test")
+        project.addCompose("androidTest")
         project.junitPlatform.instrumentationTests.includeExtensions.set(true)
         project.evaluate()
 
+        assertThat(project).configuration("testImplementation").hasDependency(coreLibrary())
+        assertThat(project).configuration("testImplementation").hasDependency(composeLibrary())
+        assertThat(project).configuration("testImplementation").hasDependency(extensionsLibrary())
         assertThat(project).configuration("androidTestImplementation").hasDependency(coreLibrary())
         assertThat(project).configuration("androidTestImplementation").hasDependency(composeLibrary())
         assertThat(project).configuration("androidTestImplementation").hasDependency(extensionsLibrary())
@@ -167,7 +217,7 @@ class InstrumentationSupportTests {
 
     @Test
     fun `register the filter-write tasks`() {
-        project.addJUnitJupiterApi()
+        project.addJUnitJupiterApi("androidTest")
         project.evaluate()
 
         // AGP only registers androidTest tasks for the debug build type
@@ -177,12 +227,14 @@ class InstrumentationSupportTests {
 
     /* Private */
 
-    private fun Project.addJUnitJupiterApi() {
-        dependencies.add("androidTestImplementation", "org.junit.jupiter:junit-jupiter-api:+")
+    private fun Project.addJUnitJupiterApi(prefix: String) {
+        val configuration = if (prefix.isEmpty()) "implementation" else "${prefix}Implementation"
+        dependencies.add(configuration, "org.junit.jupiter:junit-jupiter-api:+")
     }
 
-    private fun Project.addCompose() {
-        dependencies.add("androidTestImplementation", "androidx.compose.ui:ui-test-android:+")
+    private fun Project.addCompose(prefix: String) {
+        val configuration = if (prefix.isEmpty()) "implementation" else "${prefix}Implementation"
+        dependencies.add(configuration, "androidx.compose.ui:ui-test-android:+")
     }
 
     private fun composeLibrary(withVersion: String? = Libraries.instrumentationVersion) =