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