okf-wiki/evals/tests/test_p1_build.py
Kjell Tore Guttormsen 0fd86a23a3
okf-wiki 1.1.1
First public release, published as one snapshot. What changed between
versions is in CHANGELOG.md.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-14 21:03:20 +01:00

609 lines
30 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""Tests for the P1 method trial's build side (TRIAL, branch p1-metodeprove, not v1 code).
Covers the two trial agent types, the splitter (evals/p1/split.py), the D map and register (dmap.py), K packing
(kpack.py) and assembly with K+ (assemble.py). None of these call a model. The fixtures are synthetic text about
gardening and bread (CLAUDE.md rule 3: no text from the Claude Code documentation is committed).
Run: python3 -m unittest discover -s evals/tests -p 'test_p1_build.py'
"""
from __future__ import annotations
import hashlib
import json
import re
import sys
import tempfile
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[2]
sys.path.insert(0, str(ROOT))
sys.path.insert(0, str(ROOT / "evals"))
from okfwiki import audit, claims, view # noqa: E402
from p1 import assemble, dmap, kpack, split # noqa: E402
READER_SHA256 = "13a93bc5a9e87a7282752316ac670664cbdca321b0dac9cdaf92d9e74c383445"
BANNED = ("anthropic", "openai", "urllib", "http.client", "requests", "subprocess", "socket")
DOC_TOMATO = """# Growing tomatoes
Source: https://example.org/garden/tomatoes
How to grow tomatoes in a small garden.
## Soil
Tomatoes need deep, loose soil with `compost` mixed in.
Water the soil every morning.
* **Sun**: full sun for eight hours.
* **Space**: forty centimetres between plants,
more in a wet summer.
```bash
# not a heading
mix compost
```
| Month | Task |
|---|---|
| May | plant |
## Overview
The Kitchen Garden keeps tomatoes and basil together.
### Pruning
Remove side shoots once a week.
"""
DOC_BASIL = """# Growing basil
Source: https://example.org/garden/basil
## Soil
Basil likes warm soil and the Kitchen Garden.
Plant Sweet Genovese early.
## Watering
Water basil with `compost` tea when the leaves droop.
"""
REL_1 = """## 1.2.3
- Added the `compost` command to the Kitchen Garden planner.
- Fixed watering reminders.
"""
REL_2 = """## 1.10.0
- The Kitchen Garden planner now shows `compost` levels.
"""
REL_3 = """## 1.9.2
- Basil seedlings get their own tray.
"""
def runs8(text: str) -> set[tuple[str, ...]]:
words = re.findall(r"[a-z0-9]+", text.lower())
return {tuple(words[i:i + 8]) for i in range(len(words) - 7)}
def before_link_rule(found: list[audit.Finding]) -> list[audit.Finding]:
"""The P1 trial predates criterion 6 as structure (operator 04.10.2026), so its link-rule findings are left out."""
return [f for f in found if f.check != "link-rule"]
class Fixture(unittest.TestCase):
def setUp(self) -> None:
self._tmp = tempfile.TemporaryDirectory()
self.tmp = Path(self._tmp.name)
self.kilde = self.tmp / "wiki" / "kilde"
self.kilde.mkdir(parents=True)
files = {
"docs-en-tomatoes.md": DOC_TOMATO,
"docs-en-basil.md": DOC_BASIL,
"release-v1.2.3.md": REL_1,
"release-v1.10.0.md": REL_2,
"release-v1.9.2.md": REL_3,
}
for name, text in files.items():
(self.kilde / name).write_text(text, encoding="utf-8")
def tearDown(self) -> None:
self._tmp.cleanup()
# ---------------------------------------------------------------------------------------------- step 1: agents
class AgentFilesTest(unittest.TestCase):
def frontmatter(self, text: str) -> dict[str, str]:
self.assertTrue(text.startswith("---\n"))
head = text[4:text.index("\n---\n", 4)]
return dict(line.split(": ", 1) for line in head.splitlines())
def test_two_trial_agents_have_narrow_tools_and_a_trial_marker(self) -> None:
for name in ("p1-compiler", "p1-consolidator"):
text = (ROOT / ".claude" / "agents" / f"{name}.md").read_text(encoding="utf-8")
fm = self.frontmatter(text)
self.assertEqual(fm["name"], name)
self.assertEqual(fm["tools"], "Read, Write")
self.assertEqual(fm["model"], "opus")
body = text[text.index("\n---\n", 4) + 5:].strip()
self.assertTrue(body.startswith("TRIAL"), name)
fixture = DOC_TOMATO + DOC_BASIL + REL_1 + REL_2 + REL_3
self.assertEqual(runs8(body) & runs8(fixture), set(), name)
def test_the_reader_is_unchanged(self) -> None:
shipped = (ROOT / "agents" / "okf-wiki-reader.md").read_bytes()
self.assertEqual(hashlib.sha256(shipped).hexdigest(), READER_SHA256)
self.assertEqual(shipped, (ROOT / ".claude" / "agents" / "okf-wiki-reader.md").read_bytes())
def test_compiler_names_the_rules_it_must_keep(self) -> None:
body = (ROOT / ".claude" / "agents" / "p1-compiler.md").read_text(encoding="utf-8").lower()
for idea in ("first turn", "never read", "release note", "four tests", "json"):
self.assertIn(idea, body, idea)
def test_consolidator_keeps_every_label(self) -> None:
body = (ROOT / ".claude" / "agents" / "p1-consolidator.md").read_text(encoding="utf-8").lower()
for idea in ("every footnote label", "no new label", "json"):
self.assertIn(idea, body, idea)
# ---------------------------------------------------------------------------------------------- step 1: split
class OrderTest(unittest.TestCase):
def test_docs_first_then_release_notes_by_version_tuple(self) -> None:
names = ["release-v0.2.34.md", "docs-en-b.md", "release-v0.2.9.md", "docs-en-a.md", "release-v1.0.0.md"]
self.assertEqual(split.order(names), ["docs-en-a.md", "docs-en-b.md", "release-v0.2.9.md",
"release-v0.2.34.md", "release-v1.0.0.md"])
def test_an_unknown_name_is_refused(self) -> None:
with self.assertRaises(split.RunError):
split.order(["notes.md"])
class BlocksTest(Fixture):
def test_fence_aware_blocks_with_spans(self) -> None:
got = split.blocks(self.kilde / "docs-en-tomatoes.md")
kinds = [(b.kind, b.start, b.end) for b in got]
# line 2 "Source:" and line 4 are paragraphs; headings are not blocks
self.assertIn(("paragraph", 2, 2), kinds)
self.assertIn(("paragraph", 8, 9), kinds)
self.assertIn(("item", 11, 11), kinds)
self.assertIn(("item", 12, 13), kinds) # a continuation line belongs to its item
self.assertIn(("code", 15, 18), kinds) # the "#" inside the fence is not a heading
self.assertIn(("table", 20, 22), kinds)
heads = {b.section for b in got}
self.assertIn("Growing tomatoes › Soil", heads)
self.assertIn("Growing tomatoes › Overview › Pruning", heads)
self.assertNotIn("not a heading", " ".join(heads))
def test_every_non_blank_non_heading_line_is_in_exactly_one_block(self) -> None:
path = self.kilde / "docs-en-tomatoes.md"
lines = path.read_text(encoding="utf-8").split("\n")
got = split.blocks(path)
covered: dict[int, int] = {}
for b in got:
for n in range(b.start, b.end + 1):
covered[n] = covered.get(n, 0) + 1
for n, raw in enumerate(lines, 1):
heading = raw.startswith("#") and not (15 <= n <= 18)
if raw.strip() and not heading:
self.assertEqual(covered.get(n), 1, (n, raw))
if heading:
self.assertNotIn(n, covered, (n, raw))
def test_release_note_blocks_carry_the_version(self) -> None:
got = split.blocks(self.kilde / "release-v1.10.0.md")
self.assertEqual({b.version for b in got}, {"1.10.0"})
self.assertEqual(split.blocks(self.kilde / "docs-en-basil.md")[0].version, None)
class DocsHeadingsTest(Fixture):
def test_titles_and_second_and_third_level_headings_of_docs_pages_only(self) -> None:
got = split.docs_headings(self.kilde)
texts = [(h.file, h.level, h.text) for h in got]
self.assertIn(("docs-en-tomatoes.md", 1, "Growing tomatoes"), texts)
self.assertIn(("docs-en-tomatoes.md", 3, "Pruning"), texts)
self.assertFalse(any(f.startswith("release-") for f, _, _ in texts))
self.assertFalse(any(t == "not a heading" for _, _, t in texts))
class PickTest(Fixture):
def blocks_doc(self, order: list[str]) -> dict[str, object]:
return split.blocks_document(self.kilde, order)
def test_three_concepts_by_the_stated_rules(self) -> None:
order = split.order([p.name for p in self.kilde.iterdir()])
picked = split.pick(self.blocks_doc(order), self.kilde, focus="docs-en-tomatoes.md")
names = [p.name for p in picked]
self.assertEqual(len(names), 3)
self.assertEqual(len(set(names)), 3)
self.assertEqual(names[0], "Soil") # the focus page's heading with the most blocks
# "Kitchen Garden" and "compost" are both in 2 release notes; the tie is broken by name
self.assertEqual(names[1], "Kitchen Garden")
self.assertEqual(names[2], "compost") # in 2 docs pages and 2 release notes, distinct from 1 and 2
def test_a_document_counts_for_a_term_only_where_it_stands_as_a_term(self) -> None:
# Found in session 2: the word "and", backticked once, was counted in every document where it is prose.
(self.kilde / "docs-en-zz.md").write_text("# Joining\n\n## Words\n\nUse `and` to join two beds.\n",
encoding="utf-8")
for v in ("2.0.0", "2.0.1", "2.0.2"):
(self.kilde / f"release-v{v}.md").write_text(f"## {v}\n\n- Tomatoes and basil and mint.\n",
encoding="utf-8")
order = split.order([p.name for p in self.kilde.iterdir()])
names = [p.name for p in split.pick(self.blocks_doc(order), self.kilde, focus="docs-en-tomatoes.md")]
self.assertNotIn("and", names)
self.assertEqual(names[1:], ["Kitchen Garden", "compost"])
def test_a_backticked_term_counts_its_length_after_trimming(self) -> None:
# Found in session 2: "` or `" is four characters with its spaces, and became the two-letter term "or".
got = split.terms("Use `compost` ` or ` ` ab ` ` mulch ` here.")
self.assertEqual(got, ["compost", "mulch"])
def test_the_focus_page_must_be_in_the_order(self) -> None:
with self.assertRaises(split.RunError):
split.pick(self.blocks_doc(["docs-en-basil.md"]), self.kilde, focus="docs-en-tomatoes.md")
class CliTest(Fixture):
def test_order_refuses_names_that_differ_from_the_l4_cut(self) -> None:
manifest = self.tmp / "m.json"
manifest.write_text(json.dumps({"cut": {"names": ["docs-en-basil.md", "release-v1.2.3.md"]}}), encoding="utf-8")
l4 = self.tmp / "l4"
l4.mkdir()
(l4 / "a.md").write_text("---\ntype: Concept\nsources:\n - id: a\n resource: /kilde/docs-en-basil.md\n"
"---\n\nx\n", encoding="utf-8")
out = self.tmp / "rekkefolge.txt"
self.assertEqual(split.main(["order", "--manifest", str(manifest), "--l4", str(l4), "--out", str(out)]), 2)
self.assertFalse(out.exists())
(l4 / "b.md").write_text("---\ntype: Concept\nsources:\n - id: b\n resource: /kilde/release-v1.2.3.md\n"
"---\n\nx\n", encoding="utf-8")
self.assertEqual(split.main(["order", "--manifest", str(manifest), "--l4", str(l4), "--out", str(out)]), 0)
self.assertEqual(out.read_text(encoding="utf-8").split(), ["docs-en-basil.md", "release-v1.2.3.md"])
def test_blocks_and_pick_refuse_to_overwrite(self) -> None:
order = self.tmp / "order.txt"
order.write_text("\n".join(split.order([p.name for p in self.kilde.iterdir()])) + "\n", encoding="utf-8")
out = self.tmp / "blocks.json"
self.assertEqual(split.main(["blocks", "--kilde", str(self.kilde), "--order", str(order), "--out", str(out)]), 0)
data = json.loads(out.read_text(encoding="utf-8"))
self.assertEqual(data["schema"], "okf-wiki/p1-blocks/1")
self.assertEqual(split.main(["blocks", "--kilde", str(self.kilde), "--order", str(order), "--out", str(out)]), 2)
picked = self.tmp / "begreper.txt"
args = ["pick", "--blocks", str(out), "--kilde", str(self.kilde), "--focus", "docs-en-tomatoes.md",
"--out", str(picked)]
self.assertEqual(split.main(args), 0)
self.assertEqual(len(picked.read_text(encoding="utf-8").strip().splitlines()), 3)
self.assertEqual(split.main(args), 2)
def test_total_counts_blocks_in_every_file(self) -> None:
expected = sum(len(split.blocks(p)) for p in self.kilde.iterdir())
self.assertEqual(split.blocks_total(self.kilde), expected)
# ---------------------------------------------------------------------------------------------- step 2: D
class DMapTest(Fixture):
def build(self) -> Path:
order = split.order([p.name for p in self.kilde.iterdir()])
out = self.tmp / "D"
dmap.build(split.blocks_document(self.kilde, order), self.kilde.parent, out, at="2026-10-02T12:00:00Z")
return out
def test_d_passes_the_auditor_with_no_claims(self) -> None:
out = self.build()
self.assertEqual(before_link_rule(audit.audit(out, self.kilde.parent)), [])
found = claims.extract(out, self.kilde.parent)
self.assertEqual(found.claims, [])
self.assertTrue(found.exceptions)
def test_register_links_point_to_map_sections(self) -> None:
out = self.build()
page = (out / "r-kitchen-garden.md").read_text(encoding="utf-8")
self.assertIn("(k-docs-en-basil.md#soil)", page)
self.assertIn("(k-release-v1-2-3.md#1-2-3)", page)
def test_register_keeps_docs_headings_and_terms_in_two_documents_only(self) -> None:
out = self.build()
names = {p.name for p in out.glob("r-*.md")}
self.assertIn("r-pruning.md", names) # a docs heading (i), in one document
self.assertIn("r-compost.md", names) # a backticked term in several documents
self.assertNotIn("r-sweet-genovese.md", names) # a capitalised phrase in one document only
self.assertNotIn("r-overview.md", names) # a stop-listed heading fails test 2
def test_quotes_stand_on_their_lines_and_stay_strings(self) -> None:
out = self.build()
doc = audit.read_document(out / "r-compost.md", "r-compost.md")
assert doc.frontmatter is not None
for s in doc.frontmatter["sources"]:
self.assertIsInstance(s["x-quote"], str)
line = (self.kilde / Path(s["resource"]).name).read_text(encoding="utf-8").split("\n")[s["x-locator"]["line"] - 1]
self.assertIn(s["x-quote"], line)
self.assertIsInstance(doc.frontmatter["generated"]["at"], str)
def test_a_quote_like_no_survives_a_yaml_round_trip(self) -> None:
text = dmap.frontmatter({"type": "Concept", "sources": [{"id": "a", "x-quote": "no"}, {"id": "b", "x-quote": "1.10"}]})
path = self.tmp / "x.md"
path.write_text(text + "\n# x\n", encoding="utf-8")
fm = audit.read_document(path, "x.md").frontmatter
assert fm is not None
self.assertEqual([s["x-quote"] for s in fm["sources"]], ["no", "1.10"])
def test_the_log_records_the_thresholds_and_build_refuses_an_existing_target(self) -> None:
out = self.build()
log = (out / "log.md").read_text(encoding="utf-8")
self.assertIn("2 of the", log)
with self.assertRaises(dmap.RunError):
dmap.build({"order": [], "blocks": []}, self.kilde.parent, out, at="2026-10-02T12:00:00Z")
# ---------------------------------------------------------------------------------------------- step 3: K packing
def entry(eid: str, title: str, aliases: tuple[str, ...] = ()) -> dict[str, object]:
return {"id": eid, "title": title, "aliases": [title, *aliases], "kind": "skeleton", "merge_of": None,
"origin": None}
class KSkeletonTest(Fixture):
def test_the_skeleton_is_an_index_of_docs_headings_that_pass_test_2(self) -> None:
index = kpack.skeleton(self.kilde)
titles = {e["title"] for e in index["entries"]}
self.assertIn("Growing tomatoes", titles)
self.assertIn("Pruning", titles)
self.assertIn("Soil", titles)
self.assertNotIn("Overview", titles)
soil = [e for e in index["entries"] if e["title"] == "Soil"]
self.assertEqual(len(soil), 1) # the same heading in two pages is one entry
self.assertEqual(soil[0]["origin"]["file"], "docs-en-basil.md") # pages in name order, first one wins
self.assertFalse(any(p.suffix == ".md" for p in self.tmp.rglob("*") if p.parent.name != "kilde"))
def test_norm(self) -> None:
self.assertEqual(kpack.norm("The `Compost` bins"), "compost bin")
self.assertEqual(kpack.norm("settings.json"), "settings.json")
self.assertEqual(kpack.norm(" Kitchen Garden! "), "kitchen garden")
self.assertEqual(kpack.norm("CLI flags"), "cli flag")
class KIdentityTest(unittest.TestCase):
def setUp(self) -> None:
self.index = {"entries": [entry("kitchen-garden-planner", "Kitchen Garden planner"),
entry("compost", "compost", ("compost heap",))]}
def frag(self, concept: str, status: str = "new", file: str = "docs-en-tomatoes.md", eid: str | None = None
) -> dict[str, object]:
f: dict[str, object] = {"concept": concept, "status": status, "anchor": {"file": file, "start": 8, "end": 9}}
if eid:
f["id"] = eid
return f
def test_outcomes(self) -> None:
r = kpack.resolve
self.assertEqual(r(self.frag("x", "existing", eid="compost"), self.index), ("existing", "compost"))
self.assertEqual(r(self.frag("Kitchen Garden planners"), self.index), ("existing", "kitchen-garden-planner"))
self.assertEqual(r(self.frag("Compost heap"), self.index), ("existing", "compost"))
self.assertEqual(r(self.frag("Kitchen Garden planner tool"), self.index),
("merge-candidate", "kitchen-garden-planner"))
self.assertEqual(r(self.frag("Garden hose"), self.index), ("new", None))
self.assertEqual(r(self.frag("Garden hose", file="release-v1.2.3.md"), self.index), ("rejected", "release-note-new"))
self.assertEqual(r(self.frag("Kitchen Garden planner tool", file="release-v1.2.3.md"), self.index),
("rejected", "release-note-new"))
self.assertEqual(r(self.frag("Troubleshooting"), self.index), ("rejected", "meta"))
def test_relevant_lines_by_phrase(self) -> None:
got = kpack.relevant_lines(self.index, "We keep the compost heaps behind the shed.")
self.assertEqual([e["id"] for e in got], ["compost"])
self.assertEqual(kpack.relevant_lines(self.index, "Nothing about gardens here."), [])
class KPackTest(Fixture):
def blocks_doc(self) -> dict[str, object]:
return split.blocks_document(self.kilde, split.order([p.name for p in self.kilde.iterdir()]))
def test_packs_of_five(self) -> None:
self.assertEqual([len(p) for p in kpack.packs([f"n{i}" for i in range(19)], 5)], [5, 5, 5, 4])
def test_a_large_pack_is_split_into_parts_under_the_read_cap(self) -> None:
big = "".join(f"Line {i} says the tomatoes are fine today and tomorrow, and the basil too.\n\n"
for i in range(1110))
(self.kilde / "docs-en-big.md").write_text("# Big\n\n" + big, encoding="utf-8")
doc = split.blocks_document(self.kilde, ["docs-en-big.md"])
parts = kpack.render_input(1, ["docs-en-big.md"], doc, [], self.kilde)
self.assertGreater(sum(len(p) for p in parts), 130_000)
self.assertEqual(len(parts), 3)
self.assertTrue(all(len(p) <= kpack.PART_CHARS for p in parts))
self.assertIn("docs-en-big.md › Big › 3–3", parts[0])
def test_validate(self) -> None:
doc = self.blocks_doc()
pack = ["docs-en-tomatoes.md", "release-v1.2.3.md"]
good = {"concept": "Soil", "status": "existing", "id": "soil", "text": "Tomatoes need deep, loose soil.",
"anchor": {"file": "docs-en-tomatoes.md", "start": 8, "end": 9}}
cases = {
"anchor-crosses-blocks": {**good, "anchor": {"file": "docs-en-tomatoes.md", "start": 8, "end": 11}},
"quote-missing": {**good, "text": "Plants stand 40 cm apart."},
"quote-not-in-span": {**good, "text": "Keep 40 cm.", "quote": "forty centimetres"},
"sentence-count": {**good, "text": "One. Two. Three. Four."},
"tests-missing": {**good, "status": "new", "concept": "Loose soil"},
"anchor-outside-pack": {**good, "anchor": {"file": "docs-en-basil.md", "start": 7, "end": 7}},
"malformed": {"concept": "Soil"},
}
no_text = {**good, "text": ""}
accepted, rejected = kpack.validate([good, no_text, *cases.values()], pack, doc, self.kilde)
self.assertEqual(len(accepted), 1)
self.assertEqual(rejected["sentence-count"], 2) # the empty text and the four sentences
for reason in cases:
self.assertGreaterEqual(rejected[reason], 1, reason)
ok = {**good, "text": "Plants stand forty centimetres apart.", "anchor": {"file": "docs-en-tomatoes.md",
"start": 12, "end": 13}, "quote": "forty centimetres"}
accepted, rejected = kpack.validate([ok], pack, doc, self.kilde)
self.assertEqual((len(accepted), sum(rejected.values())), (1, 0))
class KCliTest(Fixture):
def test_skeleton_pack_and_accept(self) -> None:
work = self.tmp / "work"
blocks = self.tmp / "blocks.json"
order = split.order([p.name for p in self.kilde.iterdir()])
blocks.write_text(json.dumps(split.blocks_document(self.kilde, order)), encoding="utf-8")
index = work / "K-work" / "index.json"
self.assertEqual(kpack.main(["skeleton", "--kilde", str(self.kilde), "--out", str(index)]), 0)
self.assertEqual(kpack.main(["skeleton", "--kilde", str(self.kilde), "--out", str(index)]), 2)
root = str(self.kilde.parent)
self.assertEqual(kpack.main(["pack", "1", "--blocks", str(blocks), "--index", str(index), "--kilde-root", root,
"--work", str(work)]), 0)
self.assertTrue((work / "K-oppgaver" / "pack-1-part-1.md").is_file())
fragments = {"fragments": [
{"concept": "Soil", "status": "existing", "id": "soil", "text": "Tomatoes need deep, loose soil.",
"anchor": {"file": "docs-en-tomatoes.md", "start": 8, "end": 9}},
{"concept": "Kitchen Garden", "status": "new", "text": "The Kitchen Garden keeps tomatoes and basil.",
"anchor": {"file": "docs-en-tomatoes.md", "start": 26, "end": 26},
"tests": {"topic_shape": "a named planner", "citation": "See the Kitchen Garden reference"}},
{"concept": "Kitchen Garden", "status": "existing", "text": "The planner gained a command.",
"anchor": {"file": "release-v1.2.3.md", "start": 3, "end": 3}},
{"concept": "Watering reminders", "status": "new", "text": "Reminders were fixed.",
"anchor": {"file": "release-v1.2.3.md", "start": 4, "end": 4},
"tests": {"topic_shape": "x", "citation": "y"}},
]}
out = work / "K-fragments" / "pack-1.json"
out.parent.mkdir(parents=True)
out.write_text(json.dumps(fragments), encoding="utf-8")
self.assertEqual(kpack.main(["accept", "1", "--work", str(work), "--blocks", str(blocks), "--kilde-root", root]), 0)
acc = json.loads((work / "K-work" / "accepted.json").read_text(encoding="utf-8"))["fragments"]
self.assertEqual([a["outcome"] for a in acc], ["existing", "new", "existing"])
self.assertEqual(acc[2]["concept_id"], acc[1]["concept_id"]) # the release note enriches the new concept
self.assertEqual(acc[2]["version"], "1.2.3")
log = json.loads((work / "K-work" / "packs.json").read_text(encoding="utf-8"))
self.assertEqual(log["packs"][0]["rejected"], {"release-note-new": 1})
self.assertEqual(log["packs"][0]["proposed"], 4)
# PM 02.10: the ids of the index lines sent, and the accepted fragments whose concept was not among them
sent = log["packs"][0]["index_ids"]
self.assertIn("soil", sent)
self.assertNotIn(acc[1]["concept_id"], sent)
self.assertEqual(log["packs"][0]["not_sent"], {"total": 2, "by_outcome": {"existing": 1, "new": 1}})
# ---------------------------------------------------------------------------------------------- step 4: assembly
def accepted(cid: str, file: str, start: int, end: int, text: str, pack: int, version: str | None = None,
quote: str | None = None, quote_line: int | None = None) -> dict[str, object]:
return {"pack": pack, "position": 1, "file": file, "start": start, "end": end, "section": "-", "text": text,
"quote": quote, "quote_line": quote_line, "version": version, "concept_id": cid,
"outcome": "existing"}
class AssembleTest(Fixture):
def setUp(self) -> None:
super().setUp()
self.work = self.tmp / "work"
(self.work / "K-work").mkdir(parents=True)
index = {"entries": [
{**entry("soil", "Soil"), "origin": {"file": "docs-en-basil.md", "line": 4}},
{**entry("pruning", "Pruning"), "origin": {"file": "docs-en-tomatoes.md", "line": 28}},
{**entry("kitchen-garden", "Kitchen Garden"), "kind": "new"},
{**entry("kitchen-garden-planner", "Kitchen Garden planner"), "kind": "merge-candidate",
"merge_of": "kitchen-garden"},
]}
frags = [
accepted("soil", "docs-en-tomatoes.md", 8, 9, "Tomatoes need deep, loose soil.", 1),
accepted("kitchen-garden", "docs-en-tomatoes.md", 26, 26,
"The Kitchen Garden keeps tomatoes and basil together.", 1, quote="Kitchen Garden", quote_line=26),
accepted("kitchen-garden", "release-v1.2.3.md", 3, 3, "The planner gained a compost command.", 1, "1.2.3"),
accepted("soil", "docs-en-basil.md", 6, 7, "Basil likes warm soil near the Kitchen Garden.", 1),
accepted("kitchen-garden", "release-v1.10.0.md", 3, 3, "The planner shows compost levels.", 2, "1.10.0"),
accepted("kitchen-garden-planner", "release-v1.9.2.md", 3, 3, "Seedlings get their own tray.", 2, "1.9.2"),
]
(self.work / "K-work" / "index.json").write_text(json.dumps(index), encoding="utf-8")
(self.work / "K-work" / "accepted.json").write_text(json.dumps({"fragments": frags}), encoding="utf-8")
self.out = self.tmp / "K"
assemble.assemble(self.work, self.kilde.parent, self.out, at="2026-10-02T12:00:00Z")
def page(self, name: str) -> audit.Document:
return audit.read_document(self.out / name, name)
def test_the_bundle_passes_the_auditor(self) -> None:
self.assertEqual(before_link_rule(audit.audit(self.out, self.kilde.parent)), [])
found = claims.extract(self.out, self.kilde.parent)
self.assertEqual(claims.criterion_1(found)["total"], (6, 6))
def test_only_enriched_concepts_get_pages(self) -> None:
names = {p.name for p in self.out.glob("*.md")} - {"index.md", "log.md"}
self.assertEqual(names, {"soil.md", "kitchen-garden.md", "kitchen-garden-planner.md"})
fm = self.page("kitchen-garden-planner.md").frontmatter
assert fm is not None
self.assertEqual(fm["x-merge-candidate"], "kitchen-garden")
def test_history_in_version_order_without_version_numbers_in_the_text(self) -> None:
doc = self.page("kitchen-garden.md")
body = doc.body
self.assertLess(body.index("gained a compost command"), body.index("shows compost levels"))
prose = " ".join(b.text for b in audit.prose_blocks(doc))
self.assertEqual(view.version_numbers(audit.FOOTNOTE_REF.sub("", prose)), [])
fm = doc.frontmatter
assert fm is not None
versions = [s for s in fm["sources"] if view.is_version_heading(s)]
self.assertEqual(sorted(s["x-quote"] for s in versions), ["1.10.0", "1.2.3"])
self.assertEqual(fm["x-fragments"], 3)
def test_code_quotes_skip_structural_lines_and_are_marked(self) -> None:
fm = self.page("soil.md").frontmatter
assert fm is not None
first = fm["sources"][0]
self.assertEqual(first["x-locator"], {"line": 8})
self.assertEqual(first["x-quote-by"], "code")
self.assertEqual(first["x-span"], [8, 9])
kg = self.page("kitchen-garden.md").frontmatter
assert kg is not None
self.assertNotIn("x-quote-by", kg["sources"][0])
self.assertEqual(assemble.code_quote(["```bash", "<Note>", "|---|---|", "", " real line "], 10),
("real line", 14))
def test_a_concept_title_in_another_page_becomes_one_link(self) -> None:
self.assertIn("[Kitchen Garden](kitchen-garden.md)", self.page("soil.md").body)
class KPlusTest(AssembleTest):
def test_copy_tasks_and_apply(self) -> None:
kplus = self.tmp / "K+"
assemble.copy(self.out, kplus)
with self.assertRaises(assemble.RunError):
assemble.copy(self.out, kplus)
runs = assemble.consolidation_tasks(kplus, self.work, min_fragments=3, per_run=8)
self.assertEqual([r.pages for r in runs], [["kitchen-garden"]])
self.assertTrue(runs[0].task.is_file())
old = self.page("kitchen-garden.md").body
labels = sorted(set(audit.FOOTNOTE_REF.findall(old)))
good = "The Kitchen Garden keeps tomatoes and basil together, and its planner tracks compost " + "".join(
f"[^{x}]" for x in labels) + "."
dropped = "The Kitchen Garden keeps tomatoes and basil together[^" + labels[0] + "]."
added = good.replace(".", "[^zz].", 1)
bodies = self.tmp / "bodies.json"
bodies.write_text(json.dumps({"kitchen-garden": good, "soil": dropped}), encoding="utf-8")
self.assertEqual(assemble.apply(kplus, bodies), (1, 1))
self.assertIn("planner tracks compost", (kplus / "kitchen-garden.md").read_text(encoding="utf-8"))
self.assertEqual(before_link_rule(audit.audit(kplus, self.kilde.parent)), [])
bodies.write_text(json.dumps({"kitchen-garden": added}), encoding="utf-8")
self.assertEqual(assemble.apply(kplus, bodies), (0, 1))
class NoModelTest(unittest.TestCase):
def test_trial_modules_import_no_network_or_model_client(self) -> None:
for path in sorted((ROOT / "evals" / "p1").glob("*.py")):
source = path.read_text(encoding="utf-8")
for banned in BANNED:
self.assertNotIn(f"import {banned}", source, path.name)
self.assertNotIn(f"from {banned}", source, path.name)
if __name__ == "__main__":
unittest.main()