Improved aggregation task

Aggregate task now use settings to configure which outputs should be
aggregated (HTML, XML, debug XML and cobertura).

Tests for aggregation added using dummy test project ('water').

Author: Kwestor

Diff for: README.md

@@ -66,11 +66,15 @@ There is now experimental support for aggregating coverage statistics across sub
 The project hosting the aggregation task **must** be configured as the sub-projects are;
 i.e. with the scoverage plugin applied and the scoverage dependencies configured.
 
+You also have to declare this task:
+
 ```groovy
 task aggregateScoverage(type: org.scoverage.ScoverageAggregate)
 ```
 
-This will produce a report into _build_ / scoverage-aggregate
+This will produce a report into `build/scoverage-aggregate` directory.
+
+Aggregation uses same flags as reporting for enabling/disabling different output types.
 
 CheckScoverage
 --------------

Diff for: src/main/groovy/org/scoverage/AggregateReportApp.java

@@ -13,10 +13,23 @@ public static void main(String... args) {
         File rootDir = new File(args[0]);
         File reportDir = new File(args[1]);
         Boolean clean = Boolean.parseBoolean(args[2]);
-        reportDir.mkdirs();
+
+        Boolean coverageOutputCobertura = java.lang.Boolean.valueOf(args[3]);
+        Boolean coverageOutputXML = java.lang.Boolean.valueOf(args[4]);
+        Boolean coverageOutputHTML = java.lang.Boolean.valueOf(args[5]);
+        Boolean coverageDebug = java.lang.Boolean.valueOf(args[6]);
+
         Coverage coverage = CoverageAggregator.aggregate(rootDir, clean).get();
-        new ScoverageHtmlWriter(rootDir, reportDir).write(coverage);
-        new CoberturaXmlWriter(rootDir, reportDir).write(coverage);
+
+        ScoverageWriter.write(
+            rootDir,
+            reportDir,
+            coverage,
+            coverageOutputCobertura,
+            coverageOutputXML,
+            coverageOutputHTML,
+            coverageDebug
+        );
     }
 
 }

Diff for: src/main/groovy/org/scoverage/ScoverageAggregate.groovy

