Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

feat(coverage): read Apex deploy coverage reports (#4446)

Omishaac33aeb47554
diff --git a/packages/core/src/repowise/core/analysis/health/coverage/apex.py b/packages/core/src/repowise/core/analysis/health/coverage/apex.py
index 2d70ed6c2..f031f9676 100644
--- a/packages/core/src/repowise/core/analysis/health/coverage/apex.py
+++ b/packages/core/src/repowise/core/analysis/health/coverage/apex.py
@@ -23,6 +23,15 @@ is one test method's coverage of one class or trigger (``ApexCodeCoverage``)::
"ApexClassOrTrigger": {"Id": "01p...", "Name": "AccountService"},
"Coverage": {"coveredLines": [3, 4], "uncoveredLines": [8]}}
+- a deploy or validation result (``sf project deploy start --test-level ...
+ --json``), whose ``result.details.runTestResult.codeCoverage`` is a list, or
+ one object when a single class was covered, of counts only::
+
+ {"name": "AccountService", "type": "Class",
+ "numLocations": "28", "numLocationsNotCovered": "6"}
+
+ Counts may be strings. No line sets are stated, so none are reported.
+
Names are API names, never file paths: the file path is the name plus
``.cls`` for an ``ApexClass`` id (``01p`` prefix) or ``.trigger`` for an
``ApexTrigger`` id (``01q``), and the resolver maps that to the one file of
@@ -35,7 +44,13 @@ from __future__ import annotations
import json
from typing import Any
-from .model import ContextCoverageReport, CoverageReport, TestCoverage, file_coverage
+from .model import (
+ ContextCoverageReport,
+ CoverageReport,
+ FileCoverage,
+ TestCoverage,
+ file_coverage,
+)
#: Salesforce key prefixes of the two Apex metadata types coverage names.
_EXT_BY_ID_PREFIX = {"01p": ".cls", "01q": ".trigger"}
@@ -47,6 +62,14 @@ def _dicts(value: Any) -> list[dict]:
return [v for v in value if isinstance(v, dict)] if isinstance(value, list) else []
+def _deploy_entries(result: dict) -> list[dict]:
+ """``details.runTestResult.codeCoverage`` of a deploy result: a list, or one object."""
+ details = result.get("details")
+ run = details.get("runTestResult") if isinstance(details, dict) else None
+ cc = run.get("codeCoverage") if isinstance(run, dict) else None
+ return _dicts([cc] if isinstance(cc, dict) else cc)
+
+
def _load(text: str) -> tuple[list[dict], list[dict]]:
"""``(entries, records)`` from any of the CLI's JSON shapes, empty when unreadable."""
try:
@@ -56,10 +79,13 @@ def _load(text: str) -> tuple[list[dict], list[dict]]:
if isinstance(data, list):
return _dicts(data), []
result = data.get("result", data) if isinstance(data, dict) else None
- coverage = result.get("coverage") if isinstance(result, dict) else None
- if not isinstance(coverage, dict):
+ if not isinstance(result, dict):
return [], []
- return _dicts(coverage.get("coverage")), _dicts(coverage.get("records"))
+ deploy = _deploy_entries(result)
+ coverage = result.get("coverage")
+ if not isinstance(coverage, dict):
+ return deploy, []
+ return _dicts(coverage.get("coverage")) + deploy, _dicts(coverage.get("records"))
def _apex_path(name: Any, sf_id: Any) -> str | None:
@@ -76,11 +102,58 @@ def _lines(raw: Any) -> list[int]:
return [n for n in raw if isinstance(n, int) and not isinstance(n, bool) and n > 0]
+def _count(value: Any) -> int | None:
+ """A Salesforce count, which the metadata API sends as a string or a number."""
+ if isinstance(value, bool):
+ return None
+ if isinstance(value, (int, float)):
+ return int(value)
+ if isinstance(value, str):
+ try:
+ return int(value.strip())
+ except ValueError:
+ return None
+ return None
+
+
+def _deploy_path(entry: dict) -> str | None:
+ """``Name.trigger`` for a ``Trigger`` entry, ``Name.cls`` for a class."""
+ name = entry.get("name")
+ kind = entry.get("type")
+ if not isinstance(kind, str):
+ return _apex_path(name, entry.get("id"))
+ if not isinstance(name, str) or not name.strip():
+ return None
+ return name.strip() + (".trigger" if kind.strip().lower() == "trigger" else ".cls")
+
+
+def parse_deploy_entry(entry: dict) -> FileCoverage | None:
+ """One deploy ``codeCoverage`` entry as counts only, ``None`` when nothing is measurable.
+
+ The payload states ``numLocations`` and ``numLocationsNotCovered`` and no
+ covered-line list, so the line sets stay empty ("not stated", see
+ ``FileCoverage``) rather than being invented.
+ """
+ path = _deploy_path(entry)
+ total = _count(entry.get("numLocations"))
+ missed = _count(entry.get("numLocationsNotCovered"))
+ # Zero locations (an interface, say) has nothing to measure.
+ if path is None or total is None or missed is None or total <= 0:
+ return None
+ missed = min(max(missed, 0), total)
+ return file_coverage(path, [], [], total=total, hit=total - missed)
+
+
def parse_apex(text: str) -> CoverageReport:
"""Per-class aggregate coverage from Salesforce CLI JSON."""
entries, _ = _load(text)
files = []
for entry in entries:
+ if "numLocations" in entry:
+ deployed = parse_deploy_entry(entry)
+ if deployed is not None:
+ files.append(deployed)
+ continue
path = _apex_path(entry.get("name"), entry.get("id"))
lines = entry.get("lines")
if path is None or not isinstance(lines, dict):
@@ -134,4 +207,4 @@ def parse_apex_contexts(text: str) -> ContextCoverageReport:
test_file=f"{class_name}.cls",
)
)
- return ContextCoverageReport(source_format="apex", records=records, has_contexts=bool(records))
+ return ContextCoverageReport(source_format="apex", records=records, has_contexts=bool(records))
\ No newline at end of file
diff --git a/packages/core/src/repowise/core/analysis/health/coverage/detector.py b/packages/core/src/repowise/core/analysis/health/coverage/detector.py
index 34150a62a..642ad9550 100644
--- a/packages/core/src/repowise/core/analysis/health/coverage/detector.py
+++ b/packages/core/src/repowise/core/analysis/health/coverage/detector.py
@@ -21,7 +21,8 @@ Sniffing rules (cheap, deterministic), after stripping a UTF-8 BOM:
- JaCoCo XML declares the ``-//JACOCO//DTD`` doctype or has a ``<report``
root (and no ``<coverage`` element).
- Salesforce Apex JSON is a ``{`` result naming ``orgWideCoverage``,
- ``testRunCoverage`` or ``ApexClassOrTrigger``, or a ``[`` list of entries
+ ``testRunCoverage`` or ``ApexClassOrTrigger``, or a deploy result naming
+ ``runTestResult`` or ``numLocationsNotCovered``, or a ``[`` list of entries
with ``totalLines`` and ``lines`` (``test-result-codecoverage.json``).
If detection is ambiguous, callers can pass ``coverage add --format`` to
@@ -99,11 +100,19 @@ def _is_repowise_json(sample: str) -> bool:
def _is_apex(sample: str) -> bool:
- # The CLI's result opens with a summary naming the coverage percentages; the
- # bare entry list opens with the first class's ``totalLines`` and ``lines``.
+ # The CLI's result opens with a summary naming the coverage percentages; a
+ # deploy result names ``runTestResult`` or per-class ``numLocationsNotCovered``;
+ # the bare entry list opens with the first class's ``totalLines`` and ``lines``.
if sample.startswith("{"):
return any(
- k in sample for k in ('"orgWideCoverage"', '"testRunCoverage"', '"ApexClassOrTrigger"')
+ k in sample
+ for k in (
+ '"orgWideCoverage"',
+ '"testRunCoverage"',
+ '"ApexClassOrTrigger"',
+ '"runTestResult"',
+ '"numLocationsNotCovered"',
+ )
)
return sample.startswith("[") and '"totalLines"' in sample and '"lines"' in sample
@@ -184,4 +193,4 @@ def is_test_file(
head = source[:4096]
if any(token in head for token in _FRAMEWORK_IMPORTS):
return True
- return False
+ return False
\ No newline at end of file
diff --git a/packages/core/src/repowise/core/analysis/health/coverage/discovery.py b/packages/core/src/repowise/core/analysis/health/coverage/discovery.py
index aaf56afd4..9661b2deb 100644
--- a/packages/core/src/repowise/core/analysis/health/coverage/discovery.py
+++ b/packages/core/src/repowise/core/analysis/health/coverage/discovery.py
@@ -993,11 +993,19 @@ def _merge_into(dst: FileCoverage, src: FileCoverage) -> None:
covered = set(dst.covered_lines) | set(src.covered_lines)
coverable = set(dst.coverable_lines) | set(src.coverable_lines)
total = max(dst.total_coverable_lines, src.total_coverable_lines, len(covered))
+ # A counts-only report (a deploy result) states how many lines were hit but
+ # not which, so its line set is empty. Keep the larger stated count rather
+ # than recounting from the sets alone. A count of None means the source
+ # stated only a percentage, so it adds nothing here.
+ hit = min(
+ max(len(covered), dst.covered_line_count or 0, src.covered_line_count or 0),
+ total,
+ )
dst.covered_lines = sorted(covered)
dst.coverable_lines = sorted(coverable)
dst.total_coverable_lines = total
- dst.covered_line_count = len(covered)
- dst.line_coverage_pct = round(len(covered) / total * 100.0, 2) if total else 0.0
+ dst.covered_line_count = hit
+ dst.line_coverage_pct = round(hit / total * 100.0, 2) if total else 0.0
if src.branch_coverage_pct is not None:
dst.branch_coverage_pct = (
src.branch_coverage_pct
diff --git a/tests/fixtures/coverage/sample.apex-deploy.json b/tests/fixtures/coverage/sample.apex-deploy.json
new file mode 100644
index 000000000..ddc09b1f8
--- /dev/null
+++ b/tests/fixtures/coverage/sample.apex-deploy.json
@@ -0,0 +1,44 @@
+{
+ "status": 0,
+ "result": {
+ "details": {
+ "runTestResult": {
+ "numTestsRun": "3",
+ "codeCoverage": [
+ {
+ "id": "01p000000000001AAA",
+ "name": "AccountService",
+ "type": "Class",
+ "numLocations": "28",
+ "numLocationsNotCovered": "6",
+ "locationsNotCovered": [
+ {"line": "18", "column": "0", "numExecutions": "0", "time": "0"}
+ ]
+ },
+ {
+ "id": "01q000000000001AAA",
+ "name": "AccountTrigger",
+ "type": "Trigger",
+ "numLocations": "10",
+ "numLocationsNotCovered": 4
+ },
+ {
+ "id": "01p000000000002AAA",
+ "name": "FullyCovered",
+ "type": "Class",
+ "numLocations": 12,
+ "numLocationsNotCovered": 0
+ },
+ {
+ "id": "01p000000000003AAA",
+ "name": "IAccountService",
+ "type": "Class",
+ "numLocations": "0",
+ "numLocationsNotCovered": "0"
+ }
+ ]
+ }
+ }
+ },
+ "warnings": []
+}
\ No newline at end of file
diff --git a/tests/unit/health/test_coverage_apex.py b/tests/unit/health/test_coverage_apex.py
index 011db8908..4a34eb672 100644
--- a/tests/unit/health/test_coverage_apex.py
+++ b/tests/unit/health/test_coverage_apex.py
@@ -17,7 +17,12 @@ from repowise.core.analysis.health.coverage import (
resolve_reports,
resolve_test_reports,
)
-from repowise.core.analysis.health.coverage.model import CoverageReport, FileCoverage
+from repowise.core.analysis.health.coverage.discovery import _merge_into
+from repowise.core.analysis.health.coverage.model import (
+ CoverageReport,
+ FileCoverage,
+ file_coverage,
+)
FIXTURES = Path(__file__).resolve().parents[2] / "fixtures" / "coverage"
CLASSES = "force-app/main/default/classes"
@@ -90,21 +95,71 @@ def test_per_test_records() -> None:
assert not parse_apex_contexts(_read("sample.apex-codecoverage.json")).has_contexts
[email protected]("name", ["sample.apex.json", "sample.apex-codecoverage.json"])
+ "name", ["sample.apex.json", "sample.apex-codecoverage.json", "sample.apex-deploy.json"]
+)
def test_detect_and_dispatch(name: str) -> None:
assert detect_format(_read(name)) == "apex"
- assert detect_format("" + _read(name)) == "apex"
- assert parse("" + _read(name)).source_format == "apex"
+ assert detect_format("\ufeff" + _read(name)) == "apex"
+ assert parse("\ufeff" + _read(name)).source_format == "apex"
def test_detect_needs_the_cli_markers() -> None:
assert detect_format('{"result": {"summary": {"outcome": "Passed"}}}') is None
assert detect_format('[{"name": "x", "lines": {}}]') is None
+ assert detect_format('{"result": {"details": {"componentSuccesses": []}}}') is None
+
+
+def test_deploy_result_percentages_and_extensions() -> None:
+ report = parse(_read("sample.apex-deploy.json"))
+ assert report.source_format == "apex"
+ by_path = {f.file_path: f for f in report.files}
+ # The zero-location interface is skipped, not stored as 0%.
+ assert set(by_path) == {"AccountService.cls", "AccountTrigger.trigger", "FullyCovered.cls"}
+ svc = by_path["AccountService.cls"]
+ assert svc.line_coverage_pct == pytest.approx(78.57)
+ assert (svc.total_coverable_lines, svc.covered_line_count) == (28, 22)
+ assert by_path["AccountTrigger.trigger"].line_coverage_pct == pytest.approx(60.0)
+ assert by_path["FullyCovered.cls"].line_coverage_pct == pytest.approx(100.0)
+
+
+def test_deploy_result_states_counts_only() -> None:
+ for fc in parse_apex(_read("sample.apex-deploy.json")).files:
+ # No covered-line list in the payload: left empty, never invented.
+ assert fc.covered_lines == [] and fc.coverable_lines == []
+ assert fc.branch_coverage_pct is None
+
+
+def test_deploy_single_object_entry() -> None:
+ text = (
+ '{"result": {"details": {"runTestResult": {"codeCoverage": '
+ '{"name": "Solo", "type": "Class", "numLocations": "4", "numLocationsNotCovered": "1"}'
+ "}}}}"
+ )
+ assert detect_format(text) == "apex"
+ report = parse(text)
+ assert [(f.file_path, f.line_coverage_pct) for f in report.files] == [("Solo.cls", 75.0)]
+
+
+def test_deploy_bad_counts_are_skipped() -> None:
+ text = (
+ '{"result": {"details": {"runTestResult": {"codeCoverage": ['
+ '{"name": "A", "type": "Class", "numLocations": "x", "numLocationsNotCovered": "1"},'
+ '{"name": "B", "type": "Class", "numLocations": "5"},'
+ '{"name": "C", "type": "Class", "numLocations": "5", "numLocationsNotCovered": "9"}'
+ "]}}}}"
+ )
+ # C is clamped to 0% rather than going negative.
+ assert [(f.file_path, f.line_coverage_pct) for f in parse_apex(text).files] == [("C.cls", 0.0)]
+
+
+def test_deploy_result_has_no_per_test_records() -> None:
+ assert not parse_apex_contexts(_read("sample.apex-deploy.json")).has_contexts
def test_parse_contexts_file_reads_apex(tmp_path: Path) -> None:
path = tmp_path / "test-result-7070000000ABCDE.json"
- path.write_text("" + _read("sample.apex.json"), encoding="utf-8")
+ path.write_text("\ufeff" + _read("sample.apex.json"), encoding="utf-8")
report = parse_contexts_file(path)
assert report.source_format == "apex"
assert len(report.records) == 2
@@ -202,3 +257,44 @@ def test_test_file_stays_unset_when_the_test_class_does_not_resolve() -> None:
res = resolve_test_reports(parse_apex_contexts(text), KEYS)
assert [r.test_file for r in res.records] == [None, None]
assert res.test_files_resolved == 0
+
+
+def test_merge_two_counts_only_entries_keeps_stated_count() -> None:
+ a = file_coverage("AccountService.cls", [], [], total=28, hit=22)
+ b = file_coverage("AccountService.cls", [], [], total=28, hit=22)
+ _merge_into(a, b)
+ assert a.covered_line_count == 22
+ assert a.line_coverage_pct == pytest.approx(78.57)
+
+
+def test_merge_counts_only_with_line_sets_does_not_lose_hits() -> None:
+ counts = file_coverage("AccountService.cls", [], [], total=28, hit=22)
+ lines = file_coverage("AccountService.cls", [1, 2, 3], list(range(1, 29)))
+ _merge_into(lines, counts)
+ assert lines.covered_line_count == 22
+ assert lines.total_coverable_lines == 28
+
+
+def test_merge_order_does_not_matter() -> None:
+ counts = file_coverage("AccountService.cls", [], [], total=28, hit=22)
+ lines = file_coverage("AccountService.cls", [1, 2, 3], list(range(1, 29)))
+ _merge_into(counts, lines)
+ assert counts.covered_line_count == 22
+ assert counts.line_coverage_pct == pytest.approx(78.57)
+
+
+def test_merge_with_percentage_only_source_still_works() -> None:
+ a = file_coverage("A.cls", [1, 2], [1, 2, 3, 4])
+ b = file_coverage("A.cls", [], [], total=4)
+ # A percentage-only source states no hit count at all.
+ b.covered_line_count = None
+ _merge_into(a, b)
+ assert a.covered_line_count == 2
+
+
+def test_two_deploy_reports_for_one_class_keep_their_percentage() -> None:
+ keys = {"force-app/main/default/classes/AccountService.cls"}
+ text = _read("sample.apex-deploy.json")
+ res = resolve_reports([parse_apex(text), parse_apex(text)], keys)
+ entry = res.coverage_map["force-app/main/default/classes/AccountService.cls"]
+ assert entry["line_coverage_pct"] == pytest.approx(78.57)
\ No newline at end of file