okf-wiki/tests/test_kmerge.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

939 lines
55 KiB
Python

"""Tests for okfwiki/kmerge.py: step 18a's merge of like concepts (order 29 A3), by code, with no model call.
The model judges each candidate pair `same` or `different` in the user's session (agents/okf-wiki-merger.md); this code
draws the control pairs, writes the tasks, reads the answers and merges the pairs judged `same` in the build's work
folder, so kassemble builds the merged collection. A gardening collection of two sources stands in for collection 1:
"Watering can" and "Wateringcan" are one concept written twice, with link records on, to and between them. Every
fixture is synthetic text about gardening (CLAUDE.md rule 3).
Run: python3 -m unittest discover -s tests -p 'test_kmerge.py'
"""
from __future__ import annotations
import hashlib
import io
import json
import sys
import tempfile
import unittest
from contextlib import redirect_stderr, redirect_stdout
from pathlib import Path
from typing import Any
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from okfwiki import audit, claims, kassemble, klink, kmerge # noqa: E402
GARDEN = """# Garden
A garden needs light, water and good soil.
## Watering can
A watering can carries water to plants that a hose cannot reach.
A long spout lets you water the soil without wetting the leaves.
Fill the can in the evening so the water warms to air temperature.
## Compost
Compost turns kitchen scraps into food for the soil.
Water a dry heap from a watering can, which some call a wateringcan.
"""
TOOLS = """# Garden tools
Good tools make garden work lighter.
A wateringcan with a rose head gives a soft shower for seedlings.
A rose head on a wateringcan suits young plants.
## Spade
A spade cuts and lifts soil.
A rake levels the bed after digging.
A hoe cuts weeds at the root.
A trowel digs small holes for bulbs.
"""
G, T = "docs-en-garden.md", "docs-en-tools.md"
SOURCES = {G: GARDEN, T: TOOLS}
TITLES = {"garden": "Garden", "watering-can": "Watering can", "compost": "Compost", "garden-tools": "Garden tools",
"wateringcan": "Wateringcan", "spade": "Spade", "rake": "Rake", "hoe": "Hoe", "trowel": "Trowel"}
# (concept, file, quote, text): the fragments in pack order; pack 1 is the garden source, pack 2 the tools source
FRAGMENTS = [
("garden", G, "needs light, water and good soil", "A garden needs light, water and good soil."),
("watering-can", G, "carries water to plants that a hose cannot reach",
"A watering can carries water where a hose cannot reach."),
("watering-can", G, "without wetting the leaves", "A long spout on a wateringcan keeps the leaves dry."),
("watering-can", G, "so the water warms to air temperature", "Fill the can in the evening so the water warms."),
("compost", G, "turns kitchen scraps into food for the soil", "Compost feeds the soil with kitchen scraps."),
("compost", G, "Water a dry heap from a watering can",
"A dry heap is watered from a watering can, which some call a wateringcan."),
("garden-tools", T, "make garden work lighter", "Good tools make garden work lighter."),
("wateringcan", T, "gives a soft shower for seedlings", "A wateringcan with a rose head showers seedlings softly."),
("wateringcan", T, "suits young plants", "A rose head on a watering can suits young plants."),
("spade", T, "cuts and lifts soil", "A spade cuts and lifts soil."),
("rake", T, "levels the bed after digging", "A rake levels the bed after digging."),
("hoe", T, "cuts weeds at the root", "A hoe cuts weeds at the root."),
("trowel", T, "digs small holes for bulbs", "A trowel digs small holes for bulbs."),
("trowel", T, "cuts and lifts soil", "A trowel also cuts and lifts soil in a small bed."),
]
MAINS = {G: "garden", T: "garden-tools"}
HOMES = {"watering-can": "garden", "compost": "garden", "wateringcan": "garden-tools", "spade": "garden-tools",
"rake": "garden-tools", "hoe": "garden-tools", "trowel": "garden-tools"}
# (page, sentence starts with, anchor, target): the link pass's records
LINKS = [
("compost", "A dry heap", "watering can", "watering-can"),
("compost", "A dry heap", "wateringcan", "wateringcan"), # a duplicate once wateringcan is watering-can
("watering-can", "A long spout", "wateringcan", "wateringcan"), # a self-link after the merge
("wateringcan", "A rose head", "watering can", "watering-can"), # a self-link after the merge
("wateringcan", "A wateringcan with", "seedlings", "garden"), # moves with its sentence
("spade", "A spade", "soil", "compost"),
]
AT = "2026-10-18T10:00:00Z"
AT2 = "2026-10-18T11:00:00Z"
def run(argv: list[str]) -> tuple[int, str]:
out, err = io.StringIO(), io.StringIO()
with redirect_stdout(out), redirect_stderr(err):
code = kmerge.main(argv)
return code, out.getvalue() + err.getvalue()
def tree(root: Path) -> dict[str, bytes]:
return {p.relative_to(root).as_posix(): p.read_bytes() for p in sorted(root.rglob("*")) if p.is_file()}
def sha(path: Path) -> str:
return hashlib.sha256(path.read_bytes()).hexdigest()
class Garden(unittest.TestCase):
"""The collection built once with its links, its claim list, and a proposal with one pair."""
def setUp(self) -> None:
self._tmp = tempfile.TemporaryDirectory()
self.tmp = Path(self._tmp.name)
self.sources = self.tmp / "sources"
(self.sources / "kilde").mkdir(parents=True)
for name, text in SOURCES.items():
(self.sources / "kilde" / name).write_text(text, encoding="utf-8")
self.work = self.tmp / "work"
self.kw = self.work / "K-work"
self.kw.mkdir(parents=True)
self.wiki = self.tmp / "wiki"
self.links = self.work / "links.json"
self.write_state()
self.build(links=False, replace=False)
self.write_links()
self.build(links=True, replace=True)
self.claims = self.tmp / "claims.json"
self.list_claims()
self.proposal = self.tmp / "like-forslag.json"
self.propose([("compact-title", "watering-can.md", "wateringcan.md")])
def tearDown(self) -> None:
self._tmp.cleanup()
# --- fixture ----------------------------------------------------------------------------------------------
def write_state(self, mains: dict[str, str] | None = None, homes: dict[str, str] | None = None,
fragments: list[tuple[str, str, str, str]] | None = None,
titles: dict[str, str] | None = None) -> None:
records = []
for i, (cid, file, quote, text) in enumerate(fragments or FRAGMENTS):
line = next(n for n, raw in enumerate(SOURCES[file].split("\n"), 1) if quote in raw)
records.append({"pack": 1 if file == G else 2, "position": i + 1, "file": file, "start": line, "end": line,
"section": "", "text": text, "quote": quote, "quote_line": line, "version": None,
"provenance": "documented", "concept_id": cid, "outcome": "existing"})
mains = MAINS if mains is None else mains
homes = HOMES if homes is None else homes
files = {cid: f for cid, f, _, _ in FRAGMENTS}
accepted = {"schema": "okf-wiki/accepted/1", "fragments": records,
"main_pages": [{"source": s, "concept_id": c, "pack": 1 if s == G else 2, "by": "compiler"}
for s, c in mains.items()],
"homes": [{"source": files[c], "concept_id": c, "home": h, "pack": 1 if files[c] == G else 2,
"by": "compiler"} for c, h in homes.items()]}
index = {"schema": "okf-wiki/concept-index/1",
"entries": [{"id": c, "title": t, "aliases": [t], "kind": "skeleton", "merge_of": None,
"origin": {"file": files[c], "line": 1}} for c, t in {**TITLES, **(titles or {})}.items()]}
(self.kw / "accepted.json").write_text(json.dumps(accepted, indent=1) + "\n", encoding="utf-8")
(self.kw / "index.json").write_text(json.dumps(index, indent=1) + "\n", encoding="utf-8")
def write_links(self, links: list[tuple[str, str, str, str]] | None = None) -> None:
records = []
for page, start, anchor, target in LINKS if links is None else links:
s = self.sentence(page, start)
records.append({"page": f"{page}.md", "sentence": s.key, "anchor": anchor, "at": s.text.index(anchor),
"target": f"{target}.md"})
doc = {"schema": klink.SCHEMA, "links": records, "none": [], "none_count": 0, "accepted": len(records),
"rejected": {}}
self.links.write_text(klink.dump(doc), encoding="utf-8")
def sentence(self, page: str, start: str, wiki: Path | None = None) -> klink.Sentence:
text = ((wiki or self.wiki) / f"{page}.md").read_text(encoding="utf-8")
return next(s for s in klink.page_sentences(text) if klink.key_text(s.text).startswith(start))
def build(self, links: bool = True, replace: bool = True, at: str = AT) -> kassemble.Report:
return kassemble.build(self.work, self.sources, self.wiki, self.links if links else None, replace, at)
def list_claims(self) -> None:
with redirect_stdout(io.StringIO()):
self.assertEqual(0, claims.main(["list", str(self.wiki), str(self.sources), "--out", str(self.claims)]))
def propose(self, pairs: list[tuple[str, str, str]]) -> None:
groups = [{"kind": kind, "keep": keep, "merge_in": [merge], "pages": []} for kind, keep, merge in pairs]
self.proposal.write_text(json.dumps({"summary": {}, "groups": groups}), encoding="utf-8")
def verdicts(self, given: dict[str, str]) -> Path:
path = self.tmp / "verdicts.json"
path.write_text(json.dumps({"schema": kmerge.VERDICTS_SCHEMA, "proposal_sha256": sha(self.proposal),
"verdicts": given, "without": [], "missing": [], "controls_same": []}),
encoding="utf-8")
return path
def apply(self, given: dict[str, str], *extra: str) -> tuple[int, str]:
self.report = self.tmp / "applied.json"
return run(["apply", "--work", str(self.work), "--wiki", str(self.wiki), "--proposal", str(self.proposal),
"--claims", str(self.claims), "--verdicts", str(self.verdicts(given)), "--report",
str(self.report), *extra])
def accepted(self) -> dict[str, Any]:
doc: dict[str, Any] = json.loads((self.kw / "accepted.json").read_text(encoding="utf-8"))
return doc
def index(self) -> dict[str, dict[str, Any]]:
return {e["id"]: e for e in json.loads((self.kw / "index.json").read_text(encoding="utf-8"))["entries"]}
def link_records(self) -> list[dict[str, Any]]:
records: list[dict[str, Any]] = json.loads(self.links.read_text(encoding="utf-8"))["links"]
return records
def applied(self) -> dict[str, Any]:
doc: dict[str, Any] = json.loads(self.report.read_text(encoding="utf-8"))
return doc
class ProposalTest(Garden):
def test_the_fixture_builds_clean_with_every_link_placed(self) -> None:
self.assertEqual([], [f for f in audit.audit(self.wiki, self.sources)])
self.assertEqual((6, 0), (self.build().placed, self.build().stale))
def test_a_pair_id_is_its_number_from_one_in_groups(self) -> None:
self.propose([("compact-title", "watering-can.md", "wateringcan.md"), ("compact-title", "spade.md", "rake.md")])
pairs = kmerge.load_proposal(self.proposal)
self.assertEqual([("1", "watering-can.md", "wateringcan.md"), ("2", "spade.md", "rake.md")],
[(p.id, p.keep, p.merge_in) for p in pairs])
def test_a_pair_without_exactly_one_page_to_merge_in_is_refused(self) -> None:
for merge_in in ([], ["wateringcan.md", "rake.md"]):
self.proposal.write_text(json.dumps({"groups": [{"kind": "compact-title", "keep": "watering-can.md",
"merge_in": merge_in}]}), encoding="utf-8")
code, text = self.apply({"1": "same"})
self.assertEqual(2, code, merge_in)
self.assertIn("merge_in", text)
def test_a_page_may_stand_in_several_pairs_but_one_pair_only_once(self) -> None:
# B14: candidate pairs overlap (one short name is held by several longer ones), so the judge sees them all
self.propose([("compact", "watering-can.md", "wateringcan.md"), ("contained", "watering-can.md", "rake.md")])
self.assertEqual(["1", "2"], [p.id for p in kmerge.load_proposal(self.proposal)])
for twice in ([("compact", "watering-can.md", "wateringcan.md"), ("contained", "watering-can.md",
"wateringcan.md")],
[("compact", "watering-can.md", "watering-can.md")]):
with self.subTest(pairs=twice):
self.propose(twice)
code, text = self.apply({"1": "same", "2": "different"})
self.assertEqual(2, code)
self.assertIn("watering-can.md", text)
def test_keep_follows_the_rule_and_a_deviation_stops(self) -> None:
facts = kmerge.page_facts(self.work, self.wiki, self.claims)
self.assertEqual([], kmerge.keep_deviations(kmerge.load_proposal(self.proposal), facts))
self.propose([("compact-title", "wateringcan.md", "watering-can.md")]) # fewer claims kept
before = tree(self.work)
code, text = self.apply({"1": "same"})
self.assertEqual(2, code)
self.assertIn("keep", text)
self.assertEqual(before, tree(self.work))
def test_the_rule_is_main_page_first_then_claims_then_inbound_then_earliest_pack(self) -> None:
f = kmerge.Facts(titles={}, main={"b.md"}, claims={"a.md": 9, "b.md": 1, "c.md": 2, "d.md": 2, "e.md": 2,
"f.md": 2},
inbound={"c.md": 3, "d.md": 1, "e.md": 1, "f.md": 1}, first_pack={"e.md": 4, "f.md": 7},
homes={}, cited={})
self.assertEqual("b.md", kmerge.keep_of(["a.md", "b.md"], f))
self.assertEqual("a.md", kmerge.keep_of(["a.md", "c.md"], f))
self.assertEqual("c.md", kmerge.keep_of(["d.md", "c.md"], f))
self.assertEqual("e.md", kmerge.keep_of(["f.md", "e.md"], f))
class ProposeTest(Garden):
"""B14: code finds the candidate pairs from the names alone, for any language, and writes them all."""
def pairs(self, names: dict[str, list[str]]) -> set[tuple[str, str, str]]:
return {(c.a, c.b, c.kind) for c in kmerge.candidates(names)}
def test_a_name_is_its_words_once_case_spelling_and_a_plural_s_are_set_aside(self) -> None:
self.assertEqual(["list", "session"], kmerge.name_words("`listSessions()`"))
self.assertEqual(["list", "session"], kmerge.name_words("list_sessions()"))
self.assertEqual(["sdk", "message"], kmerge.name_words("`SDKMessage`"))
self.assertEqual(["agentic", "loop"], kmerge.name_words("The agentic loop"))
self.assertEqual(["årlig", "kontroll", "av", "kuber"], kmerge.name_words("Årlig kontroll av kuber"))
self.assertEqual("årligkontroll", kmerge.compact("Årlig-kontroll")) # letters beyond a-z are kept
def test_names_equal_once_spaces_punctuation_and_case_are_dropped_are_a_compact_pair(self) -> None:
got = self.pairs({"a.md": ["`listSessions()`"], "b.md": ["list_sessions()"], "c.md": ["List sessions"],
"d.md": ["Hook events"], "e.md": ["`HookEvent`"], "f.md": ["Årlig kontroll"],
"g.md": ["Årligkontroll"]})
self.assertEqual({("a.md", "b.md", "compact"), ("a.md", "c.md", "compact"), ("b.md", "c.md", "compact"),
("d.md", "e.md", "compact"), ("f.md", "g.md", "compact")}, got)
def test_a_name_whose_words_all_stand_in_the_other_name_is_a_contained_pair(self) -> None:
got = self.pairs({"channel.md": ["Channel"], "push.md": ["Push messages with channels"],
"loop.md": ["The agentic loop"], "how.md": ["How the agent loop works"],
"kube.md": ["Kube"], "kubene.md": ["Stell av kubene"], "spade.md": ["Spade"]})
self.assertEqual({("channel.md", "push.md", "contained"), ("how.md", "loop.md", "contained"),
("kube.md", "kubene.md", "contained")}, got)
def test_a_word_ending_counts_only_on_a_stem_of_four_letters_and_at_most_two_more(self) -> None:
self.assertTrue(kmerge.word_match("agent", "agentic"))
self.assertTrue(kmerge.word_match("kube", "kubene"))
self.assertFalse(kmerge.word_match("the", "theme"))
self.assertFalse(kmerge.word_match("check", "checkpoint"))
self.assertFalse(kmerge.word_match("bed", "beds"))
def test_any_name_of_a_page_counts_and_each_pair_stands_once_under_its_first_kind(self) -> None:
got = self.pairs({"a.md": ["Rose head", "Rosehead"], "b.md": ["Rosehead"], "c.md": ["Soft rose head shower"]})
self.assertEqual({("a.md", "b.md", "compact"), ("a.md", "c.md", "contained")}, got)
def test_every_pair_is_written_however_many_a_short_name_gives(self) -> None:
names = {"seed.md": ["Seed"], **{f"s{n:03d}.md": [f"Seed variety {n}"] for n in range(300)}}
got = self.pairs(names)
self.assertEqual(300, len(got)) # a number is a word of its own: "1" does not stand in "10"
self.assertIn(("s000.md", "seed.md", "contained"), got)
def test_propose_writes_a_proposal_the_judge_steps_accept_with_keep_by_the_rule(self) -> None:
out = self.tmp / "forslag.json"
code, text = run(["propose", "--work", str(self.work), "--wiki", str(self.wiki), "--claims", str(self.claims),
"--out", str(out)])
self.assertEqual(0, code, text)
doc = json.loads(out.read_text(encoding="utf-8"))
self.assertEqual(kmerge.PROPOSAL_SCHEMA, doc["schema"])
self.assertEqual([("compact", "watering-can.md", ["wateringcan.md"]),
("contained", "garden.md", ["garden-tools.md"])],
[(g["kind"], g["keep"], g["merge_in"]) for g in doc["groups"]])
self.assertEqual({"pairs": 2, "compact": 1, "contained": 1, "pages": 4, "calls": 1, "judged_different": 0},
doc["summary"])
self.assertEqual([], doc["judged"])
pairs, facts = kmerge.checked_pairs(out, self.work, self.wiki, self.claims)
self.assertEqual([], kmerge.keep_deviations(pairs, facts))
self.assertIn("2 pairs", text)
self.assertEqual((2, out.read_bytes()), (run(["propose", "--work", str(self.work), "--wiki", str(self.wiki),
"--claims", str(self.claims), "--out", str(out)])[0],
out.read_bytes()))
class JudgedBeforeTest(Garden):
"""B14 rest: a pair the judge has judged `different` is not proposed again (9 in wiki-38 from step 18a)."""
def earlier(self, name: str, groups: list[tuple[str, str]], given: dict[str, str]) -> tuple[Path, Path]:
proposal = self.tmp / f"{name}-proposal.json"
proposal.write_text(json.dumps({"groups": [{"kind": "", "keep": k, "merge_in": [m]} for k, m in groups]}),
encoding="utf-8")
verdicts = self.tmp / f"{name}-verdicts.json"
verdicts.write_text(json.dumps({"schema": kmerge.VERDICTS_SCHEMA, "proposal_sha256": sha(proposal),
"verdicts": given, "missing": [], "without": []}), encoding="utf-8")
return proposal, verdicts
def propose_cmd(self, *judged: tuple[Path, Path]) -> tuple[int, str, dict[str, Any]]:
out = self.tmp / f"forslag-{len(list(self.tmp.glob('forslag-*')))}.json"
extra = [x for p, v in judged for x in ("--judged", str(p), str(v))]
code, text = run(["propose", "--work", str(self.work), "--wiki", str(self.wiki), "--claims", str(self.claims),
"--out", str(out), *extra])
return code, text, json.loads(out.read_text(encoding="utf-8")) if out.is_file() else {}
def test_a_pair_judged_different_before_is_left_out_whichever_page_was_kept(self) -> None:
p, v = self.earlier("a", [("garden-tools.md", "garden.md"), ("spade.md", "rake.md")],
{"1": "different", "2": "different", "k1": "different"})
code, text, doc = self.propose_cmd((p, v))
self.assertEqual(0, code, text)
self.assertEqual([("watering-can.md", ["wateringcan.md"])], [(g["keep"], g["merge_in"]) for g in doc["groups"]])
self.assertEqual((1, 1), (doc["summary"]["pairs"], doc["summary"]["judged_different"]))
self.assertEqual([{"proposal_sha256": sha(p), "verdicts_sha256": sha(v), "different": 2, "left_out": 1}],
doc["judged"])
self.assertIn("1 pair judged different before", text)
def test_a_pair_judged_same_or_never_judged_is_proposed_again(self) -> None:
p, v = self.earlier("a", [("watering-can.md", "wateringcan.md"), ("garden.md", "garden-tools.md")],
{"1": "same"})
code, text, doc = self.propose_cmd((p, v))
self.assertEqual((0, 2, 0), (code, doc["summary"]["pairs"], doc["summary"]["judged_different"]), text)
def test_several_earlier_judgings_count_together(self) -> None:
a = self.earlier("a", [("garden.md", "garden-tools.md")], {"1": "different"})
b = self.earlier("b", [("wateringcan.md", "watering-can.md")], {"1": "different"})
code, text, doc = self.propose_cmd(a, b)
self.assertEqual((0, [], 2), (code, doc["groups"], doc["summary"]["judged_different"]), text)
def test_verdicts_that_belong_to_another_proposal_are_refused(self) -> None:
p, v = self.earlier("a", [("garden.md", "garden-tools.md")], {"1": "different"})
other, _ = self.earlier("b", [("spade.md", "rake.md")], {})
code, text, doc = self.propose_cmd((other, v))
self.assertEqual((2, {}), (code, doc))
self.assertIn("another proposal", text)
bad = self.tmp / "not-verdicts.json"
bad.write_text("{}", encoding="utf-8")
self.assertEqual(2, self.propose_cmd((p, bad))[0])
class ControlsTest(Garden):
def draw(self, seed: int, count: int) -> tuple[int, str, list[kmerge.Pair]]:
out = self.tmp / f"controls-{seed}-{count}-{len(list(self.tmp.glob('controls-*')))}.json"
code, text = run(["controls", "--proposal", str(self.proposal), "--work", str(self.work), "--wiki",
str(self.wiki), "--claims", str(self.claims), "--home", "garden-tools", "--seed", str(seed),
"--count", str(count), "--out", str(out)])
return code, text, kmerge.load_controls(out)[0] if code == 0 else []
def test_controls_share_a_home_differ_in_name_share_no_line_and_stay_out_of_the_pairs(self) -> None:
code, _, pairs = self.draw(7, 2)
self.assertEqual(0, code)
self.assertEqual(["k1", "k2"], [p.id for p in pairs])
pages = [x for p in pairs for x in (p.keep, p.merge_in)]
self.assertEqual(len(pages), len(set(pages)))
self.assertTrue(set(pages) <= {"spade.md", "rake.md", "hoe.md", "trowel.md"})
self.assertNotIn({"spade.md", "trowel.md"}, [{p.keep, p.merge_in} for p in pairs]) # both cite one line
def test_the_draw_is_fixed_by_its_seed(self) -> None:
self.assertEqual(self.draw(7, 2)[2], self.draw(7, 2)[2])
draws = {tuple((p.keep, p.merge_in) for p in self.draw(seed, 1)[2]) for seed in range(12)}
self.assertGreater(len(draws), 1)
def test_a_build_with_fewer_candidates_gets_the_controls_it_has_and_says_how_many(self) -> None:
# B14 rest: a small folder (Birøktlaget: one possible) is no reason to stop the step
code, text, pairs = self.draw(7, 6)
self.assertEqual((0, ["k1", "k2"]), (code, [p.id for p in pairs]), text)
self.assertIn("2 of 6", text)
doc = json.loads(next(self.tmp.glob("controls-7-6-*.json")).read_text(encoding="utf-8"))
self.assertEqual((6, 2), (doc["count"], doc["drawn"]))
def test_the_home_comes_first_and_the_other_concept_pages_only_when_it_has_too_few(self) -> None:
for seed in range(12): # garden-tools holds a control whatever the seed: compost (under garden) is not needed
drawn = {x for p in self.draw(seed, 1)[2] for x in (p.keep, p.merge_in)}
self.assertNotIn("compost.md", drawn, seed)
out = self.tmp / "controls-garden.json"
code, text = run(["controls", "--proposal", str(self.proposal), "--work", str(self.work), "--wiki",
str(self.wiki), "--claims", str(self.claims), "--home", "garden", "--seed", "7", "--count",
"2", "--out", str(out)])
self.assertEqual(0, code, text)
pairs = kmerge.load_controls(out)[0]
pages = [x for p in pairs for x in (p.keep, p.merge_in)]
self.assertEqual(4, len(set(pages))) # garden holds only compost, so both come from the rest
self.assertTrue(set(pages) <= {"compost.md", "spade.md", "rake.md", "hoe.md", "trowel.md"})
self.assertNotIn({"spade.md", "trowel.md"}, [{p.keep, p.merge_in} for p in pairs])
def test_without_a_home_every_concept_page_outside_the_pairs_can_be_drawn(self) -> None:
out = self.tmp / "controls-any.json"
code, text = run(["controls", "--proposal", str(self.proposal), "--work", str(self.work), "--wiki",
str(self.wiki), "--claims", str(self.claims), "--seed", "7", "--out", str(out)])
self.assertEqual(0, code, text)
pairs, doc = kmerge.load_controls(out)
self.assertEqual((2, None), (len(pairs), doc["home"]))
self.assertFalse({x for p in pairs for x in (p.keep, p.merge_in)}
& {"garden.md", "garden-tools.md", "watering-can.md", "wateringcan.md"})
def test_no_control_at_all_is_written_and_said_and_the_tasks_still_run(self) -> None:
self.propose([("compact", "watering-can.md", "wateringcan.md"), ("contained", "rake.md", "spade.md"),
("contained", "trowel.md", "hoe.md")]) # only compost is left
code, text, pairs = self.draw(7, 6)
self.assertEqual((0, []), (code, pairs), text)
self.assertIn("no control pair", text)
out = self.tmp / "tasks-none"
code, text = run(["tasks", "--proposal", str(self.proposal), "--controls",
str(next(self.tmp.glob("controls-7-6-*.json"))), "--work", str(self.work), "--wiki",
str(self.wiki), "--claims", str(self.claims), "--out", str(out)])
self.assertEqual(0, code, text)
doc = json.loads((out / "tasks.json").read_text(encoding="utf-8"))
self.assertEqual(([], ["1", "2", "3"]), (doc["controls"], sorted(x for c in doc["calls"] for x in c["pairs"])))
def test_a_draw_is_never_written_again(self) -> None:
out = self.tmp / "controls.json"
args = ["controls", "--proposal", str(self.proposal), "--work", str(self.work), "--wiki", str(self.wiki),
"--claims", str(self.claims), "--home", "garden-tools", "--seed", "7", "--count", "2", "--out", str(out)]
self.assertEqual((0, 2), (run(args)[0], run(args)[0]))
class WithTasks(Garden):
def tasks(self, *extra: str) -> tuple[int, str, Path]:
controls = self.tmp / "controls.json"
if not controls.is_file():
run(["controls", "--proposal", str(self.proposal), "--work", str(self.work), "--wiki", str(self.wiki),
"--claims", str(self.claims), "--home", "garden-tools", "--seed", "7", "--count", "2", "--out",
str(controls)])
out = self.tmp / "tasks"
code, text = run(["tasks", "--proposal", str(self.proposal), "--controls", str(controls), "--work",
str(self.work), "--wiki", str(self.wiki), "--claims", str(self.claims), "--out", str(out),
*extra])
return code, text, out
class TasksTest(WithTasks):
def test_one_call_holds_the_pairs_and_the_controls_with_ids_titles_homes_claims_and_quotes(self) -> None:
code, _, out = self.tasks()
self.assertEqual(0, code)
layout = json.loads((out / "tasks.json").read_text(encoding="utf-8"))
self.assertEqual([("k001", ["1", "k1", "k2"])], [(c["name"], sorted(c["pairs"])) for c in layout["calls"]])
task = (out / "k001.md").read_text(encoding="utf-8")
for needed in ("watering-can", "Watering can", "wateringcan", "Wateringcan", "Garden tools", "Garden",
"A watering can carries water where a hose cannot reach.",
"carries water to plants that a hose cannot reach", "same", "different"):
self.assertIn(needed, task)
self.assertNotIn("needs light", task) # a home's own claims are no part of a pair
self.assertNotIn("[^", task) # no footnote marks or other page text
self.assertNotIn("](", task) # a link in a claim is reduced to its text
self.assertIn("A long spout on a wateringcan keeps the leaves dry.", task)
def test_at_most_eight_pairs_a_call_in_a_fixed_order(self) -> None:
ids = [str(n) for n in range(1, 23)] + [f"k{n}" for n in range(1, 7)]
calls = kmerge.layout(ids, seed=7)
self.assertEqual([8, 8, 8, 4], [len(c) for c in calls])
self.assertEqual(sorted(ids), sorted(x for c in calls for x in c))
self.assertEqual(calls, kmerge.layout(list(reversed(ids)), seed=7))
def test_a_call_also_closes_before_the_pair_that_would_take_it_over_the_read_cap(self) -> None:
ids = [str(n) for n in range(1, 11)]
sizes = {x: 25_000 for x in ids} | {"3": 70_000}
calls = kmerge.layout(ids, seed=7, sizes=sizes, cap=60_000)
self.assertEqual(sorted(ids), sorted(x for c in calls for x in c))
for call in calls:
self.assertTrue(len(call) == 1 or sum(sizes[x] for x in call) <= 60_000, call)
self.assertIn(["3"], calls) # a pair over the cap stands alone, never refused
self.assertEqual(kmerge.layout(ids, seed=7), kmerge.layout(ids, seed=7, sizes={x: 1 for x in ids}))
def test_every_task_file_stays_under_the_read_cap_unless_it_holds_one_pair(self) -> None:
from unittest import mock
one = len(kmerge.render_task(["1"], {"1": kmerge.load_proposal(self.proposal)[0]},
kmerge.page_facts(self.work, self.wiki, self.claims),
{c.page: [x for x in claims.load_claims(self.claims).claims if x.page == c.page]
for c in claims.load_claims(self.claims).claims}))
with mock.patch.object(kmerge, "TASK_CHARS", one + 10):
code, _, out = self.tasks()
self.assertEqual(0, code)
layout = json.loads((out / "tasks.json").read_text(encoding="utf-8"))
self.assertGreater(len(layout["calls"]), 1)
for c in layout["calls"]:
size = len((out / f"{c['name']}.md").read_text(encoding="utf-8"))
self.assertTrue(len(c["pairs"]) == 1 or size <= one + 10, (c, size))
def test_at_most_twenty_claims_a_page_and_the_count_of_the_rest(self) -> None:
many = [claims.Claim(f"p.md#k{n}", "p.md", n, f"Claim number {n}.", [], [claims.Excerpt("f.md", n, f"q{n}")],
True) for n in range(23)]
text = kmerge.page_block("p.md", "P", ["Home"], many)
self.assertIn("Claim number 19.", text)
self.assertNotIn("Claim number 20.", text)
self.assertIn("3 more claims", text)
def test_a_new_call_for_some_pairs_gets_a_new_name_and_leaves_the_first_alone(self) -> None:
_, _, out = self.tasks()
first = (out / "k001.md").read_bytes()
code, _, _ = self.tasks("--only", "1,k2")
self.assertEqual(0, code)
layout = json.loads((out / "tasks.json").read_text(encoding="utf-8"))
self.assertEqual(["k001", "k002"], [c["name"] for c in layout["calls"]])
self.assertEqual(["1", "k2"], sorted(layout["calls"][1]["pairs"]))
self.assertEqual(first, (out / "k001.md").read_bytes())
class VerdictsTest(WithTasks):
def setUp(self) -> None:
super().setUp()
self.proj = self.tmp / "transcripts"
self.tasks()
self.n = 0
def answer(self, call: str, text: str, agent_type: str = kmerge.AGENT_TYPE) -> None:
self.n += 1
sub = self.proj / "s1" / "subagents"
sub.mkdir(parents=True, exist_ok=True)
line = {"type": "assistant", "message": {"id": f"m{self.n}", "stop_reason": "end_turn",
"content": [{"type": "text", "text": text}]}}
(sub / f"agent-a{self.n}.jsonl").write_text(json.dumps(line) + "\n", encoding="utf-8")
(sub / f"agent-a{self.n}.meta.json").write_text(json.dumps(
{"agentType": agent_type, "description": f"V1-b5m-merge-{call}"}), encoding="utf-8")
def test_a_merger_started_from_a_plugin_is_read_by_its_namespaced_type(self) -> None:
self.answer("k001", "1 same\nk1 different\nk2 different\n", agent_type="okf-wiki:okf-wiki-merger")
code, _, doc = self.collect()
self.assertEqual(0, code)
self.assertEqual({"1": "same", "k1": "different", "k2": "different"}, doc["verdicts"])
def collect(self) -> tuple[int, str, dict[str, Any]]:
out = self.tmp / "verdicts.json"
code, text = run(["verdicts", "--tasks", str(self.tmp / "tasks"), "--transcripts", str(self.proj), "--run",
"b5m", "--out", str(out)])
return code, text, json.loads(out.read_text(encoding="utf-8")) if out.is_file() else {}
def test_one_line_per_pair_gives_every_verdict(self) -> None:
self.answer("k001", "1 same\nk1 different\n\nk2 different\n")
code, _, doc = self.collect()
self.assertEqual(0, code)
self.assertEqual({"1": "same", "k1": "different", "k2": "different"}, doc["verdicts"])
self.assertEqual(sha(self.proposal), doc["proposal_sha256"])
def test_a_missing_line_or_two_lines_for_a_pair_leave_it_without_a_verdict_and_exit_1(self) -> None:
self.answer("k001", "1 same\n1 different\nk1 different\n")
code, text, doc = self.collect()
self.assertEqual(1, code)
self.assertEqual({"k1": "different"}, doc["verdicts"])
self.assertEqual(["1", "k2"], doc["missing"])
self.assertIn("1, k2", text)
def test_a_line_that_cannot_be_read_or_names_an_unknown_id_gives_no_verdict_in_its_call(self) -> None:
for reply in ("1 same\nk1 different\nk2 probably different\n", "1 same\nk1 different\nk2 different\n9 same\n"):
with self.subTest(reply=reply):
self.answer("k001", reply) if self.n == 0 else self.retarget(reply)
code, _, doc = self.collect()
self.assertEqual(1, code)
self.assertEqual({}, doc["verdicts"])
self.assertEqual(["1", "k1", "k2"], doc["missing"])
def retarget(self, reply: str) -> None:
for p in (self.proj / "s1" / "subagents").glob("*.jsonl"):
line = json.loads(p.read_text(encoding="utf-8"))
line["message"]["content"][0]["text"] = reply
p.write_text(json.dumps(line) + "\n", encoding="utf-8")
def test_a_pair_still_without_a_verdict_after_its_new_call_is_written_without_one(self) -> None:
self.answer("k001", "1 same\nk1 different\n")
self.tasks("--only", "k2")
self.answer("k002", "k2 maybe\n")
code, _, doc = self.collect()
self.assertEqual(0, code)
self.assertEqual(["k2"], doc["without"])
self.assertEqual([], doc["missing"])
def test_a_new_call_gives_the_verdict_the_first_lacked(self) -> None:
self.answer("k001", "1 same\nk1 different\n")
self.tasks("--only", "k2")
self.answer("k002", "k2 different\n")
code, _, doc = self.collect()
self.assertEqual(0, code)
self.assertEqual({"1": "same", "k1": "different", "k2": "different"}, doc["verdicts"])
def test_a_control_judged_same_stops_with_exit_3(self) -> None:
self.answer("k001", "1 same\nk1 same\nk2 different\n")
code, text, doc = self.collect()
self.assertEqual(3, code)
self.assertEqual(["k1"], doc["controls_same"])
self.assertIn("STOP", text)
def test_a_call_answered_twice_gives_no_verdict(self) -> None:
self.answer("k001", "1 same\nk1 different\nk2 different\n")
self.answer("k001", "1 same\nk1 different\nk2 different\n")
self.assertEqual(["1", "k1", "k2"], self.collect()[2]["missing"])
class ApplyTest(Garden):
def test_apply_without_a_same_leaves_work_byte_identical(self) -> None:
before = tree(self.work)
code, _ = self.apply({"1": "different"})
self.assertEqual(0, code)
self.assertEqual(before, tree(self.work))
self.assertEqual(0, self.applied()["pages_gone"])
def test_the_merged_pages_fragments_move_and_its_catalogue_entry_becomes_an_alias(self) -> None:
self.assertEqual(0, self.apply({"1": "same"})[0])
cids = [f["concept_id"] for f in self.accepted()["fragments"]]
self.assertNotIn("wateringcan", cids)
self.assertEqual(5, cids.count("watering-can"))
index = self.index()
self.assertNotIn("wateringcan", index)
self.assertEqual(["Watering can", "Wateringcan"], index["watering-can"]["aliases"])
a = self.applied()
self.assertEqual((1, 2, 1), (a["pages_gone"], a["fragments_moved"], a["aliases_added"]))
def test_its_own_home_goes_and_the_build_has_no_stale_link_and_no_record_taken_out(self) -> None:
self.apply({"1": "same"})
homes = {(h["concept_id"], h["home"]) for h in self.accepted()["homes"]}
self.assertNotIn(("wateringcan", "garden-tools"), homes)
self.assertIn(("watering-can", "garden"), homes)
report = self.build(at=AT2)
self.assertEqual((0, 0), (report.stale, report.unlinked))
self.assertEqual(["wateringcan.md"], report.gone)
self.assertEqual([], audit.audit(self.wiki, self.sources))
tools = (self.wiki / "garden-tools.md").read_text(encoding="utf-8")
self.assertNotIn("wateringcan.md", tools)
self.assertEqual(1, (self.wiki / "garden.md").read_text(encoding="utf-8").count("(watering-can.md)"))
def test_link_records_on_and_to_the_merged_page_point_to_the_kept_one(self) -> None:
self.apply({"1": "same"})
records = {(r["page"], r["anchor"], r["target"]) for r in self.link_records()}
self.assertEqual({("compost.md", "watering can", "watering-can.md"),
("watering-can.md", "seedlings", "garden.md"), ("spade.md", "soil", "compost.md")}, records)
a = self.applied()
self.assertEqual((2, 1), (a["links_removed_self"], a["links_removed_duplicate"]))
self.assertEqual(3, json.loads(self.links.read_text(encoding="utf-8"))["accepted"])
self.build(at=AT2)
kept = (self.wiki / "watering-can.md").read_text(encoding="utf-8")
self.assertIn("[seedlings](garden.md)", kept)
self.assertNotIn("(watering-can.md)", kept)
self.assertEqual(5, sum(1 for s in klink.page_sentences(kept) if s.footnoted))
def test_the_claims_count_stays_and_the_other_name_stands_on_the_kept_page_and_in_the_index(self) -> None:
before = claims.extract(self.wiki, self.sources)
self.apply({"1": "same"})
self.build(at=AT2)
after = claims.extract(self.wiki, self.sources)
self.assertEqual(len(before.claims), len(after.claims))
for page in self.wiki.glob("*.md"):
if klink.is_concept(page.name):
fm = audit.read_document(page, page.name).frontmatter or {}
self.assertEqual(["Wateringcan"] if page.name == "watering-can.md" else None, fm.get("x-aliases"),
page.name)
lines = (self.wiki / "index.md").read_text(encoding="utf-8").split("\n")
self.assertEqual(["- [Watering can](watering-can.md) - A watering can carries water where a hose cannot "
"reach. (also: Wateringcan)"], [x for x in lines if "(watering-can.md)" in x])
self.assertEqual(1, sum("(also:" in x for x in lines))
self.assertEqual([], audit.audit(self.wiki, self.sources))
def long_name(self) -> None:
"""The page the keep rule puts first (more claims) has the longer name."""
self.write_state(titles={"watering-can": "Watering can for the garden"})
self.build()
self.list_claims()
def test_the_name_rule_is_the_shortest_name_then_the_keep_rule(self) -> None:
f = kmerge.Facts(titles={"a.md": "Extend the garden with tools", "b.md": "Tools", "c.md": "`tools`",
"d.md": "Garden tool"},
main={"a.md"}, claims={"a.md": 9, "b.md": 1, "c.md": 2, "d.md": 5}, inbound={}, first_pack={},
homes={}, cited={})
self.assertEqual("a.md", kmerge.keep_of(["a.md", "b.md"], f))
self.assertEqual("b.md", kmerge.named_of(["a.md", "b.md"], f))
self.assertEqual("c.md", kmerge.named_of(["a.md", "b.md", "c.md", "d.md"], f)) # Tools, tools: more claims
def test_a_group_goes_into_the_page_with_the_shortest_name_whatever_the_keep_rule_says(self) -> None:
self.long_name()
self.assertEqual([], kmerge.keep_deviations(kmerge.load_proposal(self.proposal), kmerge.page_facts(
self.work, self.wiki, self.claims))) # the proposal's keep stands by the keep rule
code, text = self.apply({"1": "same"})
self.assertEqual(0, code, text)
cids = [f["concept_id"] for f in self.accepted()["fragments"]]
self.assertEqual((0, 5), (cids.count("watering-can"), cids.count("wateringcan")))
index = self.index()
self.assertNotIn("watering-can", index)
self.assertEqual(["Wateringcan", "Watering can for the garden"], index["wateringcan"]["aliases"])
self.assertEqual([("wateringcan.md", "watering-can.md")],
[(r["keep"], r["merge_in"]) for r in self.applied()["pairs"]])
self.assertEqual({("wateringcan", "garden-tools")},
{(h["concept_id"], h["home"]) for h in self.accepted()["homes"]
if "can" in h["concept_id"]})
report = self.build(at=AT2)
self.assertEqual((0, ["watering-can.md"]), (report.stale, report.gone))
self.assertEqual([], audit.audit(self.wiki, self.sources))
fm = audit.read_document(self.wiki / "wateringcan.md", "wateringcan.md").frontmatter or {}
self.assertEqual(("Wateringcan", ["Watering can for the garden"]), (fm["title"], fm["x-aliases"]))
def test_the_description_follows_the_name_not_the_first_fragment_moved_in(self) -> None:
self.long_name()
before = (audit.read_document(self.wiki / "wateringcan.md", "wateringcan.md").frontmatter or {})["description"]
self.apply({"1": "same"})
self.build(at=AT2)
doc = audit.read_document(self.wiki / "wateringcan.md", "wateringcan.md")
self.assertEqual("A wateringcan with a rose head showers seedlings softly.", before)
self.assertEqual(before, (doc.frontmatter or {})["description"])
self.assertLess(doc.body.index("A watering can carries water"), doc.body.index("A wateringcan with a rose head"))
self.assertEqual({"watering-can": 3, None: 2},
{k: sum(1 for f in self.accepted()["fragments"] if f["concept_id"] == "wateringcan"
and f.get("merged_from") == k) for k in ("watering-can", None)})
def test_main_page_records_and_the_homes_of_a_merged_main_page_point_to_the_kept_one(self) -> None:
mains = {G: "watering-can", T: "wateringcan"}
homes = {"garden": "watering-can", "compost": "watering-can", "garden-tools": "wateringcan",
"spade": "wateringcan", "rake": "wateringcan", "hoe": "wateringcan", "trowel": "wateringcan"}
self.write_state(mains, homes)
self.build()
self.list_claims()
self.assertEqual(0, self.apply({"1": "same"})[0])
self.assertEqual({"watering-can"}, {m["concept_id"] for m in self.accepted()["main_pages"]})
self.assertEqual(2, len(self.accepted()["main_pages"]))
self.assertTrue(all(h["home"] == "watering-can" for h in self.accepted()["homes"]))
self.assertEqual(5, self.applied()["homes_repointed"])
self.build(at=AT2)
fm = audit.read_document(self.wiki / "watering-can.md", "watering-can.md").frontmatter or {}
self.assertEqual([f"/kilde/{G}", f"/kilde/{T}"], fm["x-main-for"])
self.assertIn("[Spade](spade.md)", (self.wiki / "watering-can.md").read_text(encoding="utf-8"))
def test_a_home_on_the_kept_page_that_would_point_to_itself_is_taken_out(self) -> None:
mains = {G: "watering-can", T: "wateringcan"} # both main pages: the one with more claims is kept
homes = {"garden": "watering-can", "compost": "watering-can", "watering-can": "wateringcan",
"garden-tools": "wateringcan", "spade": "wateringcan", "rake": "wateringcan", "hoe": "wateringcan",
"trowel": "wateringcan"}
self.write_state(mains, homes)
self.build()
self.list_claims()
self.assertEqual(0, self.apply({"1": "same"})[0])
self.assertNotIn("watering-can", {h["concept_id"] for h in self.accepted()["homes"]})
self.assertEqual(1, self.applied()["homes_removed_self"])
def test_a_shared_home_stays_once(self) -> None:
self.write_state(homes=dict(HOMES, wateringcan="garden"))
self.build()
self.list_claims()
self.apply({"1": "same"})
self.assertEqual([("watering-can", "garden")],
[(h["concept_id"], h["home"]) for h in self.accepted()["homes"]
if h["concept_id"] in ("watering-can", "wateringcan")])
def like_sentence(self, text: str) -> None:
"""The second fragment of wateringcan reads `text`, which holds a sentence that also stands on watering-can,
the page with the shorter name; a link record sits on that sentence on each page."""
moved = [x if x[3] != "A rose head on a watering can suits young plants." else
("wateringcan", T, "suits young plants", text) for x in FRAGMENTS]
self.write_state(fragments=moved, titles={"wateringcan": "Wateringcan with a rose"})
self.build(links=False)
self.write_links([x for x in LINKS if x[1] != "A rose head"]
+ [("watering-can", "Fill the can", "evening", "garden"),
("wateringcan", "Fill the can", "evening", "garden"),
("wateringcan", "Fill the can", "water", "compost")])
self.assertEqual(0, self.build().stale)
self.list_claims()
pages = ["watering-can.md", "wateringcan.md"] # the proposal's keep goes by the keep rule, whatever the names
keep = kmerge.keep_of(pages, kmerge.page_facts(self.work, self.wiki, self.claims))
self.propose([("contained", keep, next(x for x in pages if x != keep))])
def test_a_sentence_that_also_stands_on_the_kept_page_is_cut_and_its_page_merges(self) -> None:
self.like_sentence("Fill the can in the evening so the water warms.")
before = claims.extract(self.wiki, self.sources)
code, text = self.apply({"1": "same"})
self.assertEqual(0, code, text)
self.assertIn("cut", text)
a = self.applied()
self.assertEqual((1, 1, 1, 1), (a["pages_gone"], a["fragments_moved"], a["sentences_cut"],
a["fragments_dropped"]))
self.assertEqual([{"keep": "watering-can.md", "merge_in": "wateringcan.md", "file": T, "quote_line": 5,
"sentence": "Fill the can in the evening so the water warms.", "fragment": "dropped"}],
a["cut"])
self.assertNotIn("collisions", a)
report = self.build(at=AT2)
self.assertEqual(0, report.stale)
kept = (self.wiki / "watering-can.md").read_text(encoding="utf-8")
self.assertEqual(1, kept.count("so the water warms"))
self.assertIn("in the [evening](garden.md) so the [water](compost.md) warms", kept)
self.assertEqual(len(before.claims) - 1, len(claims.extract(self.wiki, self.sources).claims))
self.assertEqual([], audit.audit(self.wiki, self.sources))
def test_the_rest_of_a_fragment_moves_when_one_of_its_sentences_is_cut(self) -> None:
self.like_sentence("Fill the can in the evening so the water warms. A rose head suits young plants.")
code, text = self.apply({"1": "same"})
self.assertEqual(0, code, text)
a = self.applied()
self.assertEqual((2, 1, 0, "moved"), (a["fragments_moved"], a["sentences_cut"], a["fragments_dropped"],
a["cut"][0]["fragment"]))
texts = [f["text"] for f in self.accepted()["fragments"] if f["concept_id"] == "watering-can"]
self.assertIn("A rose head suits young plants.", texts)
self.assertEqual(0, self.build(at=AT2).stale)
kept = (self.wiki / "watering-can.md").read_text(encoding="utf-8")
self.assertEqual((1, 1), (kept.count("so the water warms"), kept.count("A rose head suits young plants.")))
self.assertEqual([], audit.audit(self.wiki, self.sources))
def test_a_sentence_twice_on_one_page_stays_twice_when_the_page_moves(self) -> None:
twice = [x if x[3] != "A rose head on a watering can suits young plants." else
("wateringcan", T, "suits young plants", "A wateringcan with a rose head showers seedlings softly.")
for x in FRAGMENTS]
self.write_state(fragments=twice)
self.build(links=False)
self.write_links([x for x in LINKS if x[1] != "A rose head"])
self.build()
self.list_claims()
self.assertEqual(0, self.apply({"1": "same"})[0])
self.assertEqual((2, 0), (self.applied()["fragments_moved"], self.applied()["sentences_cut"]))
self.assertEqual(0, self.build(at=AT2).stale)
self.assertEqual(2, (self.wiki / "watering-can.md").read_text(encoding="utf-8").count("rose head showers"))
def test_a_control_judged_same_or_a_pair_still_missing_is_refused(self) -> None:
self.assertEqual(3, self.apply({"1": "same", "k1": "same"})[0])
doc = json.loads((self.tmp / "verdicts.json").read_text(encoding="utf-8"))
path = self.tmp / "verdicts.json"
path.write_text(json.dumps(dict(doc, verdicts={}, missing=["1"])), encoding="utf-8")
code, _ = run(["apply", "--work", str(self.work), "--wiki", str(self.wiki), "--proposal", str(self.proposal),
"--claims", str(self.claims), "--verdicts", str(path), "--report", str(self.tmp / "r.json")])
self.assertEqual(2, code)
def chain(self) -> None:
"""watering-can <- wateringcan, wateringcan <- trowel (the keep rule), and watering-can <- trowel."""
self.propose([("compact", "watering-can.md", "wateringcan.md"), ("contained", "wateringcan.md", "trowel.md"),
("contained", "watering-can.md", "trowel.md")])
def test_pairs_judged_same_merge_as_one_group_into_the_page_with_the_shortest_name(self) -> None:
self.chain()
code, text = self.apply({"1": "same", "2": "same", "3": "same"})
self.assertEqual(0, code, text)
cids = [f["concept_id"] for f in self.accepted()["fragments"]]
self.assertEqual(7, cids.count("trowel"))
self.assertEqual(set(), {"wateringcan", "watering-can"} & set(cids))
self.assertEqual(["Trowel", "Watering can", "Wateringcan"], self.index()["trowel"]["aliases"])
a = self.applied()
self.assertEqual(2, a["pages_gone"])
self.assertEqual({("trowel.md", "watering-can.md", ("1", "3")), ("trowel.md", "wateringcan.md", ("1", "2"))},
{(r["keep"], r["merge_in"], tuple(r["pairs"])) for r in a["pairs"]})
self.assertEqual([], a["conflicts"])
report = self.build(at=AT2)
self.assertEqual(0, report.stale)
self.assertEqual([], audit.audit(self.wiki, self.sources))
def test_a_chain_of_same_merges_even_when_the_pair_across_was_not_asked(self) -> None:
self.propose([("compact", "watering-can.md", "wateringcan.md"), ("contained", "wateringcan.md", "trowel.md")])
self.assertEqual(0, self.apply({"1": "same", "2": "same"})[0])
self.assertEqual(2, self.applied()["pages_gone"])
self.assertEqual({"trowel"}, {f["concept_id"] for f in self.accepted()["fragments"]
if f["concept_id"] in ("trowel", "wateringcan", "watering-can")})
def test_a_group_with_a_pair_inside_judged_different_is_not_merged_and_is_reported(self) -> None:
self.chain()
before = tree(self.work)
code, text = self.apply({"1": "same", "2": "same", "3": "different"})
self.assertEqual(0, code, text)
self.assertEqual(before, tree(self.work))
a = self.applied()
self.assertEqual(0, a["pages_gone"])
self.assertEqual([{"pages": ["trowel.md", "watering-can.md", "wateringcan.md"], "same": ["1", "2"],
"different": ["3"]}], a["conflicts"])
self.assertIn("conflict", text)
def operator(self, given: dict[str, str], by: str = "the operator, 13.11.2026") -> Path:
path = self.tmp / "operator.json"
path.write_text(json.dumps({"schema": kmerge.OPERATOR_SCHEMA, "by": by, "verdicts": given}), encoding="utf-8")
return path
def test_a_verdict_the_operator_set_wins_over_the_judges_and_is_listed(self) -> None:
self.chain()
given = {"1": "same", "2": "same", "3": "different"}
self.assertEqual(0, self.apply(given)[0])
self.assertEqual(0, self.applied()["pages_gone"]) # a conflict, as the judge left it
path = self.operator({"3": "same"})
code, text = self.apply(given, "--operator", str(path))
self.assertEqual(0, code, text)
a = self.applied()
self.assertEqual((2, []), (a["pages_gone"], a["conflicts"]))
self.assertEqual({"by": "the operator, 13.11.2026", "sha256": sha(path),
"set": [{"pair": "3", "from": "different", "to": "same"}]}, a["operator"])
self.assertIn("operator", text)
def test_an_operator_file_that_names_an_unknown_pair_a_control_or_no_one_is_refused(self) -> None:
before = tree(self.work)
for given, by in (({"9": "same"}, "the operator"), ({"k1": "different"}, "the operator"),
({"1": "maybe"}, "the operator"), ({"1": "same"}, " ")):
with self.subTest(given=given, by=by):
self.assertEqual(2, self.apply({"1": "different"}, "--operator", str(self.operator(given, by)))[0])
self.assertEqual(before, tree(self.work))
def test_verdicts_for_another_proposal_are_refused(self) -> None:
path = self.verdicts({"1": "same"})
self.propose([("shared-lines", "watering-can.md", "wateringcan.md")])
code, _ = run(["apply", "--work", str(self.work), "--wiki", str(self.wiki), "--proposal", str(self.proposal),
"--claims", str(self.claims), "--verdicts", str(path), "--report", str(self.tmp / "r.json")])
self.assertEqual(2, code)
if __name__ == "__main__":
unittest.main()