repositories / pi-ext
pi-ext
bugabingas pi extensions
owned by admin
extensions/web/__tests__/mcp.test.ts
Rawimport { afterEach, describe, expect, it, vi } from "vitest";
import { MAX_SEARCH_RESPONSE_BYTES } from "../constants.js";
import { callMcpTool } from "../mcp.js";
const result = { content: [{ type: "text", text: "found" }] };
const options = () => ({
url: "https://provider.test/mcp",
protocolVersion: "2025-03-26",
headers: { Authorization: "Bearer test" },
signal: new AbortController().signal,
name: "search",
arguments: { query: "example" },
});
function provider(body: string | ReadableStream<Uint8Array>, headers = {}) {
const fetch = vi
.fn()
.mockResolvedValueOnce(
new Response(
JSON.stringify({ id: 1, result: { protocolVersion: "2025-06-18" } }),
{ headers: { "mcp-session-id": "session" } },
),
)
.mockResolvedValueOnce(new Response(null, { status: 202 }))
.mockResolvedValueOnce(new Response(body, { headers }));
vi.stubGlobal("fetch", fetch);
return fetch;
}
afterEach(() => vi.unstubAllGlobals());
describe("MCP provider calls", () => {
it.each(["\r", "\n", "\r\n"])(
"accepts %j SSE lines, multiple events, multiline data and DONE",
async (newline) => {
const body = [
": keepalive",
"",
'data: {"method":"notifications/progress"}',
"",
'data: {"id":999,"result":{}}',
"",
"event: message",
'data: {"id":2,',
`data: "result":${JSON.stringify(result)}}`,
"",
"data: [DONE]",
"",
"",
].join(newline);
// Deliberately split every CRLF and JSON token across transport chunks.
const bytes = new TextEncoder().encode(body);
let offset = 0;
const fetch = provider(
new ReadableStream({
pull(controller) {
if (offset === bytes.length) controller.close();
else controller.enqueue(bytes.subarray(offset, ++offset));
},
}),
);
expect(await callMcpTool(options())).toEqual(result);
const requests = fetch.mock.calls.map(([, init]) => ({
...init,
body: JSON.parse(init.body),
}));
expect(requests.map((request) => request.body.method)).toEqual([
"initialize",
"notifications/initialized",
"tools/call",
]);
expect(requests[2]).toMatchObject({
redirect: "error",
headers: {
Authorization: "Bearer test",
"mcp-session-id": "session",
"MCP-Protocol-Version": "2025-06-18",
},
body: {
id: 2,
params: { name: "search", arguments: { query: "example" } },
},
});
},
);
it("accepts mixed SSE line endings and plain JSON", async () => {
provider(
`: ping\r\n\rdata: [DONE]\n\ndata: ${JSON.stringify({ id: 2, result })}\r\n\r\n`,
);
expect(await callMcpTool(options())).toEqual(result);
provider(JSON.stringify({ id: 2, result }));
expect(await callMcpTool(options())).toEqual(result);
});
it.each([
["data: invalid\r\r", "Malformed MCP response"],
[
'data: {"id":99,"result":{}}\r\rdata: [DONE]\r\r',
"no matching MCP response",
],
[
'data: {"id":2,"error":{"code":-32602,"message":"bad query"}}\r\r',
"bad query",
],
])("preserves malformed, unmatched and RPC errors", async (body, message) => {
provider(body);
await expect(callMcpTool(options())).rejects.toThrow(message);
});
it("preserves HTTP errors", async () => {
const fetch = provider("");
fetch
.mockReset()
.mockResolvedValue(new Response("denied", { status: 403 }));
await expect(callMcpTool(options())).rejects.toMatchObject({
name: "McpError",
status: 403,
});
});
it.each([true, false])(
"bounds SSE responses with content-length=%s",
async (declared) => {
const cancel = vi.fn();
const chunk = new Uint8Array(64 * 1024).fill(32);
provider(
new ReadableStream(
{
pull(controller) {
controller.enqueue(chunk);
},
cancel,
},
{ highWaterMark: 0 },
),
declared
? {
"content-length": String(MAX_SEARCH_RESPONSE_BYTES + 1),
}
: {},
);
await expect(callMcpTool(options())).rejects.toThrow(
"Response exceeds search response limit",
);
expect(cancel).toHaveBeenCalledOnce();
},
);
it("cancels a pending SSE read on abort", async () => {
const abort = new AbortController();
const cancel = vi.fn();
let reading!: () => void;
const started = new Promise<void>((resolve) => {
reading = resolve;
});
provider(
new ReadableStream(
{
pull() {
reading();
},
cancel,
},
{ highWaterMark: 0 },
),
);
const pending = callMcpTool({ ...options(), signal: abort.signal });
await started;
abort.abort();
await expect(pending).rejects.toMatchObject({ name: "AbortError" });
expect(cancel).toHaveBeenCalledOnce();
});
});