697 lines
27 KiB
Python
697 lines
27 KiB
Python
#!/usr/bin/env python3
|
|
"""gen_state_checkpoint_truth.py — freeze/replay parity truth for
|
|
state_checkpoint (dichotomy wave, #2479 tranche).
|
|
|
|
Freeze mode (default): exercises EVERY public function of the LIVE Python
|
|
oracle (src/rune/state_checkpoint.py) across every branch and records
|
|
(kernel_input, expected_kernel_output) pairs into
|
|
src/rust/state_checkpoint/src/frozen_sck_truth.json.
|
|
|
|
Replay mode (--replay): re-runs the SAME scenarios with the Rust core
|
|
delegation active and asserts both kernel-level (loader direct) and
|
|
facade-level (oracle functions delegate) parity against the frozen file.
|
|
|
|
Poisoned-truth law: freeze pins RUNE_SCK_CORE=python BEFORE any import (a
|
|
no-op pre-port, load-bearing post-port — the facade must never delegate
|
|
into the kernel while truth is being frozen).
|
|
|
|
No-clock law: the wall clock is frozen by patching the `datetime` symbol
|
|
in state_checkpoint, so every kernel payload carries its own `ts`/`at`
|
|
and replay is deterministic regardless of run date.
|
|
|
|
Boundary law: the FILE IO (sqlite open/count, shutil copy, ledger
|
|
load/save, env resolution in _store_db/_ledger_path) stays in the Python
|
|
facade — the kernel is a pure function of the loaded ledger doc and
|
|
facade-computed counts. The `snapshot_io`, `restore_io`, `diff_io` and
|
|
`load_corrupt` truth groups are facade-only (no kernel symbol) and are
|
|
skipped by the kernel-level replay pass.
|
|
"""
|
|
import copy
|
|
import json
|
|
import os
|
|
import shutil
|
|
import sqlite3
|
|
import sys
|
|
import tempfile
|
|
from datetime import datetime, timezone
|
|
from pathlib import Path
|
|
|
|
REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
TRUTH_PATH = os.path.join(REPO, "src", "rust", "state_checkpoint", "src",
|
|
"frozen_sck_truth.json")
|
|
REPLAY = "--replay" in sys.argv
|
|
|
|
os.environ["RUNE_SCK_CORE"] = "python" # poisoned-truth law
|
|
|
|
sys.path.insert(0, os.path.join(REPO, "src"))
|
|
sys.path.insert(0, os.path.join(REPO, "src", "rune"))
|
|
|
|
import state_checkpoint as oracle_mod # noqa: E402
|
|
|
|
if REPLAY:
|
|
from rune import sck_loader # noqa: E402 (kernel-level replay side)
|
|
# replay law: the facade pass must exercise the LIVE Rust delegation
|
|
# path, so the pin is lifted AFTER import (the facade reads the env
|
|
# at call time). The kernel pass calls the loader directly.
|
|
del os.environ["RUNE_SCK_CORE"]
|
|
|
|
FROZEN_TS = 1791806400 # 2026-10-12T12:00:00Z
|
|
FROZEN_TS_STR = "20261012T120000"
|
|
FROZEN_AT = "2026-10-12T12:00:00+00:00"
|
|
|
|
|
|
class _FrozenDT:
|
|
@staticmethod
|
|
def now(tz=None):
|
|
return datetime.fromtimestamp(FROZEN_TS, tz=timezone.utc)
|
|
|
|
|
|
oracle_mod.datetime = _FrozenDT
|
|
|
|
|
|
_DIR_SEQ = [0]
|
|
|
|
|
|
def fresh_dir():
|
|
"""Deterministic per-case dir — the frozen truth embeds absolute
|
|
paths (snapshot records carry them), so replay must see the SAME
|
|
paths the freeze saw."""
|
|
_DIR_SEQ[0] += 1
|
|
d = os.path.join(tempfile.gettempdir(), f"sck_truth_frozen_{_DIR_SEQ[0]:03d}")
|
|
shutil.rmtree(d, ignore_errors=True)
|
|
os.makedirs(d)
|
|
return d
|
|
|
|
|
|
def make_db(path, rows):
|
|
conn = sqlite3.connect(path)
|
|
conn.execute("CREATE TABLE entries (id INTEGER PRIMARY KEY, status TEXT)")
|
|
conn.executemany("INSERT INTO entries VALUES (?,?)",
|
|
list(enumerate(rows)))
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
|
|
def ledger_of(path):
|
|
return copy.deepcopy(oracle_mod._load_ledger(path))
|
|
|
|
|
|
def rec_kernel(rec, name, inp, expected, oracle_ret=None):
|
|
"""Record a kernel case; inputs deep-copied BEFORE oracle mutation."""
|
|
rec(name, copy.deepcopy(inp), oracle_ret, expected)
|
|
|
|
|
|
def rec_facade(rec, name, inp, expected, oracle_ret=None):
|
|
rec(name, inp, oracle_ret, expected)
|
|
|
|
|
|
# ── snapshot (kernel: record shaping + ledger append) ────────────────────────
|
|
|
|
def _snapshot_case(rec, name, label, rows, prior=None, db_text=False):
|
|
d = fresh_dir()
|
|
db = os.path.join(d, "store.db")
|
|
if db_text:
|
|
Path(db).write_text("not a database\n")
|
|
else:
|
|
make_db(db, rows)
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
if prior is not None:
|
|
Path(ledger).write_text(json.dumps({"snapshots": prior}, indent=1))
|
|
data_before = ledger_of(ledger)
|
|
ret = oracle_mod.snapshot(label, store_db=db, ledger_path=ledger)
|
|
inp = {"ledger_doc": data_before, "ts": FROZEN_TS_STR, "at": FROZEN_AT,
|
|
"label": label, "entries": ret["entries"], "path": ret["path"]}
|
|
rec_kernel(rec, name, inp,
|
|
{"record": ret, "ledger": ledger_of(ledger)}, oracle_ret=ret)
|
|
|
|
|
|
def c_snapshot_first(rec):
|
|
_snapshot_case(rec, "snapshot-first-empty-ledger", "nightly",
|
|
["active", "active", "retired"])
|
|
|
|
|
|
def c_snapshot_second(rec):
|
|
prior = [{"id": "20261012T110000-a", "label": "a",
|
|
"path": "/tmp/snapshot-20261012T110000-a.db", "entries": 1,
|
|
"at": "2026-10-12T11:00:00+00:00"}]
|
|
_snapshot_case(rec, "snapshot-second-appends", "nightly",
|
|
["active", "active"], prior=prior)
|
|
|
|
|
|
def c_snapshot_entries_unknown(rec):
|
|
_snapshot_case(rec, "snapshot-entries-minus-one-not-a-db", "weird",
|
|
[], db_text=True)
|
|
|
|
|
|
def c_snapshot_label_chars(rec):
|
|
_snapshot_case(rec, "snapshot-label-dashes-and-dots", "pre-restore.v2",
|
|
["active"])
|
|
|
|
|
|
# ── list_snapshots (kernel: newest-first stable sort) ────────────────────────
|
|
|
|
def _list_case(rec, name, snaps):
|
|
d = fresh_dir()
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
if snaps is not None:
|
|
Path(ledger).write_text(json.dumps({"snapshots": snaps}, indent=1))
|
|
out = oracle_mod.list_snapshots(ledger_path=ledger)
|
|
inp = {"snapshots": copy.deepcopy(snaps or [])}
|
|
rec_kernel(rec, name, inp, {"snapshots": out}, oracle_ret=out)
|
|
|
|
|
|
def c_list_empty(rec):
|
|
_list_case(rec, "list-missing-ledger-empty", None)
|
|
|
|
|
|
def c_list_newest_first(rec):
|
|
_list_case(rec, "list-newest-first", [
|
|
{"id": "s1", "at": "2026-10-12T10:00:00+00:00"},
|
|
{"id": "s2", "at": "2026-10-12T12:00:00+00:00"},
|
|
{"id": "s3", "at": "2026-10-12T11:00:00+00:00"},
|
|
])
|
|
|
|
|
|
def c_list_tie_stable(rec):
|
|
_list_case(rec, "list-tie-preserves-original-order", [
|
|
{"id": "first", "at": "2026-10-12T12:00:00+00:00"},
|
|
{"id": "second", "at": "2026-10-12T12:00:00+00:00"},
|
|
{"id": "third", "at": "2026-10-12T13:00:00+00:00"},
|
|
])
|
|
|
|
|
|
def c_list_missing_at(rec):
|
|
_list_case(rec, "list-missing-at-sorts-last", [
|
|
{"id": "no-at"},
|
|
{"id": "dated", "at": "2026-10-12T12:00:00+00:00"},
|
|
])
|
|
|
|
|
|
# ── restore decision (kernel) ────────────────────────────────────────────────
|
|
|
|
def _restore_case(rec, name, snapshot_id, dry_run, snaps, make_paths_real=False):
|
|
d = fresh_dir()
|
|
db = os.path.join(d, "store.db")
|
|
make_db(db, ["active"])
|
|
if make_paths_real:
|
|
for s in snaps:
|
|
make_db(s["path"], ["active", "active"])
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
Path(ledger).write_text(json.dumps({"snapshots": snaps}, indent=1))
|
|
decision = oracle_mod.restore(snapshot_id, ledger_path=ledger,
|
|
store_db=db, dry_run=dry_run)
|
|
inp = {"snapshots": copy.deepcopy(snaps), "snapshot_id": snapshot_id,
|
|
"dry_run": dry_run}
|
|
if "snapshot" in decision:
|
|
# proceed: the oracle's return carries facade IO results (safety
|
|
# snapshot id); the KERNEL surface is the decision only
|
|
expected = {"record": decision["snapshot"]}
|
|
else:
|
|
# error doc / dry-run doc ARE the kernel decision verbatim
|
|
expected = decision
|
|
rec_kernel(rec, name, inp, expected, oracle_ret=decision)
|
|
|
|
|
|
def c_restore_unknown(rec):
|
|
_restore_case(rec, "restore-unknown-error-doc", "nope", False,
|
|
[{"id": "s1", "path": "/x.db"}])
|
|
|
|
|
|
def c_restore_dry_run(rec):
|
|
snap = {"id": "s1", "label": "a", "path": "/tmp/s1.db", "entries": 2,
|
|
"at": "2026-10-12T12:00:00+00:00"}
|
|
_restore_case(rec, "restore-dry-run-would-restore", "s1", True, [snap])
|
|
|
|
|
|
def c_restore_found(rec):
|
|
d = fresh_dir()
|
|
snap = {"id": "s1", "label": "a", "path": os.path.join(d, "s1.db"),
|
|
"entries": 2, "at": "2026-10-12T12:00:00+00:00"}
|
|
_restore_case(rec, "restore-found-proceed-decision", "s1", False, [snap],
|
|
make_paths_real=True)
|
|
|
|
|
|
def c_restore_first_match(rec):
|
|
# restore uses the FIRST match (match[0]) — unlike diff's last-wins
|
|
snaps = [{"id": "s1", "path": "/first.db"},
|
|
{"id": "s1", "path": "/second.db"}]
|
|
_restore_case(rec, "restore-first-match-wins", "s1", True, snaps)
|
|
|
|
|
|
# ── restore_commit (kernel: final doc shaping) ───────────────────────────────
|
|
|
|
def _commit_case(rec, name):
|
|
d = fresh_dir()
|
|
db = os.path.join(d, "store.db")
|
|
make_db(db, ["active", "active"])
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
first = oracle_mod.snapshot("target", store_db=db, ledger_path=ledger)
|
|
ret = oracle_mod.restore(first["id"], ledger_path=ledger, store_db=db)
|
|
# the safety snapshot is the SECOND record in the ledger
|
|
snaps = oracle_mod._load_ledger(ledger)["snapshots"]
|
|
rec_kernel(rec, name, {"record": first, "safety_id": ret["safety_snapshot"]},
|
|
{"restored": True, "snapshot": first,
|
|
"safety_snapshot": ret["safety_snapshot"]},
|
|
oracle_ret=ret)
|
|
|
|
|
|
def c_commit_shape(rec):
|
|
_commit_case(rec, "restore-commit-final-doc")
|
|
|
|
|
|
# ── diff lookup (kernel: last-wins id map) ───────────────────────────────────
|
|
|
|
def _lookup_case(rec, name, snaps, before_id, after_id, dbs=None):
|
|
d = fresh_dir()
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
snaps = [dict(s, path=os.path.join(d, s["path"])) for s in snaps]
|
|
# the oracle diff OPENS every referenced snapshot db — back each path
|
|
for s in snaps:
|
|
make_db(s["path"], (dbs or {}).get(os.path.basename(s["path"]),
|
|
["active"]))
|
|
Path(ledger).write_text(json.dumps({"snapshots": snaps}, indent=1))
|
|
out = oracle_mod.diff(before_id, after_id, ledger_path=ledger)
|
|
inp = {"snapshots": copy.deepcopy(snaps), "before_id": before_id,
|
|
"after_id": after_id}
|
|
if "error" in out:
|
|
rec_kernel(rec, name, inp, {"error": out["error"]}, oracle_ret=out)
|
|
else:
|
|
# per-side sqlite counts are facade IO; the lookup doc is the
|
|
# kernel surface (by_id is built dict-comprehension style:
|
|
# LAST duplicate wins)
|
|
by_id = {}
|
|
for s in snaps:
|
|
by_id[s["id"]] = s
|
|
rec_kernel(rec, name, inp,
|
|
{"before_path": by_id[before_id]["path"],
|
|
"after_path": by_id[after_id]["path"]}, oracle_ret=out)
|
|
|
|
|
|
def c_lookup_both_known(rec):
|
|
_lookup_case(rec, "lookup-both-known", [
|
|
{"id": "a", "path": "a.db"}, {"id": "b", "path": "b.db"}], "a", "b")
|
|
|
|
|
|
def c_lookup_before_unknown(rec):
|
|
_lookup_case(rec, "lookup-before-unknown", [
|
|
{"id": "b", "path": "b.db"}], "ghost", "b")
|
|
|
|
|
|
def c_lookup_after_unknown(rec):
|
|
_lookup_case(rec, "lookup-after-unknown", [
|
|
{"id": "a", "path": "a.db"}], "a", "ghost")
|
|
|
|
|
|
def c_lookup_dup_last_wins(rec):
|
|
# diff's by_id map is built dict-comprehension style: LAST wins —
|
|
# real dbs with distinct counts make the choice observable
|
|
_lookup_case(rec, "lookup-duplicate-id-last-wins", [
|
|
{"id": "a", "path": "first.db"},
|
|
{"id": "a", "path": "second.db"},
|
|
{"id": "b", "path": "b.db"}], "a", "b",
|
|
dbs={"first.db": ["active"],
|
|
"second.db": ["active"] * 5,
|
|
"b.db": ["active"] * 2})
|
|
|
|
|
|
# ── diff shape (kernel: delta + per-side error tolerance) ────────────────────
|
|
|
|
def _shape_case(rec, name, before, after):
|
|
d = fresh_dir()
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
snaps = []
|
|
for sid, side, dbrows in (("a", "before", before), ("b", "after", after)):
|
|
db = os.path.join(d, f"{sid}.db")
|
|
if dbrows is None:
|
|
Path(db).write_text("not a database\n")
|
|
else:
|
|
make_db(db, dbrows)
|
|
snaps.append({"id": sid, "path": db})
|
|
Path(ledger).write_text(json.dumps({"snapshots": snaps}, indent=1))
|
|
out = oracle_mod.diff("a", "b", ledger_path=ledger)
|
|
inp = {"before": out["before"], "after": out["after"]}
|
|
rec_kernel(rec, name, inp, out, oracle_ret=out)
|
|
|
|
|
|
def c_shape_both_ok(rec):
|
|
_shape_case(rec, "shape-both-ok-delta",
|
|
["active", "active", "retired"],
|
|
["active", "active", "active", "retired"])
|
|
|
|
|
|
def c_shape_before_error(rec):
|
|
_shape_case(rec, "shape-before-error-side", None,
|
|
["active", "active"])
|
|
|
|
|
|
def c_shape_after_error(rec):
|
|
_shape_case(rec, "shape-after-error-side",
|
|
["active", "active"], None)
|
|
|
|
|
|
def c_shape_both_error(rec):
|
|
_shape_case(rec, "shape-both-error-sides", None, None)
|
|
|
|
|
|
def c_shape_zero_delta(rec):
|
|
_shape_case(rec, "shape-zero-delta",
|
|
["active", "retired"], ["active", "retired"])
|
|
|
|
|
|
# ── facade-only: FILE IO (sqlite, copy, ledger save, env resolution) ────────
|
|
|
|
def c_snapshot_io(rec):
|
|
d = fresh_dir()
|
|
db = os.path.join(d, "store.db")
|
|
make_db(db, ["active"] * 3)
|
|
ret = oracle_mod.snapshot("io", store_db=db,
|
|
ledger_path=os.path.join(d, "checkpoints.json"))
|
|
rec_facade(rec, "snapshot-io-real-count-and-file", {"label": "io"},
|
|
{"entries": ret["entries"], "path_exists":
|
|
Path(ret["path"]).is_file(),
|
|
"ledger_len": len(oracle_mod._load_ledger(
|
|
os.path.join(d, "checkpoints.json"))["snapshots"])},
|
|
oracle_ret={"entries": ret["entries"]})
|
|
|
|
|
|
def c_restore_io(rec):
|
|
d = fresh_dir()
|
|
db = os.path.join(d, "store.db")
|
|
make_db(db, ["active", "active"])
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
first = oracle_mod.snapshot("good", store_db=db, ledger_path=ledger)
|
|
conn = sqlite3.connect(db)
|
|
conn.execute("DELETE FROM entries")
|
|
conn.commit()
|
|
conn.close()
|
|
ret = oracle_mod.restore(first["id"], ledger_path=ledger, store_db=db)
|
|
conn = sqlite3.connect(db)
|
|
count = conn.execute("SELECT COUNT(*) FROM entries").fetchone()[0]
|
|
conn.close()
|
|
journal = os.path.join(d, "events.jsonl")
|
|
Path(journal).write_text("event\n")
|
|
before = Path(journal).read_text()
|
|
oracle_mod.restore(first["id"], ledger_path=ledger, store_db=db)
|
|
rec_facade(rec, "restore-io-db-repaired-journal-untouched",
|
|
{"snapshot_id": first["id"]},
|
|
{"restored": ret["restored"], "count_after": count,
|
|
"journal_untouched": Path(journal).read_text() == before,
|
|
"safety_in_ledger": ret["safety_snapshot"] in
|
|
{s["id"] for s in oracle_mod._load_ledger(ledger)["snapshots"]}},
|
|
oracle_ret=None)
|
|
|
|
|
|
def c_diff_io(rec):
|
|
d = fresh_dir()
|
|
db = os.path.join(d, "store.db")
|
|
make_db(db, ["active"])
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
a = oracle_mod.snapshot("a", store_db=db, ledger_path=ledger)
|
|
conn = sqlite3.connect(db)
|
|
conn.execute("INSERT INTO entries VALUES (99, 'active')")
|
|
conn.commit()
|
|
conn.close()
|
|
b = oracle_mod.snapshot("b", store_db=db, ledger_path=ledger)
|
|
out = oracle_mod.diff(a["id"], b["id"], ledger_path=ledger)
|
|
rec_facade(rec, "diff-io-real-sqlite-counts", {},
|
|
{"before": out["before"], "after": out["after"],
|
|
"delta_entries": out["delta_entries"]}, oracle_ret=None)
|
|
|
|
|
|
def c_load_corrupt(rec):
|
|
d = fresh_dir()
|
|
ledger = os.path.join(d, "checkpoints.json")
|
|
Path(ledger).write_text("{not json")
|
|
rec_facade(rec, "load-corrupt-ledger-reads-empty", {},
|
|
{"list": oracle_mod.list_snapshots(ledger_path=ledger),
|
|
"db": oracle_mod._load_ledger(ledger)}, oracle_ret=None)
|
|
|
|
|
|
# ── ledger IO (literal-100% residue: _load_ledger/_save_ledger kernels) ──────
|
|
|
|
def c_ledger_load_missing(rec):
|
|
d = fresh_dir()
|
|
path = os.path.join(d, "checkpoints.json")
|
|
rec("ledger-load-missing-defaults", {"fn": "load", "path": path,
|
|
"pre": None},
|
|
None, {"ledger": {"snapshots": []}})
|
|
|
|
|
|
def c_ledger_load_corrupt(rec):
|
|
d = fresh_dir()
|
|
path = os.path.join(d, "checkpoints.json")
|
|
Path(path).write_text("{not json")
|
|
rec("ledger-load-corrupt-defaults",
|
|
{"fn": "load", "path": path, "pre": {"checkpoints.json": "{not json"}},
|
|
None, {"ledger": oracle_mod._load_ledger(path)})
|
|
|
|
|
|
def c_ledger_load_valid(rec):
|
|
d = fresh_dir()
|
|
path = os.path.join(d, "checkpoints.json")
|
|
content = json.dumps({"snapshots": [{"id": "s1", "at": "t"}], "extra": {"é": 1}},
|
|
indent=1)
|
|
Path(path).write_text(content)
|
|
rec("ledger-load-valid-passthrough",
|
|
{"fn": "load", "path": path, "pre": {"checkpoints.json": content}},
|
|
None, {"ledger": oracle_mod._load_ledger(path)})
|
|
|
|
|
|
def c_ledger_load_nondict(rec):
|
|
d = fresh_dir()
|
|
path = os.path.join(d, "checkpoints.json")
|
|
content = "[1, 2]"
|
|
Path(path).write_text(content)
|
|
rec("ledger-load-list-passthrough",
|
|
{"fn": "load", "path": path, "pre": {"checkpoints.json": content}},
|
|
None, {"ledger": oracle_mod._load_ledger(path)})
|
|
|
|
|
|
def c_ledger_load_empty_file(rec):
|
|
d = fresh_dir()
|
|
path = os.path.join(d, "checkpoints.json")
|
|
Path(path).write_text("")
|
|
rec("ledger-load-empty-file-defaults",
|
|
{"fn": "load", "path": path, "pre": {"checkpoints.json": ""}},
|
|
None, {"ledger": oracle_mod._load_ledger(path)})
|
|
|
|
|
|
def _ledger_save_case(rec, name, ledger, sub=("nested", "dir", "checkpoints.json")):
|
|
d = fresh_dir()
|
|
path = os.path.join(d, *sub)
|
|
try:
|
|
oracle_mod._save_ledger(path, copy.deepcopy(ledger))
|
|
expected = {"content": Path(path).read_text()}
|
|
except (OSError, ValueError, TypeError) as exc:
|
|
expected = {"err": f"{type(exc).__name__}: {exc}"}
|
|
rec(name,
|
|
{"fn": "save", "path": path, "ledger": copy.deepcopy(ledger)},
|
|
None, expected)
|
|
|
|
|
|
def c_ledger_save_basic(rec):
|
|
_ledger_save_case(rec, "ledger-save-basic-indent1-bytes",
|
|
{"snapshots": [{"id": "s1", "label": "a", "path": "/x.db",
|
|
"entries": 2, "at": "t"}], "b": 1})
|
|
|
|
|
|
def c_ledger_save_insertion_order(rec):
|
|
# insertion order must survive byte-for-byte (no sort_keys)
|
|
_ledger_save_case(rec, "ledger-save-insertion-order-pinned",
|
|
{"z": {"last": [1, 2], "first": {}}, "a": "é ☕",
|
|
"mid": [2.0, 1.5, True, None]})
|
|
|
|
|
|
def c_ledger_save_bare_filename(rec):
|
|
# bare filename: os.makedirs('') is the oracle's crash class and the
|
|
# crash happens BEFORE any write (no stray file in the repo root)
|
|
try:
|
|
oracle_mod._save_ledger("checkpoints.json", {"snapshots": []})
|
|
expected = {"content": Path("checkpoints.json").read_text()}
|
|
except OSError as exc:
|
|
expected = {"err": f"{type(exc).__name__}: {exc}"}
|
|
rec("ledger-save-bare-filename-crash",
|
|
{"fn": "save", "path": "checkpoints.json",
|
|
"ledger": {"snapshots": []}},
|
|
None, expected)
|
|
|
|
|
|
def c_ledger_save_overwrites(rec):
|
|
d = fresh_dir()
|
|
path = os.path.join(d, "checkpoints.json")
|
|
Path(path).write_text("stale content")
|
|
oracle_mod._save_ledger(path, {"snapshots": []})
|
|
rec("ledger-save-overwrites-existing",
|
|
{"fn": "save", "path": path, "ledger": {"snapshots": []},
|
|
"pre": {"checkpoints.json": "stale content"}},
|
|
None, {"content": Path(path).read_text()})
|
|
|
|
|
|
# ── driver ───────────────────────────────────────────────────────────────────
|
|
|
|
SNAPSHOT = [c_snapshot_first, c_snapshot_second, c_snapshot_entries_unknown,
|
|
c_snapshot_label_chars]
|
|
LIST = [c_list_empty, c_list_newest_first, c_list_tie_stable,
|
|
c_list_missing_at]
|
|
RESTORE = [c_restore_unknown, c_restore_dry_run, c_restore_found,
|
|
c_restore_first_match]
|
|
COMMIT = [c_commit_shape]
|
|
LOOKUP = [c_lookup_both_known, c_lookup_before_unknown, c_lookup_after_unknown,
|
|
c_lookup_dup_last_wins]
|
|
SHAPE = [c_shape_both_ok, c_shape_before_error, c_shape_after_error,
|
|
c_shape_both_error, c_shape_zero_delta]
|
|
FACADE_IO = [c_snapshot_io, c_restore_io, c_diff_io, c_load_corrupt]
|
|
LEDGER_IO = [c_ledger_load_missing, c_ledger_load_corrupt, c_ledger_load_valid,
|
|
c_ledger_load_nondict, c_ledger_load_empty_file,
|
|
c_ledger_save_basic, c_ledger_save_insertion_order,
|
|
c_ledger_save_bare_filename, c_ledger_save_overwrites]
|
|
|
|
GROUPS = [("snapshot", SNAPSHOT), ("list", LIST), ("restore", RESTORE),
|
|
("restore_commit", COMMIT), ("diff_lookup", LOOKUP),
|
|
("diff_shape", SHAPE), ("facade_io", FACADE_IO),
|
|
("ledger_io", LEDGER_IO)]
|
|
|
|
# kernel symbol per group (None → facade-only group, skipped kernel-side)
|
|
KERNEL = {
|
|
"snapshot": "sck_snapshot",
|
|
"list": "sck_list",
|
|
"restore": "sck_restore",
|
|
"restore_commit": "sck_restore_commit",
|
|
"diff_lookup": "sck_diff_lookup",
|
|
"diff_shape": "sck_diff_shape",
|
|
"ledger_io": "sck_load_ledger/sck_save_ledger",
|
|
"facade_io": None,
|
|
}
|
|
|
|
# loader wrapper + slice of `expected` the unwrapped FFI value maps to
|
|
def _ledger_kernel_call(i, ld):
|
|
"""Seed the case's pre-state, then run the ledger kernel through the
|
|
loader with REAL file IO (byte-law observable: file content)."""
|
|
p = i["path"]
|
|
if i.get("pre"):
|
|
os.makedirs(os.path.dirname(p), exist_ok=True)
|
|
for rel, content in i["pre"].items():
|
|
Path(os.path.join(os.path.dirname(p), rel)).write_text(content)
|
|
elif i["fn"] == "load" and os.path.exists(p):
|
|
os.remove(p)
|
|
if i["fn"] == "load":
|
|
return {"ledger": ld.load_ledger(p)}
|
|
try:
|
|
ld.save_ledger(p, copy.deepcopy(i["ledger"]))
|
|
return {"content": Path(p).read_text()}
|
|
except FileNotFoundError as exc:
|
|
return {"err": f"FileNotFoundError: {exc}"}
|
|
|
|
|
|
CALLS = {
|
|
"snapshot": (lambda w: w,
|
|
lambda i, ld: ld.snapshot(ledger_doc=i["ledger_doc"], ts=i["ts"],
|
|
at=i["at"], label=i["label"],
|
|
entries=i["entries"],
|
|
snap_path=i["path"])),
|
|
"list": (lambda w: w["snapshots"],
|
|
lambda i, ld: ld.list(snapshots=i["snapshots"])),
|
|
"restore": (lambda w: w,
|
|
lambda i, ld: ld.restore(snapshots=i["snapshots"],
|
|
snapshot_id=i["snapshot_id"],
|
|
dry_run=i["dry_run"])),
|
|
"restore_commit": (lambda w: w,
|
|
lambda i, ld: ld.restore_commit(record=i["record"],
|
|
safety_id=i["safety_id"])),
|
|
"diff_lookup": (lambda w: ({"error": w["error"]} if "error" in w else
|
|
{"before_path": w["before_path"],
|
|
"after_path": w["after_path"]}),
|
|
lambda i, ld: ld.diff_lookup(snapshots=i["snapshots"],
|
|
before_id=i["before_id"],
|
|
after_id=i["after_id"])),
|
|
"diff_shape": (lambda w: w,
|
|
lambda i, ld: ld.diff_shape(before=i["before"],
|
|
after=i["after"])),
|
|
"ledger_io": (lambda w: w, _ledger_kernel_call),
|
|
}
|
|
|
|
|
|
|
|
|
|
def canon(x) -> str:
|
|
"""Content canonicalization: a sorted dump makes the comparison
|
|
key-order independent (int keys never occur here)."""
|
|
return json.dumps(json.loads(json.dumps(x)), sort_keys=True)
|
|
|
|
|
|
def main():
|
|
frozen = None
|
|
if REPLAY:
|
|
with open(TRUTH_PATH) as f:
|
|
frozen = json.load(f)["cases"]
|
|
|
|
groups = {}
|
|
for group, cases in GROUPS:
|
|
recs = []
|
|
|
|
def rec(name, inp, oracle_ret, expected, _r=recs):
|
|
entry = {"name": name, "input": inp, "return": oracle_ret,
|
|
"expected": expected}
|
|
if REPLAY:
|
|
old = next(c for c in frozen[group] if c["name"] == name)
|
|
for key in ("input", "return", "expected"):
|
|
got, want = entry[key], old[key]
|
|
if canon(got) != canon(want):
|
|
print(f"FACADE DIVERGE [{group}] {name} {key}")
|
|
print(" got: ", json.dumps(got, sort_keys=True, default=str)[:600])
|
|
print(" want:", json.dumps(want, sort_keys=True, default=str)[:600])
|
|
recs.append({"name": name, "diverged": key})
|
|
return
|
|
_r.append(entry)
|
|
|
|
for c in cases:
|
|
c(rec)
|
|
groups[group] = recs
|
|
|
|
total = sum(len(v) for v in groups.values())
|
|
if REPLAY:
|
|
facade_failures = sum(1 for v in groups.values() for c in v if "diverged" in c)
|
|
|
|
failures = 0
|
|
checked = 0
|
|
for group, cases in frozen.items():
|
|
spec = CALLS.get(group)
|
|
if spec is None:
|
|
continue
|
|
unwrap, call = spec
|
|
for case in cases:
|
|
checked += 1
|
|
got = call(copy.deepcopy(case["input"]), sck_loader)
|
|
want = unwrap(case["expected"])
|
|
if canon(got) != canon(want):
|
|
failures += 1
|
|
print(f"KERNEL DIVERGE [{group}] {case['name']}")
|
|
print(" got: ", json.dumps(got, sort_keys=True, default=str)[:600])
|
|
print(" want:", json.dumps(want, sort_keys=True, default=str)[:600])
|
|
print(f"replay: facade {total - facade_failures}/{total}, "
|
|
f"kernel {checked - failures}/{checked}")
|
|
return 1 if (failures or facade_failures) else 0
|
|
|
|
doc = {
|
|
"frozen": FROZEN_AT,
|
|
"oracle": "src/rune/state_checkpoint.py",
|
|
"pin": "RUNE_SCK_CORE=python",
|
|
"note": "Frozen via scripts/gen_state_checkpoint_truth.py against the live "
|
|
"Python oracle; wall clock frozen at " + FROZEN_AT +
|
|
" (_FrozenDT patched into state_checkpoint.datetime; epoch " +
|
|
str(FROZEN_TS) + "). Battery embeds this VERBATIM. The "
|
|
"`facade_io` group is facade-only (sqlite/copy/ledger IO stays "
|
|
"in Python).",
|
|
"cases": groups,
|
|
}
|
|
os.makedirs(os.path.dirname(TRUTH_PATH), exist_ok=True)
|
|
with open(TRUTH_PATH, "w") as f:
|
|
json.dump(doc, f, indent=1)
|
|
f.write("\n")
|
|
print(f"frozen {total} cases → {os.path.relpath(TRUTH_PATH, REPO)}")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
sys.exit(main())
|