Update kotlin to v0.8.0 (#2854)

* Update kotlin to v0.8.0

* Adapt our setup to `v0.8.0`'s changes

* Make sure verification tasks run on `check` tasks

---------

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: Jorge Martín <jorgem@element.io>

.github/workflows/nightlyReports.yml

@@ -33,7 +33,7 @@ jobs:
         run: ./gradlew verifyPaparazziDebug $CI_GRADLE_ARG_PROPERTIES
 
       - name: 📈 Generate kover report and verify coverage
-        run: ./gradlew :app:koverXmlReportGplayDebug :app:koverHtmlReportGplayDebug :app:koverVerifyGplayDebug $CI_GRADLE_ARG_PROPERTIES
+        run: ./gradlew :app:koverXmlReportGplayDebug :app:koverHtmlReportGplayDebug :app:koverVerifyAll $CI_GRADLE_ARG_PROPERTIES
 
       - name: ✅ Upload kover report
         if: always()

.github/workflows/tests.yml

@@ -55,7 +55,7 @@ jobs:
         run: ./gradlew verifyPaparazziDebug $CI_GRADLE_ARG_PROPERTIES
 
       - name: 📈Generate kover report and verify coverage
-        run: ./gradlew :app:koverXmlReportGplayDebug :app:koverHtmlReportGplayDebug :app:koverVerifyGplayDebug $CI_GRADLE_ARG_PROPERTIES
+        run: ./gradlew :app:koverXmlReportGplayDebug :app:koverHtmlReportGplayDebug :app:koverVerifyAll $CI_GRADLE_ARG_PROPERTIES
 
       - name: 🚫 Upload kover failed coverage reports
         if: failure()

gradle/libs.versions.toml

@@ -57,7 +57,7 @@ autoservice = "1.1.1"
 junit = "4.13.2"
 androidx-test-ext-junit = "1.1.5"
 espresso-core = "3.5.1"
-kover = "0.7.6"
+kover = "0.8.0"
 
 [libraries]
 # Project

plugins/src/main/kotlin/extension/KoverExtension.kt

@@ -16,10 +16,24 @@
 
 package extension
 
-import kotlinx.kover.gradle.plugin.dsl.KoverReportExtension
+import kotlinx.kover.gradle.plugin.dsl.AggregationType
+import kotlinx.kover.gradle.plugin.dsl.CoverageUnit
+import kotlinx.kover.gradle.plugin.dsl.GroupingEntityType
+import kotlinx.kover.gradle.plugin.dsl.KoverProjectExtension
+import kotlinx.kover.gradle.plugin.dsl.KoverVariantCreateConfig
 import org.gradle.api.Action
 import org.gradle.api.Project
+import org.gradle.configurationcache.extensions.capitalized
 import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.assign
+
+enum class KoverVariant(val variantName: String) {
+    Presenters("presenters"),
+    States("states"),
+    Views("views"),
+}
+
+val koverVariants = KoverVariant.values().map { it.variantName }
 
 val localAarProjects = listOf(
     ":libraries:rustsdk",
@@ -44,15 +58,24 @@ val excludedKoverSubProjects = listOf(
     ":libraries:di",
 ) + localAarProjects
 
-private fun Project.koverReport(action: Action<KoverReportExtension>) {
+private fun Project.kover(action: Action<KoverProjectExtension>) {
-    (this as org.gradle.api.plugins.ExtensionAware).extensions.configure("koverReport", action)
+    (this as org.gradle.api.plugins.ExtensionAware).extensions.configure("kover", action)
 }
 
 fun Project.setupKover() {
+    // Create verify all task joining all existing verification tasks
+    task("koverVerifyAll") {
+        group = "verification"
+        description = "Verifies the code coverage of all subprojects."
+        val dependencies = listOf(":app:koverVerifyGplayDebug") + koverVariants.map { ":app:koverVerify${it.capitalized()}" }
+        dependsOn(dependencies)
+
+    }
     // https://kotlin.github.io/kotlinx-kover/
     // Run `./gradlew :app:koverHtmlReport` to get report at ./app/build/reports/kover
     // Run `./gradlew :app:koverXmlReport` to get XML report
-    koverReport {
+    kover {
+        reports {
             filters {
                 excludes {
                     classes(
@@ -97,30 +120,38 @@ fun Project.setupKover() {
                 }
             }
 
-        defaults {
+            total {
-            // add reports of both 'debug' and 'release' Android build variants to default reports
-            mergeWith("gplayDebug")
-
                 verify {
                     onCheck = true
                     // General rule: minimum code coverage.
                     rule("Global minimum code coverage.") {
-                    isEnabled = true
+                        groupBy = GroupingEntityType.APPLICATION
-                    entity = kotlinx.kover.gradle.plugin.dsl.GroupingEntityType.APPLICATION
                         bound {
                             minValue = 70
                             // Setting a max value, so that if coverage is bigger, it means that we have to change minValue.
                             // For instance if we have minValue = 20 and maxValue = 30, and current code coverage is now 31.32%, update
                             // minValue to 25 and maxValue to 35.
                             maxValue = 80
-                        metric = kotlinx.kover.gradle.plugin.dsl.MetricType.INSTRUCTION
+                            coverageUnits = CoverageUnit.INSTRUCTION
-                        aggregation = kotlinx.kover.gradle.plugin.dsl.AggregationType.COVERED_PERCENTAGE
+                            aggregationForGroup = AggregationType.COVERED_PERCENTAGE
                         }
                     }
+                }
+            }
+            variant(KoverVariant.Presenters.variantName) {
+                verify {
+                    onCheck = true
                     // Rule to ensure that coverage of Presenters is sufficient.
                     rule("Check code coverage of presenters") {
-                    isEnabled = true
+                        groupBy = GroupingEntityType.CLASS
-                    entity = kotlinx.kover.gradle.plugin.dsl.GroupingEntityType.CLASS
+
+                        bound {
+                            minValue = 85
+                            coverageUnits = CoverageUnit.INSTRUCTION
+                            aggregationForGroup = AggregationType.COVERED_PERCENTAGE
+                        }
+                    }
+                }
                 filters {
                     includes {
                         classes(
@@ -137,16 +168,20 @@ fun Project.setupKover() {
                         )
                     }
                 }
-                    bound {
-                        minValue = 85
-                        metric = kotlinx.kover.gradle.plugin.dsl.MetricType.INSTRUCTION
-                        aggregation = kotlinx.kover.gradle.plugin.dsl.AggregationType.COVERED_PERCENTAGE
-                    }
             }
+            variant(KoverVariant.States.variantName) {
+                verify {
+                    onCheck = true
                     // Rule to ensure that coverage of States is sufficient.
                     rule("Check code coverage of states") {
-                    isEnabled = true
+                        groupBy = GroupingEntityType.CLASS
-                    entity = kotlinx.kover.gradle.plugin.dsl.GroupingEntityType.CLASS
+                        bound {
+                            minValue = 90
+                            coverageUnits = CoverageUnit.INSTRUCTION
+                            aggregationForGroup = AggregationType.COVERED_PERCENTAGE
+                        }
+                    }
+                }
                 filters {
                     includes {
                         classes(
@@ -176,16 +211,21 @@ fun Project.setupKover() {
                         )
                     }
                 }
-                    bound {
-                        minValue = 90
-                        metric = kotlinx.kover.gradle.plugin.dsl.MetricType.INSTRUCTION
-                        aggregation = kotlinx.kover.gradle.plugin.dsl.AggregationType.COVERED_PERCENTAGE
-                    }
             }
+            variant(KoverVariant.Views.variantName) {
+                verify {
+                    onCheck = true
                     // Rule to ensure that coverage of Views is sufficient (deactivated for now).
                     rule("Check code coverage of views") {
-                    isEnabled = true
+                        groupBy = GroupingEntityType.CLASS
-                    entity = kotlinx.kover.gradle.plugin.dsl.GroupingEntityType.CLASS
+                        bound {
+                            // TODO Update this value, for now there are too many missing tests.
+                            minValue = 0
+                            coverageUnits = CoverageUnit.INSTRUCTION
+                            aggregationForGroup = AggregationType.COVERED_PERCENTAGE
+                        }
+                    }
+                }
                 filters {
                     includes {
                         classes(
@@ -193,26 +233,31 @@ fun Project.setupKover() {
                         )
                     }
                 }
-                    bound {
-                        // TODO Update this value, for now there are too many missing tests.
-                        minValue = 0
-                        metric = kotlinx.kover.gradle.plugin.dsl.MetricType.INSTRUCTION
-                        aggregation = kotlinx.kover.gradle.plugin.dsl.AggregationType.COVERED_PERCENTAGE
-                    }
-                }
             }
         }
     }
 }
 
-fun Project.applyKoverPluginToAllSubProjects() = rootProject.allprojects {
+fun Project.applyKoverPluginToAllSubProjects() = rootProject.subprojects {
     if (project.path !in localAarProjects) {
         apply(plugin = "org.jetbrains.kotlinx.kover")
+        kover {
+            currentProject {
+                for (variant in koverVariants) {
+                    createVariant(variant) {
+                        defaultVariants()
+                    }
+                }
+            }
+        }
     }
 }
 
-fun Project.koverDependencies() {
+fun KoverVariantCreateConfig.defaultVariants() {
-    project.rootProject.subprojects
+    addWithDependencies("gplayDebug", "debug", optional = true)
+}
+
+fun Project.koverSubprojects() = project.rootProject.subprojects
     .filter {
         it.project.projectDir.resolve("build.gradle.kts").exists()
     }
@@ -221,6 +266,9 @@ fun Project.koverDependencies() {
     .filter {
         it !in excludedKoverSubProjects
     }
+
+fun Project.koverDependencies() {
+    project.koverSubprojects()
         .forEach {
             // println("Add $it to kover")
             dependencies.add("kover", project(it))