Allow autoconfiguration of Compose integration via the plugin

README.md.template

@@ -149,8 +149,8 @@ Can you think of more? Let's discuss in the issues section!
   <summary>Kotlin</summary>
 
   ```kotlin
-  dependencies {
-    androidTestImplementation("de.mannodermaus.junit5:android-test-extensions:${instrumentationVersion}")
+  junitPlatform {
+    instrumentationTests.includeExtensions.set(true)
   }
   ```
 </details>
@@ -159,24 +159,25 @@ Can you think of more? Let's discuss in the issues section!
   <summary>Groovy</summary>
 
   ```groovy
-  dependencies {
-    androidTestImplementation "de.mannodermaus.junit5:android-test-extensions:${instrumentationVersion}"
+  junitPlatform {
+    instrumentationTests.includeExtensions.set(true)
   }
   ```
 </details>
 
 ### Jetpack Compose
 
 To test `@Composable` functions on device with JUnit 5, first enable support for instrumentation tests as described above.
-Then, add the integration library for Jetpack Compose to the `androidTestImplementation` configuration:
+Then, add the Compose test dependency to your `androidTestImplementation` configuration
+and the plugin will autoconfigure JUnit 5 Compose support for you!
 
 <details open>
   <summary>Kotlin</summary>
 
   ```kotlin
   dependencies {
-    // Test extension & transitive dependencies
-    androidTestImplementation("de.mannodermaus.junit5:android-test-compose:${instrumentationVersion}")
+    // Compose test framework
+    androidTestImplementation("androidx.compose.ui:ui-test-android:$compose_version")
 
     // Needed for createComposeExtension() and createAndroidComposeExtension()
     debugImplementation("androidx.compose.ui:ui-test-manifest:$compose_version")
@@ -189,8 +190,8 @@ Then, add the integration library for Jetpack Compose to the `androidTestImpleme
 
   ```groovy
   dependencies {
-    // Test extension & transitive dependencies
-    androidTestImplementation "de.mannodermaus.junit5:android-test-compose:${instrumentationVersion}"
+    // Compose test framework
+    androidTestImplementation "androidx.compose.ui:ui-test-android:$compose_version"
 
     // Needed for createComposeExtension() and createAndroidComposeExtension()
     debugImplementation "androidx.compose.ui:ui-test-manifest:$compose_version"
@@ -200,6 +201,31 @@ Then, add the integration library for Jetpack Compose to the `androidTestImpleme
 
 [The wiki][wiki-home] includes a section on how to test your Composables with JUnit 5.
 
+### Override the version of instrumentation test libraries
+
+By default, the plugin will make sure to use a compatible version of the instrumentation test libraries
+when it sets up the artifacts automatically. However, it is possible to choose a custom version instead via its DSL:
+
+<details open>
+  <summary>Kotlin</summary>
+
+  ```kotlin
+  junitPlatform {
+    instrumentationTests.version.set("${instrumentationVersion}")
+  }
+  ```
+</details>
+
+<details>
+  <summary>Groovy</summary>
+
+  ```groovy
+  junitPlatform {
+    instrumentationTests.version.set("${instrumentationVersion}")
+  }
+  ```
+</details>
+
 ## Official Support
 
 At this time, Google hasn't shared any immediate plans to bring first-party support for JUnit 5 to Android. The following list is an aggregation of pending feature requests:

plugin/CHANGELOG.md

@@ -7,6 +7,8 @@ Change Log
 - Allow overriding the version of the instrumentation libraries applied with the plugin
 - 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 
 
 ## 1.10.0.0 (2023-11-05)
 - JUnit 5.10.0

plugin/android-junit5/build.gradle.kts

