fix: take branch coverage into account in the diff coverage

Author: ideepu

codecov/coverage/base.py

@@ -73,10 +73,26 @@ class DiffCoverage:
 
 
 class BaseCoverage(ABC):
-    def compute_coverage(self, num_covered: int, num_total: int) -> decimal.Decimal:
-        if num_total == 0:
+    def convert_to_decimal(self, value: float | decimal.Decimal, precision: int = 2) -> decimal.Decimal:
+        if not isinstance(value, decimal.Decimal):
+            value = decimal.Decimal(str(float(value) / 100))
+        return value.quantize(
+            exp=decimal.Decimal(10) ** -precision,
+            rounding=decimal.ROUND_DOWN,
+        )
+
+    def compute_coverage(
+        self,
+        num_covered: int,
+        num_total: int,
+        num_branches_covered: int = 0,
+        num_branches_total: int = 0,
+    ) -> decimal.Decimal:
+        numerator = decimal.Decimal(num_covered + num_branches_covered)
+        denominator = decimal.Decimal(num_total + num_branches_total)
+        if denominator == 0:
             return decimal.Decimal('1')
-        return decimal.Decimal(num_covered) / decimal.Decimal(num_total)
+        return numerator / denominator
 
     def get_coverage_info(self, coverage_path: pathlib.Path) -> Coverage:
         try:
@@ -99,6 +115,7 @@ def get_diff_coverage_info(  # pylint: disable=too-many-locals
         self,
         added_lines: dict[pathlib.Path, list[int]],
         coverage: Coverage,
+        branch_coverage: bool = False,
     ) -> DiffCoverage:
         files = {}
         total_num_lines = 0
