test(coverage): boundary + dispatch + topology tests for measurement modules (#18)

Extends the #18 coverage (PR #24 covered multi_hop/ontology_coherence/_graph_mapping; this adds the topology module + boundary/dispatch cases the original pass skipped). 72 tests across 4 files: multi_hop verdict boundaries, ontology claim dispatch, ontology topology metrics, adapter-contract conformance. Additive-only (0 deletions), all green. References upstream #18.

Author: jphein

tests/test_adapter_contract.py

@@ -23,6 +23,7 @@
 import pytest
 
 from sme.adapters.base import (
+    ContradictionPair,
     Edge,
     Entity,
     HarnessDescriptor,
@@ -248,3 +249,65 @@ def test_close_is_idempotent(adapter: SMEAdapter) -> None:
     being called more than once."""
     adapter.close()
     adapter.close()
+
+
+# --- Measurement-feeding optional defaults ----------------------------
+#
+# Three optional methods have *meaningful* defaults that feed category
+# scores: an adapter that doesn't override them must inherit behavior
+# that produces an honest zero, never a fabricated signal. These are the
+# defaults that, if quietly wrong, would inflate Cat 8 introspection or
+# Cat 3 contradiction detection for every non-overriding system.
+
+
+def test_get_introspection_report_default_is_none(adapter: SMEAdapter) -> None:
+    """The ABC default returns ``None`` → Cat 8 scores introspection 0.0
+    ("can't audit its own ontology"). An adapter may override with a dict,
+    but it must never be anything other than ``None`` or a dict — a
+    non-dict truthy value would be silently credited capability dimensions.
+    """
+    report = adapter.get_introspection_report()
+    assert report is None or isinstance(report, dict)
+
+
+def test_get_contradiction_pairs_returns_typed_list(adapter: SMEAdapter) -> None:
+    """The default derives ContradictionPair[] from ``contradicts`` edges
+    in the snapshot. Adapters with no such edges return ``[]`` (Cat 3
+    score 0); the contract is that the return is always a list of
+    ContradictionPair, never raises, and is internally consistent.
+    """
+    pairs = adapter.get_contradiction_pairs()
+    assert isinstance(pairs, list)
+    assert all(isinstance(p, ContradictionPair) for p in pairs)
+    for p in pairs:
+        # source ids must be present and distinct (a contradiction is
+        # between two different claims)
+        assert isinstance(p.source_a, str) and p.source_a
+        assert isinstance(p.source_b, str) and p.source_b
+
+
+def test_default_contradiction_pairs_derive_from_contradicts_edges() -> None:
+    """A snapshot carrying a ``contradicts`` edge must surface exactly one
+    ContradictionPair through the *base-class default* — this is the Cat 3
+    plumbing every adapter inherits for free, so it must fire without any
+    adapter override."""
+
+    class _ContradictingAdapter(MockAdapter):
+        def get_graph_snapshot(self):
+            entities = [
+                Entity(id="x", name="X earns 50k", entity_type="claim"),
+                Entity(id="y", name="X earns 80k", entity_type="claim"),
+                Entity(id="z", name="unrelated", entity_type="claim"),
+            ]
+            edges = [
+                Edge(source_id="x", target_id="y", edge_type="CONTRADICTS"),
+                Edge(source_id="x", target_id="z", edge_type="mentions"),
+            ]
+            return entities, edges
+
+    pairs = _ContradictingAdapter().get_contradiction_pairs()
+    assert len(pairs) == 1
+    pair = pairs[0]
+    # node names resolve into the pair via the default node_names map
+    assert {pair.source_a, pair.source_b} == {"x", "y"}
+    assert pair.claim_b == "X earns 80k"

tests/test_multi_hop_verdict_boundaries.py

@@ -0,0 +1,143 @@
+"""Boundary conditions for the Cat 2c multi-hop verdict.
+
+``test_multi_hop.py`` already covers the clear-cut verdict cases (a solid
+win, a solid loss, a clean neutral tax). What it does *not* pin are the
+threshold boundaries — and the verdict uses strict inequalities at three
+of them, so a value sitting exactly on the line is silently classified
+the *other* way from what a casual reader expects:
+
+  * "beats A" requires recall_delta_pp **> 5**, so a +5.0pp delta does
+    NOT count as a win.
+  * "loses to A" requires recall_delta_pp **< -5**, so a -5.0pp delta
+    does NOT count as a loss.
+  * "ratio grows" requires last **> first * 1.2**, so a ratio that lands
+    exactly on first*1.2 is "uniform scale", not "earns complexity".
+
+These off-by-epsilon boundaries are precisely where a verdict would flip
+under a tiny measurement perturbation, so they are worth nailing down.
+The expected verdicts were verified against the live ``_verdict`` before
+being pinned here.
+"""
+from __future__ import annotations
+
+from sme.categories.multi_hop import Cat2cReport, _verdict
+
+
+def _report(deltas_a, ratios, deltas_c=None) -> Cat2cReport:
+    r = Cat2cReport()
+    r.delta_B_minus_A = deltas_a
+    r.ratio_B_over_A = ratios
+    if deltas_c is not None:
+        r.delta_B_minus_C = deltas_c
+    return r
+
+
+# ── ±5pp win/loss boundaries (strict inequality) ──────────────────
+
+
+def test_exactly_plus_5pp_is_not_a_win():
+    """+5.0pp at every depth is on the boundary; the strict ``> 5`` test
+    means it doesn't count as beating flat → neutral tax, not a win."""
+    r = _report(
+        {1: {"recall_delta_pp": 5.0, "tokens_delta": 0},
+         2: {"recall_delta_pp": 5.0, "tokens_delta": 0}},
+        {1: 1.05, 2: 1.05},
+    )
+    assert _verdict(r)[0] == "structure is a neutral tax"
+
+
+def test_exactly_minus_5pp_is_not_a_loss():
+    """-5.0pp is on the boundary; the strict ``< -5`` test means it
+    doesn't count as losing → neutral tax, not harmful."""
+    r = _report(
+        {1: {"recall_delta_pp": -5.0, "tokens_delta": 0}},
+        {1: 0.95},
+    )
+    assert _verdict(r)[0] == "structure is a neutral tax"
+
+
+def test_just_over_5pp_is_a_win():
+    """5.01pp clears the boundary → counts as beating flat."""
+    r = _report(
+        {1: {"recall_delta_pp": 5.01, "tokens_delta": 0},
+         2: {"recall_delta_pp": 5.01, "tokens_delta": 0}},
+        {1: 1.05, 2: 1.05},  # flat ratio → uniform scale, but it IS a win
+    )
+    assert _verdict(r)[0] == "structure adds value at uniform scale"
+
+
+def test_just_under_minus_5pp_is_a_loss():
+    """-5.01pp clears the boundary the other way → counts as a loss."""
+    r = _report(
+        {1: {"recall_delta_pp": -5.01, "tokens_delta": 0}},
+        {1: 0.9},
+    )
+    assert _verdict(r)[0] == "structure harmful at multi-hop"
+
+
+# ── ratio-grows boundary (last > first * 1.2) ─────────────────────
+
+
+def test_ratio_exactly_at_1_2x_does_not_grow():
+    """last == first * 1.2 is on the boundary; the strict ``>`` means the
+    ratio is NOT considered to grow → uniform scale, not earns-complexity."""
+    r = _report(
+        {1: {"recall_delta_pp": 10.0, "tokens_delta": 0},
+         2: {"recall_delta_pp": 10.0, "tokens_delta": 0}},
+        {1: 1.0, 2: 1.2},  # 1.2 == 1.0 * 1.2 exactly
+    )
+    assert _verdict(r)[0] == "structure adds value at uniform scale"
+
+
+def test_ratio_just_over_1_2x_earns_complexity():
+    """last just past first * 1.2 → ratio grows → earns complexity."""
+    r = _report(
+        {1: {"recall_delta_pp": 10.0, "tokens_delta": 0},
+         2: {"recall_delta_pp": 40.0, "tokens_delta": 0}},
+        {1: 1.0, 2: 1.21},
+    )
+    assert _verdict(r)[0] == "structure earns complexity (scales with depth)"
+
+
+# ── single-ratio guard (ratio_grows needs >= 2 points) ────────────
+
+
+def test_single_hop_ratio_cannot_grow():
+    """With only one hop bucket the ratio has nothing to grow against, so
+    a win is reported as uniform scale, never earns-complexity."""
+    r = _report(
+        {1: {"recall_delta_pp": 50.0, "tokens_delta": 0}},
+        {1: 5.0},  # huge but single-point → ratio_grows stays False
+    )
+    assert _verdict(r)[0] == "structure adds value at uniform scale"
+
+
+# ── infinite-ratio entries are skipped in the grows check ─────────
+
+
+def test_infinite_ratio_skipped_in_grows_check():
+    """An inf ratio (A had zero recall at a depth) is excluded from the
+    grows comparison; the remaining finite points decide it. Here only
+    one finite ratio survives, so it can't grow → uniform scale."""
+    r = _report(
+        {1: {"recall_delta_pp": 60.0, "tokens_delta": 0},
+         2: {"recall_delta_pp": 70.0, "tokens_delta": 0}},
+        {1: float("inf"), 2: 3.0},
+    )
+    assert _verdict(r)[0] == "structure adds value at uniform scale"
+
+
+# ── C-absent narration when A is present ──────────────────────────
+
+
+def test_no_c_overlap_still_notes_missing_isolation():
+    """A populated but no B-C overlap → the verdict still narrates that
+    the structural contribution could not be isolated, so the reader
+    isn't misled into thinking C was tested."""
+    r = _report(
+        {1: {"recall_delta_pp": 10.0, "tokens_delta": 0}},
+        {1: 1.3},
+    )
+    verdict, details = _verdict(r)
+    assert verdict == "structure adds value at uniform scale"
+    assert any("no Condition C" in d for d in details)