Integration test + some other minor improvements. (#1)

* Added a proper integration test to the plugin that tests the plugin on a project with three module types: `android-library`, `android-application` and `java-library`.
* New configuration option: `testTypes`
* Updated README.md
* improved warning and error messages
* Updated version to 1.0.0.

Author: Rolf-Smit

.gitignore

@@ -1,6 +1,6 @@
 *.iml
 .gradle
-/local.properties
+local.properties
 /.idea/caches/build_file_checksums.ser
 /.idea/libraries
 /.idea/modules.xml
@@ -12,3 +12,4 @@
 .idea/
 *.exec
 repo/
+build/

README.md

@@ -1,13 +1,20 @@
 # Android-Root-Coverage-Plugin
-**A Gradle plugin for easy generation of combined code coverage reports for Android projects with multiple modules.**
-Generating code coverage reports for Android Projects that make use of the Gradle build is quite easy. Unfortunately by default code coverage is generated separately per module, this means each modules takes into account it's own sources and tests, which is in terms of domain separation fine. However 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.
+**A Gradle plugin for combined code coverage reports for Android projects.**
+Generating code coverage reports for Android Projects is in most cases quite easy. Unfortunately by
+default (using Jacoco) code coverage is generated separately per module. This means each module
+takes into account it's own sources and tests (which is in terms of domain separation fine). However
+it is very common to find multi-module Android projects where only one module actually has tests.
+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, or in other words: code in module B will show
+up as "covered" when tests in Module A touch it.
 
   - 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.
+  - Supports custom package/class filters.
+
 
 # Setup
-Apply the Android-Root-Coverage-Plugin plugin to your top-level (root project) gradle file following these 2 steps:
+Apply the Android-Root-Coverage-Plugin plugin to your top-level (root project) gradle file:
 
 ```groovy
 // Step 2: Apply the plugin to the top-level gradle file
@@ -16,13 +23,16 @@ apply plugin: 'org.neotech.plugin.rootcoverage'
 buildscript {
     dependencies {
         // Step 1: add the dependency
-        classpath 'org.neotech.plugin:android-root-coverage-plugin:0.0.1-dev'
+        classpath 'org.neotech.plugin:android-root-coverage-plugin:1.0.0'
     }
 }
 ```
 
+
 # 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::
+Currently only modules with the plugin type `com.android.application` or `com.android.library` are
+taken into account when generating the coverage report, besides this any module that does not have
+`testCoverageEnabled true` for the selected build variant (by default: `debug`) will be skipped:
 
 You can add a module by enabling `testCoverageEnabled`:
 ```groovy
@@ -35,35 +45,55 @@ android {
 }
 ```
 
-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.
+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:
+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:
 
 ```groovy
 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 = ["**/some.package/**"]
     // If true the task it self does not execute any tests (debug option)
     skipTestExecution false
+    // Type of tests to run (import com.android.builder.model.TestVariantBuildOutput.TestType)
+    testTypes = [TestType.UNIT, TestType.ANDROID_TEST]
 }
 ```
 
 
 # Development
-Want to contribute? Great! Currently this plugin is in need of extensive testing. Besides this there is also a small wish list:
+Want to contribute? Great! Currently this plugin is mainly in need of extensive testing in some more
+projects. But if you like to add some actually functionality, this is the wish list:
 
-- Support for Java modules
+- Support for Java library 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)
+- Improved integration test setup: without the hackish dynamic versions in the Gradle plugin block?
+
+**How to test your changes/additions?**
+The plugin comes with an integration test. You can run this test either by executing
+`gradlew clean test` or run the test directly from Android Studio using a proper run/test
+configuration as shown in the image *(by default it generates configuration that is not compatible
+with a plugin module)*:
+![Correct run/test configuration](correct-test-run-configuration.png)
+
 
 # Author note