@@ -126,7 +143,15 @@ def get_diff_coverage_info(  # pylint: disable=too-many-locals
             total_num_lines += count_total
             total_num_violations += count_missing
 
-            percent_covered = self.compute_coverage(num_covered=count_executed, num_total=count_total)
+            if branch_coverage:
+                percent_covered = self.compute_coverage(
+                    num_covered=count_executed,
+                    num_total=count_total,
+                    num_branches_covered=file.info.covered_branches or 0,
+                    num_branches_total=file.info.num_branches or 0,
+                )
+            else:
+                percent_covered = self.compute_coverage(num_covered=count_executed, num_total=count_total)
 
             files[path] = FileDiffCoverage(
                 path=path,
@@ -136,10 +161,18 @@ def get_diff_coverage_info(  # pylint: disable=too-many-locals
                 added_statements=sorted(added),
                 added_lines=added_lines_for_file,
             )
-        final_percentage = self.compute_coverage(
-            num_covered=total_num_lines - total_num_violations,
-            num_total=total_num_lines,
-        )
+        if branch_coverage:
+            final_percentage = self.compute_coverage(
+                num_covered=total_num_lines - total_num_violations,
+                num_total=total_num_lines,
+                num_branches_covered=coverage.info.covered_branches or 0,
+                num_branches_total=coverage.info.num_branches or 0,
+            )
+        else:
+            final_percentage = self.compute_coverage(
+                num_covered=total_num_lines - total_num_violations,
+                num_total=total_num_lines,
+            )
 
         return DiffCoverage(
             total_num_lines=total_num_lines,

codecov/coverage/pytest.py

@@ -1,16 +1,12 @@
 from __future__ import annotations
 
 import datetime
-import decimal
 import pathlib
 
 from codecov.coverage.base import BaseCoverage, Coverage, CoverageInfo, CoverageMetadata, FileCoverage
 
 
 class PytestCoverage(BaseCoverage):
-    def _convert_to_decimal(self, value: float, precision: int = 2) -> decimal.Decimal:
-        return decimal.Decimal(str(float(value) / 100)).quantize(decimal.Decimal(10) ** -precision)
-
     def extract_info(self, data: dict) -> Coverage:
         """
         {
@@ -73,7 +69,7 @@ def extract_info(self, data: dict) -> Coverage:
                     info=CoverageInfo(
                         covered_lines=file_data['summary']['covered_lines'],
                         num_statements=file_data['summary']['num_statements'],
-                        percent_covered=self._convert_to_decimal(file_data['summary']['percent_covered']),
+                        percent_covered=self.convert_to_decimal(file_data['summary']['percent_covered']),
                         percent_covered_display=file_data['summary']['percent_covered_display'],
                         missing_lines=file_data['summary']['missing_lines'],
                         excluded_lines=file_data['summary']['excluded_lines'],
@@ -88,7 +84,7 @@ def extract_info(self, data: dict) -> Coverage:
             info=CoverageInfo(
                 covered_lines=data['totals']['covered_lines'],
                 num_statements=data['totals']['num_statements'],
-                percent_covered=self._convert_to_decimal(data['totals']['percent_covered']),
+                percent_covered=self.convert_to_decimal(data['totals']['percent_covered']),
                 percent_covered_display=data['totals']['percent_covered_display'],
                 missing_lines=data['totals']['missing_lines'],
                 excluded_lines=data['totals']['excluded_lines'],

codecov/main.py

@@ -62,7 +62,11 @@ def _process_coverage(self):
         if self.config.BRANCH_COVERAGE:
             coverage = diff_grouper.fill_branch_missing_groups(coverage=coverage)
         added_lines = GithubDiffParser(diff=self.github.pr_diff).parse()
-        diff_coverage = self.coverage_module.get_diff_coverage_info(added_lines=added_lines, coverage=coverage)
+        diff_coverage = self.coverage_module.get_diff_coverage_info(
+            added_lines=added_lines,
+            coverage=coverage,
+            branch_coverage=self.config.BRANCH_COVERAGE,
+        )
         self.coverage = coverage
         self.diff_coverage = diff_coverage
 
@@ -86,24 +90,24 @@ def _process_pr(self):
         )
         try:
             comment = template.get_comment_markdown(
-                coverage=self.coverage,
-                diff_coverage=self.diff_coverage,
-                files=files_info,
-                count_files=count_files,
-                coverage_files=coverage_files_info,
-                count_coverage_files=count_coverage_files,
-                max_files=self.config.MAX_FILES_IN_COMMENT,
-                minimum_green=self.config.MINIMUM_GREEN,
-                minimum_orange=self.config.MINIMUM_ORANGE,
-                repo_name=self.config.GITHUB_REPOSITORY,
-                pr_number=self.github.pr_number,
-                base_ref=self.github.base_ref,
-                base_template=template.read_template_file('comment.md.j2'),
-                marker=marker,
+                template.read_template_file('comment.md.j2'),
+                self.coverage,
+                self.diff_coverage,
+                self.config.MINIMUM_GREEN,
+                self.config.MINIMUM_ORANGE,
+                self.config.GITHUB_REPOSITORY,
+                self.github.pr_number,
+                self.github.base_ref,
+                marker,
                 subproject_id=self.config.SUBPROJECT_ID,
                 branch_coverage=self.config.BRANCH_COVERAGE,
                 complete_project_report=self.config.COMPLETE_PROJECT_REPORT,
                 coverage_report_url=self.config.COVERAGE_REPORT_URL,
+                max_files=self.config.MAX_FILES_IN_COMMENT,
+                files=files_info,
+                count_files=count_files,
+                coverage_files=coverage_files_info,
+                count_coverage_files=count_coverage_files,
             )
         except MissingMarker as e:
             log.error(

codecov/template.py

@@ -7,6 +7,7 @@
 import itertools
 import pathlib
 from importlib import resources
+from typing import Any
 
 import jinja2
 from jinja2.sandbox import SandboxedEnvironment
@@ -61,24 +62,17 @@ class FileInfo:
 
 
 def get_comment_markdown(  # pylint: disable=too-many-arguments,too-many-locals,too-many-positional-arguments
+    base_template: str,
     coverage: Coverage,
     diff_coverage: DiffCoverage,
-    files: list[FileInfo],
-    count_files: int,
-    coverage_files: list[FileInfo],
-    count_coverage_files: int,
-    max_files: int | None,
     minimum_green: decimal.Decimal,
     minimum_orange: decimal.Decimal,
     repo_name: str,
     pr_number: int,
     base_ref: str,
-    base_template: str,
     marker: str,
-    subproject_id: str | None = None,
-    branch_coverage: bool = False,
-    complete_project_report: bool = False,
-    coverage_report_url: str | None = None,
+    /,
+    **kwargs: Any,
 ):
     env = SandboxedEnvironment(loader=jinja2.FileSystemLoader('codecov/template_files/'))
     env.filters['pct'] = pct
@@ -116,18 +110,10 @@ def get_comment_markdown(  # pylint: disable=too-many-arguments,too-many-locals,
         comment = env.from_string(base_template).render(
             coverage=coverage,
             diff_coverage=diff_coverage,
-            max_files=max_files,
-            files=files,
-            count_files=count_files,
-            coverage_files=coverage_files,
-            count_coverage_files=count_coverage_files,
             missing_diff_lines=missing_diff_lines,
             missing_lines_for_whole_project=missing_lines_for_whole_project,
-            subproject_id=subproject_id,
             marker=marker,
-            branch_coverage=branch_coverage,
-            complete_project_report=complete_project_report,
-            coverage_report_url=coverage_report_url,
+            **kwargs,
         )
     except jinja2.exceptions.TemplateError as exc:
         log.error('Template rendering error: %s', str(exc))

tests/coverage/test_pytest.py

@@ -24,7 +24,7 @@ def test_extract_info(self, coverage_json):
                     info=CoverageInfo(
                         covered_lines=6,
                         num_statements=10,
-                        percent_covered=PytestCoverage()._convert_to_decimal(60.0),
+                        percent_covered=PytestCoverage().convert_to_decimal(60.0),
                         percent_covered_display='60%',
                         missing_lines=4,
                         excluded_lines=0,
@@ -40,7 +40,7 @@ def test_extract_info(self, coverage_json):
             info=CoverageInfo(
                 covered_lines=6,
                 num_statements=10,
-                percent_covered=PytestCoverage()._convert_to_decimal(60.0),
+                percent_covered=PytestCoverage().convert_to_decimal(60.0),
                 percent_covered_display='60%',
                 missing_lines=4,
                 excluded_lines=0,