open/portfolio-optimiser-claude
1
0
Fork 0
Code Issues Releases 1 Activity

test(ingest-spec): §11's two tables get the §12 row-anchor form

Browse source 
_STRUCTURE_MARKERS binds one phrase per section — blind to a row DROPPED
from a section that keeps its other prose, exactly the gap _CONTRACT_FIELDS
closes for §12. §11 carries two machine-readable tables of its own (golden
extraction format, 4 rows; load-bearing conformance seams, 9 rows), keyed
on a plain-text first column, never row-anchored until now.

Repeats the §12 form (table slice, undocumented-row check, row-removed/
row-renamed red-proofs, fail-closed heading rename) for both tables. The
selection is the hard part for the 9 seam rows: each is a CLAIM that a test
in this repo goes RED when the seam detaches, not a contract field. 7 of 9
anchor to a named test; 2 are deliberately left unanchored because no test
here makes the claim true — "Stamp integrity (curated writers)" is the
library's authoring surface, which exposes no curated-writer primitive at
all, and "Title link-safety" has no bracket-title test (only "two\nlines"
is covered, a different rejection).

Denominator measured on disk: each of the 11 anchored rows individually
deleted from the real shared/ingest-spec.md (git-restored + sha256-verified
after every mutation), full suite run — every row reds exactly its own two
new tests, nothing pre-existing. 884 -> 923 tests.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018TPNsXNGzqJ96N8y3ehg1h
This commit is contained in:
Kjell Tore Guttormsen 2026-08-20 23:18:23 +02:00
commit de11f2db35
1 changed files with 262 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

267
tests/test_ingest_spec_loadbearing.py
View file