@@ -9,13 +9,21 @@ class ScoverageAggregate extends JavaExec {
 
     @Override
     void exec() {
+        def extension = ScoveragePlugin.extensionIn(project)
         setClasspath(ScoveragePlugin.extensionIn(project).pluginClasspath)
         setMain('org.scoverage.AggregateReportApp')
         def reportPath = reportDirOrDefault()
-        setArgs([project.projectDir, reportPath.absolutePath, clean])
+        setArgs([
+            project.projectDir,
+            reportPath.absolutePath,
+            clean,
+            // TODO - consider separate options for `report` and `aggregate` tasks
+            extension.coverageOutputCobertura,
+            extension.coverageOutputXML,
+            extension.coverageOutputHTML,
+            extension.coverageDebug
+        ])
         super.exec()
-        def reportEntryPoint = new File(reportPath, 'index.html').absolutePath
-        project.logger.lifecycle("Wrote aggregated scoverage report to ${reportEntryPoint}")
     }
 
     def reportDirOrDefault() {

Diff for: src/test/groovy/org/scoverage/AcceptanceTestUtils.groovy

@@ -0,0 +1,31 @@
+package org.scoverage
+
+import org.gradle.tooling.BuildLauncher
+import org.gradle.tooling.GradleConnector
+import org.hamcrest.core.Is
+import org.junit.Assert
+
+/**
+ * Some utils for easy acceptance testing.
+ */
+class AcceptanceTestUtils {
+
+
+    protected BuildLauncher setupBuild(File projectRoot, boolean useAnt) {
+        return GradleConnector.
+            newConnector().
+            forProjectDirectory(projectRoot).
+            connect().
+            newBuild().
+            withArguments("-PuseAnt=$useAnt")
+    }
+
+    protected void checkFile(String description, File file, boolean shouldExist) throws Exception {
+        Assert.assertThat(description + ' should be created at ' + file.absolutePath, file.exists(), Is.is(shouldExist))
+    }
+
+    protected File reportDir(File baseDir) {
+        return new File(baseDir, 'build/reports/scoverage')
+    }
+
+}

Diff for: src/test/groovy/org/scoverage/AggregationAcceptanceTest.groovy

@@ -0,0 +1,42 @@
+package org.scoverage
+
+import org.junit.Test
+
+class AggregationAcceptanceTest extends AcceptanceTestUtils {
+
+    private static File aggregateReportDir(File baseDir) {
+        return new File(baseDir, 'build/scoverage-aggregate')
+    }
+
+    private testWater(boolean useAnt) throws Exception {
+        File projectDir = new File('src/test/water')
+
+        def build = setupBuild(projectDir, useAnt)
+        build.forTasks('clean', 'reportScoverage', 'aggregateScoverage').run()
+
+        def indexHtml = new File(aggregateReportDir(projectDir), 'index.html')
+        checkFile('an aggregated index HTML file', indexHtml, true)
+
+        def cobertura = new File(aggregateReportDir(projectDir), 'cobertura.xml')
+        checkFile('an aggregated cobertura XML file', cobertura, true)
+
+        def scoverageXml = new File(aggregateReportDir(projectDir), 'scoverage.xml')
+        checkFile('an aggregated scoverage XML file', scoverageXml, true)
+
+        def krillsHtml = new File(aggregateReportDir(projectDir), 'krills.html')
+        checkFile('a HTML file for \'krills\' sub-project', krillsHtml, true)
+
+        def whalesHtml = new File(aggregateReportDir(projectDir), 'whales.html')
+        checkFile('a HTML file for \'whales\' sub-project', whalesHtml, true)
+    }
+
+    @Test
+    public void testMultiProjectAggregationWithAnt() throws Exception {
+        testWater(true)
+    }
+
+    @Test
+    public void testMultiProjectAggregationWithZinc() throws Exception {
+        testWater(false)
+    }
+}

Diff for: src/test/groovy/org/scoverage/PluginAcceptanceTest.groovy

@@ -0,0 +1,31 @@
+package org.scoverage
+
+import org.junit.Test
+
+class SimpleReportAcceptanceTest extends AcceptanceTestUtils {
+
+    private testHappyDay(boolean useAnt) throws Exception {
+        File projectRoot = new File('src/test/happy day')
+        def build = setupBuild(projectRoot, useAnt)
+
+        build.forTasks('clean', 'checkScoverage').run()
+
+        def html = new File(reportDir(projectRoot), 'index.html')
+        checkFile('an index HTML file', html, true)
+        def cobertura = new File(reportDir(projectRoot), 'cobertura.xml')
+        checkFile('a cobertura XML file', cobertura, true)
+        def scoverageXml = new File(reportDir(projectRoot), 'scoverage.xml')
+        checkFile('a scoverage XML file', scoverageXml, true)
+    }
+
+    @Test
+    public void testAntProjectWithCompleteCoverage() throws Exception {
+        testHappyDay(true)
+    }
+
+    @Test
+    public void testZincProjectWithCompleteCoverage() throws Exception {
+        testHappyDay(false)
+    }
+
+}

Diff for: src/test/groovy/org/scoverage/SimpleReportAcceptanceTest.groovy

@@ -0,0 +1,5 @@
+package whales
+
+class BlueWhale {
+  def swim(): String = "I'm swimming!"
+}

Diff for: src/test/water/bluewhale/src/main/scala/whales/BlueWhale.scala

@@ -0,0 +1,11 @@
+package whales
+
+import org.junit.Test
+import org.junit.Assert
+
+class BlueWhaleTest {
+
+  @Test def bob(): Unit = {
+    Assert.assertEquals("Whale cannot swim :(", new BlueWhale().swim(), "I'm swimming!")
+  }
+}

Diff for: src/test/water/bluewhale/src/test/scala/whales/BlueWhaleTest.scala

@@ -0,0 +1,29 @@
+description = 'a multi-project setup for gradle-scoverage'
+
+buildscript {
+    repositories {
+        // need to get up to the working directory of gradle-plugins build
+        flatDir dir: "${project.projectDir}/../../../build/libs"
+    }
+    dependencies {
+        classpath name: 'gradle-scoverage', version: '+'
+    }
+}
+
+task aggregateScoverage(type: org.scoverage.ScoverageAggregate)
+
+allprojects {
+    repositories {
+        mavenCentral()
+    }
+
+    apply plugin: 'scoverage'
+
+    dependencies {
+        scoverage 'org.scoverage:scalac-scoverage-plugin_2.11:1.0.4',
+            'org.scoverage:scalac-scoverage-runtime_2.11:1.0.4'
+        compile 'org.scala-lang:scala-library:2.11.5'
+
+        testCompile 'junit:junit:4.11'
+    }
+}

Diff for: src/test/water/build.gradle

@@ -0,0 +1,5 @@
+package krills
+
+class NorthernKrill {
+  def swim(): String = "I can only float :("
+}

Diff for: src/test/water/krill/src/main/scala/krills/NorthernKrill.scala

@@ -0,0 +1,11 @@
+package krills
+
+import org.junit.Test
+import org.junit.Assert
+
+class NorthernKrillTest {
+
+  @Test def bob(): Unit = {
+    Assert.assertEquals("Krill can swim", new NorthernKrill().swim(), "I can only float :(")
+  }
+}

Diff for: src/test/water/krill/src/test/scala/krills/NorthernKrillTest.scala

@@ -0,0 +1 @@
+include 'bluewhale', 'krill'