-Many thanks to [Hans van Dam](https://github.com/hansvdam) for helping with testing and the inital idea.
+Many thanks to [Hans van Dam](https://github.com/hansvdam) for helping with testing and the initial idea.

app/build.gradle

@@ -1,39 +1,21 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
-apply plugin: 'jacoco'
-apply plugin: 'org.neotech.plugin.rootcoverage'
-
 buildscript {
-    ext.versions = [
-            minSdk: 21,
-            targetSdk: 28,
-            compileSdk: 28,
-            kotlin: "1.2.71",
-            gradlePlugin: "3.2.1"
-    ]
-    ext.deps = [
-            kotlinPlugin: "org.jetbrains.kotlin:kotlin-gradle-plugin:${versions.kotlin}",
-            gradlePlugin: "com.android.tools.build:gradle:${versions.gradlePlugin}",
-            kotlinStdlibJdk7: "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${versions.kotlin}"
-    ]
+
+    // Import versions
+    apply from: "gradle/dependencies.gradle"
 
     repositories {
         google()
         jcenter()
-
-        // Local maven repository for development purposes.
-        maven {
-            url uri('/repo')
-        }
     }
     dependencies {
-        classpath deps.gradlePlugin
-        classpath deps.kotlinPlugin
+        classpath projectDependency.gradlePlugin
+        classpath projectDependency.kotlinPlugin
 
         // Bintray & Maven for publishing
         classpath 'com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4'
         classpath 'com.github.dcendents:android-maven-gradle-plugin:2.1'
 
-        classpath 'org.neotech.plugin:android-root-coverage-plugin:0.0.2-dev'
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
     }
@@ -48,16 +30,4 @@ allprojects {
 
 task clean(type: Delete) {
     delete rootProject.buildDir
-}
-
-
-jacoco {
-    toolVersion = "0.8.2"
-}
-
-rootCoverage {
-    buildVariant "debug"
-    buildVariantOverrides ":library_a" : "debug", ":library_b": "debug"
-    //excludes = ["**/LibraryAJava.class"]
-    //skipTestExecution true
 }

app/src/androidTest/java/org/neotech/app/multimoduleapplication/ExampleInstrumentedTest.kt

@@ -19,7 +19,7 @@ org.gradle.jvmargs=-Xmx1536m
 #PACKAGING=jar
 
 GROUP=org.neotech.plugin
-VERSION=0.0.2-dev
+VERSION=1.0.0
 DESCRIPTION=A Gradle plugin for easy generation of combined code coverage reports for Android projects with multiple modules.
 
 PROJECT_WEBSITE=https://github.com/NeoTech-Software/android-root-coverage-plugin

app/src/test/java/org/neotech/app/multimoduleapplication/ExampleUnitTest.kt

@@ -0,0 +1,30 @@
+ext {
+    projectVersion = [
+            minSdk      : 21,
+            targetSdk   : 28,
+            compileSdk  : 28,
+            // Kotlin version is used in multiple places hence it is available as version variable
+            kotlin      : "1.2.71"
+    ]
+    projectDependency = [
+
+            // Gradle Plugins
+            kotlinPlugin      : "org.jetbrains.kotlin:kotlin-gradle-plugin:${projectVersion.kotlin}",
+            gradlePlugin      : "com.android.tools.build:gradle:3.2.1",
+
+            // Dependencies
+            kotlinStdlibJdk7  : "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${projectVersion.kotlin}",
+            appCompat         : "com.android.support:appcompat-v7:28.0.0",
+
+            // Test dependencies
+            junit             : "junit:junit:4.12",
+            truth             : "com.google.truth:truth:0.42",
+            supportTestRunner : "com.android.support.test:runner:1.0.2",
+            espressoCore      : "com.android.support.test.espresso:espresso-core:3.0.2"
+    ]
+
+    // Used by the plugin-version-handler.gradle
+    pluginVersions = [
+            "org.jetbrains.kotlin.android": "${projectVersion.kotlin}"
+    ]
+}

build.gradle

@@ -0,0 +1,40 @@
+// Copyright (C) 2018 Rolf Smit
+//
+// This file can be used as a hack to make it possible to use variable/dynamic version numbers for
+// plugins in the new Gradle Plugins Block:
+// https://docs.gradle.org/current/userguide/plugins.html#sec:plugins_block
+// Normally variables cannot be used, but through the project settings.pluginManagement DSL some
+// configuration is possible.
+//
+// How to use?
+//
+// 1. Add the following to your settings.gradle file:
+//
+// pluginManagement {
+//     apply from: "path/to/plugin-version-handler.gradle", to: pluginManagement
+// }
+//
+// 2. Add the plugins that you want to use variable/dynamic version for to the dependencies.gradle
+// file:
+//
+// ext {
+//     projectVersion = [
+//             kotlin      : "1.3.0",
+//     ]
+//
+//     pluginVersions = [
+//             "org.jetbrains.kotlin.android": "${projectVersion.kotlin}"
+//     ]
+// }
+
+
+apply from: "dependencies.gradle"
+
+resolutionStrategy {
+    eachPlugin {
+        def version = pluginVersions[requested.id.id]
+        if (requested.version == null && version != null) {
+            useVersion version
+        }
+    }
+}