Additional tweaks to JUnit 5 task's classpath for both AGP 2.x & 3.x

Author: Marcel Schnelle

android-junit5/build.gradle

@@ -45,11 +45,10 @@ dependencies {
     compile localGroovy()
     compile "com.github.zafarkhaja:java-semver:$SEMVER_VERSION"
     compile "org.junit.platform:junit-platform-gradle-plugin:$JUNIT_PLATFORM_VERSION"
-    compileOnly "com.android.tools.build:gradle:$ANDROID_PLUGIN_VERSION_2X"
+    compileOnly "com.android.tools.build:gradle:$ANDROID_PLUGIN_VERSION_3X"
 
     testCompile "junit:junit:$JUNIT4_VERSION"
     testCompile("org.spockframework:spock-core:$SPOCK_VERSION") { transitive = false }
-    testCompileOnly "com.android.tools.build:gradle:$ANDROID_PLUGIN_VERSION_3X"
 
     testAgp2xCompile "com.android.tools.build:gradle:$ANDROID_PLUGIN_VERSION_2X"
     testAgp3xCompile "com.android.tools.build:gradle:$ANDROID_PLUGIN_VERSION_3X"
@@ -68,7 +67,10 @@ task testAgp3x(type: Test) {
 }
 
 // Combine all tests when executing the main JUnit task
-tasks.getByName("test").dependsOn(testAgp2x, testAgp3x)
+tasks.getByName("test").dependsOn(
+        testAgp2x,
+        testAgp3x
+)
 
 version = VERSION_NAME
 

android-junit5/src/main/groovy/de/mannodermaus/gradle/anj5/AndroidJUnit5Compat.groovy

@@ -1,37 +1,53 @@
 package de.mannodermaus.gradle.anj5
 
+import com.android.build.gradle.internal.publishing.AndroidArtifacts
 import com.android.build.gradle.internal.scope.VariantScope
 import com.github.zafarkhaja.semver.Version
+import com.google.common.collect.ImmutableList
+import com.google.common.collect.Iterables
+import org.gradle.api.Project
 
 class AndroidJUnit5Compat {
 
+    private static final int AGP_2 = 2
     private static final Version AGP_2_2_0 = Version.valueOf("2.2.0-alpha1")
-    private static final Version AGP_3_0_0 = Version.valueOf("3.0.0-alpha1")
 
     /**
      * Fetches the Java output directories for the given Variant scopes
      * across different versions of the Android Gradle plugin.
+     * @param project Gradle project context
      * @param agpVersion Version of the Android Gradle Plugin
      * @param variantScope VariantScope to look up the Java outputs from
      * @see {@link VariantScope}
      * @return An Iterable container depicting the output directories
      */
-    static Iterable<File> getJavaOutputDirs(Version agpVersion, def variantScope) {
-        if (agpVersion.lessThan(AGP_2_2_0)) {
-            // Below the first alpha of AGP 2.2.0, there was a typo in VariantScope
-            // related to the Java outputs of a Variant
-            return variantScope.javaOuptuts
+    @SuppressWarnings("GroovyAssignabilityCheck")
+    static Iterable<File> getJavaOutputDirs(Project project, Version agpVersion, def variantScope) {
+        if (agpVersion.majorVersion <= AGP_2) {
+            // AGP 2.x: Java Outputs & Annotation Processor outputs are aggregated.
+            // Wee need to account for a typo that existed before 2.2.0
+            def javaOutputs = agpVersion.lessThan(AGP_2_2_0) ?
+                    variantScope.javaOuptuts :
+                    variantScope.javaOutputs
 
-        } else if (agpVersion.lessThan(AGP_3_0_0)) {
-            // Below the first alpha of AGP 3.0.0, use the unified VariantScope method
-            return variantScope.javaOutputs
+            // Add the runtime configuration explicitly
+            def testApk = project.configurations.findByName("testApk")
+
+            return Iterables.concat(
+                    javaOutputs,
+                    testApk != null ?
+                            ImmutableList.of(variantScope.annotationProcessorOutputDir, testApk) :
+                            ImmutableList.of(variantScope.annotationProcessorOutputDir))
 
         } else {
-            // On and after AGP 3.0.0, use the separated methods for Java and annotation processors
-            return [
-                    variantScope.javaOutputDir as File,
-                    variantScope.annotationProcessorOutputDir as File
-            ]
+            // AGP 3.x: Use the refined Java Classpath API to collect runtime elements.
+            // Since we're querying the entire runtime classpath directly,
+            // there's no need to add the runtime configuration ("testRuntimeOnly") explicitly
+            return Iterables.concat(
+                    variantScope.getJavaClasspath(
+                            AndroidArtifacts.ConsumedConfigType.RUNTIME_CLASSPATH,
+                            AndroidArtifacts.ArtifactType.CLASSES),
+                    ImmutableList.of(variantScope.javaOutputDir))
         }
     }
 }

android-junit5/src/main/groovy/de/mannodermaus/gradle/anj5/AndroidJUnitPlatformPlugin.groovy

@@ -1,5 +1,6 @@
 package de.mannodermaus.gradle.anj5
 
+import com.android.SdkConstants
 import com.android.build.gradle.internal.scope.VariantScope
 import com.github.zafarkhaja.semver.Version
 import org.gradle.api.GradleException
@@ -22,7 +23,8 @@ class AndroidJUnitPlatformPlugin extends JUnitPlatformPlugin {
 
     private static final String LOG_TAG = "[android-junit5]"
 
-    private static final String VINTAGE_WARNING = "AGPBI: {\"kind\":\"warning\",\"text\":\"$LOG_TAG You don't need to depend on junitVintage() directly anymore!\",\"sources\":[{},{}]}"
+    private static
+    final String VINTAGE_WARNING = "AGPBI: {\"kind\":\"warning\",\"text\":\"$LOG_TAG You don't need to depend on junitVintage() directly anymore!\",\"sources\":[{},{}]}"
 
     private static final String EXTENSION_NAME = 'junitPlatform'
     private static final String TASK_NAME = 'junitPlatformTest'
@@ -113,13 +115,13 @@ class AndroidJUnitPlatformPlugin extends JUnitPlatformPlugin {
             // Obtain variant properties
             def variantData = variant.variantData
             VariantScope variantScope = variantData.scope
-            def scopeJavaOutputs = AndroidJUnit5Compat.getJavaOutputDirs(agpVersion, variantScope)
+            def scopeJavaOutputs = AndroidJUnit5Compat.getJavaOutputDirs(project, agpVersion, variantScope)
 
             // Obtain tested variant properties
             def testedVariantData = variant.testedVariant.variantData
             VariantScope testedVariantScope = testedVariantData.scope
 
-            def testedScopeJavaOutputs = AndroidJUnit5Compat.getJavaOutputDirs(agpVersion, testedVariantScope)
+            def testedScopeJavaOutputs = AndroidJUnit5Compat.getJavaOutputDirs(project, agpVersion, testedVariantScope)
 
             // Collect the root directories for unit tests from the variant's scopes
             def testRootDirs = []
@@ -134,19 +136,10 @@ class AndroidJUnitPlatformPlugin extends JUnitPlatformPlugin {
                 def javaCompiler = variant.javaCompiler
                 classpath.add(javaCompiler.classpath)
                 classpath.add(javaCompiler.outputs.files)
-            } else {
-                classpath.add(testedScopeJavaOutputs)
-                classpath.add(scopeJavaOutputs)
             }
 
-            // 2) Add the runtime configurations
-            def testRuntime = project.configurations.findByName("testRuntimeOnly")
-            if (testRuntime == null) {
-                testRuntime = project.configurations.findByName("testApk")
-            }
-            if (testRuntime != null) {
-                classpath.add(testRuntime)
-            }
+            classpath.add(testedScopeJavaOutputs)
+            classpath.add(scopeJavaOutputs)
 
             // 3) Add test resources
             classpath.add(variantData.javaResourcesForUnitTesting)
@@ -155,7 +148,7 @@ class AndroidJUnitPlatformPlugin extends JUnitPlatformPlugin {
             // 4) Add filtered boot classpath
             def globalScope = variantScope.globalScope
             classpath.add(globalScope.androidBuilder.getBootClasspath(false).findAll {
-                it.name != "android.jar"
+                it.name != SdkConstants.FN_FRAMEWORK_LIBRARY
             })
 
             // 5) Add mocked version of android.jar

android-junit5/src/test/groovy/de/mannodermaus/gradle/anj5/AndroidJUnitPlatformSpec.groovy

@@ -57,6 +57,12 @@ abstract class AndroidJUnitPlatformSpec extends Specification {
         testRoot.file("local.properties").withWriter { it.write(sdkDir) }
     }
 
+    /* Abstract */
+
+    protected abstract String testCompileDependency()
+    protected abstract String testRuntimeDependency()
+
+
     /* Test Cases */
 
     def "requires android plugin"() {
@@ -119,6 +125,85 @@ abstract class AndroidJUnitPlatformSpec extends Specification {
         p.tasks.getByName("junitPlatformTestRelease")
     }
 
+    def "classpath assembled correctly"() {
+        when:
+        // Prepare another test project to link to
+        Project testApkProject = ProjectBuilder.builder()
+                .withParent(testRoot)
+                .withName("library")
+                .build()
+        testApkProject.file(".").mkdir()
+        testApkProject.file("src/main").mkdirs()
+        testApkProject.file("src/main/AndroidManifest.xml").withWriter { it.write(ANDROID_MANIFEST) }
+
+        testApkProject.apply plugin: 'com.android.library'
+        testApkProject.android {
+            compileSdkVersion COMPILE_SDK
+            buildToolsVersion BUILD_TOOLS
+        }
+
+        Project p = ProjectBuilder.builder().withParent(testRoot).build()
+        p.file(".").mkdir()
+        p.file("src/main").mkdirs()
+        p.file("src/main/AndroidManifest.xml").withWriter { it.write(ANDROID_MANIFEST) }
+
+        p.apply plugin: 'com.android.application'
+        p.apply plugin: 'de.mannodermaus.android-junit5'
+        p.repositories {
+            jcenter()
+        }
+        p.android {
+            compileSdkVersion COMPILE_SDK
+            buildToolsVersion BUILD_TOOLS
+
+            defaultConfig {
+                applicationId APPLICATION_ID
+                minSdkVersion MIN_SDK
+                targetSdkVersion TARGET_SDK
+                versionCode VERSION_CODE
+                versionName VERSION_NAME
+            }
+        }
+        p.dependencies {
+            // "testApk" or "testRuntimeOnly"
+            add(testRuntimeDependency(), testApkProject)
+        }
+        p.evaluate()
+
+        then:
+        // Check that all expected folders are contained in the JUnit task's classpath
+        [p.tasks.getByName("junitPlatformTestDebug"),
+         p.tasks.getByName("junitPlatformTestRelease")].forEach { task ->
+            def classpath = task.classpath.collect { it.absolutePath }
+
+//            println "---- $task.name"
+//            classpath.each {
+//                println "  > $it"
+//            }
+
+            // Source set's outputs
+            assert classpath.find { it.contains("test/build/intermediates/classes/") } != null
+            assert classpath.find { it.contains("test/build/intermediates/classes/test/") } != null
+
+            // Annotation Processor outputs
+            assert classpath.find { it.contains("test/build/generated/source/apt/") } != null
+            assert classpath.find { it.contains("test/build/generated/source/apt/test/") } != null
+
+            // Resource Files
+            assert classpath.find { it.contains("test/build/intermediates/sourceFolderJavaResources/") } != null
+            assert classpath.find { it.contains("test/build/intermediates/sourceFolderJavaResources/test/") } != null
+
+            // Mockable android.jar
+            assert classpath.find { it.contains("build/generated/mockable-android-") } != null
+
+            // Runtime Library dependency (each version stores it slightly differently)
+            assert classpath.find {
+                it.contains("library/build/outputs/") ||
+                        it.contains("library/build/intermediates/")
+            } != null
+        }
+    }
+
     def "application with product flavors"() {
         when:
         Project p = ProjectBuilder.builder().withParent(testRoot).build()
@@ -160,4 +245,43 @@ abstract class AndroidJUnitPlatformSpec extends Specification {
         p.tasks.getByName("junitPlatformTestPaidDebug")
         p.tasks.getByName("junitPlatformTestPaidRelease")
     }
+
+    def "show warning if depending on junitVintage() directly"() {
+        when:
+        Project p = ProjectBuilder.builder().withParent(testRoot).build()
+
+        p.file(".").mkdir()
+        p.file("src/main").mkdirs()
+        p.file("src/main/AndroidManifest.xml").withWriter { it.write(ANDROID_MANIFEST) }
+
+        p.apply plugin: 'com.android.application'
+        p.apply plugin: 'de.mannodermaus.android-junit5'
+        p.android {
+            compileSdkVersion COMPILE_SDK
+            buildToolsVersion BUILD_TOOLS
+
+            defaultConfig {
+                applicationId APPLICATION_ID
+                minSdkVersion MIN_SDK
+                targetSdkVersion TARGET_SDK
+                versionCode VERSION_CODE
+                versionName VERSION_NAME
+            }
+        }
+        p.repositories {
+            jcenter()
+        }
+        p.dependencies {
+            // "testCompile" or "testApi"
+            invokeMethod(testCompileDependency(), junitJupiter())
+            // "testApk" or "testRuntimeOnly"
+            invokeMethod(testRuntimeDependency(), junitVintage())
+        }
+
+        then:
+        p.evaluate()
+        // Unsure how to capture the output directly
+        // (Project.logging listeners don't seem to work)
+        assert true == true
+    }
 }