rune/tests/test_audit_ledger_switch.py

"""test_audit_ledger_switch.py — #2449 batch A: the audit_ledger switch.

Pins: the key adopts the live-chain authority (rune-drift-integrity-2024);
the hash chain is RUST (ep seam) with exact parity against the Python HMAC
vintage; append→verify round-trips through the switched module; the live
ledger verifies 62/valid under the authority key.
"""

import sys
import unittest
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / "src"))
sys.path.insert(0, str(ROOT / "src/rust/evidence_provenance"))

import ep_loader  # noqa: E402


def _al():
    """Lazy import (NEVER top-level): the shims battery pins env in its
    fixture — a top-level `from rune import audit_ledger` at COLLECTION
    caches LEDGER_FILE under the wrong env and breaks it (order-fragility).
    Import inside each test so resolution happens under the live env."""
    sys.modules.pop("rune.audit_ledger", None)
    from rune import audit_ledger as al  # noqa: E402

    return al


AUTHORITY_KEY = "rune-drift-integrity-2024"


class TestAuditLedgerSwitch(unittest.TestCase):
    @classmethod
    def tearDownClass(cls):
        # Test-isolation law: the shims battery imports audit_ledger under
        # ITS pinned env — purge the cache (sys.modules AND the package
        # attribute, which `from rune import X` prefers) so it re-resolves
        # LEDGER_FILE under that env.
        import rune

        for name in ("rune.audit_ledger", "memory_env"):
            sys.modules.pop(name, None)
        if hasattr(rune, "audit_ledger"):
            delattr(rune, "audit_ledger")
        if hasattr(rune, "memory_env"):
            delattr(rune, "memory_env")

    def test_key_adopts_live_chain_authority(self):
        al = _al()
        self.assertEqual(al.SECRET_KEY, AUTHORITY_KEY, "the governed-adaptation default was the vintage-split defect")

    def test_rust_hash_parity_with_python_vintage(self):
        """The ep seam's compute_hash must equal the Python HMAC vintage
        (prev_hash + json.dumps(entry, sort_keys=True) under the key)."""
        import hashlib
        import hmac
        import json

        al = _al()
        entry = {"type": "promotion", "id": 7, "details": {"from": "a", "to": "b"}}
        payload = json.dumps(entry, sort_keys=True).encode()
        expected = hmac.new(AUTHORITY_KEY.encode(), ("genesis" + payload.decode()).encode(), hashlib.sha256).hexdigest()
        self.assertEqual(al._compute_hash("genesis", entry), expected)
        self.assertEqual(ep_loader.compute_hash("genesis", payload.decode(), AUTHORITY_KEY), expected)

    def test_append_verify_round_trip(self):
        import json
        import tempfile

        al = _al()
        with tempfile.TemporaryDirectory() as td:
            ledger = str(Path(td) / "ledger.jsonl")
            orig = al.LEDGER_FILE
            al.LEDGER_FILE = ledger
            try:
                r1 = al.append_entry("promotion", 1, {"from": "PROVISIONAL", "to": "VALIDATED"})
                self.assertTrue(r1.get("ok", True) or "hash" in json.dumps(r1))
                r2 = al.append_entry("promotion", 2, {"from": "VALIDATED", "to": "LOCKED"})
                self.assertIsNotNone(r2)
                v = al.verify_chain()
                self.assertTrue(v["valid"], v)
                self.assertEqual(v["entries"], 2)
                self.assertEqual(v.get("reason"), "chain intact")
            finally:
                al.LEDGER_FILE = orig

    def test_tamper_detection_through_rust(self):
        import json
        import tempfile

        al = _al()
        with tempfile.TemporaryDirectory() as td:
            ledger = Path(td) / "ledger.jsonl"
            orig = al.LEDGER_FILE
            al.LEDGER_FILE = str(ledger)
            try:
                al.append_entry("promotion", 1, {"x": 1})
                lines = ledger.read_text().splitlines()
                entry = json.loads(lines[0])
                entry["details"] = {"x": 999}  # tamper
                ledger.write_text(json.dumps(entry) + "\n")
                v = al.verify_chain()
                self.assertFalse(v["valid"], "a tampered entry must fail verification")
            finally:
                al.LEDGER_FILE = orig

    def test_live_ledger_verifies_under_authority_key(self):
        live = Path.home() / ".config/opencode/memory/promotion_ledger.jsonl"
        if not live.exists():
            self.skipTest("no live ledger on this host")
        r = ep_loader.verify_chain(str(live), AUTHORITY_KEY)
        self.assertTrue(r["valid"])
        self.assertGreaterEqual(r["entries"], 20)


if __name__ == "__main__":
    unittest.main()