186 lines
6.6 KiB
Python
186 lines
6.6 KiB
Python
import asyncio
|
|
import unittest
|
|
from unittest.mock import patch
|
|
|
|
from nocobase_crm_mcp import server as server_module
|
|
from nocobase_crm_mcp.nb_client import NbCommandError
|
|
from nocobase_crm_mcp.server import BearerTokenAuthMiddleware, FastMCP, create_http_app, create_server
|
|
|
|
|
|
async def _ok_app(scope, receive, send):
|
|
await send({"type": "http.response.start", "status": 200, "headers": []})
|
|
await send({"type": "http.response.body", "body": b"ok"})
|
|
|
|
|
|
def run_asgi_request(app, *, authorization=None, method="POST", path="/mcp"):
|
|
events = []
|
|
headers = []
|
|
if authorization is not None:
|
|
headers.append((b"authorization", authorization.encode("latin1")))
|
|
|
|
async def receive():
|
|
return {"type": "http.request", "body": b"", "more_body": False}
|
|
|
|
async def send(message):
|
|
events.append(message)
|
|
|
|
scope = {"type": "http", "method": method, "path": path, "headers": headers}
|
|
asyncio.run(app(scope, receive, send))
|
|
return events
|
|
|
|
|
|
class FakeCrmService:
|
|
def crm_health(self):
|
|
return {"ok": True}
|
|
|
|
def crm_schema(self, include_fields=False):
|
|
return {"include_fields": include_fields}
|
|
|
|
def crm_overview(self, **kwargs):
|
|
return {"totals": {"customers": 1}}
|
|
|
|
def crm_config_template(self):
|
|
return {"collections": {}}
|
|
|
|
def crm_filter_options(self, **kwargs):
|
|
return {"customer_status": []}
|
|
|
|
def resolve_owner(self, **kwargs):
|
|
return {"results": []}
|
|
|
|
def list_customers(self, **kwargs):
|
|
return {"results": []}
|
|
|
|
def get_customer(self, **kwargs):
|
|
return {"customer": None}
|
|
|
|
def list_contacts(self, **kwargs):
|
|
return {"results": []}
|
|
|
|
def list_followups(self, **kwargs):
|
|
return {"results": []}
|
|
|
|
|
|
class ErrorCrmService(FakeCrmService):
|
|
def list_customers(self, **kwargs):
|
|
raise NbCommandError("nb command failed with exit code 1: denied")
|
|
|
|
|
|
class MissingNbCrmService(FakeCrmService):
|
|
def crm_health(self):
|
|
raise FileNotFoundError(2, "No such file or directory", "nb")
|
|
|
|
|
|
class ServerTests(unittest.TestCase):
|
|
def test_bearer_token_middleware_rejects_missing_or_wrong_token(self) -> None:
|
|
app = BearerTokenAuthMiddleware(_ok_app, "secret")
|
|
|
|
self.assertEqual(run_asgi_request(app)[0]["status"], 401)
|
|
self.assertEqual(run_asgi_request(app, authorization="Bearer wrong")[0]["status"], 401)
|
|
|
|
def test_bearer_token_middleware_allows_matching_token(self) -> None:
|
|
app = BearerTokenAuthMiddleware(_ok_app, "secret")
|
|
|
|
events = run_asgi_request(app, authorization="Bearer secret")
|
|
|
|
self.assertEqual(events[0]["status"], 200)
|
|
self.assertEqual(events[1]["body"], b"ok")
|
|
|
|
def test_bearer_token_middleware_allows_options_preflight_without_token(self) -> None:
|
|
app = BearerTokenAuthMiddleware(_ok_app, "secret")
|
|
|
|
events = run_asgi_request(app, method="OPTIONS")
|
|
|
|
self.assertEqual(events[0]["status"], 204)
|
|
|
|
def test_readonly_server_exposes_crm_tools_only(self) -> None:
|
|
if FastMCP is None:
|
|
self.skipTest("MCP SDK is not installed")
|
|
|
|
server = create_server(crm_service=FakeCrmService(), readonly=True)
|
|
tools = asyncio.run(server.list_tools())
|
|
|
|
self.assertEqual(
|
|
{tool.name for tool in tools},
|
|
{
|
|
"crm_health",
|
|
"crm_schema",
|
|
"crm_overview",
|
|
"crm_filter_options",
|
|
"resolve_owner",
|
|
"list_customers",
|
|
"get_customer",
|
|
"list_contacts",
|
|
"list_followups",
|
|
},
|
|
)
|
|
|
|
def test_tool_schemas_expose_raw_opt_in_parameters(self) -> None:
|
|
if FastMCP is None:
|
|
self.skipTest("MCP SDK is not installed")
|
|
|
|
server = create_server(crm_service=FakeCrmService(), readonly=True)
|
|
tools = {tool.name: tool for tool in asyncio.run(server.list_tools())}
|
|
|
|
self.assertIn("include_raw", tools["list_customers"].inputSchema["properties"])
|
|
self.assertIn("include_raw", tools["list_contacts"].inputSchema["properties"])
|
|
self.assertIn("include_raw", tools["list_followups"].inputSchema["properties"])
|
|
self.assertIn("include_raw_followups", tools["get_customer"].inputSchema["properties"])
|
|
|
|
def test_tools_return_structured_error_for_nb_failures(self) -> None:
|
|
if FastMCP is None:
|
|
self.skipTest("MCP SDK is not installed")
|
|
|
|
server = create_server(crm_service=ErrorCrmService(), readonly=True)
|
|
|
|
_content, structured = asyncio.run(server.call_tool("list_customers", {}))
|
|
|
|
self.assertEqual(structured["error"]["code"], "nb_command_failed")
|
|
self.assertIn("denied", structured["error"]["message"])
|
|
self.assertFalse(structured["error"]["retryable"])
|
|
|
|
def test_tools_return_specific_error_when_nb_is_not_found(self) -> None:
|
|
if FastMCP is None:
|
|
self.skipTest("MCP SDK is not installed")
|
|
|
|
server = create_server(crm_service=MissingNbCrmService(), readonly=True)
|
|
|
|
_content, structured = asyncio.run(server.call_tool("crm_health", {}))
|
|
|
|
self.assertEqual(structured["error"]["code"], "nb_not_found")
|
|
self.assertIn("NOCOBASE_MCP_NB_BIN", structured["error"]["hint"])
|
|
self.assertFalse(structured["error"]["retryable"])
|
|
|
|
def test_make_service_uses_nb_bin_from_environment(self) -> None:
|
|
with (
|
|
patch.dict("os.environ", {"NOCOBASE_MCP_NB_BIN": "/opt/node/bin/nb"}),
|
|
patch.object(server_module, "NbClient") as nb_client,
|
|
patch.object(server_module, "CrmService", side_effect=lambda config, client: {"config": config, "client": client}),
|
|
):
|
|
service = server_module._make_service()
|
|
|
|
self.assertIs(service["client"], nb_client.return_value)
|
|
nb_client.assert_called_once_with(env_name="nb-mcp", data_source="main", nb_bin="/opt/node/bin/nb")
|
|
|
|
def test_config_template_tool_is_opt_in(self) -> None:
|
|
if FastMCP is None:
|
|
self.skipTest("MCP SDK is not installed")
|
|
|
|
with patch.dict("os.environ", {"NOCOBASE_MCP_ENABLE_CONFIG_TOOLS": "1"}):
|
|
server = create_server(crm_service=FakeCrmService(), readonly=True)
|
|
tools = asyncio.run(server.list_tools())
|
|
|
|
self.assertIn("crm_config_template", {tool.name for tool in tools})
|
|
|
|
def test_create_http_app_requires_bearer_token(self) -> None:
|
|
if FastMCP is None:
|
|
self.skipTest("MCP SDK is not installed")
|
|
|
|
server = create_server(crm_service=FakeCrmService(), readonly=True)
|
|
with self.assertRaises(ValueError):
|
|
create_http_app(server, "")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|