Fix part of #5343: Building proto with coverage results for data processing

scripts/src/java/org/oppia/android/scripts/coverage/BUILD.bazel

@@ -27,5 +27,6 @@ kt_jvm_library(
     visibility = ["//scripts:oppia_script_binary_visibility"],
     deps = [
         "//scripts/src/java/org/oppia/android/scripts/common:bazel_client",
+        "//scripts/src/java/org/oppia/android/scripts/proto:coverage_java_proto",
     ],
 )

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

@@ -6,7 +6,13 @@ 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.Coverage
+import org.oppia.android.scripts.proto.CoverageReport
+import org.oppia.android.scripts.proto.CoveredLine
 import java.io.File
+import java.nio.file.Files
+import java.nio.file.Paths
+import java.security.MessageDigest
 
 /**
  * Class responsible for running coverage analysis asynchronously.
@@ -30,9 +36,12 @@ class CoverageRunner(
    */
   fun runWithCoverageAsync(
     bazelTestTarget: String
-  ): Deferred<List<String>?> {
+  ): Deferred<CoverageReport> {
     return CoroutineScope(scriptBgDispatcher).async {
-      retrieveCoverageResult(bazelTestTarget)
+      val coverageResult = retrieveCoverageResult(bazelTestTarget)
+        ?: error("Failed to retrieve coverage result for $bazelTestTarget")
+
+      coverageDataFileLines(coverageResult, bazelTestTarget)
     }
   }
 
@@ -41,4 +50,67 @@ class CoverageRunner(
   ): List<String>? {
     return bazelClient.runCoverageForTestTarget(bazelTestTarget)
   }
+
+  private fun coverageDataFileLines(
+    coverageData: List<String>,
+    bazelTestTarget: String
+  ): CoverageReport {
+    val extractedFileName = "${extractTargetName(bazelTestTarget)}.kt"
+
+    val sfStartIdx = coverageData.indexOfFirst {
+      it.startsWith("SF:") && it.substringAfter("SF:").substringAfterLast("/") == extractedFileName
+    }
+    if (sfStartIdx == -1) throw IllegalArgumentException("File not found")
+    val eofIdx = coverageData.subList(sfStartIdx, coverageData.size).indexOfFirst {
+      it.startsWith("end_of_record")
+    }
+    if (eofIdx == -1) throw IllegalArgumentException("End of record not found")
+
+    val fileSpecificCovDatLines = coverageData.subList(sfStartIdx, sfStartIdx + eofIdx + 1)
+
+    val coverageDataProps = fileSpecificCovDatLines.groupBy { line ->
+      line.substringBefore(":")
+    }.mapValues { (_, lines) ->
+      lines.map { line ->
+        line.substringAfter(":").split(",")
+      }
+    }
+
+    val filePath = coverageDataProps["SF"]?.firstOrNull()?.get(0)
+      ?: throw IllegalArgumentException("File path not found")
+
+    val linesFound = coverageDataProps["LF"]?.singleOrNull()?.single()?.toInt() ?: 0
+    val linesHit = coverageDataProps["LH"]?.singleOrNull()?.single()?.toInt() ?: 0
+
+    val coveredLines = coverageDataProps["DA"]?.map { (lineNumStr, hitCountStr) ->
+      CoveredLine.newBuilder().apply {
+        this.lineNumber = lineNumStr.toInt()
+        this.coverage = if (hitCountStr.toInt() > 0) Coverage.FULL else Coverage.NONE
+      }.build()
+    }.orEmpty()
+
+    val file = File(repoRoot, filePath)
+    val fileSha1Hash = calculateSha1(file.absolutePath)
+
+    return CoverageReport.newBuilder()
+      .setBazelTestTarget(bazelTestTarget)
+      .setFilePath(filePath)
+      .setFileSha1Hash(fileSha1Hash)
+      .addAllCoveredLine(coveredLines)
+      .setLinesFound(linesFound)
+      .setLinesHit(linesHit)
+      .build()
+  }
+}
+
+private fun extractTargetName(bazelTestTarget: String): String {
+  val targetName = bazelTestTarget.substringAfterLast(":").trim()
+  return targetName.removeSuffix("LocalTest").removeSuffix("Test")
+}
+
+private fun calculateSha1(filePath: String): String {
+  val fileBytes = Files.readAllBytes(Paths.get(filePath))
+  val digest = MessageDigest.getInstance("SHA-1")
+  val hashBytes = digest.digest(fileBytes)
+  return hashBytes.joinToString("") { "%02x".format(it) }
 }

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

