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>
This commit is contained in:
Kjell Tore Guttormsen 2026-11-14 21:03:20 +01:00
commit 0fd86a23a3
Signed by: ktg
SSH key fingerprint: SHA256:JakMjO6FTBBzN0Bhfj9saOoEjaFxlSdYuZQQpM/lF9Q
227 changed files with 96077 additions and 0 deletions

490
tests/test_serve.py Normal file
View file

@ -0,0 +1,490 @@
"""The read-only MCP server (motor C21): `okfwiki.serve` answers lookups in one or more built collections over stdio,
with no model call and no file written.
Choices held here, one test each or more:
- the protocol is JSON-RPC 2.0, one message per line on stdin and stdout (MCP stdio transport); the server answers
initialize (the client's protocol version when it is one the server knows, else the newest), ping, tools/list and
tools/call, ignores notifications, and answers anything else with the JSON-RPC error for it;
- four tools, all marked read-only: `collections`, `search`, `page`, `source` - the skill's router for answering
(search the index, open the main page, follow links, open the source at the line);
- search reads only `index.md` (SPEC section 8: a line per concept with its description), so a collection of 3 000
pages answers at once; it matches words, never meaning, ranks a page by how rare its matching words are, a word in
the title counting twice, and reports how many pages each word hits and how many matched of how many;
- a page is named by its concept id (SPEC section 2: the path without `.md`) and comes back with its sources, quotes and
places, its links out (each marked when it names no page) and the pages that link to it;
- a source line comes from the frozen copy, with the heading above it, its page, slide or cell, and the original file;
- nothing leaves the collection's folder or its copy of the sources, and a rebuilt collection is read again.
Every document here is synthetic (gardening). Run: python3 -m unittest discover -s tests -p 'test_serve.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
from unittest import mock
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from okfwiki import serve # noqa: E402
INDEX = """---
okf_version: "0.2"
---
# Concepts
- [Bier i hagen](bier-i-hagen.md) - Heftet om bier i hagen, sverming og året.
- [Sverming](sverming.md) - Sverming skjer når kuben blir for trang.
- [Årshjul for bigården](aarshjul.md) - Året i bigården følger blomstringen.
- [Compost heap](compost-heap.md) - A compost heap needs air and water.
"""
def concept(title: str, description: str, body: str, sources: str = "", main_for: str = "") -> str:
return (f"---\ntype: Concept\ntitle: {title}\ndescription: {description}\n{sources}{main_for}"
f"generated:\n by: okf-wiki/kassemble\n at: '2026-11-08T06:00:00Z'\n---\n\n# {title}\n\n{body}\n")
SVERMING_SOURCES = """sources:
- id: s1
resource: /kilde/bier.pdf.md
title: Bier i hagen › Sverming
x-locator:
line: 4
page: 2
x-quote: Kuben svermer når den blir for trang.
x-span:
- 4
- 4
x-provenance: documented
"""
PAGES = {
"bier-i-hagen.md": concept(
"Bier i hagen", "Heftet om bier i hagen, sverming og året.",
"Heftet handler om [sverming](sverming.md) og [året](aarshjul.md).[^s0]\n\n[^s0]: bier.pdf.md, line 1",
main_for="x-main-for:\n- /kilde/bier.pdf.md\n"),
"sverming.md": concept(
"Sverming", "Sverming skjer når kuben blir for trang.",
"Kuben svermer når den blir for trang, se [årshjulet](aarshjul.md).[^s1]\n\n[^s1]: bier.pdf.md, page 2",
sources=SVERMING_SOURCES),
"aarshjul.md": concept("Årshjul for bigården", "Året i bigården følger blomstringen.",
"Året i bigården følger blomstringen.[^s2]\n\n[^s2]: bier.pdf.md, page 3"),
"compost-heap.md": concept(
"Compost heap", "A compost heap needs air and water.",
"A compost heap needs air and water, see [turning](mangler.md).[^s3]\n\n[^s3]: kompost.md, line 2",
main_for="x-main-for:\n- /kilde/kompost.md\n"),
}
BIER = ["# Bier i hagen", "", "## Sverming", "Kuben svermer når den blir for trang.", "Avleggere forebygger sverming.",
"## Året", "Året i bigården følger blomstringen."]
KOMPOST = ["# Compost", "A compost heap needs air and water.", "Turn it each month."]
def make_collection(root: Path, with_sources: bool = True) -> tuple[Path, Path]:
wiki, src = root / "wiki", root / "sources"
wiki.mkdir(parents=True)
(wiki / "index.md").write_text(INDEX, encoding="utf-8")
(wiki / "log.md").write_text("# Log\n\n## 2026-11-08\n\n- built\n", encoding="utf-8")
for name, text in PAGES.items():
(wiki / name).write_text(text, encoding="utf-8")
if with_sources:
(src / "kilde").mkdir(parents=True)
(src / "original").mkdir()
(src / "kilde" / "bier.pdf.md").write_text("\n".join(BIER) + "\n", encoding="utf-8")
(src / "kilde" / "kompost.md").write_text("\n".join(KOMPOST) + "\n", encoding="utf-8")
(src / "original" / "bier.pdf").write_bytes(b"%PDF-1.4 synthetic")
places = [{"page": 1}, None, {"page": 2}, {"page": 2}, {"page": 2}, {"page": 3}, {"page": 3}]
manifest = {"collection": "hage", "folder": "/x/hage", "sources": [
{"path": "kilde/bier.pdf.md", "kind": "document", "original": "bier.pdf",
"original_copy": "original/bier.pdf", "url": "file:///x/hage/bier.pdf", "places": places},
{"path": "kilde/kompost.md", "kind": "document", "original": "kompost.md",
"url": "file:///x/hage/kompost.md"}]}
(src / "source-manifest.json").write_text(json.dumps(manifest), encoding="utf-8")
return wiki, src
def tree_hash(*roots: Path) -> str:
h = hashlib.sha256()
for root in roots:
for p in sorted(root.rglob("*")):
h.update(str(p.relative_to(root)).encode())
if p.is_file():
h.update(p.read_bytes())
return h.hexdigest()
def call(server: serve.Server, tool: str, **args: Any) -> tuple[Any, bool]:
reply = server.handle({"jsonrpc": "2.0", "id": 7, "method": "tools/call", "params": {"name": tool, "arguments": args}})
assert reply is not None
result = reply["result"]
return json.loads(result["content"][0]["text"]), bool(result.get("isError"))
class Base(unittest.TestCase):
def setUp(self) -> None:
self.tmp = tempfile.TemporaryDirectory()
self.root = Path(self.tmp.name)
self.wiki, self.src = make_collection(self.root / "hage")
self.server = serve.Server([serve.Collection("hage", self.wiki, self.src)])
def tearDown(self) -> None:
self.tmp.cleanup()
class ProtocolTest(Base):
def test_initialize_echoes_a_known_version_and_names_the_server(self) -> None:
reply = self.server.handle({"jsonrpc": "2.0", "id": 1, "method": "initialize",
"params": {"protocolVersion": "2025-06-18", "capabilities": {},
"clientInfo": {"name": "t", "version": "0"}}})
assert reply is not None
self.assertEqual(reply["id"], 1)
r = reply["result"]
self.assertEqual(r["protocolVersion"], "2025-06-18")
self.assertEqual(r["serverInfo"]["name"], "okf-wiki")
self.assertIn("tools", r["capabilities"])
self.assertIn("model", r["instructions"])
def test_initialize_with_an_unknown_version_gets_the_newest(self) -> None:
reply = self.server.handle({"jsonrpc": "2.0", "id": 1, "method": "initialize",
"params": {"protocolVersion": "1999-01-01"}})
assert reply is not None
self.assertEqual(reply["result"]["protocolVersion"], serve.PROTOCOL_VERSIONS[0])
def test_notifications_get_no_answer_and_ping_an_empty_one(self) -> None:
self.assertIsNone(self.server.handle({"jsonrpc": "2.0", "method": "notifications/initialized"}))
self.assertEqual(self.server.handle({"jsonrpc": "2.0", "id": "p", "method": "ping"}),
{"jsonrpc": "2.0", "id": "p", "result": {}})
def test_unknown_method_and_unknown_tool_are_protocol_errors(self) -> None:
reply = self.server.handle({"jsonrpc": "2.0", "id": 2, "method": "resources/list"})
assert reply is not None
self.assertEqual(reply["error"]["code"], -32601)
reply = self.server.handle({"jsonrpc": "2.0", "id": 3, "method": "tools/call",
"params": {"name": "write", "arguments": {}}})
assert reply is not None
self.assertEqual(reply["error"]["code"], -32602)
def test_tools_list_has_four_read_only_tools_with_schemas(self) -> None:
reply = self.server.handle({"jsonrpc": "2.0", "id": 4, "method": "tools/list"})
assert reply is not None
tools = reply["result"]["tools"]
self.assertEqual([t["name"] for t in tools], ["collections", "search", "page", "source"])
for t in tools:
self.assertEqual(t["inputSchema"]["type"], "object")
self.assertTrue(t["annotations"]["readOnlyHint"])
self.assertFalse(t["annotations"]["openWorldHint"])
def test_run_answers_line_by_line_and_reports_a_line_that_is_not_json(self) -> None:
lines = [json.dumps({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {}}),
json.dumps({"jsonrpc": "2.0", "method": "notifications/initialized"}),
"", "{not json", json.dumps([1, 2]),
json.dumps({"jsonrpc": "2.0", "id": 2, "method": "tools/list"})]
out = io.StringIO()
serve.run(self.server, io.StringIO("\n".join(lines) + "\n"), out)
replies = [json.loads(x) for x in out.getvalue().splitlines()]
self.assertEqual([r.get("id") for r in replies], [1, None, None, 2])
self.assertEqual(replies[1]["error"]["code"], -32700)
self.assertEqual(replies[2]["error"]["code"], -32600)
class CollectionsTest(Base):
def test_counts_pages_and_main_pages_and_names_the_folders(self) -> None:
data, err = call(self.server, "collections")
self.assertFalse(err)
[c] = data["collections"]
self.assertEqual(c["collection"], "hage")
self.assertEqual(c["pages"], 4) # index.md and log.md are not concepts (SPEC 3.1)
self.assertEqual(c["main_pages"], 2)
self.assertEqual(c["okf_version"], "0.2")
self.assertEqual(c["wiki"], str(self.wiki.resolve()))
self.assertEqual(c["sources"], str(self.src.resolve()))
self.assertEqual(c["source_files"], 2)
class SearchTest(Base):
def test_title_match_ranks_above_description_and_counts_are_reported(self) -> None:
data, err = call(self.server, "search", words="sverming")
self.assertFalse(err)
[c] = data["collections"]
self.assertEqual((c["matched"], c["pages"]), (2, 4))
self.assertEqual([r["id"] for r in c["results"]], ["sverming", "bier-i-hagen"])
self.assertEqual(c["words"], [{"word": "sverming", "pages": 2}])
self.assertGreater(c["results"][0]["score"], c["results"][1]["score"])
self.assertEqual(c["results"][0]["title"], "Sverming")
def test_a_word_with_a_short_ending_matches_and_letters_beyond_a_z_count(self) -> None:
data, _ = call(self.server, "search", words="kube")
self.assertEqual([r["id"] for r in data["collections"][0]["results"]], ["sverming"])
data, _ = call(self.server, "search", words="Årshjul") # sverming's text links to "årshjulet"
self.assertEqual([r["id"] for r in data["collections"][0]["results"]], ["aarshjul", "sverming"])
def test_a_rare_word_outweighs_a_common_one(self) -> None:
data, _ = call(self.server, "search", words="i blomstringen")
ids = [r["id"] for r in data["collections"][0]["results"]]
self.assertEqual(ids[0], "aarshjul")
def test_a_word_only_in_a_page_text_is_found_below_a_title_match(self) -> None:
# "rammer" stands in no index line; the phase gate's set read 16 of 20 with page text, 11 of 20 without
(self.wiki / "sverming.md").write_text(PAGES["sverming.md"].replace("se [årshjulet]", "flytt rammer, se [årshjulet]"),
encoding="utf-8")
(self.wiki / "rammer.md").write_text(concept("Rammer", "Rammer i kuben.", "Tekst."), encoding="utf-8")
with (self.wiki / "index.md").open("a", encoding="utf-8") as f:
f.write("- [Rammer](rammer.md) - Rammer i kuben.\n")
data, _ = call(self.server, "search", words="rammer")
self.assertEqual([r["id"] for r in data["collections"][0]["results"]], ["rammer", "sverming"])
def test_no_hit_is_reported_as_zero_of_all(self) -> None:
data, err = call(self.server, "search", words="rakett")
self.assertFalse(err)
c = data["collections"][0]
self.assertEqual((c["matched"], c["pages"], c["results"]), (0, 4, []))
self.assertEqual(c["words"], [{"word": "rakett", "pages": 0}])
def test_main_only_without_words_lists_every_main_page_with_its_document(self) -> None:
data, _ = call(self.server, "search", main_only=True)
res = data["collections"][0]["results"]
self.assertEqual([(r["id"], r["main_for"]) for r in res],
[("bier-i-hagen", ["/kilde/bier.pdf.md"]), ("compost-heap", ["/kilde/kompost.md"])])
def test_paging_reports_the_rest(self) -> None:
first, _ = call(self.server, "search", words="sverming", limit=1)
second, _ = call(self.server, "search", words="sverming", limit=1, offset=1)
self.assertEqual([r["id"] for r in first["collections"][0]["results"]], ["sverming"])
self.assertTrue(first["collections"][0]["more"])
self.assertEqual([r["id"] for r in second["collections"][0]["results"]], ["bier-i-hagen"])
self.assertFalse(second["collections"][0]["more"])
def test_every_collection_is_searched_unless_one_is_named(self) -> None:
wiki2, src2 = make_collection(self.root / "hage2")
server = serve.Server([serve.Collection("hage", self.wiki, self.src), serve.Collection("hage2", wiki2, src2)])
data, _ = call(server, "search", words="compost")
self.assertEqual([c["collection"] for c in data["collections"]], ["hage", "hage2"])
data, _ = call(server, "search", words="compost", collection="hage2")
self.assertEqual([c["collection"] for c in data["collections"]], ["hage2"])
def test_bad_arguments_are_tool_errors(self) -> None:
for args in ({"words": "x", "collection": "ukjent"}, {}, {"words": " "}, {"words": "x", "limit": 0},
{"words": "x", "offset": -1}):
data, err = call(self.server, "search", **args)
self.assertTrue(err, args)
self.assertIn("error", data)
def test_a_rebuilt_collection_is_read_again(self) -> None:
call(self.server, "search", words="rakett")
(self.wiki / "rakett.md").write_text(concept("Rakett", "En rakett i hagen.", "Tekst."), encoding="utf-8")
with (self.wiki / "index.md").open("a", encoding="utf-8") as f:
f.write("- [Rakett](rakett.md) - En rakett i hagen.\n")
data, _ = call(self.server, "search", words="rakett")
self.assertEqual([r["id"] for r in data["collections"][0]["results"]], ["rakett"])
class OtherNamesTest(Base):
"""A page's other names (`x-aliases`, at the end of its index line as kassemble writes it) are searched as its
title is, and come back with the page."""
def setUp(self) -> None:
super().setUp()
index = (self.wiki / "index.md").read_text(encoding="utf-8")
(self.wiki / "index.md").write_text(index.replace(
"- [Sverming](sverming.md) - Sverming skjer når kuben blir for trang.",
"- [Sverming](sverming.md) - Sverming skjer når kuben blir for trang. (also: Kuben deler seg; Yngleflukt)"),
encoding="utf-8")
page = (self.wiki / "sverming.md").read_text(encoding="utf-8")
(self.wiki / "sverming.md").write_text(page.replace(
"generated:", "x-aliases:\n- Kuben deler seg\n- Yngleflukt\ngenerated:"), encoding="utf-8")
def test_a_search_for_another_name_finds_the_page_and_shows_its_names(self) -> None:
data, err = call(self.server, "search", words="yngleflukt")
self.assertFalse(err)
[r] = data["collections"][0]["results"]
self.assertEqual((r["id"], r["title"], r["aliases"]), ("sverming", "Sverming", ["Kuben deler seg", "Yngleflukt"]))
self.assertEqual(r["description"], "Sverming skjer når kuben blir for trang.")
def test_a_word_of_another_name_counts_as_a_word_of_the_title(self) -> None:
# "deler" stands in sverming's other name and in the text of rammer: the name ranks first
(self.wiki / "rammer.md").write_text(concept("Rammer", "Rammer i kuben.", "Birøkteren deler rammer."),
encoding="utf-8")
with (self.wiki / "index.md").open("a", encoding="utf-8") as f:
f.write("- [Rammer](rammer.md) - Rammer i kuben.\n")
data, _ = call(self.server, "search", words="deler")
res = data["collections"][0]["results"]
self.assertEqual([r["id"] for r in res], ["sverming", "rammer"])
self.assertGreater(res[0]["score"], res[1]["score"])
self.assertEqual(res[1]["aliases"], [])
def test_the_page_comes_with_its_other_names(self) -> None:
data, _ = call(self.server, "page", collection="hage", id="sverming")
self.assertEqual(data["aliases"], ["Kuben deler seg", "Yngleflukt"])
data, _ = call(self.server, "page", collection="hage", id="aarshjul")
self.assertEqual(data["aliases"], [])
class PageTest(Base):
def test_a_page_comes_with_sources_places_and_links_both_ways(self) -> None:
data, err = call(self.server, "page", collection="hage", id="sverming")
self.assertFalse(err)
self.assertEqual(data["id"], "sverming")
self.assertEqual(data["title"], "Sverming")
self.assertEqual(data["path"], str((self.wiki / "sverming.md").resolve()))
[s] = data["sources"]
self.assertEqual((s["id"], s["resource"], s["line"], s["place"], s["provenance"]),
("s1", "/kilde/bier.pdf.md", 4, "page 2", "documented"))
self.assertEqual(s["quote"], "Kuben svermer når den blir for trang.")
self.assertEqual(data["links_out"], [{"id": "aarshjul", "exists": True}])
self.assertEqual(data["linked_from"], ["bier-i-hagen"])
self.assertEqual(data["main_for"], [])
self.assertIn("[^s1]", data["body"])
def test_main_page_inbound_links_and_a_link_to_no_page(self) -> None:
data, _ = call(self.server, "page", collection="hage", id="bier-i-hagen.md")
self.assertEqual(data["id"], "bier-i-hagen")
self.assertEqual(data["main_for"], ["/kilde/bier.pdf.md"])
data, _ = call(self.server, "page", collection="hage", id="aarshjul")
self.assertEqual(data["linked_from"], ["bier-i-hagen", "sverming"])
data, _ = call(self.server, "page", collection="hage", id="compost-heap")
self.assertEqual(data["links_out"], [{"id": "mangler", "exists": False}])
def test_no_page_outside_the_collection_and_none_that_is_not_a_concept(self) -> None:
(self.root / "hage" / "hemmelig.md").write_text("---\ntype: Concept\n---\n", encoding="utf-8")
for pid in ("../hemmelig", "/etc/passwd", "finnes-ikke", "index", "log", ""):
data, err = call(self.server, "page", collection="hage", id=pid)
self.assertTrue(err, pid)
data, _ = call(self.server, "page", collection="hage", id="finnes-ikke")
self.assertIn("search", data["error"])
class PagePartsTest(Base):
"""Claude Code keeps a tool result whole up to a limit: 47 062 characters came back whole and 55 819 were put in
a file (2.1.319, 08.11), so a long page comes in parts of at most PART_CHARS, and nothing is left out."""
def long_page(self) -> None:
paras = [f"Avsnitt {n} om sverming og kuben, med nok tekst til at delene fylles opp.[^s{n}]" for n in range(30)]
srcs = "sources:\n" + "".join(
f"- id: s{n}\n resource: /kilde/bier.pdf.md\n x-locator:\n line: 4\n x-quote: Kuben svermer når den "
f"blir for trang.\n x-provenance: documented\n" for n in range(30))
(self.wiki / "lang.md").write_text(concept("Lang", "En lang side.", "\n\n".join(paras), sources=srcs),
encoding="utf-8")
def test_a_short_page_is_one_part_and_replies_are_compact(self) -> None:
reply = self.server.handle({"jsonrpc": "2.0", "id": 1, "method": "tools/call",
"params": {"name": "page", "arguments": {"collection": "hage", "id": "sverming"}}})
assert reply is not None
text = reply["result"]["content"][0]["text"]
self.assertNotIn("\n", text)
data = json.loads(text)
self.assertEqual((data["part"], data["parts"]), (1, 1))
def test_a_long_page_comes_in_parts_that_add_up_to_the_page(self) -> None:
self.long_page()
whole, _ = call(self.server, "page", collection="hage", id="lang")
with mock.patch.object(serve, "PART_CHARS", 1500):
first, err = call(self.server, "page", collection="hage", id="lang")
self.assertFalse(err)
parts = [first] + [call(self.server, "page", collection="hage", id="lang", part=k)[0]
for k in range(2, first["parts"] + 1)]
texts = [json.dumps(p, ensure_ascii=False, separators=(",", ":")) for p in parts]
past, err = call(self.server, "page", collection="hage", id="lang", part=first["parts"] + 1)
self.assertTrue(err)
_, err = call(self.server, "page", collection="hage", id="lang", part=0)
self.assertTrue(err)
self.assertGreater(first["parts"], 2)
self.assertTrue(all(len(t) <= 1500 for t in texts), [len(t) for t in texts])
self.assertEqual([p["part"] for p in parts], list(range(1, first["parts"] + 1)))
self.assertEqual("\n\n".join(p["body"] for p in parts if p["body"]), whole["body"])
self.assertEqual([s for p in parts for s in p["sources"]], whole["sources"])
self.assertEqual(first["title"], "Lang")
self.assertEqual(set(parts[1]), {"collection", "id", "part", "parts", "body", "sources"})
class SourceTest(Base):
def test_lines_around_a_line_with_heading_place_and_original(self) -> None:
data, err = call(self.server, "source", collection="hage", resource="/kilde/bier.pdf.md", line=4,
before=1, after=1)
self.assertFalse(err)
self.assertEqual([(x["line"], x["text"], x["place"]) for x in data["lines"]],
[(3, "## Sverming", "page 2"), (4, BIER[3], "page 2"), (5, BIER[4], "page 2")])
self.assertEqual(data["heading"], {"line": 3, "text": "Sverming"})
self.assertEqual(data["lines_total"], 7)
self.assertEqual(data["path"], str((self.src / "kilde" / "bier.pdf.md").resolve()))
self.assertEqual(data["original"], {"name": "bier.pdf", "url": "file:///x/hage/bier.pdf",
"copy": str((self.src / "original" / "bier.pdf").resolve())})
def test_default_window_and_a_text_source_without_places(self) -> None:
data, _ = call(self.server, "source", collection="hage", resource="/kilde/kompost.md", line=2)
self.assertEqual([x["line"] for x in data["lines"]], [1, 2, 3])
self.assertNotIn("place", data["lines"][1])
self.assertEqual(data["original"], {"name": "kompost.md", "url": "file:///x/hage/kompost.md"})
def test_whole_file_on_request(self) -> None:
data, _ = call(self.server, "source", collection="hage", resource="/kilde/bier.pdf.md", line=1, after=1000)
self.assertEqual(len(data["lines"]), 7)
def test_refused_lines_paths_and_a_collection_without_sources(self) -> None:
for args in ({"resource": "/kilde/bier.pdf.md", "line": 0}, {"resource": "/kilde/bier.pdf.md", "line": 8},
{"resource": "/../../etc/passwd", "line": 1}, {"resource": "/kilde/mangler.md", "line": 1},
{"resource": "/source-manifest.json", "line": 1},
{"resource": "https://example.org/x", "line": 1}, {"resource": "/kilde/bier.pdf.md", "line": 2,
"before": -1}):
data, err = call(self.server, "source", collection="hage", **args)
self.assertTrue(err, args)
bare_wiki, _ = make_collection(self.root / "bar", with_sources=False)
server = serve.Server([serve.Collection("bar", bare_wiki, None)])
data, err = call(server, "source", collection="bar", resource="/kilde/bier.pdf.md", line=1)
self.assertTrue(err)
self.assertIn("sources", data["error"])
class ReadOnlyTest(Base):
def test_no_call_changes_or_adds_a_file(self) -> None:
before = tree_hash(self.root)
call(self.server, "collections")
call(self.server, "search", words="sverming kube")
call(self.server, "search", main_only=True)
call(self.server, "page", collection="hage", id="sverming")
call(self.server, "page", collection="hage", id="../x")
call(self.server, "source", collection="hage", resource="/kilde/bier.pdf.md", line=4)
call(self.server, "source", collection="hage", resource="/kilde/x.md", line=4)
self.assertEqual(tree_hash(self.root), before)
class MainTest(Base):
def run_main(self, argv: list[str], stdin: str = "") -> tuple[int, str, str]:
out, err = io.StringIO(), io.StringIO()
with redirect_stdout(out), redirect_stderr(err), mock.patch.object(sys, "stdin", io.StringIO(stdin)):
code = serve.main(argv)
return code, out.getvalue(), err.getvalue()
def test_serves_until_stdin_ends(self) -> None:
code, out, _ = self.run_main(["--bundle", "hage", str(self.wiki), str(self.src)],
json.dumps({"jsonrpc": "2.0", "id": 1, "method": "ping"}) + "\n")
self.assertEqual(code, 0)
self.assertEqual(json.loads(out), {"jsonrpc": "2.0", "id": 1, "result": {}})
def test_a_collection_without_sources_is_allowed(self) -> None:
code, _, _ = self.run_main(["--bundle", "hage", str(self.wiki)])
self.assertEqual(code, 0)
def test_refuses_what_it_cannot_serve(self) -> None:
empty = self.root / "tom"
empty.mkdir()
for argv in ([], ["--bundle", "hage"], ["--bundle", "hage", str(empty)],
["--bundle", "hage", str(self.wiki), str(empty)],
["--bundle", "hage", str(self.wiki), str(self.src), "x"],
["--bundle", "hage", str(self.wiki), "--bundle", "hage", str(self.wiki)]):
code, out, err = self.run_main(argv)
self.assertEqual(code, 2, argv)
self.assertEqual(out, "")
self.assertTrue(err)
if __name__ == "__main__":
unittest.main()