155 lines
7.2 KiB
Python
155 lines
7.2 KiB
Python
from __future__ import annotations
|
|
|
|
import shutil
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
from mcp import ClientSession, StdioServerParameters
|
|
from mcp.client.stdio import stdio_client
|
|
from mcp.shared.memory import create_connected_server_and_client_session
|
|
|
|
from docforge.index import ProjectIndex
|
|
from docforge.mcp_server import CONTENT_WARNING, READ_TOOLS, create_server
|
|
from docforge.project import Project
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
FIXTURES = ROOT / "tests" / "fixtures"
|
|
|
|
|
|
class DocForgeMcpTests(unittest.IsolatedAsyncioTestCase):
|
|
def copy_fixture(self, name: str, destination: Path) -> Path:
|
|
root = destination / name
|
|
shutil.copytree(FIXTURES / name, root)
|
|
return root
|
|
|
|
async def test_protocol_lists_only_the_fixed_read_surface(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = self.copy_fixture("alpha", Path(directory))
|
|
ProjectIndex(Project.open(root)).build()
|
|
async with create_connected_server_and_client_session(
|
|
create_server(root), raise_exceptions=True
|
|
) as session:
|
|
response = await session.list_tools()
|
|
|
|
names = tuple(tool.name for tool in response.tools)
|
|
self.assertEqual(READ_TOOLS, names)
|
|
self.assertFalse(
|
|
any(
|
|
token in name
|
|
for name in names
|
|
for token in ("write", "apply", "commit", "push", "deploy", "propose")
|
|
)
|
|
)
|
|
|
|
async def test_every_read_tool_returns_scoped_structured_results(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = self.copy_fixture("alpha", Path(directory))
|
|
ProjectIndex(Project.open(root)).build()
|
|
calls = (
|
|
("docforge_project_info", {}),
|
|
("docforge_get_contract", {}),
|
|
("docforge_get_node", {"node_id": "guide.workflow"}),
|
|
("docforge_search", {"query": "canonical nodes", "limit": 5}),
|
|
("docforge_filter_nodes", {"family": "proof", "tag": "validation"}),
|
|
("docforge_backlinks", {"node_id": "guide.workflow"}),
|
|
("docforge_dependencies", {"node_id": "guide.workflow", "depth": 2}),
|
|
("docforge_impact", {"node_id": "guide.foundation", "depth": 2}),
|
|
("docforge_get_context", {"profile": "active", "budget": 180}),
|
|
("docforge_validate_project", {}),
|
|
("docforge_render_status", {}),
|
|
)
|
|
async with create_connected_server_and_client_session(
|
|
create_server(root), raise_exceptions=True
|
|
) as session:
|
|
results = [await session.call_tool(name, arguments) for name, arguments in calls]
|
|
|
|
for result in results:
|
|
self.assertFalse(result.isError)
|
|
self.assertIsNotNone(result.structuredContent)
|
|
payload = result.structuredContent
|
|
self.assertEqual("ok", payload["status"])
|
|
self.assertEqual("alpha-docs", payload["project_id"])
|
|
self.assertEqual(CONTENT_WARNING, payload["content_warning"])
|
|
self.assertTrue(payload["project_root_fingerprint"])
|
|
self.assertEqual("current", payload["staleness"])
|
|
contract = results[1].structuredContent
|
|
self.assertFalse(contract["canonical_writes_allowed"])
|
|
self.assertFalse(contract["project_switching_allowed"])
|
|
self.assertIn("canonical_writes", contract["excluded_operations"])
|
|
context = results[8].structuredContent
|
|
self.assertLessEqual(context["estimated_tokens"], 180)
|
|
self.assertTrue(context["omissions"])
|
|
|
|
async def test_missing_node_and_stale_index_are_structured_failures(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = self.copy_fixture("alpha", Path(directory))
|
|
ProjectIndex(Project.open(root)).build()
|
|
server = create_server(root)
|
|
async with create_connected_server_and_client_session(
|
|
server, raise_exceptions=True
|
|
) as session:
|
|
missing = await session.call_tool(
|
|
"docforge_get_node", {"node_id": "research.question"}
|
|
)
|
|
workflow = root / "docs" / "content" / "workflow.md"
|
|
workflow.write_text(
|
|
workflow.read_text(encoding="utf-8") + "\nChanged after startup.\n",
|
|
encoding="utf-8",
|
|
)
|
|
stale = await session.call_tool("docforge_get_node", {"node_id": "guide.workflow"})
|
|
|
|
self.assertEqual("missing_node", missing.structuredContent["error"]["code"])
|
|
self.assertEqual("stale_index", stale.structuredContent["error"]["code"])
|
|
self.assertEqual("current", missing.structuredContent["staleness"])
|
|
self.assertEqual("stale", stale.structuredContent["staleness"])
|
|
self.assertTrue(missing.structuredContent["source_hash"])
|
|
self.assertTrue(stale.structuredContent["source_hash"])
|
|
self.assertFalse(missing.isError)
|
|
self.assertFalse(stale.isError)
|
|
|
|
async def test_output_limit_fails_without_returning_partial_content(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = self.copy_fixture("alpha", Path(directory))
|
|
descriptor = root / ".docforge" / "project.toml"
|
|
descriptor.write_text(
|
|
descriptor.read_text(encoding="utf-8").replace(
|
|
"max_context_tokens = 2000",
|
|
"max_context_tokens = 2000\nmax_tool_output_chars = 700",
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
ProjectIndex(Project.open(root)).build()
|
|
async with create_connected_server_and_client_session(
|
|
create_server(root), raise_exceptions=True
|
|
) as session:
|
|
result = await session.call_tool("docforge_get_contract", {})
|
|
|
|
payload = result.structuredContent
|
|
self.assertEqual("error", payload["status"])
|
|
self.assertEqual("result_too_large", payload["error"]["code"])
|
|
self.assertNotIn("canonical_paths", payload)
|
|
|
|
async def test_stdio_transport_serves_the_same_project_bound_contract(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = self.copy_fixture("beta", Path(directory))
|
|
ProjectIndex(Project.open(root)).build()
|
|
parameters = StdioServerParameters(
|
|
command=sys.executable,
|
|
args=["-m", "docforge.mcp_server", "--project-root", str(root)],
|
|
)
|
|
async with (
|
|
stdio_client(parameters) as (read, write),
|
|
ClientSession(read, write) as session,
|
|
):
|
|
await session.initialize()
|
|
result = await session.call_tool("docforge_project_info", {})
|
|
|
|
self.assertFalse(result.isError)
|
|
self.assertEqual("beta-notes", result.structuredContent["project_id"])
|
|
self.assertEqual(1, result.structuredContent["node_count"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|