mongodb-mcp-server 0.0.5 → 0.0.7

package/tests/integration/tools/atlas/atlasHelpers.ts

@@ -2,16 +2,18 @@ import { ObjectId } from "mongodb";
 import { Group } from "../../../../src/common/atlas/openapi.js";
 import { ApiClient } from "../../../../src/common/atlas/apiClient.js";
 import { setupIntegrationTest, IntegrationTest } from "../../helpers.js";
+import { config } from "../../../../src/config.js";
 
 export type IntegrationTestFunction = (integration: IntegrationTest) => void;
 
-export function sleep(ms: number) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 export function describeWithAtlas(name: string, fn: IntegrationTestFunction) {
     const testDefinition = () => {
-        const integration = setupIntegrationTest();
+        const integration = setupIntegrationTest(() => ({
+            ...config,
+            apiClientId: process.env.MDB_MCP_API_CLIENT_ID,
+            apiClientSecret: process.env.MDB_MCP_API_CLIENT_SECRET,
+        }));
+
         describe(name, () => {
             fn(integration);
         });

package/tests/integration/tools/atlas/clusters.test.ts

@@ -1,14 +1,18 @@
 import { Session } from "../../../../src/session.js";
 import { expectDefined } from "../../helpers.js";
-import { describeWithAtlas, withProject, sleep, randomId } from "./atlasHelpers.js";
+import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 
+function sleep(ms: number) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 async function deleteAndWaitCluster(session: Session, projectId: string, clusterName: string) {
     await session.apiClient.deleteCluster({
         params: {
             path: {
                 groupId: projectId,
-                clusterName: clusterName,
+                clusterName,
             },
         },
     });
@@ -18,7 +22,7 @@ async function deleteAndWaitCluster(session: Session, projectId: string, cluster
                 params: {
                     path: {
                         groupId: projectId,
-                        clusterName: clusterName,
+                        clusterName,
                     },
                 },
             });
@@ -29,6 +33,23 @@ async function deleteAndWaitCluster(session: Session, projectId: string, cluster
     }
 }
 
+async function waitClusterState(session: Session, projectId: string, clusterName: string, state: string) {
+    while (true) {
+        const cluster = await session.apiClient.getCluster({
+            params: {
+                path: {
+                    groupId: projectId,
+                    clusterName,
+                },
+            },
+        });
+        if (cluster?.stateName === state) {
+            return;
+        }
+        await sleep(1000);
+    }
+}
+
 describeWithAtlas("clusters", (integration) => {
     withProject(integration, ({ getProjectId }) => {
         const clusterName = "ClusterTest-" + randomId;
@@ -66,7 +87,7 @@ describeWithAtlas("clusters", (integration) => {
                     },
                 })) as CallToolResult;
                 expect(response.content).toBeArray();
-                expect(response.content).toHaveLength(1);
+                expect(response.content).toHaveLength(2);
                 expect(response.content[0].text).toContain("has been created");
             });
         });
@@ -117,5 +138,48 @@ describeWithAtlas("clusters", (integration) => {
                 expect(response.content[1].text).toContain(`${clusterName} | `);
             });
         });
+
+        describe("atlas-connect-cluster", () => {
+            beforeAll(async () => {
+                const projectId = getProjectId();
+                await waitClusterState(integration.mcpServer().session, projectId, clusterName, "IDLE");
+                await integration.mcpServer().session.apiClient.createProjectIpAccessList({
+                    params: {
+                        path: {
+                            groupId: projectId,
+                        },
+                    },
+                    body: [
+                        {
+                            comment: "MCP test",
+                            cidrBlock: "0.0.0.0/0",
+                        },
+                    ],
+                });
+            });
+
+            it("should have correct metadata", async () => {
+                const { tools } = await integration.mcpClient().listTools();
+                const connectCluster = tools.find((tool) => tool.name === "atlas-connect-cluster");
+
+                expectDefined(connectCluster);
+                expect(connectCluster.inputSchema.type).toBe("object");
+                expectDefined(connectCluster.inputSchema.properties);
+                expect(connectCluster.inputSchema.properties).toHaveProperty("projectId");
+                expect(connectCluster.inputSchema.properties).toHaveProperty("clusterName");
+            });
+
+            it("connects to cluster", async () => {
+                const projectId = getProjectId();
+
+                const response = (await integration.mcpClient().callTool({
+                    name: "atlas-connect-cluster",
+                    arguments: { projectId, clusterName },
+                })) as CallToolResult;
+                expect(response.content).toBeArray();
+                expect(response.content).toHaveLength(1);
+                expect(response.content[0].text).toContain(`Connected to cluster "${clusterName}"`);
+            });
+        });
     });
 });

