scoverage#171 Migrate CoverageChecker (and its test) from Groovy to Kotlin

Author: eyalroth

build.gradle.kts

@@ -2,6 +2,7 @@ plugins {
     `java-gradle-plugin`
     id("com.gradle.plugin-publish") version "0.15.0"
     id("org.jetbrains.gradle.plugin.idea-ext") version "1.0"
+    kotlin("jvm") version "1.5.31"
 }
 
 repositories {
@@ -38,17 +39,30 @@ pluginBundle {
 }
 
 apply(plugin = "maven-publish")
+// TODO #171 remove once all groovy classes are migrated to kotlin
 apply(plugin = "groovy")
 
 java {
     sourceCompatibility = JavaVersion.VERSION_1_8
     targetCompatibility = JavaVersion.VERSION_1_8
 }
 
+// TODO #171 remove once all groovy classes are migrated to kotlin
+val compileKotlinTask = tasks.compileKotlin.get()
+tasks {
+    named<GroovyCompile>("compileGroovy") {
+        dependsOn(compileKotlin)
+        classpath = classpath.plus(files(compileKotlinTask.destinationDirectory))
+    }
+}
+
 dependencies {
     compileOnly("org.scoverage:scalac-scoverage-plugin_2.13:1.4.2")
     implementation(group = "commons-io", name = "commons-io", version = "2.6")
 
+    implementation(kotlin("script-runtime"))
+    testImplementation(kotlin("test"))
+
     testImplementation("junit:junit:4.12")
     testImplementation("org.junit.jupiter:junit-jupiter-api:5.5.2")
     testRuntimeOnly("org.junit.vintage:junit-vintage-engine:5.5.2")
@@ -122,6 +136,7 @@ gradlePlugin {
     testSourceSets(sourceSets["functionalTest"], sourceSets["crossScalaVersionTest"])
 }
 
+// TODO #171 remove once all groovy classes are migrated to kotlin
 val groovydocJar by tasks.registering(Jar::class) {
     from("$buildDir/docs/groovydoc")
     classifier = "groovydoc"

src/main/groovy/org/scoverage/CoverageChecker.groovy

@@ -0,0 +1,94 @@
+package org.scoverage
+
+import groovy.xml.XmlParser
+import org.gradle.api.GradleException
+import org.gradle.internal.impldep.com.google.common.annotations.VisibleForTesting
+import org.slf4j.Logger
+import java.io.File
+import java.io.FileNotFoundException
+
+import java.text.DecimalFormat
+import java.text.NumberFormat
+import java.util.*
+import kotlin.jvm.Throws
+
+/**
+ * Handles different types of coverage Scoverage can measure.
+ *
+ * @param configurationName Name of enum option the way it appears in the build configuration.
+ * @param fileName Name of file with coverage data.
+ * @param paramName Name of param in XML file with coverage value.
+ * @param factor Used to normalize coverage value.
+ */
+enum class CoverageType(
+    private val configurationName: String,
+    val fileName: String,
+    val paramName: String,
+    private val factor: Double
+) {
+    Line("Line", "cobertura.xml", "line-rate", 1.0),
+    Statement("Statement", "scoverage.xml", "statement-rate", 100.0),
+    Branch("Branch", "scoverage.xml", "branch-rate", 100.0);
+
+    /** Normalize coverage value to [0, 1] */
+    fun normalize(value: Double): Double = value / factor
+
+    companion object {
+        fun find(configurationName: String): CoverageType? {
+            return values().find { it -> it.configurationName.lowercase() == configurationName.lowercase() }
+        }
+    }
+}
+
+/**
+ * Throws a GradleException if overall coverage dips below the configured percentage.
+ */
+class CoverageChecker(private val logger: Logger) {
+
+    @JvmOverloads
+    @Throws(GradleException::class)
+    fun checkLineCoverage(
+        reportDir: File,
+        coverageType: CoverageType,
+        minimumRate: Double,
+        nf: NumberFormat = NumberFormat.getInstance(Locale.getDefault())
+    ) {
+        logger.info("Checking coverage. Type: {}. Minimum rate: {}", coverageType, minimumRate)
+
+        val parser = XmlParser()
+        parser.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false)
+        parser.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false)
+
+        val df = DecimalFormat("#.##")
+
+        try {
+            val reportFile = File(reportDir, coverageType.fileName)
+            val xml = parser.parse(reportFile)
+            val coverageValue: Double = nf.parse(xml.attribute(coverageType.paramName) as String).toDouble()
+            val overallRate: Double = coverageType.normalize(coverageValue)
+
+            val difference = minimumRate - overallRate
+
+            if (difference > 1e-7) {
+                val iss = df.format(overallRate * 100)
+                val needed = df.format(minimumRate * 100)
+                throw GradleException(errorMsg(iss, needed, coverageType))
+            }
+        } catch (fnfe: FileNotFoundException) {
+            throw GradleException(fileNotFoundErrorMsg(coverageType), fnfe)
+        }
+    }
+
+    companion object {
+        @VisibleForTesting
+        internal fun errorMsg(actual: String, expected: String, type: CoverageType): String {
+            return "Only $actual% of project is covered by tests instead of $expected% (coverageType: $type)"
+        }
+
+        @VisibleForTesting
+        internal fun fileNotFoundErrorMsg(coverageType: CoverageType): String {
+            return "Coverage file (type: $coverageType) not found, check your configuration."
+        }
+    }
+
+}

src/main/kotlin/org/scoverage/CoverageChecker.kt

@@ -11,25 +11,26 @@ import org.slf4j.LoggerFactory
 
 import java.nio.file.Paths
 import java.text.NumberFormat
+import java.util.*
 
-import static org.junit.Assert.assertThat
-import static org.junit.jupiter.api.Assertions.assertThrows
+import org.junit.Assert.assertThat
+import org.junit.jupiter.api.Assertions.assertThrows
 
 class CoverageCheckerTest {
 
-    private NumberFormat numberFormat = NumberFormat.getInstance(Locale.US)
+    private val numberFormat = NumberFormat.getInstance(Locale.US)
 
-    private File reportDir = Paths.get(getClass().getClassLoader().getResource("checkTask").toURI()).toFile()
+    private val reportDir = Paths.get(javaClass.getClassLoader().getResource("checkTask").toURI()).toFile()
 
-    private CoverageChecker checker = new CoverageChecker(LoggerFactory.getLogger(CoverageCheckerTest.class))
+    private val checker = CoverageChecker(LoggerFactory.getLogger(CoverageCheckerTest::class.java))
 
-    @Rule
-    public TemporaryFolder tempDir = new TemporaryFolder()
+    @get:Rule
+    val tempDir = TemporaryFolder()
 
     // error when report file is not there
 
     @Test
-    void failsWhenReportFileIsNotFound() {
+    fun failsWhenReportFileIsNotFound() {
         assertFailure(CoverageChecker.fileNotFoundErrorMsg(CoverageType.Line), {
             checker.checkLineCoverage(tempDir.getRoot(), CoverageType.Line, 0.0, numberFormat)
         })
@@ -38,85 +39,78 @@ class CoverageCheckerTest {
     // line coverage
 
     @Test
-    void failsWhenLineRateIsBelowTarget() {
+    fun failsWhenLineRateIsBelowTarget() {
         assertFailure(CoverageChecker.errorMsg("66", "100", CoverageType.Line), {
             checker.checkLineCoverage(reportDir, CoverageType.Line, 1.0, numberFormat)
         })
     }
 
     @Test
-    void doesNotFailWhenLineRateIsAtTarget() {
+    fun doesNotFailWhenLineRateIsAtTarget() {
         checker.checkLineCoverage(reportDir, CoverageType.Line, 0.66, numberFormat)
     }
 
     @Test
-    void doesNotFailWhenLineRateIsAboveTarget() {
+    fun doesNotFailWhenLineRateIsAboveTarget() {
         checker.checkLineCoverage(reportDir, CoverageType.Line, 0.6, numberFormat)
     }
 
     // Statement coverage
 
     @Test
-    void failsWhenStatementRateIsBelowTarget() {
-        assertFailure(CoverageChecker.errorMsg(numberFormat.format(new Double(33.33)), "100", CoverageType.Statement), {
+    fun failsWhenStatementRateIsBelowTarget() {
+        assertFailure(CoverageChecker.errorMsg(numberFormat.format(33.33), "100", CoverageType.Statement), {
             checker.checkLineCoverage(reportDir, CoverageType.Statement, 1.0, numberFormat)
         })
     }
 
     @Test
-    void doesNotFailWhenStatementRateIsAtTarget() {
+    fun doesNotFailWhenStatementRateIsAtTarget() {
         checker.checkLineCoverage(reportDir, CoverageType.Statement, 0.33, numberFormat)
     }
 
     @Test
-    void doesNotFailWhenStatementRateIsAboveTarget() {
+    fun doesNotFailWhenStatementRateIsAboveTarget() {
         checker.checkLineCoverage(reportDir, CoverageType.Statement, 0.3, numberFormat)
     }
 
     // Branch coverage
 
     @Test
-    void failsWhenBranchRateIsBelowTarget() {
+    fun failsWhenBranchRateIsBelowTarget() {
         assertFailure(CoverageChecker.errorMsg("50", "100", CoverageType.Branch), {
             checker.checkLineCoverage(reportDir, CoverageType.Branch, 1.0, numberFormat)
         })
     }
 
     @Test
-    void doesNotFailWhenBranchRateIsAtTarget() {
+    fun doesNotFailWhenBranchRateIsAtTarget() {
         checker.checkLineCoverage(reportDir, CoverageType.Branch, 0.5, numberFormat)
     }
 
     @Test
-    void doesNotFailWhenBranchRateIsAboveTarget() {
+    fun doesNotFailWhenBranchRateIsAboveTarget() {
         checker.checkLineCoverage(reportDir, CoverageType.Branch, 0.45, numberFormat)
     }
 
-    private void assertFailure(String message, Executable executable) {
-        GradleException e = assertThrows(GradleException.class, executable)
-        assertThat(e, new CauseMatcher(message))
+    private fun assertFailure(message: String, executable: Executable) {
+        val e: GradleException = assertThrows(GradleException::class.java, executable)
+        assertThat(e, CauseMatcher(message))
     }
 }
 
 /**
  * Copied from the Internet, just to check if we have correct exception thrown.
  */
-class CauseMatcher extends TypeSafeMatcher<GradleException> {
-
-    private final String expectedMessage
-
-    CauseMatcher(String expectedMessage) {
-        this.expectedMessage = expectedMessage
-    }
+class CauseMatcher(private val expectedMessage: String): TypeSafeMatcher<GradleException>() {
 
     @Override
-    protected boolean matchesSafely(GradleException item) {
-        return item.getMessage().contains(expectedMessage)
+    protected override fun matchesSafely(item: GradleException): Boolean {
+        return item.message?.contains(expectedMessage) == true
     }
 
-    @Override
-    void describeTo(Description description) {
+    override fun describeTo(description: Description) {
         description.appendText("expects message ")
                 .appendValue(expectedMessage)
     }
-}
+}