@@ -88,6 +88,7 @@ val versionClassTask = tasks.register<Copy>("createVersionClass") {
         mapOf(
             "tokens" to mapOf(
                 "INSTRUMENTATION_GROUP" to Artifacts.Instrumentation.groupId,
+                "INSTRUMENTATION_COMPOSE" to Artifacts.Instrumentation.Compose.artifactId,
                 "INSTRUMENTATION_CORE" to Artifacts.Instrumentation.Core.artifactId,
                 "INSTRUMENTATION_EXTENSIONS" to Artifacts.Instrumentation.Extensions.artifactId,
                 "INSTRUMENTATION_RUNNER" to Artifacts.Instrumentation.Runner.artifactId,

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

@@ -14,12 +14,16 @@ import de.mannodermaus.gradle.plugins.junit5.internal.config.PluginConfig
 import de.mannodermaus.gradle.plugins.junit5.internal.extensions.android
 import de.mannodermaus.gradle.plugins.junit5.internal.extensions.getAsList
 import de.mannodermaus.gradle.plugins.junit5.internal.extensions.getTaskName
+import de.mannodermaus.gradle.plugins.junit5.internal.extensions.hasDependency
 import de.mannodermaus.gradle.plugins.junit5.internal.extensions.junit5Warn
 import de.mannodermaus.gradle.plugins.junit5.internal.extensions.namedOrNull
+import de.mannodermaus.gradle.plugins.junit5.internal.extensions.usesComposeIn
+import de.mannodermaus.gradle.plugins.junit5.internal.extensions.usesJUnitJupiterIn
 import de.mannodermaus.gradle.plugins.junit5.internal.utils.excludedPackagingOptions
 import de.mannodermaus.gradle.plugins.junit5.tasks.AndroidJUnit5JacocoReport
 import de.mannodermaus.gradle.plugins.junit5.tasks.AndroidJUnit5WriteFilters
 import org.gradle.api.Project
+import org.gradle.api.artifacts.Dependency
 import org.gradle.api.tasks.testing.Test
 
 internal fun configureJUnit5(
@@ -109,11 +113,7 @@ private fun AndroidJUnitPlatformExtension.prepareInstrumentationTests(project: P
     if (!instrumentationTests.enabled.get()) return
 
     // Automatically configure instrumentation tests when JUnit 5 is detected in that configuration
-    val hasJupiterApi = project.configurations
-        .getByName("androidTestImplementation")
-        .dependencies
-        .any { it.group == "org.junit.jupiter" && it.name == "junit-jupiter-api" }
-    if (!hasJupiterApi) return
+    if (!project.usesJUnitJupiterIn("androidTestImplementation")) return
 
     // Attach the JUnit 5 RunnerBuilder to the list, unless it's already added
     val runnerBuilders = android.defaultConfig.testInstrumentationRunnerArguments.getAsList("runnerBuilder")
@@ -141,6 +141,13 @@ private fun AndroidJUnitPlatformExtension.prepareInstrumentationTests(project: P
             "${Libraries.instrumentationExtensions}:$version"
         )
     }
+
+    if (project.usesComposeIn("androidTestImplementation")) {
+        project.dependencies.add(
+            "androidTestImplementation",
+            "${Libraries.instrumentationCompose}:$version"
+        )
+    }
 }
 
 private fun AndroidJUnitPlatformExtension.configureUnitTests(project: Project, variant: Variant) {

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

@@ -5,6 +5,7 @@ import com.android.build.gradle.BasePlugin
 import de.mannodermaus.gradle.plugins.junit5.dsl.AndroidJUnitPlatformExtension
 import de.mannodermaus.gradle.plugins.junit5.internal.config.EXTENSION_NAME
 import org.gradle.api.Project
+import org.gradle.api.artifacts.Dependency
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
@@ -35,3 +36,21 @@ internal fun Project.whenAndroidPluginAdded(block: (BasePlugin) -> Unit) {
         }
     }
 }
+
+internal fun Project.hasDependency(configurationName: String, matching: (Dependency) -> Boolean): Boolean {
+    val configuration = project.configurations.getByName(configurationName)
+
+    return configuration.dependencies.any(matching)
+}
+
+internal fun Project.usesJUnitJupiterIn(configurationName: String): Boolean {
+    return project.hasDependency(configurationName) {
+        it.group == "org.junit.jupiter" && it.name == "junit-jupiter-api"
+    }
+}
+
+internal fun Project.usesComposeIn(configurationName: String): Boolean {
+    return project.hasDependency(configurationName) {
+        it.group?.startsWith("androidx.compose") ?: false
+    }
+}

plugin/android-junit5/src/main/templates/Libraries.kt

@@ -2,6 +2,7 @@ package de.mannodermaus
 
 internal object Libraries {
     const val instrumentationVersion = "@INSTRUMENTATION_VERSION@"
+    const val instrumentationCompose = "@INSTRUMENTATION_GROUP@:@INSTRUMENTATION_COMPOSE@"
     const val instrumentationCore = "@INSTRUMENTATION_GROUP@:@INSTRUMENTATION_CORE@"
     const val instrumentationExtensions = "@INSTRUMENTATION_GROUP@:@INSTRUMENTATION_EXTENSIONS@"
     const val instrumentationRunner = "@INSTRUMENTATION_GROUP@:@INSTRUMENTATION_RUNNER@"

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

@@ -5,6 +5,7 @@ import de.mannodermaus.Libraries
 import de.mannodermaus.gradle.plugins.junit5.internal.config.ANDROID_JUNIT5_RUNNER_BUILDER_CLASS
 import de.mannodermaus.gradle.plugins.junit5.internal.extensions.android
 import de.mannodermaus.gradle.plugins.junit5.internal.extensions.junitPlatform
+import de.mannodermaus.gradle.plugins.junit5.util.assertThat
 import de.mannodermaus.gradle.plugins.junit5.util.evaluate
 import org.gradle.api.Project
 import org.junit.jupiter.api.BeforeEach
@@ -67,14 +68,15 @@ class InstrumentationSupportTests {
     /* Dependencies */
 
     @Test
-    fun `add the dependencies`() {
+    fun `add only the main dependencies`() {
         project.addJUnitJupiterApi()
         project.evaluate()
 
-        assertThat(project.dependencyNamed("androidTestImplementation", "android-test-core"))
-            .isEqualTo("${Libraries.instrumentationCore}:${Libraries.instrumentationVersion}")
-        assertThat(project.dependencyNamed("androidTestRuntimeOnly", "android-test-runner"))
-            .isEqualTo("${Libraries.instrumentationRunner}:${Libraries.instrumentationVersion}")
+        assertThat(project).configuration("androidTestImplementation").hasDependency(coreLibrary())
+        assertThat(project).configuration("androidTestRuntimeOnly").hasDependency(runnerLibrary())
+
+        assertThat(project).configuration("androidTestImplementation").doesNotHaveDependency(extensionsLibrary())
+        assertThat(project).configuration("androidTestImplementation").doesNotHaveDependency(composeLibrary())
     }
 
     @Test
@@ -83,8 +85,8 @@ class InstrumentationSupportTests {
         project.junitPlatform.instrumentationTests.version.set("1.3.3.7")
         project.evaluate()
 
-        assertThat(project.dependencyNamed("androidTestImplementation", "android-test-core")).endsWith("1.3.3.7")
-        assertThat(project.dependencyNamed("androidTestRuntimeOnly", "android-test-runner")).endsWith("1.3.3.7")
+        assertThat(project).configuration("androidTestImplementation").hasDependency(coreLibrary("1.3.3.7"))
+        assertThat(project).configuration("androidTestRuntimeOnly").hasDependency(runnerLibrary("1.3.3.7"))
     }
 
     @Test
@@ -96,8 +98,8 @@ class InstrumentationSupportTests {
         project.dependencies.add("androidTestRuntimeOnly", addedRunner)
         project.evaluate()
 
-        assertThat(project.dependencyNamed("androidTestImplementation", "android-test-core")).isEqualTo(addedCore)
-        assertThat(project.dependencyNamed("androidTestRuntimeOnly", "android-test-runner")).isEqualTo(addedRunner)
+        assertThat(project).configuration("androidTestImplementation").hasDependency(coreLibrary("0.1.3.3.7"))
+        assertThat(project).configuration("androidTestRuntimeOnly").hasDependency(runnerLibrary("0.1.3.3.7"))
     }
 
     @Test
@@ -106,16 +108,61 @@ class InstrumentationSupportTests {
         project.junitPlatform.instrumentationTests.enabled.set(false)
         project.evaluate()
 
-        assertThat(project.dependencyNamed("androidTestImplementation", "android-test-core")).isNull()
-        assertThat(project.dependencyNamed("androidTestRuntimeOnly", "android-test-runner")).isNull()
+        assertThat(project).configuration("androidTestImplementation").doesNotHaveDependency(coreLibrary(null))
+        assertThat(project).configuration("androidTestRuntimeOnly").doesNotHaveDependency(runnerLibrary(null))
     }
 
     @Test
     fun `do not add the dependencies when Jupiter is not added`() {
         project.evaluate()
 
-        assertThat(project.dependencyNamed("androidTestImplementation", "android-test-core")).isNull()
-        assertThat(project.dependencyNamed("androidTestRuntimeOnly", "android-test-runner")).isNull()
+        assertThat(project).configuration("androidTestImplementation").doesNotHaveDependency(coreLibrary(null))
+        assertThat(project).configuration("androidTestRuntimeOnly").doesNotHaveDependency(runnerLibrary(null))
+    }
+
+    @Test
+    fun `do not add the dependencies when Jupiter is not added, even if extension is configured to be added`() {
+        project.junitPlatform.instrumentationTests.includeExtensions.set(true)
+        project.evaluate()
+
+        assertThat(project).configuration("androidTestImplementation").doesNotHaveDependency(coreLibrary(null))
+        assertThat(project).configuration("androidTestImplementation").doesNotHaveDependency(extensionsLibrary(null))
+        assertThat(project).configuration("androidTestRuntimeOnly").doesNotHaveDependency(runnerLibrary(null))
+    }
+
+    @Test
+    fun `add the extension library if configured`() {
+        project.addJUnitJupiterApi()
+        project.junitPlatform.instrumentationTests.includeExtensions.set(true)
+        project.evaluate()
+
+        assertThat(project).configuration("androidTestImplementation").hasDependency(coreLibrary())
+        assertThat(project).configuration("androidTestImplementation").hasDependency(extensionsLibrary())
+        assertThat(project).configuration("androidTestRuntimeOnly").hasDependency(runnerLibrary())
+    }
+
+    @Test
+    fun `add the compose library if configured`() {
+        project.addJUnitJupiterApi()
+        project.addCompose()
+        project.evaluate()
+
+        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.junitPlatform.instrumentationTests.includeExtensions.set(true)
+        project.evaluate()
+
+        assertThat(project).configuration("androidTestImplementation").hasDependency(coreLibrary())
+        assertThat(project).configuration("androidTestImplementation").hasDependency(composeLibrary())
+        assertThat(project).configuration("androidTestImplementation").hasDependency(extensionsLibrary())
+        assertThat(project).configuration("androidTestRuntimeOnly").hasDependency(runnerLibrary())
     }
 
     /* Private */
@@ -124,10 +171,27 @@ class InstrumentationSupportTests {
         dependencies.add("androidTestImplementation", "org.junit.jupiter:junit-jupiter-api:+")
     }
 
-    private fun Project.dependencyNamed(configurationName: String, name: String): String? {
-        return configurations.getByName(configurationName)
-            .dependencies
-            .firstOrNull { it.name == name }
-            ?.run { "$group:$name:$version" }
+    private fun Project.addCompose() {
+        dependencies.add("androidTestImplementation", "androidx.compose.ui:ui-test-android:+")
+    }
+
+    private fun composeLibrary(withVersion: String? = Libraries.instrumentationVersion) =
+        library(Libraries.instrumentationCompose, withVersion)
+
+    private fun coreLibrary(withVersion: String? = Libraries.instrumentationVersion) =
+        library(Libraries.instrumentationCore, withVersion)
+
+    private fun extensionsLibrary(withVersion: String? = Libraries.instrumentationVersion) =
+        library(Libraries.instrumentationExtensions, withVersion)
+
+    private fun runnerLibrary(withVersion: String? = Libraries.instrumentationVersion) =
+        library(Libraries.instrumentationRunner, withVersion)
+
+    private fun library(artifactId: String, version: String?) = buildString {
+        append(artifactId)
+        if (version != null) {
+            append(':')
+            append(version)
+        }
     }
 }