add tests

Author: nirinchev

src/common/config.ts

@@ -116,7 +116,7 @@ export interface UserConfig extends CliOptions {
     transport: "stdio" | "http";
     httpPort: number;
     httpHost: string;
-    httpHeaders?: Record<string, string>;
+    httpHeaders: Record<string, string>;
     loggers: Array<"stderr" | "disk" | "mcp">;
     idleTimeoutMs: number;
     notificationTimeoutMs: number;
@@ -138,6 +138,7 @@ export const defaultUserConfig: UserConfig = {
     loggers: ["disk", "mcp"],
     idleTimeoutMs: 600000, // 10 minutes
     notificationTimeoutMs: 540000, // 9 minutes
+    httpHeaders: {},
 };
 
 export const config = setupUserConfig({

src/transports/streamableHttp.ts

@@ -45,13 +45,11 @@ export class StreamableHttpRunner extends TransportRunnerBase {
         app.enable("trust proxy"); // needed for reverse proxy support
         app.use(express.json());
         app.use((req, res, next) => {
-            if (this.userConfig.httpHeaders) {
-                for (const [key, value] of Object.entries(this.userConfig.httpHeaders)) {
-                    const header = req.headers[key];
-                    if (!header || header !== value) {
-                        res.sendStatus(403).json({ error: `Invalid ${key} header` });
-                        return;
-                    }
+            for (const [key, value] of Object.entries(this.userConfig.httpHeaders)) {
+                const header = req.headers[key];
+                if (!header || header !== value) {
+                    res.sendStatus(403).json({ error: `Invalid ${key} header` });
+                    return;
                 }
             }
 

tests/integration/transports/streamableHttp.test.ts

@@ -9,14 +9,12 @@ describe("StreamableHttpRunner", () => {
     let oldTelemetry: "enabled" | "disabled";
     let oldLoggers: ("stderr" | "disk" | "mcp")[];
 
-    beforeAll(async () => {
+    beforeAll(() => {
         oldTelemetry = config.telemetry;
         oldLoggers = config.loggers;
         config.telemetry = "disabled";
         config.loggers = ["stderr"];
         config.httpPort = 0; // Use a random port for testing
-        runner = new StreamableHttpRunner(config);
-        await runner.start();
     });
 
     afterAll(async () => {
@@ -25,33 +23,81 @@ describe("StreamableHttpRunner", () => {
         config.loggers = oldLoggers;
     });
 
-    describe("client connects successfully", () => {
-        let client: Client;
-        let transport: StreamableHTTPClientTransport;
-        beforeAll(async () => {
-            transport = new StreamableHTTPClientTransport(new URL(`${runner.address}/mcp`));
+    const headerTestCases: { headers: Record<string, string>; description: string }[] = [
+        { headers: {}, description: "without headers" },
+        { headers: { "x-custom-header": "test-value" }, description: "with headers" },
+    ];
 
-            client = new Client({
-                name: "test",
-                version: "0.0.0",
+    for (const { headers, description } of headerTestCases) {
+        describe(description, () => {
+            beforeAll(async () => {
+                config.httpHeaders = headers;
+                runner = new StreamableHttpRunner(config);
+                await runner.start();
             });
-            await client.connect(transport);
-        });
 
-        afterAll(async () => {
-            await client.close();
-            await transport.close();
-        });
+            const clientHeaderTestCases = [
+                {
+                    headers: {},
+                    description: "without client headers",
+                    expectSuccess: Object.keys(headers).length === 0,
+                },
+                { headers, description: "with matching client headers", expectSuccess: true },
+                { headers: { ...headers, foo: "bar" }, description: "with extra client headers", expectSuccess: true },
+                {
+                    headers: { foo: "bar" },
+                    description: "with non-matching client headers",
+                    expectSuccess: Object.keys(headers).length === 0,
+                },
+            ];
+
+            for (const {
+                headers: clientHeaders,
+                description: clientDescription,
+                expectSuccess,
+            } of clientHeaderTestCases) {
+                describe(clientDescription, () => {
+                    let client: Client;
+                    let transport: StreamableHTTPClientTransport;
+                    beforeAll(() => {
+                        client = new Client({
+                            name: "test",
+                            version: "0.0.0",
+                        });
+                        transport = new StreamableHTTPClientTransport(new URL(`${runner.address}/mcp`), {
+                            requestInit: {
+                                headers: clientHeaders,
+                            },
+                        });
+                    });
 
-        it("handles requests and sends responses", async () => {
-            const response = await client.listTools();
-            expect(response).toBeDefined();
-            expect(response.tools).toBeDefined();
-            expect(response.tools.length).toBeGreaterThan(0);
+                    afterAll(async () => {
+                        await client.close();
+                        await transport.close();
+                    });
 
-            const sortedTools = response.tools.sort((a, b) => a.name.localeCompare(b.name));
-            expect(sortedTools[0]?.name).toBe("aggregate");
-            expect(sortedTools[0]?.description).toBe("Run an aggregation against a MongoDB collection");
+                    it(`should ${expectSuccess ? "succeed" : "fail"}`, async () => {
+                        try {
+                            await client.connect(transport);
+                            const response = await client.listTools();
+                            expect(response).toBeDefined();
+                            expect(response.tools).toBeDefined();
+                            expect(response.tools.length).toBeGreaterThan(0);
+
+                            const sortedTools = response.tools.sort((a, b) => a.name.localeCompare(b.name));
+                            expect(sortedTools[0]?.name).toBe("aggregate");
+                            expect(sortedTools[0]?.description).toBe("Run an aggregation against a MongoDB collection");
+                        } catch (err) {
+                            if (expectSuccess) {
+                                throw err;
+                            } else {
+                                expect(err).toBeDefined();
+                                expect(err?.toString()).toContain("HTTP 403");
+                            }
+                        }
+                    });
+                });
+            }
         });
-    });
+    }
 });