Build variant checks + README

Rolf-Smit · Rolf-Smit · commit 0e66ab44a9b5 · 2018-10-15T12:14:23.000+02:00
diff --git a/README.md b/README.md
@@ -0,0 +1,75 @@
+# Android-Root-Coverage-Plugin
+**A Gradle plugin for easy generation of combined code coverage reports for Android projects with multiple modules.**
+Android Projects that make use of the Gradle build system by default come with easy methods to generate code coverage reports. Unfortently by default code coverage is generated seperatly per module, this means each modules takes into account it's own sources and tests, which is in terms of domain seperation fine. Howerver it is very common to find multi-module Android project where only one module has instrumented tests, or full-fledged UI tests using Espresso. This plugin comes in handy for those projects. It generates code coverage reports using Jacoco taking into account all the modules and tests at once.
+
+  - Supports both Android app and library modules (`com.android.application` & `com.android.library`).
+  - Supports different build variants per module within the same report.
+  - Supports custom filters.
+
+# Download
+The plugin is not yet available on Maven Central, so currently it is needed to add the following repository to your top-level gradle file:
+
+**Step 1:**
+```
+// Step 3: Apply the plugin to the top-level gradle file
+apply plugin: 'org.neotech.plugin.rootcoverage'
+
+buildscript {
+    repositories {
+        // Step 1: add the repository
+        // This plugin is not yet available on Maven Central, so currently it is needed to add the following repository:
+        maven {
+            url  "http://dl.bintray.com/rolf-smit/maven"
+        }
+    }
+    dependencies {
+        // Step 2: add the dependency
+        classpath 'org.neotech.plugin:android-root-coverage-plugin:0.0.1-dev'
+    }
+}
+```
+
+# How to use
+Currently only modules with the plugin type `com.android.application` or `com.android.library` are taken into account when generating the root code coverage report, besides this any module that does not have `testCoverageEnabled true` for the default build variant (`debug`) will be skipped::
+
+You can add a module by enableing `testCoverageEnabled`:
+```
+android {
+    buildTypes {
+        debug {
+            testCoverageEnabled true
+        }
+    }
+}
+```
+
+The Android-Root-Coverage-Plugin generates a special Gradle task `:rootCodeCoverageReport` that when executed generates a Jacoco code coverage report. You can either run this task directly from Android Studio using the Gradle Tool Window (see: https://www.jetbrains.com/help/idea/jetgradle-tool-window.html) or from the terminal.
+
+- **Gradle Tool Window:** You can find the task under: `Tasks > reporting > rootCodeCoverageReport`, double click to  execute it.
+- **Terminal:** Execute the task using `gradlew rootCodeCoverageReport`.
+
+# Configuration
+By default the plugin generates code coverage reports using the build variant `debug` for every module. However in some cases different build variants per module might be required, especially if there is no `debug` build variant available. In those cases you can configure custom build variants for specific modules:
+
+```
+rootCoverage {
+    // The default build variant for every module
+    buildVariant "debug"
+    // Overrides the default build variant for specific modules.
+    buildVariantOverrides ":moduleA" : "debugFlavourA", ":moduleB": "debugFlavourA"
+    // Class exclude patterns
+    excludes ["**/library.a/**"]
+}
+```
+
+
+# Development
+Want to contribute? Great! Currently this plugin is in need of extensive testing. Besides this there is also a small whish list:
+
+- Support for Java modules
+- Make use of the JacocoMerge task? To merge the `exec` en `ec` files?
+- Support for configuring the output type: html, xml etc. (Just like Jacoco)
+- Actual Plugin unit-tests (instead of a test project)
+
+# Author note
+Many thanks to [Hans van Dam](https://github.com/hansvdam) for helping with testing and the inital idea.
diff --git a/build.gradle b/build.gradle
@@ -57,5 +57,6 @@ jacoco {
 
 rootCoverage {
     buildVariant "debug"
+    buildVariantOverrides ":library_a" : "debug", ":library_b": "debug"
     //excludes ["**/library.a/**"]
 }
diff --git a/plugin/src/main/kotlin/org/neotech/plugin/rootcoverage/RootCoveragePlugin.kt b/plugin/src/main/kotlin/org/neotech/plugin/rootcoverage/RootCoveragePlugin.kt
@@ -1,12 +1,15 @@
 package org.neotech.plugin.rootcoverage
 
 import com.android.build.gradle.AppExtension
+import com.android.build.gradle.BaseExtension
 import com.android.build.gradle.LibraryExtension
 import com.android.build.gradle.api.BaseVariant
 import com.android.build.gradle.api.SourceKind
+import org.gradle.api.DomainObjectSet
 import org.gradle.api.GradleException
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.internal.DefaultDomainObjectSet
 import org.gradle.testing.jacoco.plugins.JacocoPlugin
 import org.gradle.testing.jacoco.tasks.JacocoReport
 
@@ -61,6 +64,17 @@ class RootCoveragePlugin: Plugin<Project> {
         return rootProjectExtension.buildVariantOverrides[project.path] ?: rootProjectExtension.buildVariant
     }
 
+    /**
+     * Throws a GradleException if the given buildVariant is not found in the set. This method only
+     * works correctly if used after the Gradle evaluation phase! Use it for example in Task.doFirst
+     * or Task.doLast.
+     */
+    private fun <T: BaseVariant> assertVariantExists(set: DomainObjectSet<T>, buildVariant: String, project: Project) {
+         set.find {
+             it.name.capitalize() == buildVariant.capitalize()
+        } ?: throw GradleException("Build variant `$buildVariant` required for module `${project.name}` does not exist! Make sure to use a proper build variant configuration using rootCoverage.buildVariant and rootCoverage.buildVariantOverrides!")
+    }
+
     private fun createCoverageTaskForRoot(project: Project) {
         // Aggregates jacoco results from the app sub-project and bankingright sub-project and generates a report.
         // The report can be found at the root of the project in /build/reports/jacoco, so don't look in
@@ -74,6 +88,21 @@ class RootCoveragePlugin: Plugin<Project> {
         task.reports.csv.isEnabled = false
         task.reports.html.destination = project.file("${project.buildDir}/reports/jacoco")
 
+        // Add some run-time checks.
+        task.doFirst {
+            it.project.allprojects.forEach { subProject ->
+                val extension = subProject.extensions.findByName("android")
+                if(extension != null) {
+                    val buildVariant = getBuildVariantFor(subProject)
+                    when(extension) {
+                        is LibraryExtension -> assertVariantExists(extension.libraryVariants, buildVariant, subProject)
+                        is AppExtension -> assertVariantExists(extension.applicationVariants, buildVariant, subProject)
+                    }
+                }
+            }
+        }
+
+        // Configure the root task with sub-tasks for the sub-projects.
         project.subprojects.forEach {
             it.afterEvaluate { subProject ->
                 createCoverageTaskForSubProject(subProject, task)
@@ -94,43 +123,41 @@ class RootCoveragePlugin: Plugin<Project> {
             return
         }
 
-       /* if (subProject.plugins.withType(JacocoPlugin::class.java).isEmpty()) {
-            subProject.logger.warn("Jacoco plugin not applied to project: '${subProject.name}'! RootCoveragePlugin automatically applied it but you should do this manually: ${subProject.buildFile}")
-            subProject.plugins.apply(JacocoPlugin::class.java)
-        }*/
-
-        // If the sub-project does not apply the jacoco plugin, skip that project.
-        //if (subProject.plugins.withType(JacocoPlugin::class.java).isNotEmpty()) {
-
-            // Get the exact required build variant for the current subproject.
-            val buildVariant = getBuildVariantFor(subProject)
-            when(extension) {
-                is LibraryExtension -> {
-                    extension.libraryVariants.all { variant ->
-                        if (variant.buildType.isTestCoverageEnabled && variant.name.capitalize() == buildVariant.capitalize()) {
-                            if (subProject.plugins.withType(JacocoPlugin::class.java).isEmpty()) {
-                                subProject.logger.warn("Jacoco plugin not applied to project: '${subProject.name}'! RootCoveragePlugin automatically applied it but you should do this manually: ${subProject.buildFile}")
-                                subProject.plugins.apply(JacocoPlugin::class.java)
-                            }
-                            val subTask = createTask(subProject, variant)
-                            addSubTaskDependencyToRootTask(task, subTask)
+        // Get the exact required build variant for the current sub-project.
+        val buildVariant = getBuildVariantFor(subProject)
+        when(extension) {
+            is LibraryExtension -> {
+
+                //assertVariantExists(extension.libraryVariants, buildVariant, subProject)
+
+                extension.libraryVariants.all { variant ->
+
+                    if (variant.buildType.isTestCoverageEnabled && variant.name.capitalize() == buildVariant.capitalize()) {
+                        if (subProject.plugins.withType(JacocoPlugin::class.java).isEmpty()) {
+                            subProject.logger.warn("Jacoco plugin not applied to project: '${subProject.name}'! RootCoveragePlugin automatically applied it but you should do this manually: ${subProject.buildFile}")
+                            subProject.plugins.apply(JacocoPlugin::class.java)
                         }
+                        val subTask = createTask(subProject, variant)
+                        addSubTaskDependencyToRootTask(task, subTask)
                     }
                 }
-                is AppExtension -> {
-                    extension.applicationVariants.all { variant ->
-                        if (variant.buildType.isTestCoverageEnabled && variant.name.capitalize() == buildVariant.capitalize()) {
-                            if (subProject.plugins.withType(JacocoPlugin::class.java).isEmpty()) {
-                                subProject.logger.warn("Jacoco plugin not applied to project: '${subProject.name}'! RootCoveragePlugin automatically applied it but you should do this manually: ${subProject.buildFile}")
-                                subProject.plugins.apply(JacocoPlugin::class.java)
-                            }
-                            val subTask = createTask(subProject, variant)
-                            addSubTaskDependencyToRootTask(task, subTask)
+            }
+            is AppExtension -> {
+
+                //assertVariantExists(extension.libraryVariants, buildVariant, subProject)
+
+                extension.applicationVariants.all { variant ->
+                    if (variant.buildType.isTestCoverageEnabled && variant.name.capitalize() == buildVariant.capitalize()) {
+                        if (subProject.plugins.withType(JacocoPlugin::class.java).isEmpty()) {
+                            subProject.logger.warn("Jacoco plugin not applied to project: '${subProject.name}'! RootCoveragePlugin automatically applied it but you should do this manually: ${subProject.buildFile}")
+                            subProject.plugins.apply(JacocoPlugin::class.java)
                         }
+                        val subTask = createTask(subProject, variant)
+                        addSubTaskDependencyToRootTask(task, subTask)
                     }
                 }
             }
-        //}
+        }
     }
 
     private fun createTask(project: Project, variant: BaseVariant): RootCoverageModuleTask {
@@ -143,11 +170,6 @@ class RootCoveragePlugin: Plugin<Project> {
         task.description = "Generate unified Jacoco code codecoverage report"
         task.dependsOn("test${name}UnitTest", "connected${name}AndroidTest")
 
-        //task.reports.html.isEnabled = false
-        //task.reports.xml.isEnabled = false
-        //task.reports.csv.isEnabled = false
-        //task.reports.html.destination = project.file("${project.buildDir}/reports/jacoco")
-
         // Collect the class files based on the Java Compiler output
         val javaClassTrees = variant.javaCompiler.outputs.files.map { file ->
             project.fileTree(file, excludes = getFileFilter()).excludeNonClassFiles()
@@ -165,9 +187,6 @@ class RootCoveragePlugin: Plugin<Project> {
         task.classDirectories = project.files(javaClassTrees, kotlinClassTree)
         task.executionData = project.fileTree(project.buildDir, includes = listOf("jacoco/test${name}UnitTest.exec", "outputs/code-coverage/connected/*coverage.ec"))
 
-        //task.onlyIf { true }
-        //println("Source files: ${task.classDirectories.files}")
-
         return task
     }
 

Original file line number	Diff line number	Diff line change
`@@ -57,5 +57,6 @@ jacoco {`
`57`	`57`
`58`	`58`	`rootCoverage {`
`59`	`59`	`buildVariant "debug"`
	`60`	`+ buildVariantOverrides ":library_a" : "debug", ":library_b": "debug"`
`60`	`61`	`//excludes ["/library.a/"]`
`61`	`62`	`}`