Integrate instrumentation tests (#131)

Generate a task that runs unit tests and instrumentation tests for a module and combines their execution data in a single report. Add the option to include instrumentation tests in the global merged report.

Author: vRallev

README.md

@@ -4,11 +4,28 @@ Gradle plugin that generates Jacoco reports from a Gradle Project. Android Appli
 
 ### Android project
 
+*JVM Unit-Tests*
 - Task `jacocoTestReport<Flavor><BuildType>`
   - Executes the `test<Flavor><BuildType>UnitTest` task before
   - Gets executed when the `check` task is executed
   - Generated Jacoco reports can be found under `build/reports/jacoco/<Flavor>/<BuildType>`.
 
+*Instrumented tests*
+- Task `combinedTestReport<Flavor><BuildType>`
+  - Executes the `test<Flavor><BuildType>UnitTest` and `create<Flavor><BuildType>CoverageReports` tasks before (JVM and instrumented tests)
+  - Gets executed when the `check` task is executed
+  - Generated Jacoco reports can be found under `build/reports/jacocoCombined/<Flavor>/<BuildType>`.
+Note that this task is only generated, if you set `testCoverageEnabled = true` for your [build type](https://google.github.io/android-gradle-dsl/current/com.android.build.gradle.internal.dsl.BuildType.html#com.android.build.gradle.internal.dsl.BuildType:testCoverageEnabled), e.g.
+```groovy
+android {
+  buildTypes {
+    debug {
+      testCoverageEnabled true
+    }
+  }
+}
+```
+
 Where `<BuildType>` is usually `debug` & `release` unless additional build types where specified.
 `<Flavor>` is optional and will be ignored if not specified.
 
@@ -75,6 +92,7 @@ junitJacoco {
   ignoreProjects = [] // type String array
   excludes // type String List
   includeNoLocationClasses = false // type boolean
+  includeInstrumentationCoverageInMergedReport = false // type boolean
 }
 ```
 

src/main/groovy/com/vanniktech/android/junit/jacoco/GenerationPlugin.groovy

@@ -115,6 +115,8 @@ class GenerationPlugin implements Plugin<Project> {
             it.jacoco.includeNoLocationClasses = extension.includeNoLocationClasses
         }
 
+        subProject.android.jacoco.version = extension.jacocoVersion
+
         Collection<BaseVariant> variants = []
         if (isAndroidApplication(subProject)) {
             variants = subProject.android.applicationVariants
@@ -129,7 +131,8 @@ class GenerationPlugin implements Plugin<Project> {
         variants.all { variant ->
 
             def productFlavorName = variant.getFlavorName()
-            def buildTypeName = variant.getBuildType().name
+            def buildType = variant.getBuildType()
+            def buildTypeName = buildType.name
 
             def sourceName, sourcePath
             if (!productFlavorName) {
@@ -139,85 +142,124 @@ class GenerationPlugin implements Plugin<Project> {
                 sourcePath = "${productFlavorName}/${buildTypeName}"
             }
 
-            final def testTaskName = "test${sourceName.capitalize()}UnitTest"
-            final def taskName = "jacocoTestReport${sourceName.capitalize()}"
+            final def jvmTaskName = "jacocoTestReport${sourceName.capitalize()}"
+            final def combinedTaskName = "combinedTestReport${sourceName.capitalize()}"
 
-            subProject.task(taskName, type: JacocoReport, dependsOn: testTaskName) {
-                group = 'Reporting'
-                description = "Generate Jacoco coverage reports after running ${sourceName} tests."
+            final def jvmTestTaskName = "test${sourceName.capitalize()}UnitTest"
+            final def instrumentationTestTaskName = "create${sourceName.capitalize()}CoverageReport"
 
-                reports {
-                    xml {
-                        enabled = true
-                        destination subProject.file("${subProject.buildDir}/reports/jacoco/${sourceName}/jacoco.xml")
-                    }
-                    csv {
-                        enabled = true
-                        destination subProject.file("${subProject.buildDir}/reports/jacoco/${sourceName}/jacoco.csv")
-                    }
-                    html {
-                        enabled = true
-                        destination subProject.file("${subProject.buildDir}/reports/jacoco/${sourceName}")
-                    }
-                }
+            addJacocoTask(false, subProject, extension, mergeTask, mergedReportTask, jvmTaskName,
+                jvmTestTaskName, instrumentationTestTaskName, sourceName, sourcePath, productFlavorName, buildTypeName)
 
-                def classPaths = [
-                  "**/intermediates/classes/${sourcePath}/**",
-                  "**/intermediates/javac/${sourceName}/*/classes/**" // Android Gradle Plugin 3.2.x support.
-                ]
+            if (buildType.testCoverageEnabled) {
+                addJacocoTask(true, subProject, extension, mergeTask, mergedReportTask, combinedTaskName,
+                    jvmTestTaskName, instrumentationTestTaskName, sourceName, sourcePath, productFlavorName, buildTypeName)
+            }
+        }
 
-                if (isKotlinAndroid(subProject)) {
-                    classPaths << "**/tmp/kotlin-classes/${sourcePath}/**"
-                    if (productFlavorName) {
-                        classPaths << "**/tmp/kotlin-classes/${productFlavorName}${buildTypeName.capitalize()}/**"
-                    }
+        return true
+    }
+
+    private static void addJacocoTask(final boolean combined, final Project subProject, final JunitJacocoExtension extension,
+                                      JacocoMerge mergeTask, JacocoReport mergedReportTask, final String taskName,
+                                      final String jvmTestTaskName, final String instrumentationTestTaskName, final String sourceName,
+                                      final String sourcePath, final String productFlavorName, final String buildTypeName) {
+        final def destinationDir
+        if (combined) {
+            destinationDir = "${subProject.buildDir}/reports/jacocoCombined"
+        } else {
+            destinationDir = "${subProject.buildDir}/reports/jacoco"
+        }
+
+        subProject.task(taskName, type: JacocoReport) {
+            group = 'Reporting'
+            description = "Generate Jacoco coverage reports after running ${sourceName} tests."
+
+            if (combined) {
+                dependsOn jvmTestTaskName, instrumentationTestTaskName
+            } else {
+                dependsOn jvmTestTaskName
+            }
+
+            reports {
+                xml {
+                    enabled = true
+                    destination subProject.file("$destinationDir/${sourceName}/jacoco.xml")
+                }
+                csv {
+                    enabled = true
+                    destination subProject.file("$destinationDir/${sourceName}/jacoco.csv")
                 }
+                html {
+                    enabled = true
+                    destination subProject.file("$destinationDir/${sourceName}")
+                }
+            }
 
-                classDirectories = subProject.fileTree(
-                        dir: subProject.buildDir,
-                        includes: classPaths,
-                        excludes: getExcludes(extension)
-                )
-
-                final def coverageSourceDirs = [
-                        "src/main/clojure",
-                        "src/main/groovy",
-                        "src/main/java",
-                        "src/main/kotlin",
-                        "src/main/scala",
-                        "src/$buildTypeName/clojure",
-                        "src/$buildTypeName/groovy",
-                        "src/$buildTypeName/java",
-                        "src/$buildTypeName/kotlin",
-                        "src/$buildTypeName/scala"
-                ]
+            def classPaths = [
+                "**/intermediates/classes/${sourcePath}/**",
+                "**/intermediates/javac/${sourceName}/*/classes/**" // Android Gradle Plugin 3.2.x support.
+            ]
 
+            if (isKotlinAndroid(subProject)) {
+                classPaths << "**/tmp/kotlin-classes/${sourcePath}/**"
                 if (productFlavorName) {
-                    coverageSourceDirs.add("src/$productFlavorName/clojure")
-                    coverageSourceDirs.add("src/$productFlavorName/groovy")
-                    coverageSourceDirs.add("src/$productFlavorName/java")
-                    coverageSourceDirs.add("src/$productFlavorName/kotlin")
-                    coverageSourceDirs.add("src/$productFlavorName/scala")
+                    classPaths << "**/tmp/kotlin-classes/${productFlavorName}${buildTypeName.capitalize()}/**"
                 }
+            }
 
-                additionalSourceDirs = subProject.files(coverageSourceDirs)
-                sourceDirectories = subProject.files(coverageSourceDirs)
-                executionData = subProject.files("${subProject.buildDir}/jacoco/${testTaskName}.exec")
+            classDirectories = subProject.fileTree(
+                dir: subProject.buildDir,
+                includes: classPaths,
+                excludes: getExcludes(extension)
+            )
 
-                if (mergeTask != null) {
-                    mergeTask.executionData += executionData
-                }
-                if (mergedReportTask != null) {
-                    mergedReportTask.classDirectories += classDirectories
-                    mergedReportTask.additionalSourceDirs += additionalSourceDirs
-                    mergedReportTask.sourceDirectories += sourceDirectories
+            final def coverageSourceDirs = [
+                "src/main/clojure",
+                "src/main/groovy",
+                "src/main/java",
+                "src/main/kotlin",
+                "src/main/scala",
+                "src/$buildTypeName/clojure",
+                "src/$buildTypeName/groovy",
+                "src/$buildTypeName/java",
+                "src/$buildTypeName/kotlin",
+                "src/$buildTypeName/scala"
+            ]
+
+            if (productFlavorName) {
+                coverageSourceDirs.add("src/$productFlavorName/clojure")
+                coverageSourceDirs.add("src/$productFlavorName/groovy")
+                coverageSourceDirs.add("src/$productFlavorName/java")
+                coverageSourceDirs.add("src/$productFlavorName/kotlin")
+                coverageSourceDirs.add("src/$productFlavorName/scala")
+            }
+
+            additionalSourceDirs = subProject.files(coverageSourceDirs)
+            sourceDirectories = subProject.files(coverageSourceDirs)
+            executionData = subProject.files("${subProject.buildDir}/jacoco/${jvmTestTaskName}.exec")
+
+            if (combined) {
+                // add instrumentation coverage execution data
+                executionData += subProject.fileTree("${subProject.buildDir}/outputs/code_coverage").matching {
+                    include "**/*.ec"
                 }
             }
 
-            subProject.check.dependsOn "${taskName}"
+            // add if true in extension or for the unit test Jacoco task
+            def addToMergeTask = !combined || extension.includeInstrumentationCoverageInMergedReport
+
+            if (mergeTask != null && addToMergeTask) {
+                mergeTask.executionData += executionData
+            }
+            if (mergedReportTask != null && addToMergeTask) {
+                mergedReportTask.classDirectories += classDirectories
+                mergedReportTask.additionalSourceDirs += additionalSourceDirs
+                mergedReportTask.sourceDirectories += sourceDirectories
+            }
         }
 
-        return true
+        subProject.check.dependsOn "${taskName}"
     }
 
     private static addJacocoMergeToRootProject(final Project project, final JunitJacocoExtension extension) {

src/main/groovy/com/vanniktech/android/junit/jacoco/JunitJacocoExtension.groovy

@@ -28,4 +28,11 @@ class JunitJacocoExtension {
      * @since 0.6.0
      */
     boolean includeNoLocationClasses
+
+    /**
+     * Whether or not to include instrumentation coverage in the final global merged report.
+     * Note that this will run all instrumentation tests when true.
+     * @since 0.13.0
+     */
+    boolean includeInstrumentationCoverageInMergedReport = false
 }