update

test_smoke.py

@@ -0,0 +1,179 @@
+"""Smoke test: run the MCP server against a fake BookStack API."""
+
+import asyncio
+import os
+import threading
+import time
+
+import uvicorn
+from starlette.applications import Starlette
+from starlette.responses import JSONResponse, PlainTextResponse
+from starlette.routing import Route
+
+# ---------------- fake BookStack ----------------
+
+EXPECTED_AUTH = "Token tok-id:tok-secret"
+
+
+def check(request):
+    assert request.headers.get("authorization") == EXPECTED_AUTH, "bad auth header"
+
+
+async def search(request):
+    check(request)
+    q = request.query_params.get("query")
+    return JSONResponse({
+        "data": [{
+            "id": 42, "name": "Firewall Rules", "type": "page", "book_id": 3,
+            "chapter_id": 0, "url": "https://wiki.test/books/net/page/firewall-rules",
+            "preview_html": {"name": "<strong>Firewall</strong> Rules",
+                             "content": "Inbound <em>443</em> allowed &amp; logged"},
+            "tags": [{"name": "env", "value": "prod"}],
+            "updated_at": "2026-08-01T10:00:00Z",
+        }],
+        "total": 1, "query": q,
+    })
+
+
+async def page_detail(request):
+    check(request)
+    return JSONResponse({
+        "id": 42, "name": "Firewall Rules", "book_id": 3, "chapter_id": 0,
+        "slug": "firewall-rules", "book_slug": "net",
+        "tags": [{"name": "env", "value": "prod"}],
+        "updated_at": "2026-08-01T10:00:00Z", "html": "<p>hi</p>",
+    })
+
+
+async def page_export(request):
+    check(request)
+    return PlainTextResponse("# Firewall Rules\n\nInbound 443 allowed.\n")
+
+
+async def books(request):
+    check(request)
+    return JSONResponse({"data": [{"id": 3, "name": "Networking",
+                                   "description": "net docs",
+                                   "updated_at": "2026-08-01T10:00:00Z"}], "total": 1})
+
+
+async def book_detail(request):
+    check(request)
+    return JSONResponse({
+        "id": 3, "name": "Networking", "description": "net docs", "tags": [],
+        "updated_at": "2026-08-01T10:00:00Z",
+        "contents": [
+            {"type": "chapter", "id": 7, "name": "Edge",
+             "pages": [{"id": 42, "name": "Firewall Rules"}]},
+            {"type": "page", "id": 43, "name": "Loose Page"},
+        ],
+    })
+
+
+async def create_page(request):
+    check(request)
+    body = await request.json()
+    assert body["markdown"], "missing markdown"
+    return JSONResponse({"id": 99, "name": body["name"], "slug": "new-page"})
+
+
+async def forbidden(request):
+    return JSONResponse({"error": "nope"}, status_code=403)
+
+
+fake = Starlette(routes=[
+    Route("/api/search", search),
+    Route("/api/pages/42", page_detail),
+    Route("/api/pages/42/export/markdown", page_export),
+    Route("/api/pages", books, methods=["GET"]),
+    Route("/api/pages", create_page, methods=["POST"]),
+    Route("/api/books", books, methods=["GET"]),
+    Route("/api/books/3", book_detail),
+    Route("/api/shelves", forbidden),
+])
+
+
+def serve(app, port):
+    uvicorn.run(app, host="127.0.0.1", port=port, log_level="error")
+
+
+async def main():
+    threading.Thread(target=serve, args=(fake, 9911), daemon=True).start()
+
+    os.environ.update({
+        "BOOKSTACK_URL": "http://127.0.0.1:9911",
+        "BOOKSTACK_TOKEN_ID": "tok-id",
+        "BOOKSTACK_TOKEN_SECRET": "tok-secret",
+        "BOOKSTACK_READ_ONLY": "false",
+        "MCP_AUTH_MODE": "token",
+        "MCP_STATIC_TOKENS": "secret-abc,secret-def",
+        "MCP_PORT": "9912",
+    })
+
+    from bookstack_mcp.__main__ import build_app
+    app, settings = build_app()
+    threading.Thread(target=serve, args=(app, 9912), daemon=True).start()
+    time.sleep(2.5)
+
+    from fastmcp import Client
+    from fastmcp.client.auth import BearerAuth
+
+    url = "http://127.0.0.1:9912/mcp"
+
+    # 1. unauthenticated must fail
+    try:
+        async with Client(url) as c:
+            await c.list_tools()
+        print("FAIL: unauthenticated access was allowed")
+    except Exception as exc:
+        print(f"PASS auth required -> {type(exc).__name__}")
+
+    # 2. authenticated
+    async with Client(url, auth=BearerAuth("secret-abc")) as c:
+        tools = sorted(t.name for t in await c.list_tools())
+        print("PASS tools:", tools)
+
+        r = await c.call_tool("search_content", {"query": "{type:page} firewall"})
+        hit = r.data["results"][0]
+        assert hit["name"] == "Firewall Rules", hit
+        assert hit["excerpt"] == "Inbound 443 allowed & logged", hit["excerpt"]
+        assert hit["tags"] == ["env=prod"], hit["tags"]
+        print("PASS search_content ->", hit["name"], "|", hit["excerpt"], "|", hit["tags"])
+
+        r = await c.call_tool("get_page", {"page_id": 42})
+        assert r.data["content"].startswith("# Firewall Rules"), r.data
+        print("PASS get_page ->", repr(r.data["content"][:30]), "url:", r.data["url"])
+
+        r = await c.call_tool("get_book", {"book_id": 3})
+        assert r.data["contents"][0]["pages"][0]["id"] == 42
+        print("PASS get_book ->", r.data["contents"])
+
+        r = await c.call_tool("create_page", {
+            "name": "New", "markdown": "# hi", "book_id": 3, "tags": ["env=dev", "draft"]})
+        assert r.data["id"] == 99
+        print("PASS create_page ->", r.data)
+
+        # error surfacing: shelves endpoint returns 403
+        try:
+            await c.call_tool("list_shelves", {})
+            print("FAIL: 403 was not surfaced")
+        except Exception as exc:
+            print("PASS 403 surfaced ->", str(exc)[:80])
+
+        # validation
+        try:
+            await c.call_tool("create_page", {"name": "x", "markdown": "y"})
+            print("FAIL: missing parent not caught")
+        except Exception as exc:
+            print("PASS missing parent ->", str(exc)[:60])
+
+    # 3. wrong token rejected
+    try:
+        async with Client(url, auth=BearerAuth("wrong")) as c:
+            await c.list_tools()
+        print("FAIL: bad token accepted")
+    except Exception as exc:
+        print(f"PASS bad token rejected -> {type(exc).__name__}")
+
+
+asyncio.run(main())