package/tests/integration/tools/mongodb/metadata/connect.test.ts

@@ -1,147 +1,132 @@
 import { describeWithMongoDB } from "../mongodbHelpers.js";
-
-import { getResponseContent, validateToolMetadata } from "../../../helpers.js";
-
+import { getResponseContent, validateThrowsForInvalidArguments, validateToolMetadata } from "../../../helpers.js";
 import { config } from "../../../../../src/config.js";
 
-describeWithMongoDB("Connect tool", (integration) => {
-    validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
-        {
-            name: "options",
-            description:
-                "Options for connecting to MongoDB. If not provided, the connection string from the config://connection-string resource will be used. If the user hasn't specified Atlas cluster name or a connection string explicitly and the `config://connection-string` resource is present, always invoke this with no arguments.",
-            type: "array",
-            required: false,
-        },
-    ]);
-
-    describe("without arguments", () => {
-        it("prompts for connection string if not set", async () => {
-            const response = await integration.mcpClient().callTool({ name: "connect" });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("No connection details provided");
+// These tests are temporarily skipped because the connect tool is disabled for the initial release.
+// TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
+describeWithMongoDB(
+    "switchConnection tool",
+    (integration) => {
+        beforeEach(() => {
+            integration.mcpServer().userConfig.connectionString = integration.connectionString();
         });
 
-        it("connects to the database if connection string is set", async () => {
-            config.connectionString = integration.connectionString();
-
-            const response = await integration.mcpClient().callTool({ name: "connect" });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("Successfully connected");
-            expect(content).toContain(integration.connectionString());
-        });
-    });
+        validateToolMetadata(
+            integration,
+            "switch-connection",
+            "Switch to a different MongoDB connection. If the user has configured a connection string or has previously called the connect tool, a connection is already established and there's no need to call this tool unless the user has explicitly requested to switch to a new instance.",
+            [
+                {
+                    name: "connectionString",
+                    description: "MongoDB connection string to switch to (in the mongodb:// or mongodb+srv:// format)",
+                    type: "string",
+                    required: false,
+                },
+            ]
+        );
 
-    describe("with default config", () => {
-        describe("without connection string", () => {
-            it("prompts for connection string", async () => {
-                const response = await integration.mcpClient().callTool({ name: "connect", arguments: {} });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("No connection details provided");
-            });
-        });
+        validateThrowsForInvalidArguments(integration, "switch-connection", [{ connectionString: 123 }]);
 
-        describe("with connection string", () => {
+        describe("without arguments", () => {
             it("connects to the database", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: {
-                        options: [
-                            {
-                                connectionString: integration.connectionString(),
-                            },
-                        ],
-                    },
-                });
+                const response = await integration.mcpClient().callTool({ name: "switch-connection" });
                 const content = getResponseContent(response.content);
                 expect(content).toContain("Successfully connected");
-                expect(content).toContain(integration.connectionString());
             });
         });
 
-        describe("with invalid connection string", () => {
-            it("returns error message", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: { options: [{ connectionString: "mongodb://localhost:12345" }] },
-                });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Error running connect");
-
-                // Should not suggest using the config connection string (because we don't have one)
-                expect(content).not.toContain("Your config lists a different connection string");
-            });
+        it("doesn't have the connect tool registered", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const tool = tools.find((tool) => tool.name === "connect");
+            expect(tool).toBeUndefined();
         });
-    });
 
-    describe("with connection string in config", () => {
-        beforeEach(() => {
-            config.connectionString = integration.connectionString();
-        });
-
-        it("uses the connection string from config", async () => {
-            const response = await integration.mcpClient().callTool({ name: "connect", arguments: {} });
+        it("defaults to the connection string from config", async () => {
+            const response = await integration.mcpClient().callTool({ name: "switch-connection", arguments: {} });
             const content = getResponseContent(response.content);
             expect(content).toContain("Successfully connected");
-            expect(content).toContain(integration.connectionString());
         });
 
-        it("prefers connection string from arguments", async () => {
+        it("switches to the connection string from the arguments", async () => {
             const newConnectionString = `${integration.connectionString()}?appName=foo-bar`;
             const response = await integration.mcpClient().callTool({
-                name: "connect",
+                name: "switch-connection",
                 arguments: {
-                    options: [
-                        {
-                            connectionString: newConnectionString,
-                        },
-                    ],
+                    connectionString: newConnectionString,
                 },
             });
             const content = getResponseContent(response.content);
             expect(content).toContain("Successfully connected");
-            expect(content).toContain(newConnectionString);
         });
 
         describe("when the arugment connection string is invalid", () => {
-            it("suggests the config connection string if set", async () => {
+            it("returns error message", async () => {
                 const response = await integration.mcpClient().callTool({
-                    name: "connect",
+                    name: "switch-connection",
                     arguments: {
-                        options: [
-                            {
-                                connectionString: "mongodb://localhost:12345",
-                            },
-                        ],
+                        connectionString: "mongodb://localhost:12345",
                     },
                 });
+
                 const content = getResponseContent(response.content);
-                expect(content).toContain("Failed to connect to MongoDB at 'mongodb://localhost:12345'");
-                expect(content).toContain(
-                    `Your config lists a different connection string: '${config.connectionString}' - do you want to try connecting to it instead?`
-                );
+
+                expect(content).toContain("Error running switch-connection");
             });
+        });
+    },
+    (mdbIntegration) => ({
+        ...config,
+        connectionString: mdbIntegration.connectionString(),
+    }),
+    describe.skip
+);
+describeWithMongoDB(
+    "Connect tool",
+    (integration) => {
+        validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
+            {
+                name: "connectionString",
+                description: "MongoDB connection string (in the mongodb:// or mongodb+srv:// format)",
+                type: "string",
+                required: true,
+            },
+        ]);
+
+        validateThrowsForInvalidArguments(integration, "connect", [{}, { connectionString: 123 }]);
+
+        it("doesn't have the switch-connection tool registered", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const tool = tools.find((tool) => tool.name === "switch-connection");
+            expect(tool).toBeUndefined();
+        });
 
-            it("returns error message if the config connection string matches the argument", async () => {
-                config.connectionString = "mongodb://localhost:12345";
+        describe("with connection string", () => {
+            it("connects to the database", async () => {
                 const response = await integration.mcpClient().callTool({
                     name: "connect",
                     arguments: {
-                        options: [
-                            {
-                                connectionString: "mongodb://localhost:12345",
-                            },
-                        ],
+                        connectionString: integration.connectionString(),
                     },
                 });
-
                 const content = getResponseContent(response.content);
+                expect(content).toContain("Successfully connected");
+            });
+        });
 
-                // Should be handled by default error handler and not suggest the config connection string
-                // because it matches the argument connection string
+        describe("with invalid connection string", () => {
+            it("returns error message", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: { connectionString: "mongodb://localhost:12345" },
+                });
+                const content = getResponseContent(response.content);
                 expect(content).toContain("Error running connect");
+
+                // Should not suggest using the config connection string (because we don't have one)
                 expect(content).not.toContain("Your config lists a different connection string");
             });
         });
-    });
-});
+    },
+    () => config,
+    describe.skip
+);

