Fix part of #5343: Enable Code Coverage Analysis for many to one test target files

scripts/src/java/org/oppia/android/scripts/common/BazelClient.kt

@@ -142,7 +142,8 @@ class BazelClient(private val rootDirectory: File, private val commandExecutor:
    *     or null if the coverage data file could not be parsed
    */
   fun runCoverageForTestTarget(bazelTestTarget: String): List<String>? {
-    val computeInstrumentation = bazelTestTarget.split("/").let { "//${it[2]}/..." }
+    val instrumentation = bazelTestTarget.split(":")[0]
+    val computeInstrumentation = instrumentation.split("/").let { "//${it[2]}/..." }
     val coverageCommandOutputLines = executeBazelCommand(
       "coverage",
       bazelTestTarget,
@@ -159,7 +160,7 @@ class BazelClient(private val rootDirectory: File, private val commandExecutor:
       val match = regex.find(line)
       val extractedPath = match?.value?.substringAfterLast(",")?.trim()
       if (extractedPath != null) {
-        println("Parsed Coverage Data File: $extractedPath")
+        println("Raw Coverage Data: $extractedPath")
         return extractedPath
       }
     }

scripts/src/java/org/oppia/android/scripts/coverage/CoverageReporter.kt

@@ -8,21 +8,21 @@ import java.io.File
  * Class responsible for generating rich text coverage report.
  *
  * @param repoRoot the root directory of the repository
- * @param coverageReportList the list of coverage data proto
+ * @param coverageReport the coverage data proto
  * @param reportFormat the format in which the report will be generated
  */
 class CoverageReporter(
   private val repoRoot: String,
-  private val coverageReportList: List<CoverageReport>,
+  private val coverageReport: CoverageReport,
   private val reportFormat: ReportFormat,
 ) {
   private val computedCoverageRatio = computeCoverageRatio()
   private val formattedCoveragePercentage = "%.2f".format(computedCoverageRatio * 100)
 
-  private val filePath = coverageReportList.firstOrNull()?.filePath ?: "Unknown"
+  private val filePath = coverageReport.filePath
 
-  private val totalLinesFound = coverageReportList.getOrNull(0)?.linesFound ?: 0
-  private val totalLinesHit = coverageReportList.getOrNull(0)?.linesHit ?: 0
+  private val totalLinesFound = coverageReport.linesFound
+  private val totalLinesHit = coverageReport.linesHit
 
   /**
    * Generates a rich text report for the analysed coverage data based on the specified format.
@@ -32,7 +32,7 @@ class CoverageReporter(
    *     and the second value is the generated report text
    */
   fun generateRichTextReport(): Pair<Float, String> {
-    println("report format: $reportFormat")
+    println("Report format: $reportFormat")
     return when (reportFormat) {
       ReportFormat.MARKDOWN -> generateMarkdownReport()
       ReportFormat.HTML -> generateHtmlReport()
@@ -66,6 +66,7 @@ class CoverageReporter(
       <style>
         body {
             font-family: Arial, sans-serif;
+            font-size: 12px;
             line-height: 1.6;
             padding: 20px;
         }
@@ -78,24 +79,20 @@ class CoverageReporter(
             padding: 8px;
             margin-left: 20px;
             text-align: left;
-            border-bottom: 1px solid #fdfdfd;
+            white-space: pre-wrap;
+            border-bottom: 1px solid #e3e3e3;
         }
         .line-number-col {
-            width: 2%;
+            width: 4%;
         }
         .line-number-row {
-            border-right: 1px dashed #000000
+            border-right: 1px solid #ababab
         }
         .source-code-col {
-            width: 98%;
+            width: 96%;
         }
         .covered-line, .not-covered-line, .uncovered-line {
-            white-space: pre-wrap;
-            word-wrap: break-word;
-            box-sizing: border-box;
-            border-radius: 4px;
-            padding: 2px 8px 2px 4px;
-            display: inline-block;
+            /*white-space: pre-wrap;*/
         }
         .covered-line {
             background-color: #c8e6c9; /* Light green */
@@ -104,7 +101,7 @@ class CoverageReporter(
             background-color: #ffcdd2; /* Light red */
         }
         .uncovered-line {
-            background-color: #f1f1f1; /* light gray */
+            background-color: #f7f7f7; /* light gray */
         }
         .coverage-summary {
           margin-bottom: 20px;
@@ -118,7 +115,6 @@ class CoverageReporter(
           text-align: center;
         }
         .summary-box {
-          background-color: #f0f0f0;
           border: 1px solid #ccc;
           border-radius: 8px;
           padding: 10px;
@@ -152,12 +148,12 @@ class CoverageReporter(
           background-color: #ffcdd2; /* Light red */
         }
         @media screen and (max-width: 768px) {
-            body {
-                padding: 10px;
-            }
-            table {
-                width: auto;
-            }
+          body {
+              padding: 10px;
+          }
+          table {
+              width: auto;
+          }
         }
       </style>
     </head>
@@ -189,12 +185,11 @@ class CoverageReporter(
       """.trimIndent()
 
     val fileContent = File(repoRoot, filePath).readLines()
-    val coverageMap = coverageReportList
-      .firstOrNull()?.coveredLineList?.associateBy { it.lineNumber }
+    val coverageMap = coverageReport.coveredLineList.associateBy { it.lineNumber }
 
     fileContent.forEachIndexed { index, line ->
       val lineNumber = index + 1
-      val lineClass = when (coverageMap?.get(lineNumber)?.coverage) {
+      val lineClass = when (coverageMap.get(lineNumber)?.coverage) {
         Coverage.FULL -> "covered-line"
         Coverage.NONE -> "not-covered-line"
         else -> "uncovered-line"
@@ -218,9 +213,8 @@ class CoverageReporter(
   }
 
   private fun computeCoverageRatio(): Float {
-    val report = coverageReportList.getOrNull(0)
-    return if (report != null && report.linesFound != 0) {
-      report.linesHit.toFloat() / report.linesFound.toFloat()
+    return if (coverageReport.linesFound != 0) {
+      coverageReport.linesHit.toFloat() / coverageReport.linesFound.toFloat()
     } else {
       0f
     }

scripts/src/java/org/oppia/android/scripts/coverage/CoverageRunner.kt

@@ -1,11 +1,9 @@
 package org.oppia.android.scripts.coverage
 
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Deferred
-import kotlinx.coroutines.async
 import org.oppia.android.scripts.common.BazelClient
 import org.oppia.android.scripts.common.CommandExecutor
 import org.oppia.android.scripts.common.ScriptBackgroundCoroutineDispatcher
+import org.oppia.android.scripts.proto.BazelTestTarget
 import org.oppia.android.scripts.proto.Coverage
 import org.oppia.android.scripts.proto.CoverageReport
 import org.oppia.android.scripts.proto.CoveredLine
@@ -34,15 +32,13 @@ class CoverageRunner(
    * @param bazelTestTarget Bazel test target to analyze coverage
    * @return a deferred value that contains the coverage data
    */
-  fun runWithCoverageAsync(
+  fun retrieveCoverageDataForTestTarget(
     bazelTestTarget: String
-  ): Deferred<CoverageReport> {
-    return CoroutineScope(scriptBgDispatcher).async {
-      val coverageResult = retrieveCoverageResult(bazelTestTarget)
-        ?: error("Failed to retrieve coverage result for $bazelTestTarget")
+  ): CoverageReport {
+    val coverageResult = retrieveCoverageResult(bazelTestTarget)
+      ?: error("Failed to retrieve coverage result for $bazelTestTarget")
 
-      coverageDataFileLines(coverageResult, bazelTestTarget)
-    }
+    return coverageDataFileLines(coverageResult, bazelTestTarget)
   }
 
   private fun retrieveCoverageResult(
@@ -93,8 +89,12 @@ class CoverageRunner(
     val file = File(repoRoot, filePath)
     val fileSha1Hash = calculateSha1(file.absolutePath)
 
+    val bazelTestTargetName = BazelTestTarget.newBuilder()
+      .setTestTargetName(bazelTestTarget)
+      .build()
+
     return CoverageReport.newBuilder()
-      .setBazelTestTarget(bazelTestTarget)
+      .addBazelTestTargets(bazelTestTargetName)
       .setFilePath(filePath)
       .setFileSha1Hash(fileSha1Hash)
       .addAllCoveredLine(coveredLines)

scripts/src/java/org/oppia/android/scripts/coverage/RunCoverage.kt

@@ -1,11 +1,12 @@
 package org.oppia.android.scripts.coverage
 
-import kotlinx.coroutines.runBlocking
 import org.oppia.android.scripts.common.BazelClient
 import org.oppia.android.scripts.common.CommandExecutor
 import org.oppia.android.scripts.common.CommandExecutorImpl
 import org.oppia.android.scripts.common.ScriptBackgroundCoroutineDispatcher
+import org.oppia.android.scripts.proto.Coverage
 import org.oppia.android.scripts.proto.CoverageReport
+import org.oppia.android.scripts.proto.CoveredLine
 import org.oppia.android.scripts.proto.TestFileExemptions
 import java.io.File
 import java.util.concurrent.TimeUnit
@@ -27,7 +28,7 @@ import java.util.concurrent.TimeUnit
  *     utility/src/main/java/org/oppia/android/util/parser/math/MathModel.kt format=HTML
  * Example with custom process timeout:
  *     bazel run //scripts:run_coverage -- $(pwd)
- *     utility/src/main/java/org/oppia/android/util/parser/math/MathModel.kt processTimeout=10
+ *     utility/src/main/java/org/oppia/android/util/parser/math/MathModel.kt processTimeout=15
  *
  */
 fun main(vararg args: String) {
@@ -46,8 +47,8 @@ fun main(vararg args: String) {
 
   val reportOutputPath = getReportOutputPath(repoRoot, filePath, reportFormat)
 
-  if (!File(repoRoot, filePath).exists()) {
-    error("File doesn't exist: $filePath.")
+  check(File(repoRoot, filePath).exists()) {
+    "File doesn't exist: $filePath."
   }
 
   ScriptBackgroundCoroutineDispatcher().use { scriptBgDispatcher ->
@@ -110,22 +111,21 @@ class RunCoverage(
 
     if (filePath in testFileExemptionList) {
       println("This file is exempted from having a test file; skipping coverage check.")
-      return
-    }
-
-    val testFilePaths = findTestFile(repoRoot, filePath)
-    if (testFilePaths.isEmpty()) {
-      error("No appropriate test file found for $filePath")
-    }
+    } else {
+      val testFilePaths = findTestFiles(repoRoot, filePath)
+      check(testFilePaths.isNotEmpty()) {
+        "No appropriate test file found for $filePath"
+      }
 
-    val testTargets = bazelClient.retrieveBazelTargets(testFilePaths)
+      val testTargets = bazelClient.retrieveBazelTargets(testFilePaths)
 
-    val coverageReports = testTargets.mapNotNull { testTarget ->
-      runCoverageForTarget(testTarget)
-    }
+      val coverageReports = testTargets.map { testTarget ->
+        CoverageRunner(rootDirectory, scriptBgDispatcher, commandExecutor)
+          .retrieveCoverageDataForTestTarget(testTarget.removeSuffix(".kt"))
+      }
 
-    coverageReports.takeIf { it.isNotEmpty() }?.run {
-      val reporter = CoverageReporter(repoRoot, this, reportFormat)
+      val aggregatedCoverageReport = calculateAggregateCoverageReport(coverageReports)
+      val reporter = CoverageReporter(repoRoot, aggregatedCoverageReport, reportFormat)
       val (computedCoverageRatio, reportText) = reporter.generateRichTextReport()
 
       File(reportOutputPath).apply {
@@ -137,19 +137,50 @@ class RunCoverage(
         println("\nComputed Coverage Ratio is: $computedCoverageRatio")
         println("\nGenerated report at: $reportOutputPath\n")
       }
-    } ?: println("No coverage reports generated.")
-  }
 
-  private fun runCoverageForTarget(testTarget: String): CoverageReport {
-    return runBlocking {
-      CoverageRunner(rootDirectory, scriptBgDispatcher, commandExecutor)
-        .runWithCoverageAsync(testTarget.removeSuffix(".kt"))
-        .await()
+      println("COVERAGE ANALYSIS COMPLETED.")
     }
   }
 }
 
-private fun findTestFile(repoRoot: String, filePath: String): List<String> {
+private fun calculateAggregateCoverageReport(
+  coverageReports: List<CoverageReport>
+): CoverageReport {
+  fun aggregateCoverage(coverages: List<Coverage>): Coverage {
+    return coverages.find { it == Coverage.FULL } ?: Coverage.NONE
+  }
+
+  val groupedCoverageReports = coverageReports.groupBy {
+    Pair(it.filePath, it.fileSha1Hash)
+  }
+
+  val (key, reports) = groupedCoverageReports.entries.single()
+  val (filePath, fileSha1Hash) = key
+
+  val allBazelTestTargets = reports.flatMap { it.bazelTestTargetsList }
+  val allCoveredLines = reports.flatMap { it.coveredLineList }
+  val groupedCoveredLines = allCoveredLines.groupBy { it.lineNumber }
+  val aggregatedCoveredLines = groupedCoveredLines.map { (lineNumber, coveredLines) ->
+    CoveredLine.newBuilder()
+      .setLineNumber(lineNumber)
+      .setCoverage(aggregateCoverage(coveredLines.map { it.coverage }))
+      .build()
+  }
+
+  val totalLinesFound = aggregatedCoveredLines.size
+  val totalLinesHit = aggregatedCoveredLines.count { it.coverage == Coverage.FULL }
+
+  return CoverageReport.newBuilder()
+    .addAllBazelTestTargets(allBazelTestTargets)
+    .setFilePath(filePath)
+    .setFileSha1Hash(fileSha1Hash)
+    .addAllCoveredLine(aggregatedCoveredLines)
+    .setLinesFound(totalLinesFound)
+    .setLinesHit(totalLinesHit)
+    .build()
+}
+
+private fun findTestFiles(repoRoot: String, filePath: String): List<String> {
   val possibleTestFilePaths = when {
     filePath.startsWith("scripts/") -> {
       listOf(filePath.replace("/java/", "/javatests/").replace(".kt", "Test.kt"))

scripts/src/java/org/oppia/android/scripts/proto/coverage.proto

@@ -9,7 +9,7 @@ option java_multiple_files = true;
 // Bazel coverage execution.
 message CoverageReport {
   // The test target for which the coverage report is generated.
-  string bazel_test_target = 1;
+  repeated BazelTestTarget bazel_test_targets = 1;
   // The relative path of the covered file.
   string file_path = 2;
   // SHA-1 hash of the file content at the time of report (to guard against changes).
@@ -22,6 +22,12 @@ message CoverageReport {
   int32 lines_hit = 6;
 }
 
+// Represents a single bazel test target corresponding to a test file.
+message BazelTestTarget {
+  // The name of the bazel test target.
+  string test_target_name = 1;
+}
+
 // Information about a single line that was covered during the tests.
 message CoveredLine {
   // The line number of the covered line.
@@ -33,8 +39,8 @@ message CoveredLine {
 enum Coverage {
   // Coverage status is unspecified.
   UNSPECIFIED = 0;
-  // The line, branch, or function is fully covered, ie. executed atleast once.
+  // The line is fully covered in a test, that is, it was executed at least once.
   FULL = 1;
-  // The line, branch, or function is not covered at all.
+  // The line is not covered at all, that is, it was never executed during a test.
   NONE = 2;
 }