@ -12,11 +12,14 @@ one-off spot-check that dies with the session. Red-proofs run against a mutated
the spec in ``tmp_path`` — never against ``shared/`` itself.
**Second half — structure markers (added after a measurement).** Everything above anchors
§12 plus two whole-document properties. Measured: gutting ANY of §1–§11 to its heading alone
left this guard green for 11 of 11 sections — and measured wider, for 10 of the 11 nothing in
the whole 806-test suite went red either, so a commons pull could empty a normative section
and no test would notice. (§7 is the single overlap: the O2 ratchet reads its `generated`
row.) ``_STRUCTURE_MARKERS`` closes that hole by
§12 plus two whole-document properties. Measured AT THE TIME (806-test suite, before the
§11 row anchors below existed): gutting ANY of §1–§11 to its heading alone left this guard
green for 11 of 11 sections — and measured wider, for 10 of the 11 nothing in the whole
suite went red either, so a commons pull could empty a normative section and no test would
notice. (§7 was the single overlap: the O2 ratchet reads its `generated` row.) That claim is
now STALE for §11 specifically — gutting §11 today also reds all 11 row anchors below, since
their tables live in the same body the marker phrase does. ``_STRUCTURE_MARKERS`` closes that
hole by
binding ONE verbatim normative phrase to the section that OWNS it, the form already proven in
``test_method_spec_rule_phrases_loadbearing.py``. Two properties make the binding real rather
than decorative: the phrase must appear in ITS OWN section body (presence anywhere is what a
@ -31,6 +34,36 @@ green-but-dead of the opposite kind — protecting spec text nothing here depend
here on a second, independent sentence.
Matching is whitespace- and emphasis-normalized so a reflow or a bolding change does not
false-red; the normalization has its own controls below.
**Third half — §11 row anchors (STATE pkt. 4, ORDER 20260818T155933Z).** ``_STRUCTURE_MARKERS``
binds ONE phrase per section, so it cannot see a row DROPPED from a section that keeps its
other prose intact — exactly the §12 gap ``_CONTRACT_FIELDS`` closes for the machine-readable
contract fields. §11 carries two of its own machine-readable tables, keyed on a plain-text
(not backtick) FIRST column, never covered by a row anchor: the golden extraction format
(4 rows) and the load-bearing conformance seams (9 rows). This section repeats the §12 form
— ``*_table`` slice, ``_undocumented_*`` row check, row-removed/row-renamed red-proofs,
fail-closed heading rename — for both.
The SELECTION is, again, ours — and here it is the hard part, because §11's 9 seam rows are
not machine-readable contract fields, they are CLAIMS that a test in this repo goes RED when
the row's seam detaches. A row anchored without such a test would be green-but-dead of the
opposite kind: protecting spec text nothing here depends on. Two of the nine are NOT anchored
because no test in this repo makes that claim true (see ``_LOAD_BEARING_SEAMS`` below for the
per-row citation, and the comment beside it for the two exclusions and why).
DENOMINATOR, measured on disk (not just detach-proved in-process): each of the 11 anchored
rows was individually deleted from the real ``shared/ingest-spec.md`` (git-restored after
every mutation, `git status` clean + sha256 unchanged before and after), and the full 923-test
suite run against the mutation. Every one of the 11 reds EXACTLY its own two new tests
(``test_spec_documents_*`` + ``test_guard_red_when_*_row_removed``) — nothing pre-existing
reds for any of them, so these anchors are the only thing standing there, not a second copy
of coverage that already existed.
KNOWN LIMITATION (inherited, not fixed here): the row match is exact-whitespace
(``f"| {row} |"``), like ``_CONTRACT_FIELDS`` above and unlike ``_STRUCTURE_MARKERS``'s
normalized match. A commons reflow that pads these two tables for column alignment would
false-red all 11 row anchors at once. Left as-is for consistency with the §12 form this
section mirrors; not a live problem today (measured against the current spec).
"""
from __future__ import annotations
@ -376,3 +409,227 @@ def test_normalization_is_not_so_loose_that_anything_matches() -> None:
assert _normalize("a b\n c") == "a b c"
assert _normalize("**bold** text") == "bold text"
assert _normalize("MUST fail fast") != _normalize("MUST fail slowly")
# --- §11 row anchors: two tables, plain-text FIRST column, the §12 form repeated ------
_GOLDEN_FORMAT_HEADING = "**Golden extraction format:**"
_LOAD_BEARING_HEADING = "**Load-bearing conformance tests**"
# Golden extraction format (§11), entry -> the test that reads/writes it by this exact name.
_GOLDEN_FORMAT_ENTRIES: dict[str, str] = {
"manifest.json": "test_ingest_golden.py (GOLDEN / 'manifest.json', every test)",
"fixture/": "test_ingest_golden.py::TestMutationControl (case / 'fixture' / 'costs.csv')",
"ingested-at.txt": "test_ingest_golden.py::_ingested_at (the fixed §5 timestamp)",
"expected-bundle/": "test_ingest_golden.py::test_materializes_golden_byte_for_byte",
}
# Load-bearing conformance seams (§11), seam -> the test that goes RED when it detaches.
# Anchored: seven of nine — each cites a test in THIS repo that makes the row's claim true.
_LOAD_BEARING_SEAMS: dict[str, str] = {
"Provenance stamping": (
"test_ingest_loadbearing.py::TestProvenanceStamping"
"::test_generated_file_carries_the_provenance_layer"
),
"Navigability": (
"test_ingest_loadbearing.py::TestNavigability::test_generated_bundle_navigates_via_unchanged_okf"
),
"Verdict reservation": (
"test_ingest_loadbearing.py::TestVerdictReservation::test_verdict_okf_type_is_rejected"
),
"Re-ingest layer safety": (
"test_ingest_loadbearing.py::TestReingestLayerSafety"
"::test_promoted_verdict_and_curated_survive_reingest"
),
"Golden regression": "test_ingest_golden.py::test_materializes_golden_byte_for_byte",
# We carry this seam as a REFUSAL, not as an http connector (§1 makes http optional):
# the adapter never passes the network opt-in, so an http source is refused fail-fast.
"Network gate": (
"test_ingest_adoption.py::TestOfflineInvariant::test_http_source_is_refused_at_the_network_gate"
),
# Self-referential and deliberately so: this row's three clauses ARE the three guards
# already in this file.
"Spec integrity": (
"test_spec_is_present / test_spec_names_no_agent_toolkit / "
"test_spec_documents_contract_field (this file)"
),
}
# NOT anchored — no test in this repo makes the row's claim true; anchoring either would be
# green-but-dead, protecting spec text nothing here depends on:
#
# - "Stamp integrity (curated writers)": the reject-on-complete-stamp check is the §3
# verbatim-authoring-path's job. It lives in the llm-ingestion-okf LIBRARY, not in this
# repo's src/ — verified: the library's public surface (Extraction, FileSource, HttpSource,
# IngestError, IngestResult, Manifest, ManifestError, MaterializationError, NetworkGateError,
# RenderError, SourceError, SqlSource, connectors, errors, load_manifest, manifest,
# materialize, materialize_bundle, render) exposes no curated-writer / authoring primitive
# at all, and no test here forges the ownership stamp and asserts rejection. `inbox.py`'s
# "authoring primitive" is a different one (method-spec §5 verdict JSON, not OKF concept
# frontmatter) and does not touch this seam.
# - "Title link-safety": no test here supplies a title containing `[` or `]` and asserts
# fail-fast rejection. `test_ingest.py::TestManifestValidation::test_malformed_manifest_is_rejected`
# mutates title to `"two\nlines"` — a different rejection, not this one.
def _golden_format_table(text: str) -> str:
"""The golden-format table body — heading to the start of the next table."""
start = text.index(_GOLDEN_FORMAT_HEADING) # RED (ValueError) if the heading is renamed
end = text.index(_LOAD_BEARING_HEADING, start)
return text[start:end]
def _load_bearing_table(text: str) -> str:
"""The load-bearing table body — heading to end-of-spec or the next section."""
start = text.index(_LOAD_BEARING_HEADING) # RED (ValueError) if the heading is renamed
end = text.find("\n## ", start + len(_LOAD_BEARING_HEADING))
return text[start:] if end == -1 else text[start:end]
def _golden_slice_defects(table: str) -> list[str]:
defects = []
if not table.startswith(_GOLDEN_FORMAT_HEADING):
defects.append("does not start at the golden-format heading")
if _LOAD_BEARING_HEADING in table:
defects.append("leaked the load-bearing table")
if "\n## " in table:
defects.append("leaked past §11 into a following section")
return defects
def _load_bearing_slice_defects(table: str) -> list[str]:
defects = []
if not table.startswith(_LOAD_BEARING_HEADING):
defects.append("does not start at the load-bearing heading")
if _CROSS_CHECK_HEADING in table:
defects.append("leaked §12")
if "\n## " in table:
defects.append("leaked a following section")
return defects
def _undocumented_golden_entries(text: str) -> list[str]:
table = _golden_format_table(text)
return [entry for entry in _GOLDEN_FORMAT_ENTRIES if f"| `{entry}` |" not in table]
def _undocumented_loadbearing_seams(text: str) -> list[str]:
table = _load_bearing_table(text)
return [seam for seam in _LOAD_BEARING_SEAMS if f"| {seam} |" not in table]
def _golden_row_removed(text: str, entry: str) -> str:
table = _golden_format_table(text)
marker = f"| `{entry}` |"
kept = [ln for ln in table.splitlines(keepends=True) if not ln.startswith(marker)]
return text.replace(table, "".join(kept))
def _golden_row_renamed(text: str, entry: str) -> str:
table = _golden_format_table(text)
marker = f"| `{entry}` |"
return text.replace(table, table.replace(marker, f"| `{entry}_renamed` |"))
def _loadbearing_row_removed(text: str, seam: str) -> str:
table = _load_bearing_table(text)
marker = f"| {seam} |"
kept = [ln for ln in table.splitlines(keepends=True) if not ln.startswith(marker)]
return text.replace(table, "".join(kept))
def _loadbearing_row_renamed(text: str, seam: str) -> str:
table = _load_bearing_table(text)
marker = f"| {seam} |"
return text.replace(table, table.replace(marker, f"| {seam} (renamed) |"))
def test_golden_format_slice_is_a_slice_and_not_the_whole_spec() -> None:
defects = _golden_slice_defects(_golden_format_table(SPEC.read_text(encoding="utf-8")))
assert not defects, f"the golden-format anchor degenerated: {defects}"
def test_load_bearing_slice_is_a_slice_and_not_the_whole_spec() -> None:
defects = _load_bearing_slice_defects(_load_bearing_table(SPEC.read_text(encoding="utf-8")))
assert not defects, f"the load-bearing anchor degenerated: {defects}"
@pytest.mark.parametrize("entry", _GOLDEN_FORMAT_ENTRIES)
def test_spec_documents_golden_format_entry(entry: str) -> None:
# RED when an amendment drops or renames a golden-format row.
undocumented = _undocumented_golden_entries(SPEC.read_text(encoding="utf-8"))
assert entry not in undocumented, f"golden-format entry {entry!r} is no longer a row in §11"
@pytest.mark.parametrize("seam", _LOAD_BEARING_SEAMS)
def test_spec_documents_loadbearing_seam(seam: str) -> None:
# RED when an amendment drops or renames an anchored load-bearing row.
undocumented = _undocumented_loadbearing_seams(SPEC.read_text(encoding="utf-8"))
assert seam not in undocumented, f"load-bearing seam {seam!r} is no longer a row in §11"
@pytest.mark.parametrize("entry", _GOLDEN_FORMAT_ENTRIES)
def test_guard_red_when_golden_row_removed(tmp_path: Path, entry: str) -> None:
text = SPEC.read_text(encoding="utf-8")
assert entry not in _undocumented_golden_entries(text) # positive control first
copy = tmp_path / "ingest-spec.md"
copy.write_text(_golden_row_removed(text, entry), encoding="utf-8")
assert entry in _undocumented_golden_entries(copy.read_text(encoding="utf-8"))
@pytest.mark.parametrize("entry", _GOLDEN_FORMAT_ENTRIES)
def test_guard_red_when_golden_row_renamed(tmp_path: Path, entry: str) -> None:
# A detach-proof is not a value-proof — the row still exists, under another name.
copy = tmp_path / "ingest-spec.md"
copy.write_text(_golden_row_renamed(SPEC.read_text(encoding="utf-8"), entry), encoding="utf-8")
assert entry in _undocumented_golden_entries(copy.read_text(encoding="utf-8"))
@pytest.mark.parametrize("seam", _LOAD_BEARING_SEAMS)
def test_guard_red_when_loadbearing_row_removed(tmp_path: Path, seam: str) -> None:
text = SPEC.read_text(encoding="utf-8")
assert seam not in _undocumented_loadbearing_seams(text) # positive control first
copy = tmp_path / "ingest-spec.md"
copy.write_text(_loadbearing_row_removed(text, seam), encoding="utf-8")
assert seam in _undocumented_loadbearing_seams(copy.read_text(encoding="utf-8"))
@pytest.mark.parametrize("seam", _LOAD_BEARING_SEAMS)
def test_guard_red_when_loadbearing_row_renamed(tmp_path: Path, seam: str) -> None:
copy = tmp_path / "ingest-spec.md"
copy.write_text(
_loadbearing_row_renamed(SPEC.read_text(encoding="utf-8"), seam), encoding="utf-8"
)
assert seam in _undocumented_loadbearing_seams(copy.read_text(encoding="utf-8"))
def test_guard_red_when_golden_format_heading_renamed(tmp_path: Path) -> None:
# Fail-closed: no heading means no anchor, and the slice must raise, not silently fall
# back to a wider (green-but-dead) match.
mutated = SPEC.read_text(encoding="utf-8").replace(
_GOLDEN_FORMAT_HEADING, "**Golden fixture format:**"
)
copy = tmp_path / "ingest-spec.md"
copy.write_text(mutated, encoding="utf-8")
with pytest.raises(ValueError):
_golden_format_table(copy.read_text(encoding="utf-8"))
def test_guard_red_when_load_bearing_heading_renamed(tmp_path: Path) -> None:
mutated = SPEC.read_text(encoding="utf-8").replace(
_LOAD_BEARING_HEADING, "**Load-bearing regression tests**"
)
copy = tmp_path / "ingest-spec.md"
copy.write_text(mutated, encoding="utf-8")
with pytest.raises(ValueError):
_load_bearing_table(copy.read_text(encoding="utf-8"))
def test_golden_slice_guard_red_when_anchor_degenerates_to_whole_spec() -> None:
defects = _golden_slice_defects(SPEC.read_text(encoding="utf-8"))
assert defects, "the golden-format slice guard accepts the whole spec — it is dead"
def test_load_bearing_slice_guard_red_when_anchor_degenerates_to_whole_spec() -> None:
defects = _load_bearing_slice_defects(SPEC.read_text(encoding="utf-8"))
assert defects, "the load-bearing slice guard accepts the whole spec — it is dead"