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>
490 lines
27 KiB
Python
490 lines
27 KiB
Python
"""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()
|