@@ -5,6 +5,7 @@ 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.CoverageReport
 import org.oppia.android.scripts.proto.TestFileExemptions
 import java.io.File
 import java.util.concurrent.TimeUnit
@@ -78,7 +79,7 @@ class RunCoverage(
    * @return a list of lists containing coverage data for each requested test target, if
    *     the file is exempted from having a test file, an empty list is returned
    */
-  fun execute(): List<List<String>> {
+  fun execute(): List<CoverageReport> {
     val testFileExemptionList = loadTestFileExemptionsProto(testFileExemptionTextProto)
       .testFileExemptionList
       .filter { it.testFileNotRequired }
@@ -97,15 +98,11 @@ class RunCoverage(
     val testTargets = bazelClient.retrieveBazelTargets(testFilePaths)
 
     return testTargets.mapNotNull { testTarget ->
-      val coverageData = runCoverageForTarget(testTarget)
-      if (coverageData == null) {
-        println("Coverage data for $testTarget is null")
-      }
-      coverageData
+      runCoverageForTarget(testTarget)
     }
   }
 
-  private fun runCoverageForTarget(testTarget: String): List<String>? {
+  private fun runCoverageForTarget(testTarget: String): CoverageReport {
     return runBlocking {
       CoverageRunner(rootDirectory, scriptBgDispatcher, commandExecutor)
         .runWithCoverageAsync(testTarget.removeSuffix(".kt"))

scripts/src/java/org/oppia/android/scripts/proto/BUILD.bazel

@@ -21,6 +21,17 @@ java_proto_library(
     deps = [":affected_tests_proto"],
 )
 
+oppia_proto_library(
+    name = "coverage_proto",
+    srcs = ["coverage.proto"],
+)
+
+java_proto_library(
+    name = "coverage_java_proto",
+    visibility = ["//scripts:oppia_script_library_visibility"],
+    deps = [":coverage_proto"],
+)
+
 oppia_proto_library(
     name = "filename_pattern_validation_checks_proto",
     srcs = ["filename_pattern_validation_checks.proto"],

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

@@ -0,0 +1,40 @@
+syntax = "proto3";
+
+package proto;
+
+option java_package = "org.oppia.android.scripts.proto";
+option java_multiple_files = true;
+
+// Coverage Report that contains the bazel coverage data retrieved from the
+// Bazel coverage execution.
+message CoverageReport {
+  // The test target for which the coverage report is generated.
+  string bazel_test_target = 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).
+  string file_sha1_hash = 3;
+  // The lines of code covered in the report.
+  repeated CoveredLine covered_line = 4;
+  // The total number of lines found in the covered file.
+  int32 lines_found = 5;
+  // The total number of lines hit in the covered file.
+  int32 lines_hit = 6;
+}
+
+// Information about a single line that was covered during the tests.
+message CoveredLine {
+  // The line number of the covered line.
+  int32 line_number = 1;
+  // The coverage status of the covered line.
+  Coverage coverage = 2;
+}
+
+enum Coverage {
+  // Coverage status is unspecified.
+  UNSPECIFIED = 0;
+  // The line, branch, or function is fully covered, ie. executed atleast once.
+  FULL = 1;
+  // The line, branch, or function is not covered at all.
+  NONE = 2;
+}

scripts/src/java/org/oppia/android/scripts/testing/TestBazelWorkspace.kt

@@ -62,6 +62,7 @@ class TestBazelWorkspace(private val temporaryRootFolder: TemporaryFolder) {
    */
   fun addSourceAndTestFileWithContent(
     filename: String,
+    testFilename: String,
     sourceContent: String,
     testContent: String,
     sourceSubpackage: String,
@@ -73,10 +74,9 @@ class TestBazelWorkspace(private val temporaryRootFolder: TemporaryFolder) {
       sourceSubpackage
     )
 
-    val testFileName = "${filename}Test"
     addTestContentAndBuildFile(
       filename,
-      testFileName,
+      testFilename,
       testContent,
       sourceSubpackage,
       testSubpackage

scripts/src/javatests/org/oppia/android/scripts/common/BazelClientTest.kt

@@ -422,6 +422,7 @@ class BazelClientTest {
 
     testBazelWorkspace.addSourceAndTestFileWithContent(
       filename = "TwoSum",
+      testFilename = "TwoSumTest",
       sourceContent = sourceContent,
       testContent = testContent,
       sourceSubpackage = "coverage/main/java/com/example",

scripts/src/javatests/org/oppia/android/scripts/coverage/CoverageRunnerTest.kt

@@ -9,6 +9,9 @@ import org.junit.Test
 import org.junit.rules.TemporaryFolder
 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.testing.TestBazelWorkspace
 import org.oppia.android.testing.assertThrows
 import java.util.concurrent.TimeUnit
@@ -103,6 +106,7 @@ class CoverageRunnerTest {
 
     testBazelWorkspace.addSourceAndTestFileWithContent(
       filename = "TwoSum",
+      testFilename = "TwoSumTest",
       sourceContent = sourceContent,
       testContent = testContent,
       sourceSubpackage = "coverage/main/java/com/example",
@@ -114,28 +118,38 @@ class CoverageRunnerTest {
         "//coverage/test/java/com/example:TwoSumTest"
       ).await()
     }
-    val expectedResult = listOf(
-      "SF:coverage/main/java/com/example/TwoSum.kt",
-      "FN:7,com/example/TwoSum${'$'}Companion::sumNumbers (II)Ljava/lang/Object;",
-      "FN:3,com/example/TwoSum::<init> ()V",
-      "FNDA:1,com/example/TwoSum${'$'}Companion::sumNumbers (II)Ljava/lang/Object;",
-      "FNDA:0,com/example/TwoSum::<init> ()V",
-      "FNF:2",
-      "FNH:1",
-      "BRDA:7,0,0,1",
-      "BRDA:7,0,1,1",
-      "BRDA:7,0,2,1",
-      "BRDA:7,0,3,1",
-      "BRF:4",
-      "BRH:4",
-      "DA:3,0",
-      "DA:7,1",
-      "DA:8,1",
-      "DA:10,1",
-      "LH:3",
-      "LF:4",
-      "end_of_record"
-    )
+
+    val expectedResult = CoverageReport.newBuilder()
+      .setBazelTestTarget("//coverage/test/java/com/example:TwoSumTest")
+      .setFilePath("coverage/main/java/com/example/TwoSum.kt")
+      .setFileSha1Hash("f6fb075e115775f6729615a79f0e7e34fe9735b5")
+      .addCoveredLine(
+        CoveredLine.newBuilder()
+          .setLineNumber(3)
+          .setCoverage(Coverage.NONE)
+          .build()
+      )
+      .addCoveredLine(
+        CoveredLine.newBuilder()
+          .setLineNumber(7)
+          .setCoverage(Coverage.FULL)
+          .build()
+      )
+      .addCoveredLine(
+        CoveredLine.newBuilder()
+          .setLineNumber(8)
+          .setCoverage(Coverage.FULL)
+          .build()
+      )
+      .addCoveredLine(
+        CoveredLine.newBuilder()
+          .setLineNumber(10)
+          .setCoverage(Coverage.FULL)
+          .build()
+      )
+      .setLinesFound(4)
+      .setLinesHit(3)
+      .build()
 
     assertThat(result).isEqualTo(expectedResult)
   }