Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
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.pyindex 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 annotationsimport jsonfrom 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)+ continuepath = _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 filediff --git a/packages/core/src/repowise/core/analysis/health/coverage/detector.py b/packages/core/src/repowise/core/analysis/health/coverage/detector.pyindex 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 entrieswith ``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 filediff --git a/packages/core/src/repowise/core/analysis/health/coverage/discovery.py b/packages/core/src/repowise/core/analysis/health/coverage/discovery.pyindex 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.0if src.branch_coverage_pct is not None:dst.branch_coverage_pct = (src.branch_coverage_pctdiff --git a/tests/fixtures/coverage/sample.apex-deploy.json b/tests/fixtures/coverage/sample.apex-deploy.jsonnew file mode 100644index 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 filediff --git a/tests/unit/health/test_coverage_apex.py b/tests/unit/health/test_coverage_apex.pyindex 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 Noneassert 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_contextsdef 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