Initial Commit

packages/devtools/tooling/mcp/src/e2e/server-edge-cases.test.ts

@@ -0,0 +1,444 @@
+/**
+ * MCPServer edge-case coverage — exercises server-side branches not naturally
+ * hit by happy-path tests: provider fall-backs, list-helpers with optional
+ * fields, normaliseToolResult array path, Zod root-level error formatting,
+ * authorize-true branch, signal forwarding to direct invocation API.
+ */
+import { describe, expect, it } from "@suaveplan/testing/runner";
+import { MCPClient } from "../client/mcp-client/mcp-client.js";
+import { MCP_CODES } from "../error-codes/error-codes.js";
+import { JsonRpcDispatcher } from "../jsonrpc/dispatcher/dispatcher.js";
+import { MCPServer } from "../server/mcp-server/mcp-server.js";
+import { InMemoryTransport } from "../transport/in-memory/in-memory.js";
+
+describe("server edge cases", () => {
+    it("server without sampling/completion provider falls back", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        const [a, b] = InMemoryTransport.pair();
+        await server.start(a);
+        const peer = new JsonRpcDispatcher({
+            side: "client",
+            transport: b,
+            dispatcherId: "X",
+        });
+        const completion = await peer.request("completion/complete", {
+            ref: { type: "ref/prompt", name: "x" },
+            argument: { name: "a", value: "b" },
+        });
+        expect(
+            (completion as { completion: { values: string[] } }).completion
+                .values
+        ).toEqual([]);
+        const pong = await peer.request("ping", {});
+        expect(pong).toEqual({});
+        const list = await peer.request("resources/list", {});
+        expect((list as { resources: unknown[] }).resources).toEqual([]);
+        const tplList = await peer.request("resources/templates/list", {});
+        expect(
+            (tplList as { resourceTemplates: unknown[] }).resourceTemplates
+        ).toEqual([]);
+        await expect(
+            peer.request("tools/call", { name: "nope" })
+        ).rejects.toMatchObject({ code: MCP_CODES.INTERNAL_ERROR });
+        await expect(
+            peer.request("resources/read", { uri: "mem://nope" })
+        ).rejects.toMatchObject({ code: MCP_CODES.INTERNAL_ERROR });
+        await expect(
+            peer.request("prompts/get", { name: "nope" })
+        ).rejects.toMatchObject({ code: MCP_CODES.INTERNAL_ERROR });
+        await peer.request("resources/subscribe", { uri: "mem://x" });
+        await peer.request("resources/unsubscribe", { uri: "mem://x" });
+        await peer.close();
+        await server.stop();
+    });
+
+    it("tool with paramsSchema validates over the dispatcher", {
+        timeout: 5000,
+    }, async () => {
+        const z = await import("zod");
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerTool({
+            name: "validated",
+            inputSchema: {},
+            paramsSchema: z.default.object({ n: z.default.number() }),
+            async handler(args) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: String((args as { n: number }).n),
+                        },
+                    ],
+                };
+            },
+        });
+        const [a, b] = InMemoryTransport.pair();
+        await server.start(a);
+        const peer = new JsonRpcDispatcher({
+            side: "client",
+            transport: b,
+            dispatcherId: "X",
+        });
+        await expect(
+            peer.request("tools/call", {
+                name: "validated",
+                arguments: { n: "not-a-number" },
+            })
+        ).rejects.toMatchObject({ code: MCP_CODES.INVALID_PARAMS });
+        const ok = await peer.request("tools/call", {
+            name: "validated",
+            arguments: { n: 7 },
+        });
+        expect(
+            (ok as { content: Array<{ text: string }> }).content[0]?.text
+        ).toBe("7");
+        await peer.close();
+        await server.stop();
+    });
+
+    it("readResource and getPromptMessages accept signal", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerResource({
+            uri: "mem://x",
+            name: "x",
+            async handler({ signal }) {
+                return {
+                    uri: "mem://x",
+                    text: signal.aborted ? "aborted" : "ok",
+                };
+            },
+        });
+        server.registerPrompt({
+            name: "p",
+            async handler() {
+                return [
+                    {
+                        role: "user",
+                        content: { type: "text", text: "hi" },
+                    },
+                ];
+            },
+        });
+        const ac = new AbortController();
+        const r = await server.readResource("mem://x", { signal: ac.signal });
+        expect(r[0]?.text).toBe("ok");
+        const m = await server.getPromptMessages(
+            "p",
+            {},
+            { signal: ac.signal }
+        );
+        expect(m.length).toBe(1);
+        server.registerTool({
+            name: "fast",
+            inputSchema: {},
+            async handler(_args, ctx) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: ctx.signal.aborted ? "x" : "ok",
+                        },
+                    ],
+                };
+            },
+        });
+        const r2 = await server.invokeTool("fast", {}, { signal: ac.signal });
+        expect(r2.content[0]).toMatchObject({ text: "ok" });
+    });
+
+    it("server invokeTool with paramsSchema replaces params with parsed data", {
+        timeout: 5000,
+    }, async () => {
+        const z = await import("zod");
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerTool({
+            name: "sum",
+            inputSchema: {},
+            paramsSchema: z.default.object({
+                a: z.default.number(),
+                b: z.default.number(),
+            }),
+            async handler(args) {
+                const { a, b } = args as { a: number; b: number };
+                return {
+                    content: [{ type: "text", text: String(a + b) }],
+                };
+            },
+        });
+        const result = await server.invokeTool("sum", { a: 2, b: 3 });
+        expect(result.content[0]).toMatchObject({ text: "5" });
+    });
+
+    it("server initialized getter starts false and flips true after handshake", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        expect(server.initialized).toBe(false);
+        const client = new MCPClient({
+            info: { name: "c", version: "0.1.0" },
+        });
+        const [a, b] = InMemoryTransport.pair();
+        await server.start(a);
+        await client.connect(b);
+        expect(server.initialized).toBe(true);
+        await client.disconnect();
+        await server.stop();
+    });
+
+    it("server rejects initialize for unsupported protocol version", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        const [a, b] = InMemoryTransport.pair();
+        await server.start(a);
+        const peer = new JsonRpcDispatcher({
+            side: "client",
+            transport: b,
+            dispatcherId: "X",
+        });
+        await expect(
+            peer.request("initialize", {
+                protocolVersion: "9999-01-01",
+                capabilities: {},
+                clientInfo: { name: "c", version: "0.1.0" },
+            })
+        ).rejects.toMatchObject({
+            code: MCP_CODES.INTERNAL_ERROR,
+        });
+        await peer.close();
+        await server.stop();
+    });
+
+    it("tool handler returning a ContentItem array is normalised", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerTool({
+            name: "arr",
+            inputSchema: {},
+            async handler() {
+                return [{ type: "text" as const, text: "x" }];
+            },
+        });
+        const result = await server.invokeTool("arr", {});
+        expect(result.content).toEqual([{ type: "text", text: "x" }]);
+        expect(result.isError).toBeUndefined();
+    });
+
+    it("server resource handler returning array passes through", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerResource({
+            uri: "mem://multi",
+            name: "multi",
+            async handler() {
+                return [
+                    { uri: "mem://multi", text: "part1" },
+                    { uri: "mem://multi", text: "part2" },
+                ];
+            },
+        });
+        const [a, b] = InMemoryTransport.pair();
+        await server.start(a);
+        const peer = new JsonRpcDispatcher({
+            side: "client",
+            transport: b,
+            dispatcherId: "X",
+        });
+        const out = (await peer.request("resources/read", {
+            uri: "mem://multi",
+        })) as { contents: unknown[] };
+        expect(out.contents.length).toBe(2);
+        await peer.close();
+        await server.stop();
+    });
+
+    it("prompts/get over the wire surfaces handler description", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerPrompt({
+            name: "with-desc",
+            description: "a documented prompt",
+            async handler() {
+                return [
+                    {
+                        role: "user" as const,
+                        content: { type: "text" as const, text: "hi" },
+                    },
+                ];
+            },
+        });
+        const [a, b] = InMemoryTransport.pair();
+        await server.start(a);
+        const peer = new JsonRpcDispatcher({
+            side: "client",
+            transport: b,
+            dispatcherId: "X",
+        });
+        const out = (await peer.request("prompts/get", {
+            name: "with-desc",
+        })) as { description?: string; messages: unknown[] };
+        expect(out.description).toBe("a documented prompt");
+        expect(out.messages.length).toBe(1);
+        await peer.close();
+        await server.stop();
+    });
+
+    it("server unregisterTool without dispatcher does not notify", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerTool({
+            name: "z",
+            inputSchema: {},
+            async handler() {
+                return { content: [] };
+            },
+        });
+        expect(server.unregisterTool("z")).toBe(true);
+        expect(server.unregisterTool("z")).toBe(false);
+    });
+
+    it("unregister returns false for unknown resource/prompt names", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        expect(server.unregisterResource("mem://missing")).toBe(false);
+        expect(server.unregisterPrompt("missing")).toBe(false);
+    });
+
+    it("list helpers surface optional description/mimeType/arguments", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerResource({
+            uri: "mem://r",
+            name: "r",
+            description: "rd",
+            mimeType: "text/plain",
+            async handler() {
+                return { uri: "mem://r" };
+            },
+        });
+        server.registerPrompt({
+            name: "p",
+            description: "pd",
+            arguments: [{ name: "a" }],
+            async handler() {
+                return [];
+            },
+        });
+        server.registerTool({
+            name: "t",
+            description: "td",
+            inputSchema: {},
+            async handler() {
+                return { content: [] };
+            },
+        });
+        const resources = server.listResources();
+        expect(resources[0]?.description).toBe("rd");
+        expect(resources[0]?.mimeType).toBe("text/plain");
+        const prompts = server.listPrompts();
+        expect(prompts[0]?.description).toBe("pd");
+        expect(prompts[0]?.arguments).toEqual([{ name: "a" }]);
+        const tools = server.listTools();
+        expect(tools[0]?.description).toBe("td");
+    });
+
+    it("markResourceUpdated before start is a silent no-op", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.markResourceUpdated("mem://x");
+    });
+
+    it("server invokeTool wraps non-Error handler throws into isError", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerTool({
+            name: "throwsString",
+            inputSchema: {},
+            async handler() {
+                const v: unknown = "raw-string";
+                throw v;
+            },
+        });
+        const result = await server.invokeTool("throwsString", {});
+        expect(result.isError).toBe(true);
+        expect(result.content[0]).toMatchObject({ text: "Error: raw-string" });
+    });
+
+    it("server readResource returns array handler output unwrapped", {
+        timeout: 5000,
+    }, async () => {
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+        });
+        server.registerResource({
+            uri: "mem://multi",
+            name: "multi",
+            async handler() {
+                return [
+                    { uri: "mem://multi", text: "a" },
+                    { uri: "mem://multi", text: "b" },
+                ];
+            },
+        });
+        const out = await server.readResource("mem://multi");
+        expect(out.length).toBe(2);
+    });
+
+    it("server start wires injected clock and idGenerator", {
+        timeout: 5000,
+    }, async () => {
+        let n = 0;
+        const server = new MCPServer({
+            info: { name: "s", version: "0.1.0" },
+            clock: () => 4242,
+            idGenerator: () => {
+                n += 1;
+                return `s-${n}`;
+            },
+        });
+        const [t] = InMemoryTransport.pair();
+        await server.start(t);
+        expect(server.running).toBe(true);
+        await server.stop();
+    });
+});