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>
939 lines
55 KiB
Python
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()
|