feat(test): conservative coverage selection ladder

Author: sbryngelson

toolchain/mfc/test/coverage.py

@@ -67,3 +67,51 @@ def load_map(path: Path) -> Tuple[Optional[dict], Optional[dict]]:
         return None, None
     meta = data.pop("_meta")
     return data, meta
+
+
+def _covered_fpp(coverage_map: dict) -> set:
+    files = set()
+    for cov in coverage_map.values():
+        files.update(cov)
+    return files
+
+
+def select_tests(cases, coverage_map, changed_files):
+    """Return (to_run, skipped, reason). Conservative ladder -- only over-includes.
+
+    `cases` items expose `.coverage_key()`. `changed_files` is a set of repo-relative
+    paths, or None if detection failed.
+    """
+    # Rung 1: no changed-file info -> run all.
+    if changed_files is None:
+        return list(cases), [], "rung1: changed-file list unavailable"
+
+    # Rung 2: macro/codegen/build inputs -> run all.
+    if is_always_run_all(changed_files):
+        return list(cases), [], "rung2: macro/codegen/build input changed"
+
+    # Rung 3: changed .f90/.f under src/ (map tracks .fpp only) -> run all.
+    if any(f.startswith("src/") and f.endswith((".f90", ".f")) for f in changed_files):
+        return list(cases), [], "rung3: hand-written .f90/.f changed"
+
+    changed_fpp = {f for f in changed_files if f.endswith(".fpp")}
+    if not changed_fpp:
+        return [], list(cases), "rung7: no Fortran source changed"
+
+    # Rung 4: a changed .fpp that no test covers -> run all (GPU-only blind spot).
+    covered = _covered_fpp(coverage_map)
+    if changed_fpp - covered:
+        return list(cases), [], "rung4: changed .fpp not covered by any test"
+
+    # Rungs 5-7: per-test.
+    to_run, skipped = [], []
+    for case in cases:
+        key = case.coverage_key()
+        cov = coverage_map.get(key)
+        if cov is None:  # rung 5: unmapped/new test
+            to_run.append(case)
+        elif set(cov) & changed_fpp:  # rung 6: overlap
+            to_run.append(case)
+        else:  # rung 7: skip
+            skipped.append(case)
+    return to_run, skipped, f"selected {len(to_run)}/{len(cases)} by coverage overlap"

toolchain/mfc/test/test_coverage_unit.py

@@ -1,7 +1,7 @@
 import tempfile
 from pathlib import Path
 
-from mfc.test.coverage import is_always_run_all, load_map, param_hash, save_map
+from mfc.test.coverage import is_always_run_all, load_map, param_hash, save_map, select_tests
 
 
 def test_param_hash_is_order_independent():
@@ -67,3 +67,55 @@ def test_ordinary_common_module_does_not_force_all():
 
 def test_ordinary_sim_module_does_not_force_all():
     assert not is_always_run_all({"src/simulation/m_rhs.fpp"})
+
+
+class _Case:
+    def __init__(self, ph, params=None):
+        self._ph = ph
+        self.params = params or {}
+
+    def coverage_key(self):
+        return self._ph
+
+
+def _cases(*phs):
+    return [_Case(p) for p in phs]
+
+
+def test_rung1_no_changed_files_runs_all():
+    cases = _cases("a", "b")
+    run, skip, reason = select_tests(cases, {"a": ["src/x.fpp"]}, None)
+    assert len(run) == 2 and skip == [] and reason.startswith("rung1")
+
+
+def test_rung2_always_run_all():
+    cases = _cases("a", "b")
+    run, skip, reason = select_tests(cases, {"a": [], "b": []}, {"CMakeLists.txt"})
+    assert len(run) == 2 and reason.startswith("rung2")
+
+
+def test_rung3_f90_change_runs_all():
+    cases = _cases("a")
+    run, skip, reason = select_tests(cases, {"a": []}, {"src/common/m_precision_select.f90"})
+    assert len(run) == 1 and reason.startswith("rung3")
+
+
+def test_rung4_changed_fpp_with_zero_coverage_runs_all():
+    cases = _cases("a")
+    # m_gpu_only.fpp is covered by no test in the map
+    run, skip, reason = select_tests(cases, {"a": ["src/simulation/m_rhs.fpp"]}, {"src/simulation/m_gpu_only.fpp"})
+    assert len(run) == 1 and reason.startswith("rung4")
+
+
+def test_rung5_unmapped_test_is_included():
+    cases = _cases("a", "new")  # 'new' not in map
+    run, skip, _ = select_tests(cases, {"a": ["src/simulation/m_rhs.fpp"]}, {"src/simulation/m_rhs.fpp"})
+    assert {c.coverage_key() for c in run} == {"a", "new"}
+
+
+def test_rung6_and_7_overlap_selects_subset():
+    cases = _cases("hit", "miss")
+    cov = {"hit": ["src/simulation/m_bubbles_EE.fpp"], "miss": ["src/simulation/m_rhs.fpp"]}
+    run, skip, _ = select_tests(cases, cov, {"src/simulation/m_bubbles_EE.fpp"})
+    assert [c.coverage_key() for c in run] == ["hit"]
+    assert [c.coverage_key() for c in skip] == ["miss"]