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

490 lines
27 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters

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

"""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()