(#121) Add a warning when scala subprojects don't have scoverage applied to them (and the parent does)

Author: eyalroth

src/functionalTest/java/org.scoverage/MultiModulePluginNotConfiguredForScalaTest.java

@@ -0,0 +1,38 @@
+package org.scoverage;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class MultiModulePluginNotConfiguredForScalaTest extends ScoverageFunctionalTest {
+
+    public MultiModulePluginNotConfiguredForScalaTest() {
+        super("multi-module-plugin-not-configured-for-scala");
+    }
+
+    @Test
+    public void checkAndAggregateScoverage() throws Exception {
+
+        AssertableBuildResult result = run("clean", ScoveragePlugin.getCHECK_NAME(),
+                ScoveragePlugin.getAGGREGATE_NAME());
+
+        result.assertTaskSkipped(ScoveragePlugin.getREPORT_NAME());
+        result.assertTaskSkipped("scala_only:" + ScoveragePlugin.getREPORT_NAME());
+        result.assertTaskSkipped("java_only:" + ScoveragePlugin.getREPORT_NAME());
+        result.assertTaskSkipped(ScoveragePlugin.getCHECK_NAME());
+        result.assertTaskSkipped("scala_only:" + ScoveragePlugin.getCHECK_NAME());
+        result.assertTaskSkipped("java_only:" + ScoveragePlugin.getCHECK_NAME());
+        result.assertTaskSkipped(ScoveragePlugin.getAGGREGATE_NAME());
+
+        assertReportDirsEmpty();
+
+        Assert.assertTrue(result.getResult().getOutput().contains("Scala sub-project 'scala_only' doesn't have Scoverage applied"));
+        Assert.assertFalse(result.getResult().getOutput().contains("Scala sub-project 'java_only' doesn't have Scoverage applied"));
+    }
+
+    private void assertReportDirsEmpty() {
+
+        Assert.assertFalse(reportDir().exists());
+        Assert.assertFalse(reportDir(projectDir().toPath().resolve("scala_only").toFile()).exists());
+        Assert.assertFalse(reportDir(projectDir().toPath().resolve("java_only").toFile()).exists());
+    }
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/build.gradle

@@ -0,0 +1,30 @@
+plugins {
+    id 'org.scoverage' apply false
+}
+
+description = 'a multi-module Scala and Java project that defines scoverage only on root but not on subprojects'
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}
+
+subprojects { p ->
+    if (p.name != 'dependencies') {
+        apply plugin: 'java'
+        dependencies {
+            implementation platform(project(':dependencies'))
+            testCompile group: 'org.junit.platform', name: 'junit-platform-runner'
+        }
+
+        test {
+            useJUnitPlatform()
+        }
+    }
+}
+
+apply plugin: 'org.scoverage'
+scoverage {
+    minimumRate = 0.5
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/dependencies/build.gradle

@@ -0,0 +1,14 @@
+plugins {
+    id 'java-platform'
+}
+
+dependencies {
+    constraints {
+        api group: 'org.scala-lang', name: 'scala-library', version: "${scalaVersionMajor}.${scalaVersionMinor}.${scalaVersionBuild}"
+
+        api group: 'org.junit.vintage', name: 'junit-vintage-engine', version: junitVersion
+        api group: 'org.junit.platform', name: 'junit-platform-runner', version: junitPlatformVersion
+
+        api group: 'org.scalatest', name: "scalatest_${scalaVersionMajor}.${scalaVersionMinor}", version: scalatestVersion
+    }
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/java_only/build.gradle

@@ -0,0 +1,3 @@
+dependencies {
+    testRuntime group: 'org.junit.vintage', name: 'junit-vintage-engine'
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/java_only/src/main/java/org/hello/WorldJavaOnly.java

@@ -0,0 +1,9 @@
+package org.hello;
+
+public class WorldJavaOnly {
+
+    public String foo() {
+        String s = "java_only" + "a";
+        return s;
+    }
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/java_only/src/test/java/org/hello/WorldJavaOnlyTest.java

@@ -0,0 +1,11 @@
+package org.hello;
+
+import org.junit.Test;
+
+public class WorldJavaOnlyTest {
+
+    @Test
+    public void foo() {
+        new WorldJavaOnly().foo();
+    }
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/scala_only/build.gradle

@@ -0,0 +1,9 @@
+apply plugin: 'scala'
+// apply plugin: 'org.scoverage' // Oops forgot to configure scoverage
+
+dependencies {
+    compile group: 'org.scala-lang', name: 'scala-library'
+
+    testRuntime group: 'org.junit.vintage', name: 'junit-vintage-engine'
+    testCompile group: 'org.scalatest', name: "scalatest_${scalaVersionMajor}.${scalaVersionMinor}"
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/scala_only/src/main/scala/org/hello/WorldScalaOnly.scala

@@ -0,0 +1,9 @@
+package org.hello
+
+class WorldScalaOnly {
+
+  def foo(): String = {
+    val s = "scala_only" + "a"
+    s
+  }
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/scala_only/src/test/scala/org/hello/WorldScalaOnlySuite.scala

@@ -0,0 +1,13 @@
+package org.hello
+
+import org.junit.runner.RunWith
+import org.scalatest.FunSuite
+import org.scalatest.junit.JUnitRunner
+
+@RunWith(classOf[JUnitRunner])
+class WorldScalaOnlySuite extends FunSuite {
+
+  test("foo") {
+    new WorldScalaOnly().foo()
+  }
+}

src/functionalTest/resources/projects/multi-module-plugin-not-configured-for-scala/settings.gradle

@@ -0,0 +1 @@
+include 'dependencies', 'java_only', 'scala_only'

src/main/groovy/org/scoverage/ScoveragePlugin.groovy

@@ -6,6 +6,7 @@ import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.invocation.Gradle
 import org.gradle.api.plugins.PluginAware
+import org.gradle.api.plugins.scala.ScalaPlugin
 import org.gradle.api.tasks.SourceSet
 import org.gradle.api.tasks.scala.ScalaCompile
 import org.gradle.api.tasks.testing.Test
@@ -281,14 +282,23 @@ class ScoveragePlugin implements Plugin<PluginAware> {
             }
 
             // define aggregation task
-            if (project.childProjects.size() > 0) {
+            if (!project.subprojects.empty) {
                 project.gradle.projectsEvaluated {
-                    def allReportTasks = project.getAllprojects().findResults {
+                    project.subprojects.each {
+                        if (it.plugins.hasPlugin(ScalaPlugin) && !it.plugins.hasPlugin(ScoveragePlugin)) {
+                            it.logger.warn("Scala sub-project '${it.name}' doesn't have Scoverage applied and will be ignored in parent project aggregation")
+                        }
+                    }
+                    def childReportTasks = project.subprojects.findResults {
                         it.tasks.find { task ->
                             task.name == REPORT_NAME && task instanceof ScoverageAggregate
                         }
                     }
+                    def allReportTasks = childReportTasks + globalReportTask
                     def aggregationTask = project.tasks.create(AGGREGATE_NAME, ScoverageAggregate) {
+                        onlyIf {
+                            !childReportTasks.empty
+                        }
                         dependsOn(allReportTasks)
                         group = 'verification'
                         runner = scoverageRunner