586 lines
31 KiB
Python
586 lines
31 KiB
Python
#!/usr/bin/env python3
|
|
"""Freeze the dichotomy-wave gap-closing truth corpus for
|
|
src/rune/structural_store.py (contract BUILDER-2026-10-13T00:32:22Z-bc3aae-
|
|
factory-gap-ss, issue #2479 tranche).
|
|
|
|
LAW (poisoned-truth): RUNE_STRUCTURAL_CORE=python is pinned at the top —
|
|
truth is generated by the PYTHON ORACLE ONLY. Inputs are deep-copied before
|
|
every oracle call (no leakage between cases). The clock is pinned by
|
|
monkeypatching structural_store.now (no-clock law on the Rust side).
|
|
|
|
The frozen corpus is embedded VERBATIM in the crate's cfg(test) battery
|
|
(src/frozen_battery.rs, include_str!) and replayed by
|
|
scripts/check_structural_store_parity.py through the live FFI.
|
|
"""
|
|
import calendar
|
|
import copy
|
|
import json
|
|
import os
|
|
import sys
|
|
import tempfile
|
|
import time as _time
|
|
import types
|
|
from pathlib import Path
|
|
|
|
os.environ["RUNE_STRUCTURAL_CORE"] = "python" # poisoned-truth law
|
|
|
|
REPO = Path(__file__).resolve().parents[1]
|
|
sys.path.insert(0, str(REPO / "src"))
|
|
|
|
from rune import structural_store as ss # noqa: E402
|
|
|
|
FIXED_NOW = "2026-10-13T01:02:03Z"
|
|
FIXED_EPOCH = calendar.timegm(_time.strptime(FIXED_NOW, "%Y-%m-%dT%H:%M:%SZ"))
|
|
ss.now = lambda: FIXED_NOW # pin the clock
|
|
# snapshot() formats its stamp straight off time.strftime/gmtime — pin the
|
|
# module reference the oracle actually uses.
|
|
ss.time = types.SimpleNamespace(
|
|
gmtime=lambda: _time.gmtime(FIXED_EPOCH),
|
|
strftime=lambda fmt, t=None: _time.strftime(fmt, t if t is not None else _time.gmtime()),
|
|
)
|
|
|
|
OUT = (REPO / "src" / "rust" / "structural_store" / "src"
|
|
/ "frozen_ss_truth.json")
|
|
|
|
groups: dict[str, list] = {}
|
|
|
|
|
|
def case(group, name, args, expect):
|
|
groups.setdefault(group, []).append(
|
|
{"fn": group, "name": name, "args": args, "expect": expect})
|
|
|
|
|
|
def run(group, name, args, call):
|
|
"""Freeze one case: input deep-copied, oracle called, outcome recorded."""
|
|
frozen_args = copy.deepcopy(args)
|
|
try:
|
|
expect = {"ok": call(copy.deepcopy(args))}
|
|
except ValueError as exc:
|
|
expect = {"err": str(exc)}
|
|
case(group, name, frozen_args, expect)
|
|
|
|
|
|
def ent(id, kind="module", maturity="DECLARED", **kw):
|
|
e = {"id": id, "kind": kind, "maturity": maturity, "evidence_refs": []}
|
|
e.update(kw)
|
|
return e
|
|
|
|
|
|
def doc(*entities, rels=(), obs=(), **kw):
|
|
d = {"schema_version": 1, "generated_at": FIXED_NOW,
|
|
"entities": list(entities), "relationships": list(rels),
|
|
"observations": list(obs)}
|
|
d.update(kw)
|
|
return d
|
|
|
|
|
|
def rel(t, f, to, **kw):
|
|
r = {"type": t, "from": f, "to": to, "evidence_refs": ["ev"],
|
|
"observed_at": FIXED_NOW}
|
|
r.update(kw)
|
|
return r
|
|
|
|
|
|
def main():
|
|
# ── _sorted ─────────────────────────────────────────────────────────
|
|
for name, v in [
|
|
("dict_keys_sorted", {"b": 1, "a": {"z": 2, "y": [3, {"c": 4, "b": 5}]}}),
|
|
("list_of_dicts_by_canonical_form", [{"b": 2, "a": 1}, {"a": 9}, {"a": 1, "b": 2}, {}]),
|
|
("list_of_scalars", [3, 1, 2, "b", "a", True, None]),
|
|
("nested_lists", [[2], [1, 2], [1], []]),
|
|
("unicode_keys_and_values", {"é": "ü", "z": "a", "a": ["z", "é"]}),
|
|
("floats_and_ints", [1.5, 0.5, 2, 1, -1.25]),
|
|
("empty_containers", {"e": [], "f": {}, "g": [[]]}),
|
|
("dict_of_scalars_passthrough", {"x": 1, "y": "s", "z": None, "w": False}),
|
|
]:
|
|
run("sorted", name, {"value": v}, lambda a: ss._sorted(a["value"]))
|
|
|
|
# ── new_doc ─────────────────────────────────────────────────────────
|
|
run("new_doc", "basic", {"now": FIXED_NOW}, lambda a: ss.new_doc())
|
|
|
|
# ── _redact_secrets ─────────────────────────────────────────────────
|
|
for name, v in [
|
|
("exact_names", {"token": "t", "api_token": "t", "api_key": "t",
|
|
"apikey": "t", "password": "t", "secret": "t",
|
|
"auth_header": "t", "authorization": "t",
|
|
"credential": "t", "credentials": "t",
|
|
"private_key": "t", "access_token": "t",
|
|
"bearer": "t", "safe": "keep"}),
|
|
("substring_names", {"my_token": "t", "API_KEY": "t",
|
|
"user_password_hash": "t", "client_secret": "t",
|
|
"my_credentials_v2": "t", "token_count": "t"}),
|
|
("nested", {"a": {"token": "deep"}, "b": [{"password": "x"}, {"ok": 1}]}),
|
|
("non_secret_passthrough", {"a": 1, "b": "s", "c": None, "d": [1, 2]}),
|
|
("case_insensitive", {"Token": "t", "PASSWORD": "t"}),
|
|
]:
|
|
run("redact", name, {"value": v}, lambda a: ss._redact_secrets(a["value"]))
|
|
|
|
# ── save (byte law frozen from the real filesystem) ────────────────
|
|
with tempfile.TemporaryDirectory() as td:
|
|
def save_call(args):
|
|
p = ss.save(copy.deepcopy(args["doc"]),
|
|
Path(td) / args["name"] / "store.json")
|
|
return {"content": Path(p).read_text(), "doc": p and None}
|
|
# capture the mutated doc separately (save mutates schema_version in)
|
|
def save_case(name, d, expect_err=False):
|
|
args = {"doc": copy.deepcopy(d), "name": name}
|
|
try:
|
|
probe = copy.deepcopy(d)
|
|
p = ss.save(probe, Path(td) / name / "store.json")
|
|
content = Path(p).read_text()
|
|
expect = {"ok": {"content": content, "doc": probe}}
|
|
except ValueError as exc:
|
|
expect = {"err": str(exc)}
|
|
case("save", name, args, expect)
|
|
|
|
base = doc(ent("m:a"), rels=[rel("depends_on", "m:a", "m:b")], generated_at=FIXED_NOW)
|
|
save_case("full_doc", base)
|
|
save_case("no_schema_version", {k: v for k, v in base.items() if k != "schema_version"})
|
|
save_case("schema_one_float", {**base, "schema_version": 1.0})
|
|
save_case("schema_ninety_nine", {**base, "schema_version": 99})
|
|
save_case("schema_string", {**base, "schema_version": "x"})
|
|
save_case("secrets_redacted_on_disk", {**base, "credentials": {"token": "s3cret", "note": "x"}})
|
|
save_case("unicode_escaped", {**base, "note": "café ☕ — ok"})
|
|
save_case("empty_doc", {"schema_version": 1})
|
|
save_case("nested_empty", {**base, "ext": {"a": [], "b": {}}})
|
|
|
|
# ── canonical_digest ────────────────────────────────────────────────
|
|
dd = doc(ent("m:a"), rels=[rel("depends_on", "m:a", "m:b")])
|
|
run("digest", "basic", {"doc": dd}, lambda a: ss.canonical_digest(a["doc"]))
|
|
run("digest", "key_order_irrelevant",
|
|
{"doc": dd, "doc_reordered": {"entities": dd["entities"], "schema_version": 1,
|
|
"observations": dd["observations"],
|
|
"relationships": dd["relationships"],
|
|
"generated_at": dd["generated_at"]}},
|
|
lambda a: [ss.canonical_digest(a["doc"]), ss.canonical_digest(a["doc_reordered"])])
|
|
run("digest", "secret_never_changes_digest",
|
|
{"doc": {**dd, "token": "s3cret"}},
|
|
lambda a: [ss.canonical_digest(a["doc"]), ss.canonical_digest({**a["doc"], "token": "other"})])
|
|
run("digest", "unicode", {"doc": {**dd, "note": "é"}}, lambda a: ss.canonical_digest(a["doc"]))
|
|
|
|
# ── snapshot ────────────────────────────────────────────────────────
|
|
with tempfile.TemporaryDirectory() as td:
|
|
def snap_case(name, d, label, tag):
|
|
args = {"doc": copy.deepcopy(d), "dir": "snaps", "label": label, "tag": tag}
|
|
probe = copy.deepcopy(d)
|
|
p = ss.snapshot(probe, Path(td) / name / "snaps", label, tag=tag)
|
|
content = Path(p).read_text()
|
|
case("snapshot", name, args,
|
|
{"ok": {"path": "snaps/" + Path(p).name, "content": content, "doc": probe}})
|
|
snap_case("label_and_tag", dd, "l1", "deadbeef1234")
|
|
snap_case("no_label", dd, "", "deadbeef1234")
|
|
snap_case("empty_tag_is_noident", dd, "l1", "")
|
|
snap_case("short_tag", dd, "", "abc")
|
|
|
|
# ── alias ───────────────────────────────────────────────────────────
|
|
adoc = doc(ent("m:a"), ent("m:b"))
|
|
run("alias", "new_alias", {"doc": adoc, "cid": "m:a", "old": "m:old"},
|
|
lambda a: ss.alias(a["doc"], a["cid"], a["old"]))
|
|
run("alias", "idempotent",
|
|
{"doc": doc(ent("m:a", aliases=["m:old"])), "cid": "m:a", "old": "m:old"},
|
|
lambda a: ss.alias(a["doc"], a["cid"], a["old"]))
|
|
run("alias", "target_missing", {"doc": adoc, "cid": "m:zz", "old": "m:old"},
|
|
lambda a: ss.alias(a["doc"], a["cid"], a["old"]))
|
|
run("alias", "self_alias", {"doc": adoc, "cid": "m:a", "old": "m:a"},
|
|
lambda a: ss.alias(a["doc"], a["cid"], a["old"]))
|
|
run("alias", "via_alias_resolution",
|
|
{"doc": doc(ent("m:a", aliases=["m:old"])), "cid": "m:old", "old": "m:older"},
|
|
lambda a: ss.alias(a["doc"], a["cid"], a["old"]))
|
|
|
|
# ── spine_uri / resolve_uri ─────────────────────────────────────────
|
|
for name, eid in [("kind_name", "project:alpha"), ("no_colon", "alpha"),
|
|
("two_colons", "project:al:pha")]:
|
|
run("spine_uri", name, {"entity_id": eid}, lambda a: ss.spine_uri(a["entity_id"]))
|
|
for name, uri in [("ok", "spine://project/alpha"), ("no_slash", "spine://alpha"),
|
|
("wrong_scheme", "memory://project/alpha"), ("no_scheme", "project/alpha"),
|
|
("nested_slash", "spine://project/a/b")]:
|
|
run("resolve_uri", name, {"uri": uri}, lambda a: ss.resolve_uri(a["uri"]))
|
|
|
|
# ── _doc_authorities ────────────────────────────────────────────────
|
|
for name, d in [
|
|
("defaults_in", doc(ent("m:a"))),
|
|
("existing_untouched", {**doc(ent("m:a")), "authority_generations": {"p": {"generation": 2}}}),
|
|
]:
|
|
a = {"doc": copy.deepcopy(d)}
|
|
d2 = copy.deepcopy(d)
|
|
r = ss._doc_authorities(d2)
|
|
case("doc_authorities", name, a, {"ok": {"doc": d2, "ret": r}})
|
|
|
|
# ── authority_health ────────────────────────────────────────────────
|
|
run("authority_health", "empty", {"doc": doc(ent("m:a"))}, lambda a: ss.authority_health(a["doc"]))
|
|
run("authority_health", "populated",
|
|
{"doc": {**doc(ent("m:a")), "authority_generations": {
|
|
"z-proj": {"generation": 3, "status": "CURRENT", "last_success": FIXED_NOW,
|
|
"last_attempt": FIXED_NOW, "last_error": None, "observed": ["owns|a|b", "owns|c|d"]},
|
|
"a-proj": {"generation": 1, "status": "DEGRADED", "observed": []}}}},
|
|
lambda a: ss.authority_health(a["doc"]))
|
|
run("authority_health", "missing_fields",
|
|
{"doc": {**doc(ent("m:a")), "authority_generations": {"p": {}}}},
|
|
lambda a: ss.authority_health(a["doc"]))
|
|
|
|
# ── bind_task / task_entities ───────────────────────────────────────
|
|
for name, d, task_id, ids, ev in [
|
|
("with_evidence", doc(ent("m:a"), ent("m:b")), "T1", ["m:a", "m:b"], "ev-1"),
|
|
("fallback_evidence", doc(ent("m:a")), "T2", ["m:a"], ""),
|
|
("dedupes_relationships", doc(ent("m:a")), "T3", ["m:a", "m:a"], "ev"),
|
|
]:
|
|
a = {"doc": copy.deepcopy(d), "task_id": task_id, "entity_ids": ids, "evidence_ref": ev}
|
|
d2 = copy.deepcopy(d)
|
|
r = ss.bind_task(d2, task_id, copy.deepcopy(ids), ev)
|
|
case("bind_task", name, a, {"ok": {"doc": d2, "ret": r}})
|
|
tdoc = doc(ent("m:a"), ent("m:b"),
|
|
rels=[rel("affects", "task:T1", "m:b"), rel("affects", "task:T1", "m:a"),
|
|
rel("affects", "task:T9", "m:b")])
|
|
run("task_entities", "sorted_for_task", {"doc": tdoc, "task_id": "T1"},
|
|
lambda a: ss.task_entities(a["doc"], a["task_id"]))
|
|
run("task_entities", "no_bindings", {"doc": tdoc, "task_id": "TX"},
|
|
lambda a: ss.task_entities(a["doc"], a["task_id"]))
|
|
|
|
# ── impact_frontier (branch battery) ────────────────────────────────
|
|
def frontier_case(name, d, seeds, change_kind=None, max_level=2):
|
|
args = {"doc": copy.deepcopy(d), "seeds": seeds,
|
|
"change_kind": change_kind, "max_level": max_level}
|
|
run("impact_frontier", name, args,
|
|
lambda a: ss.impact_frontier(a["doc"], a["seeds"], max_level=a["max_level"],
|
|
change_kind=a["change_kind"]))
|
|
|
|
impl_doc = doc(
|
|
ent("m:core"), ent("m:app"), ent("m:lib"), ent("m:tests"), ent("m:deploy"),
|
|
rels=[
|
|
rel("depends_on", "m:app", "m:core"),
|
|
rel("implements", "m:app", "c:api"),
|
|
rel("implements", "m:lib", "c:api"),
|
|
rel("consumes", "m:core", "c:api"),
|
|
rel("verified_by", "m:app", "k:canary"),
|
|
rel("deployed_as", "m:core", "d:live"),
|
|
rel("documented_by", "m:core", "doc:r"),
|
|
rel("supersedes", "m:lib", "m:old"),
|
|
rel("consumed_by", "m:lib", "m:core"),
|
|
])
|
|
frontier_case("implementation_change", impl_doc, ["m:app"])
|
|
frontier_case("contract_change", impl_doc, ["c:api"])
|
|
frontier_case("contract_violation", impl_doc, ["c:api"], change_kind="contract_violation")
|
|
frontier_case("inferred_from_contract_kind", impl_doc, ["c:api"], change_kind=None)
|
|
frontier_case("stale_and_candidate_skipped",
|
|
doc(ent("m:a"), ent("m:b"), ent("m:c"),
|
|
rels=[rel("depends_on", "m:a", "m:b", status="STALE"),
|
|
rel("depends_on", "m:a", "m:c", status="CANDIDATE")]),
|
|
["m:a"])
|
|
frontier_case("non_obligation_never_expands",
|
|
doc(ent("m:a"), ent("m:b"),
|
|
rels=[rel("documented_by", "m:a", "m:b")]),
|
|
["m:a"])
|
|
frontier_case("consumed_by_reverse",
|
|
doc(ent("m:a"), ent("m:b"),
|
|
rels=[rel("consumed_by", "m:b", "m:a")]),
|
|
["m:a"])
|
|
frontier_case("level2_from_level1_and_contextual", impl_doc, ["m:core"])
|
|
frontier_case("multi_seed_dedup", impl_doc, ["m:app", "m:app", "m:core"])
|
|
frontier_case("alias_seed_kind",
|
|
doc(ent("c:api", kind="contract", aliases=["c:old"]),
|
|
ent("m:app"),
|
|
rels=[rel("implements", "m:app", "c:api")]),
|
|
["c:old"])
|
|
|
|
# ── record_observed_impact ──────────────────────────────────────────
|
|
for name, items in [
|
|
("basic", [{"entity": "m:a", "source": "test", "detail": "d", "authority": "ci"},
|
|
{"entity": "m:b"}]),
|
|
("empty_entity_skipped", [{"entity": "", "source": "x"}, {"entity": "m:a"}]),
|
|
("detail_truncated_300", [{"entity": "m:a", "detail": "x" * 500}]),
|
|
("detail_multibyte_truncated", [{"entity": "m:a", "detail": "é" * 400}]),
|
|
("defaults", [{"entity": "m:a"}]),
|
|
]:
|
|
d0 = doc(ent("m:a"), ent("m:b"))
|
|
a = {"doc": copy.deepcopy(d0), "task_id": "T1", "items": copy.deepcopy(items)}
|
|
d2 = copy.deepcopy(d0)
|
|
result = ss.record_observed_impact(d2, "T1", copy.deepcopy(items))
|
|
case("observed_impact", name, a, {"ok": {"doc": d2, "result": result}})
|
|
|
|
# ── predicted_vs_observed ───────────────────────────────────────────
|
|
pdoc = doc(ent("m:a"), ent("m:b"), ent("m:c"),
|
|
rels=[rel("depends_on", "m:a", "m:b"), rel("depends_on", "m:a", "m:c")])
|
|
pred = {"level0_direct": ["m:a"], "level1_obligations": ["m:b"],
|
|
"contracts": [], "level2_verification": []}
|
|
run("predicted_vs_observed", "miss_and_needless",
|
|
{"predicted": pred, "observed_doc": pdoc, "seeds": ["m:a"]},
|
|
lambda a: ss.predicted_vs_observed(a["predicted"], a["observed_doc"], a["seeds"]))
|
|
run("predicted_vs_observed", "exact_match",
|
|
{"predicted": {"level0_direct": ["m:a"], "level1_obligations": ["m:b", "m:c"],
|
|
"contracts": [], "level2_verification": []},
|
|
"observed_doc": pdoc, "seeds": ["m:a"]},
|
|
lambda a: ss.predicted_vs_observed(a["predicted"], a["observed_doc"], a["seeds"]))
|
|
|
|
# ── structural_events ───────────────────────────────────────────────
|
|
run("events", "full",
|
|
{"doc": doc(ent("m:a", observed_at=FIXED_NOW), ent("m:b", observed_at=FIXED_NOW),
|
|
rels=[rel("depends_on", "m:a", "m:b")],
|
|
obs=[{"kind": "superseded", "old": "x", "new": "y", "observed_at": FIXED_NOW}])},
|
|
lambda a: ss.structural_events(a["doc"]))
|
|
run("events", "observation_kind_default_and_type_override",
|
|
{"doc": doc(ent("m:a"),
|
|
obs=[{"note": "no kind"}, {"kind": "k1", "type": "explicit_type"}])},
|
|
lambda a: ss.structural_events(a["doc"]))
|
|
|
|
# ── diff ────────────────────────────────────────────────────────────
|
|
old = doc(ent("m:a"), ent("m:gone"), ent("m:same", identities={"p": 1}, maturity="DECLARED"),
|
|
rels=[rel("depends_on", "m:a", "m:gone")])
|
|
new = doc(ent("m:a"), ent("m:new"), ent("m:same", identities={"p": 2}, maturity="WIRED"),
|
|
rels=[rel("depends_on", "m:a", "m:new"), rel("depends_on", "m:a", "m:a")])
|
|
run("diff", "all_categories", {"old": old, "new": new}, lambda a: ss.diff(a["old"], a["new"]))
|
|
run("diff", "no_changes", {"old": old, "new": copy.deepcopy(old)},
|
|
lambda a: ss.diff(a["old"], a["new"]))
|
|
|
|
# ── dedupe_observations ─────────────────────────────────────────────
|
|
for name, d in [
|
|
("exact_dups", doc(ent("m:a"), obs=[{"kind": "k", "x": 1}, {"x": 1, "kind": "k"},
|
|
{"kind": "k", "x": 2}])),
|
|
("nested_dups", doc(ent("m:a"), obs=[{"a": {"z": 1, "b": [2]}}, {"a": {"b": [2], "z": 1}}])),
|
|
("empty", doc(ent("m:a"))),
|
|
]:
|
|
a = {"doc": copy.deepcopy(d)}
|
|
d2 = copy.deepcopy(d)
|
|
r = ss.dedupe_observations(d2)
|
|
case("dedupe", name, a, {"ok": {"doc": d2, "ret": r}})
|
|
|
|
# ── fixed-kernel regressions (oracle parity proofs) ─────────────────
|
|
for name, d, eid, state, ev, ret in [
|
|
("unknown_entity_returns_none", doc(ent("m:a")), "m:zz", "PRESENT", "e", None),
|
|
("via_alias", doc(ent("m:a", aliases=["m:old"])), "m:old", "PRESENT", "e", "PRESENT"),
|
|
("missing_entity_beats_bad_state", doc(ent("m:a")), "m:zz", "BOGUS", "", None),
|
|
("demotion_recorded", doc(ent("m:a", maturity="PRESENT")), "m:a", "DECLARED", "e2", "PRESENT"),
|
|
]:
|
|
a = {"doc": copy.deepcopy(d), "id": eid, "state": state, "ev": ev}
|
|
d2 = copy.deepcopy(d)
|
|
r = ss.promote(d2, eid, state, ev)
|
|
case("promote_fix", name, a, {"ok": {"ret": r, "doc": d2}})
|
|
run("resolve_status_fix", "status_verbatim",
|
|
{"entity": {"status": "WEIRD"}}, lambda a: ss.resolve_status(a["entity"]))
|
|
run("resolve_status_fix", "empty_conflicts_not_conflicting",
|
|
{"entity": {"maturity": "DECLARED", "ext": {"conflicts": []}}},
|
|
lambda a: ss.resolve_status(a["entity"]))
|
|
for name, d, nid, oid in [
|
|
("rel_has_observed_at", doc(ent("m:a"), ent("m:b")), "m:b", "m:a"),
|
|
("via_alias", doc(ent("m:a", aliases=["m:old"]), ent("m:b")), "m:b", "m:old"),
|
|
]:
|
|
a = {"doc": copy.deepcopy(d), "new": nid, "old": oid, "ev": "ev-s"}
|
|
d2 = copy.deepcopy(d)
|
|
ss.supersede(d2, nid, oid, "ev-s")
|
|
case("supersede_fix", name, a, {"ok": {"doc": d2}})
|
|
|
|
# ── segments (store v2, 2026-10-13 segment law) ────────────────────
|
|
for name, eid in [
|
|
("colons", "task:T-1"), ("spaces", "m:a b"), ("unicode", "é-unit"),
|
|
("slashes", "a/b/c"), ("dots_ok", "a.b.c"), ("empty", ""),
|
|
("mixed", "x:y/z w!@"), ("trailing_dash", "ok-_.x"),
|
|
]:
|
|
run("safe_id", name, {"entity_id": eid},
|
|
lambda a: ss._safe_id(a["entity_id"]))
|
|
for name, sp in [("bare", "store.json"), ("rel", "a/b/store.json"),
|
|
("abs", "/x/y/store.json"), ("deep", "a/b/c/d/s.json")]:
|
|
run("segments_dir", name, {"store_path": sp},
|
|
lambda a: str(ss.segments_dir(a["store_path"])))
|
|
|
|
def seg_ent(id, phase=None, observed_at=None, ext=None, **kw):
|
|
e = {"id": id, "kind": "module", "maturity": "DECLARED"}
|
|
if phase is not None:
|
|
e["phase"] = phase
|
|
if observed_at is not None:
|
|
e["observed_at"] = observed_at
|
|
if ext is not None:
|
|
e["ext"] = ext
|
|
e.update(kw)
|
|
return e
|
|
|
|
for name, ents in [
|
|
("empty", []),
|
|
("no_duplicates", [seg_ent("m:a", "open", "2026-01-01T00:00:00Z")]),
|
|
("phase_rank_wins", [
|
|
seg_ent("m:a", "open", "2026-12-01T00:00:00Z"),
|
|
seg_ent("m:a", "closed", "2026-01-01T00:00:00Z")]),
|
|
("later_phase_first_wins_over_later_time", [
|
|
seg_ent("m:a", "verifying", "2026-01-01T00:00:00Z"),
|
|
seg_ent("m:a", "building", "2026-12-01T00:00:00Z")]),
|
|
("observed_at_tiebreak", [
|
|
seg_ent("m:a", "approved", "2026-01-01T00:00:00Z"),
|
|
seg_ent("m:a", "approved", "2026-02-01T00:00:00Z")]),
|
|
("contract_quality_tiebreak", [
|
|
seg_ent("m:a", "approved", "2026-01-01T00:00:00Z"),
|
|
seg_ent("m:a", "approved", "2026-01-01T00:00:00Z",
|
|
ext={"contract_quality": {"rows": 3}})]),
|
|
("equal_scores_first_wins", [
|
|
seg_ent("m:a", "open", "2026-01-01T00:00:00Z", note="first"),
|
|
seg_ent("m:a", "open", "2026-01-01T00:00:00Z", note="second")]),
|
|
("unknown_phase_ranks_open", [
|
|
seg_ent("m:a", "WEIRD", "2026-01-01T00:00:00Z"),
|
|
seg_ent("m:a", None, "2026-01-01T00:00:00Z", note="default")]),
|
|
("missing_fields_default", [{"id": "m:a"}, {"id": "m:a", "phase": "closed"}]),
|
|
("missing_ids_key_empty", [{"kind": "x"}, {"id": "", "phase": "closed"}]),
|
|
("distinct_ids_kept", [seg_ent("m:a"), seg_ent("m:b"), seg_ent("m:c")]),
|
|
("ext_list_membership", [
|
|
seg_ent("m:a", "open", "2026-01-01T00:00:00Z", ext=["contract_quality"]),
|
|
seg_ent("m:a", "open", "2026-01-01T00:00:00Z")]),
|
|
("ext_string_substring", [
|
|
seg_ent("m:a", "open", "2026-01-01T00:00:00Z", ext="xcontract_qualityy"),
|
|
seg_ent("m:a", "open", "2026-01-01T00:00:00Z")]),
|
|
]:
|
|
a = {"entities": copy.deepcopy(ents)}
|
|
try:
|
|
expect = {"ok": ss._collapse_entities(copy.deepcopy(ents))}
|
|
except (ValueError, TypeError, KeyError) as exc:
|
|
expect = {"err": f"{type(exc).__name__}: {exc}"}
|
|
case("collapse", name, a, expect)
|
|
for name, ents in [
|
|
# crash classes need a SECOND same-id variant: the oracle's
|
|
# `k not in best or ...` short-circuit stores the first unscored
|
|
("ext_null_crash", [
|
|
{"id": "m:a", "ext": None}, {"id": "m:a"}]),
|
|
("ext_null_crash_second_variant", [
|
|
{"id": "m:a"}, {"id": "m:a", "ext": None}]),
|
|
("observed_at_int_vs_str_crash", [
|
|
seg_ent("m:a", "open", 5), seg_ent("m:a", "open", "2026")]),
|
|
("observed_at_none_vs_str_crash", [
|
|
{"id": "m:a", "phase": "open", "observed_at": None},
|
|
seg_ent("m:a", "open", "2026")]),
|
|
]:
|
|
a = {"entities": copy.deepcopy(ents)}
|
|
try:
|
|
expect = {"ok": ss._collapse_entities(copy.deepcopy(ents))}
|
|
except (ValueError, TypeError, KeyError) as exc:
|
|
expect = {"err": f"{type(exc).__name__}: {exc}"}
|
|
case("collapse", name, a, expect)
|
|
|
|
def tree_of(root: Path) -> dict:
|
|
out = {}
|
|
for p in sorted(root.rglob("*")):
|
|
if p.is_file():
|
|
out[str(p.relative_to(root))] = p.read_text()
|
|
return out
|
|
|
|
with tempfile.TemporaryDirectory() as td:
|
|
def seg_save_case(name, pre, d):
|
|
case_dir = Path(td) / name
|
|
for rel, content in (pre or {}).items():
|
|
p = case_dir / rel
|
|
p.parent.mkdir(parents=True, exist_ok=True)
|
|
p.write_text(content)
|
|
a = {"doc": copy.deepcopy(d), "pre": copy.deepcopy(pre or {})}
|
|
try:
|
|
ret = ss.save_segments(copy.deepcopy(d), case_dir / "store.json")
|
|
expect = {"ok": {"ret": "segments", "files": tree_of(case_dir)}}
|
|
except (ValueError, TypeError, KeyError) as exc:
|
|
expect = {"err": f"{type(exc).__name__}: {exc}"}
|
|
case("save_segments", name, a, expect)
|
|
|
|
full_doc = doc(
|
|
ent("m:core", phase="building", observed_at=FIXED_NOW),
|
|
ent("m:app", observed_at=FIXED_NOW, ext={"n": 1},
|
|
credentials={"token": "s3cret"}),
|
|
rels=[rel("depends_on", "m:app", "m:core")],
|
|
obs=[{"kind": "superseded", "old": "x", "new": "y",
|
|
"observed_at": FIXED_NOW}])
|
|
seg_save_case("fresh_full", None, full_doc)
|
|
# idempotency: pre-write the m:app segment with the SAME JSON in a
|
|
# different key order and NO trailing newline — a save that
|
|
# respects parsed-equality leaves those bytes untouched.
|
|
pre_reorder = {
|
|
"segments/entities/m__app.json":
|
|
'{ "maturity": "DECLARED",\n "id": "m:app",\n "kind": "module",'
|
|
'\n "evidence_refs": [],\n "ext": { "n": 1 },'
|
|
'\n "credentials": "<redacted>",\n "observed_at":'
|
|
f' "{FIXED_NOW}" }}',
|
|
}
|
|
seg_save_case("idempotent_no_rewrite", pre_reorder, full_doc)
|
|
seg_save_case("corrupt_entity_rewritten",
|
|
{"segments/entities/m__app.json": "not json{"}, full_doc)
|
|
# journal dedup parses stored lines: a stored line in different key
|
|
# order still suppresses the append (file bytes untouched).
|
|
pre_journal = {
|
|
"segments/entities/m__core.json":
|
|
json.dumps(ss._sorted(ss._redact_secrets(full_doc["entities"][0])),
|
|
indent=1, sort_keys=True) + "\n",
|
|
"segments/entities/m__app.json":
|
|
json.dumps(ss._sorted(ss._redact_secrets(full_doc["entities"][1])),
|
|
indent=1, sort_keys=True) + "\n",
|
|
"segments/observations.jsonl":
|
|
f'{{"observed_at": "{FIXED_NOW}", "kind": "superseded", "new": "y",'
|
|
' "old": "x"}\n\nnot json\n',
|
|
"segments/relationships.jsonl":
|
|
f'{{"evidence_refs": ["ev"], "from": "m:app", "observed_at":'
|
|
f' "{FIXED_NOW}", "to": "m:core", "type": "depends_on"}}\n',
|
|
}
|
|
seg_save_case("journal_dedup_blank_corrupt", pre_journal, full_doc)
|
|
seg_save_case("collapse_before_write", None, doc(
|
|
seg_ent("m:dup", "open", "2026-12-01T00:00:00Z"),
|
|
seg_ent("m:dup", "closed", "2026-01-01T00:00:00Z")))
|
|
seg_save_case("missing_id_crash", None, {"entities": [{"kind": "x"}]})
|
|
seg_save_case("ext_null_crash", None,
|
|
{"entities": [{"id": "m:a", "ext": None}, {"id": "m:a"}]})
|
|
seg_save_case("empty_doc_creates_empty_journals", None, {})
|
|
seg_save_case("unicode_ids", None, doc(
|
|
ent("é-unit:φ"), ent("m:ok"),
|
|
obs=[{"kind": "k", "note": "café ☕"}]))
|
|
|
|
def seg_load_case(name, pre):
|
|
case_dir = Path(td) / name
|
|
for rel, content in (pre or {}).items():
|
|
p = case_dir / rel
|
|
p.parent.mkdir(parents=True, exist_ok=True)
|
|
p.write_text(content)
|
|
a = {"pre": copy.deepcopy(pre or {})}
|
|
got = ss.load_segments(case_dir / "store.json")
|
|
expect = {"ok": got}
|
|
case("load_segments", name, a, expect)
|
|
|
|
seg_load_case("no_segments", None)
|
|
seg_load_case("full_tree", pre_journal)
|
|
seg_load_case("corrupt_entity_skipped", {
|
|
"segments/entities/bad.json": "{oops",
|
|
"segments/entities/ok.json": '{"id": "m:ok"}',
|
|
"segments/entities/notjson.txt": "ignored by glob",
|
|
})
|
|
seg_load_case("filename_order_pinned", {
|
|
"segments/entities/a__b.json": '{"id": "a:b"}',
|
|
"segments/entities/a.json": '{"id": "a"}',
|
|
"segments/entities/A.json": '{"id": "A"}',
|
|
"segments/entities/é.json": '{"id": "é"}',
|
|
})
|
|
seg_load_case("journal_blank_corrupt_lines", {
|
|
"segments/entities/x.json": '{"id": "m:x"}',
|
|
"segments/observations.jsonl": '{"kind": "k"}\n\nnot json\n{"kind":"k2"}\n',
|
|
"segments/relationships.jsonl": '[1, 2]\n',
|
|
})
|
|
seg_load_case("non_dict_entity_value", {
|
|
"segments/entities/list.json": '[1, 2]',
|
|
})
|
|
|
|
for name, d in [
|
|
("basic", doc(ent("m:a"), ent("m:b"))),
|
|
("secret_redacted", doc(ent("m:a", credentials={"token": "s3cret"}))),
|
|
("key_order_irrelevant", doc(ent("m:a"))),
|
|
("unicode", doc(ent("é-unit:φ"))),
|
|
("missing_id_crash", {"entities": [{"kind": "x"}]}),
|
|
("int_id_coerced", {"entities": [{"id": 1, "kind": "x"}]}),
|
|
]:
|
|
a = {"doc": copy.deepcopy(d)}
|
|
try:
|
|
if name == "key_order_irrelevant":
|
|
d2 = {"entities": [{"kind": "module", "id": "m:a",
|
|
"maturity": "DECLARED", "evidence_refs": []}]}
|
|
expect = {"ok": [ss.entity_content_hashes(copy.deepcopy(d)),
|
|
ss.entity_content_hashes(d2)]}
|
|
else:
|
|
expect = {"ok": ss.entity_content_hashes(copy.deepcopy(d))}
|
|
except (ValueError, TypeError, KeyError) as exc:
|
|
expect = {"err": f"{type(exc).__name__}: {exc}"}
|
|
case("content_hashes", name, a, expect)
|
|
|
|
out = {"module": "structural_store", "now": FIXED_NOW, "groups": groups}
|
|
OUT.write_text(json.dumps(out, indent=1, sort_keys=True) + "\n")
|
|
total = sum(len(v) for v in groups.values())
|
|
print(f"frozen {total} cases across {len(groups)} groups -> {OUT}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|