package/tests/integration/tools/mongodb/mongodbHelpers.ts

@@ -3,29 +3,47 @@ import path from "path";
 import fs from "fs/promises";
 import { MongoClient, ObjectId } from "mongodb";
 import { getResponseContent, IntegrationTest, setupIntegrationTest } from "../../helpers.js";
-import { config } from "../../../../src/config.js";
+import { config, UserConfig } from "../../../../src/config.js";
 
 interface MongoDBIntegrationTest {
     mongoClient: () => MongoClient;
     connectionString: () => string;
-    connectMcpClient: () => Promise<void>;
     randomDbName: () => string;
 }
 
 export function describeWithMongoDB(
     name: string,
-    fn: (integration: IntegrationTest & MongoDBIntegrationTest) => void
-): void {
-    describe("mongodb", () => {
-        const integration = setupIntegrationTest();
-        const mdbIntegration = setupMongoDBIntegrationTest(integration);
-        describe(name, () => {
-            fn({ ...integration, ...mdbIntegration });
+    fn: (integration: IntegrationTest & MongoDBIntegrationTest & { connectMcpClient: () => Promise<void> }) => void,
+    getUserConfig: (mdbIntegration: MongoDBIntegrationTest) => UserConfig = () => config,
+    describeFn = describe
+) {
+    describeFn(name, () => {
+        const mdbIntegration = setupMongoDBIntegrationTest();
+        const integration = setupIntegrationTest(() => ({
+            ...getUserConfig(mdbIntegration),
+            connectionString: mdbIntegration.connectionString(),
+        }));
+
+        beforeEach(() => {
+            integration.mcpServer().userConfig.connectionString = mdbIntegration.connectionString();
+        });
+
+        fn({
+            ...integration,
+            ...mdbIntegration,
+            connectMcpClient: async () => {
+                // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when
+                // the connect tool is reenabled
+                // await integration.mcpClient().callTool({
+                //     name: "connect",
+                //     arguments: { connectionString: mdbIntegration.connectionString() },
+                // });
+            },
         });
     });
 }
 
-export function setupMongoDBIntegrationTest(integration: IntegrationTest): MongoDBIntegrationTest {
+export function setupMongoDBIntegrationTest(): MongoDBIntegrationTest {
     let mongoCluster: // TODO: Fix this type once mongodb-runner is updated.
     | {
               connectionString: string;
@@ -40,9 +58,6 @@ export function setupMongoDBIntegrationTest(integration: IntegrationTest): Mongo
     });
 
     afterEach(async () => {
-        await integration.mcpServer().session.close();
-        config.connectionString = undefined;
-
         await mongoClient?.close();
         mongoClient = undefined;
     });
@@ -108,12 +123,7 @@ export function setupMongoDBIntegrationTest(integration: IntegrationTest): Mongo
             return mongoClient;
         },
         connectionString: getConnectionString,
-        connectMcpClient: async () => {
-            await integration.mcpClient().callTool({
-                name: "connect",
-                arguments: { options: [{ connectionString: getConnectionString() }] },
-            });
-        },
+
         randomDbName: () => randomDbName,
     };
 }
@@ -128,13 +138,14 @@ export function validateAutoConnectBehavior(
     },
     beforeEachImpl?: () => Promise<void>
 ): void {
-    describe("when not connected", () => {
+    // TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
+    describe.skip("when not connected", () => {
         if (beforeEachImpl) {
             beforeEach(() => beforeEachImpl());
         }
 
         it("connects automatically if connection string is configured", async () => {
-            config.connectionString = integration.connectionString();
+            integration.mcpServer().userConfig.connectionString = integration.connectionString();
 
             const validationInfo = validation();
 

package/tests/unit/telemetry.test.ts

@@ -0,0 +1,200 @@
+import { ApiClient } from "../../src/common/atlas/apiClient.js";
+import { Session } from "../../src/session.js";
+import { Telemetry } from "../../src/telemetry/telemetry.js";
+import { BaseEvent, TelemetryResult } from "../../src/telemetry/types.js";
+import { EventCache } from "../../src/telemetry/eventCache.js";
+import { config } from "../../src/config.js";
+
+// Mock the ApiClient to avoid real API calls
+jest.mock("../../src/common/atlas/apiClient.js");
+const MockApiClient = ApiClient as jest.MockedClass<typeof ApiClient>;
+
+// Mock EventCache to control and verify caching behavior
+jest.mock("../../src/telemetry/eventCache.js");
+const MockEventCache = EventCache as jest.MockedClass<typeof EventCache>;
+
+describe("Telemetry", () => {
+    let mockApiClient: jest.Mocked<ApiClient>;
+    let mockEventCache: jest.Mocked<EventCache>;
+    let session: Session;
+    let telemetry: Telemetry;
+
+    // Helper function to create properly typed test events
+    function createTestEvent(options?: {
+        source?: string;
+        result?: TelemetryResult;
+        component?: string;
+        category?: string;
+        command?: string;
+        duration_ms?: number;
+    }): BaseEvent {
+        return {
+            timestamp: new Date().toISOString(),
+            source: options?.source || "mdbmcp",
+            properties: {
+                component: options?.component || "test-component",
+                duration_ms: options?.duration_ms || 100,
+                result: options?.result || "success",
+                category: options?.category || "test",
+                command: options?.command || "test-command",
+            },
+        };
+    }
+
+    // Helper function to verify mock calls to reduce duplication
+    function verifyMockCalls({
+        sendEventsCalls = 0,
+        clearEventsCalls = 0,
+        appendEventsCalls = 0,
+        sendEventsCalledWith = undefined,
+        appendEventsCalledWith = undefined,
+    } = {}) {
+        const { calls: sendEvents } = mockApiClient.sendEvents.mock;
+        const { calls: clearEvents } = mockEventCache.clearEvents.mock;
+        const { calls: appendEvents } = mockEventCache.appendEvents.mock;
+
+        expect(sendEvents.length).toBe(sendEventsCalls);
+        expect(clearEvents.length).toBe(clearEventsCalls);
+        expect(appendEvents.length).toBe(appendEventsCalls);
+
+        if (sendEventsCalledWith) {
+            expect(sendEvents[0]?.[0]).toEqual(sendEventsCalledWith);
+        }
+
+        if (appendEventsCalledWith) {
+            expect(appendEvents[0]?.[0]).toEqual(appendEventsCalledWith);
+        }
+    }
+
+    beforeEach(() => {
+        // Reset mocks before each test
+        jest.clearAllMocks();
+
+        // Setup mocked API client
+        mockApiClient = new MockApiClient() as jest.Mocked<ApiClient>;
+        mockApiClient.sendEvents = jest.fn().mockResolvedValue(undefined);
+        mockApiClient.hasCredentials = jest.fn().mockReturnValue(true);
+
+        // Setup mocked EventCache
+        mockEventCache = new MockEventCache() as jest.Mocked<EventCache>;
+        mockEventCache.getEvents = jest.fn().mockReturnValue([]);
+        mockEventCache.clearEvents = jest.fn().mockResolvedValue(undefined);
+        mockEventCache.appendEvents = jest.fn().mockResolvedValue(undefined);
+        MockEventCache.getInstance = jest.fn().mockReturnValue(mockEventCache);
+
+        // Create a simplified session with our mocked API client
+        session = {
+            apiClient: mockApiClient,
+            sessionId: "test-session-id",
+            agentRunner: { name: "test-agent", version: "1.0.0" } as const,
+            close: jest.fn().mockResolvedValue(undefined),
+            setAgentRunner: jest.fn().mockResolvedValue(undefined),
+        } as unknown as Session;
+
+        // Create the telemetry instance with mocked dependencies
+        telemetry = new Telemetry(session, mockEventCache);
+
+        config.telemetry = "enabled";
+    });
+
+    describe("when telemetry is enabled", () => {
+        it("should send events successfully", async () => {
+            const testEvent = createTestEvent();
+
+            await telemetry.emitEvents([testEvent]);
+
+            verifyMockCalls({
+                sendEventsCalls: 1,
+                clearEventsCalls: 1,
+                sendEventsCalledWith: [testEvent],
+            });
+        });
+
+        it("should cache events when sending fails", async () => {
+            mockApiClient.sendEvents.mockRejectedValueOnce(new Error("API error"));
+
+            const testEvent = createTestEvent();
+
+            await telemetry.emitEvents([testEvent]);
+
+            verifyMockCalls({
+                sendEventsCalls: 1,
+                appendEventsCalls: 1,
+                appendEventsCalledWith: [testEvent],
+            });
+        });
+
+        it("should include cached events when sending", async () => {
+            const cachedEvent = createTestEvent({
+                command: "cached-command",
+                component: "cached-component",
+            });
+
+            const newEvent = createTestEvent({
+                command: "new-command",
+                component: "new-component",
+            });
+
+            // Set up mock to return cached events
+            mockEventCache.getEvents.mockReturnValueOnce([cachedEvent]);
+
+            await telemetry.emitEvents([newEvent]);
+
+            verifyMockCalls({
+                sendEventsCalls: 1,
+                clearEventsCalls: 1,
+                sendEventsCalledWith: [cachedEvent, newEvent],
+            });
+        });
+    });
+
+    describe("when telemetry is disabled", () => {
+        beforeEach(() => {
+            config.telemetry = "disabled";
+        });
+
+        it("should not send events", async () => {
+            const testEvent = createTestEvent();
+
+            await telemetry.emitEvents([testEvent]);
+
+            verifyMockCalls();
+        });
+    });
+
+    it("should correctly add common properties to events", () => {
+        const commonProps = telemetry.getCommonProperties();
+
+        // Use explicit type assertion
+        const expectedProps: Record<string, string> = {
+            mcp_client_version: "1.0.0",
+            mcp_client_name: "test-agent",
+            session_id: "test-session-id",
+            config_atlas_auth: "true",
+            config_connection_string: expect.any(String) as unknown as string,
+        };
+
+        expect(commonProps).toMatchObject(expectedProps);
+    });
+
+    describe("when DO_NOT_TRACK environment variable is set", () => {
+        let originalEnv: string | undefined;
+
+        beforeEach(() => {
+            originalEnv = process.env.DO_NOT_TRACK;
+            process.env.DO_NOT_TRACK = "1";
+        });
+
+        afterEach(() => {
+            process.env.DO_NOT_TRACK = originalEnv;
+        });
+
+        it("should not send events", async () => {
+            const testEvent = createTestEvent();
+
+            await telemetry.emitEvents([testEvent]);
+
+            verifyMockCalls();
+        });
+    });
+});