mongodb-mcp-server 0.1.3 → 0.3.0

package/tests/integration/indexCheck.test.ts

@@ -1,463 +0,0 @@
-import { defaultTestConfig, getResponseContent } from "./helpers.js";
-import { describeWithMongoDB } from "./tools/mongodb/mongodbHelpers.js";
-
-describe("IndexCheck integration tests", () => {
-    describe("with indexCheck enabled", () => {
-        describeWithMongoDB(
-            "indexCheck functionality",
-            (integration) => {
-                beforeEach(async () => {
-                    await integration.connectMcpClient();
-                });
-
-                describe("find operations", () => {
-                    beforeEach(async () => {
-                        // Insert test data for find operations
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("find-test-collection")
-                            .insertMany([
-                                { name: "document1", value: 1, category: "A" },
-                                { name: "document2", value: 2, category: "B" },
-                                { name: "document3", value: 3, category: "A" },
-                            ]);
-                    });
-
-                    it("should reject queries that perform collection scans", async () => {
-                        const response = await integration.mcpClient().callTool({
-                            name: "find",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "find-test-collection",
-                                filter: { category: "A" }, // No index on category field
-                            },
-                        });
-
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Index check failed");
-                        expect(content).toContain("collection scan (COLLSCAN)");
-                        expect(content).toContain("MDB_MCP_INDEX_CHECK");
-                        expect(response.isError).toBe(true);
-                    });
-
-                    it("should allow queries that use indexes", async () => {
-                        // Create an index on the category field
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("find-test-collection")
-                            .createIndex({ category: 1 });
-
-                        const response = await integration.mcpClient().callTool({
-                            name: "find",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "find-test-collection",
-                                filter: { category: "A" }, // Now has index
-                            },
-                        });
-
-                        expect(response.isError).toBeFalsy();
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Found");
-                        expect(content).toContain("documents");
-                    });
-
-                    it("should allow queries using _id (IDHACK)", async () => {
-                        const docs = await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("find-test-collection")
-                            .find({})
-                            .toArray();
-
-                        expect(docs.length).toBeGreaterThan(0);
-
-                        const response = await integration.mcpClient().callTool({
-                            name: "find",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "find-test-collection",
-                                filter: { _id: docs[0]?._id }, // Uses _id index (IDHACK)
-                            },
-                        });
-
-                        expect(response.isError).toBeFalsy();
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Found 1 documents");
-                    });
-                });
-
-                describe("count operations", () => {
-                    beforeEach(async () => {
-                        // Insert test data for count operations
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("count-test-collection")
-                            .insertMany([
-                                { name: "document1", value: 1, category: "A" },
-                                { name: "document2", value: 2, category: "B" },
-                                { name: "document3", value: 3, category: "A" },
-                            ]);
-                    });
-
-                    it("should reject count queries that perform collection scans", async () => {
-                        const response = await integration.mcpClient().callTool({
-                            name: "count",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "count-test-collection",
-                                query: { value: { $gt: 1 } }, // No index on value field
-                            },
-                        });
-
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Index check failed");
-                        expect(content).toContain("count operation");
-                        expect(response.isError).toBe(true);
-                    });
-
-                    it("should allow count queries with indexes", async () => {
-                        // Create an index on the value field
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("count-test-collection")
-                            .createIndex({ value: 1 });
-
-                        const response = await integration.mcpClient().callTool({
-                            name: "count",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "count-test-collection",
-                                query: { value: { $gt: 1 } }, // Now has index
-                            },
-                        });
-
-                        expect(response.isError).toBeFalsy();
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Found");
-                        expect(content).toMatch(/\d+ documents/);
-                    });
-                });
-
-                describe("aggregate operations", () => {
-                    beforeEach(async () => {
-                        // Insert test data for aggregate operations
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("aggregate-test-collection")
-                            .insertMany([
-                                { name: "document1", value: 1, category: "A" },
-                                { name: "document2", value: 2, category: "B" },
-                                { name: "document3", value: 3, category: "A" },
-                            ]);
-                    });
-
-                    it("should reject aggregation queries that perform collection scans", async () => {
-                        const response = await integration.mcpClient().callTool({
-                            name: "aggregate",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "aggregate-test-collection",
-                                pipeline: [
-                                    { $match: { category: "A" } }, // No index on category
-                                    { $group: { _id: "$category", count: { $sum: 1 } } },
-                                ],
-                            },
-                        });
-
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Index check failed");
-                        expect(content).toContain("aggregate operation");
-                        expect(response.isError).toBe(true);
-                    });
-
-                    it("should allow aggregation queries with indexes", async () => {
-                        // Create an index on the category field
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("aggregate-test-collection")
-                            .createIndex({ category: 1 });
-
-                        const response = await integration.mcpClient().callTool({
-                            name: "aggregate",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "aggregate-test-collection",
-                                pipeline: [
-                                    { $match: { category: "A" } }, // Now has index
-                                ],
-                            },
-                        });
-
-                        expect(response.isError).toBeFalsy();
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Found");
-                    });
-                });
-
-                describe("updateMany operations", () => {
-                    beforeEach(async () => {
-                        // Insert test data for updateMany operations
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("update-test-collection")
-                            .insertMany([
-                                { name: "document1", value: 1, category: "A" },
-                                { name: "document2", value: 2, category: "B" },
-                                { name: "document3", value: 3, category: "A" },
-                            ]);
-                    });
-
-                    it("should reject updateMany queries that perform collection scans", async () => {
-                        const response = await integration.mcpClient().callTool({
-                            name: "update-many",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "update-test-collection",
-                                filter: { category: "A" }, // No index on category
-                                update: { $set: { updated: true } },
-                            },
-                        });
-
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Index check failed");
-                        expect(content).toContain("updateMany operation");
-                        expect(response.isError).toBe(true);
-                    });
-
-                    it("should allow updateMany queries with indexes", async () => {
-                        // Create an index on the category field
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("update-test-collection")
-                            .createIndex({ category: 1 });
-
-                        const response = await integration.mcpClient().callTool({
-                            name: "update-many",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "update-test-collection",
-                                filter: { category: "A" }, // Now has index
-                                update: { $set: { updated: true } },
-                            },
-                        });
-
-                        expect(response.isError).toBeFalsy();
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Matched");
-                        expect(content).toContain("Modified");
-                    });
-                });
-
-                describe("deleteMany operations", () => {
-                    beforeEach(async () => {
-                        // Insert test data for deleteMany operations
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("delete-test-collection")
-                            .insertMany([
-                                { name: "document1", value: 1, category: "A" },
-                                { name: "document2", value: 2, category: "B" },
-                                { name: "document3", value: 3, category: "A" },
-                            ]);
-                    });
-
-                    it("should reject deleteMany queries that perform collection scans", async () => {
-                        const response = await integration.mcpClient().callTool({
-                            name: "delete-many",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "delete-test-collection",
-                                filter: { value: { $lt: 2 } }, // No index on value
-                            },
-                        });
-
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Index check failed");
-                        expect(content).toContain("deleteMany operation");
-                        expect(response.isError).toBe(true);
-                    });
-
-                    it("should allow deleteMany queries with indexes", async () => {
-                        // Create an index on the value field
-                        await integration
-                            .mongoClient()
-                            .db(integration.randomDbName())
-                            .collection("delete-test-collection")
-                            .createIndex({ value: 1 });
-
-                        const response = await integration.mcpClient().callTool({
-                            name: "delete-many",
-                            arguments: {
-                                database: integration.randomDbName(),
-                                collection: "delete-test-collection",
-                                filter: { value: { $lt: 2 } }, // Now has index
-                            },
-                        });
-
-                        expect(response.isError).toBeFalsy();
-                        const content = getResponseContent(response.content);
-                        expect(content).toContain("Deleted");
-                        expect(content).toMatch(/`\d+` document\(s\)/);
-                    });
-                });
-            },
-            () => ({
-                ...defaultTestConfig,
-                indexCheck: true, // Enable indexCheck
-            })
-        );
-    });
-
-    describe("with indexCheck disabled", () => {
-        describeWithMongoDB(
-            "indexCheck disabled functionality",
-            (integration) => {
-                beforeEach(async () => {
-                    await integration.connectMcpClient();
-
-                    // insert test data for disabled indexCheck tests
-                    await integration
-                        .mongoClient()
-                        .db(integration.randomDbName())
-                        .collection("disabled-test-collection")
-                        .insertMany([
-                            { name: "document1", value: 1, category: "A" },
-                            { name: "document2", value: 2, category: "B" },
-                            { name: "document3", value: 3, category: "A" },
-                        ]);
-                });
-
-                it("should allow all queries regardless of index usage", async () => {
-                    // Test find operation without index
-                    const findResponse = await integration.mcpClient().callTool({
-                        name: "find",
-                        arguments: {
-                            database: integration.randomDbName(),
-                            collection: "disabled-test-collection",
-                            filter: { category: "A" }, // No index, but should be allowed
-                        },
-                    });
-
-                    expect(findResponse.isError).toBeFalsy();
-                    const findContent = getResponseContent(findResponse.content);
-                    expect(findContent).toContain("Found");
-                    expect(findContent).not.toContain("Index check failed");
-                });
-
-                it("should allow count operations without indexes", async () => {
-                    const response = await integration.mcpClient().callTool({
-                        name: "count",
-                        arguments: {
-                            database: integration.randomDbName(),
-                            collection: "disabled-test-collection",
-                            query: { value: { $gt: 1 } }, // No index, but should be allowed
-                        },
-                    });
-
-                    expect(response.isError).toBeFalsy();
-                    const content = getResponseContent(response.content);
-                    expect(content).toContain("Found");
-                    expect(content).not.toContain("Index check failed");
-                });
-
-                it("should allow aggregate operations without indexes", async () => {
-                    const response = await integration.mcpClient().callTool({
-                        name: "aggregate",
-                        arguments: {
-                            database: integration.randomDbName(),
-                            collection: "disabled-test-collection",
-                            pipeline: [
-                                { $match: { category: "A" } }, // No index, but should be allowed
-                                { $group: { _id: "$category", count: { $sum: 1 } } },
-                            ],
-                        },
-                    });
-
-                    expect(response.isError).toBeFalsy();
-                    const content = getResponseContent(response.content);
-                    expect(content).toContain("Found");
-                    expect(content).not.toContain("Index check failed");
-                });
-
-                it("should allow updateMany operations without indexes", async () => {
-                    const response = await integration.mcpClient().callTool({
-                        name: "update-many",
-                        arguments: {
-                            database: integration.randomDbName(),
-                            collection: "disabled-test-collection",
-                            filter: { category: "A" }, // No index, but should be allowed
-                            update: { $set: { updated: true } },
-                        },
-                    });
-
-                    expect(response.isError).toBeFalsy();
-                    const content = getResponseContent(response.content);
-                    expect(content).toContain("Matched");
-                    expect(content).not.toContain("Index check failed");
-                });
-
-                it("should allow deleteMany operations without indexes", async () => {
-                    const response = await integration.mcpClient().callTool({
-                        name: "delete-many",
-                        arguments: {
-                            database: integration.randomDbName(),
-                            collection: "disabled-test-collection",
-                            filter: { value: { $lt: 2 } }, // No index, but should be allowed
-                        },
-                    });
-
-                    expect(response.isError).toBeFalsy();
-                    const content = getResponseContent(response.content);
-                    expect(content).toContain("Deleted");
-                    expect(content).not.toContain("Index check failed");
-                });
-            },
-            () => ({
-                ...defaultTestConfig,
-                indexCheck: false, // Disable indexCheck
-            })
-        );
-    });
-
-    describe("indexCheck configuration validation", () => {
-        describeWithMongoDB(
-            "default indexCheck behavior",
-            (integration) => {
-                it("should allow collection scans by default when indexCheck is not specified", async () => {
-                    await integration.connectMcpClient();
-
-                    await integration
-                        .mongoClient()
-                        .db(integration.randomDbName())
-                        .collection("default-test-collection")
-                        .insertOne({ name: "test", value: 1 });
-
-                    const response = await integration.mcpClient().callTool({
-                        name: "find",
-                        arguments: {
-                            database: integration.randomDbName(),
-                            collection: "default-test-collection",
-                            filter: { name: "test" }, // No index, should be allowed by default
-                        },
-                    });
-
-                    expect(response.isError).toBeFalsy();
-                });
-            },
-            () => ({
-                ...defaultTestConfig,
-                // indexCheck not specified, should default to false
-            })
-        );
-    });
-});

package/tests/integration/server.test.ts

@@ -1,87 +0,0 @@
-import { defaultTestConfig, expectDefined, setupIntegrationTest } from "./helpers.js";
-import { describeWithMongoDB } from "./tools/mongodb/mongodbHelpers.js";
-
-describe("Server integration test", () => {
-    describeWithMongoDB(
-        "without atlas",
-        (integration) => {
-            it("should return positive number of tools and have no atlas tools", async () => {
-                const tools = await integration.mcpClient().listTools();
-                expectDefined(tools);
-                expect(tools.tools.length).toBeGreaterThan(0);
-
-                const atlasTools = tools.tools.filter((tool) => tool.name.startsWith("atlas-"));
-                expect(atlasTools.length).toBeLessThanOrEqual(0);
-            });
-        },
-        () => ({
-            ...defaultTestConfig,
-            apiClientId: undefined,
-            apiClientSecret: undefined,
-        })
-    );
-
-    describe("with atlas", () => {
-        const integration = setupIntegrationTest(() => ({
-            ...defaultTestConfig,
-            apiClientId: "test",
-            apiClientSecret: "test",
-        }));
-
-        describe("list capabilities", () => {
-            it("should return positive number of tools and have some atlas tools", async () => {
-                const tools = await integration.mcpClient().listTools();
-                expectDefined(tools);
-                expect(tools.tools.length).toBeGreaterThan(0);
-
-                const atlasTools = tools.tools.filter((tool) => tool.name.startsWith("atlas-"));
-                expect(atlasTools.length).toBeGreaterThan(0);
-            });
-
-            it("should return no prompts", async () => {
-                await expect(() => integration.mcpClient().listPrompts()).rejects.toMatchObject({
-                    message: "MCP error -32601: Method not found",
-                });
-            });
-
-            it("should return capabilities", () => {
-                const capabilities = integration.mcpClient().getServerCapabilities();
-                expectDefined(capabilities);
-                expectDefined(capabilities?.logging);
-                expectDefined(capabilities?.completions);
-                expectDefined(capabilities?.tools);
-                expectDefined(capabilities?.resources);
-                expect(capabilities.experimental).toBeUndefined();
-                expect(capabilities.prompts).toBeUndefined();
-            });
-        });
-    });
-
-    describe("with read-only mode", () => {
-        const integration = setupIntegrationTest(() => ({
-            ...defaultTestConfig,
-            readOnly: true,
-            apiClientId: "test",
-            apiClientSecret: "test",
-        }));
-
-        it("should only register read and metadata operation tools when read-only mode is enabled", async () => {
-            const tools = await integration.mcpClient().listTools();
-            expectDefined(tools);
-            expect(tools.tools.length).toBeGreaterThan(0);
-
-            // Check that we have some tools available (the read and metadata ones)
-            expect(tools.tools.some((tool) => tool.name === "find")).toBe(true);
-            expect(tools.tools.some((tool) => tool.name === "collection-schema")).toBe(true);
-            expect(tools.tools.some((tool) => tool.name === "list-databases")).toBe(true);
-            expect(tools.tools.some((tool) => tool.name === "atlas-list-orgs")).toBe(true);
-            expect(tools.tools.some((tool) => tool.name === "atlas-list-projects")).toBe(true);
-
-            // Check that non-read tools are NOT available
-            expect(tools.tools.some((tool) => tool.name === "insert-one")).toBe(false);
-            expect(tools.tools.some((tool) => tool.name === "update-many")).toBe(false);
-            expect(tools.tools.some((tool) => tool.name === "delete-one")).toBe(false);
-            expect(tools.tools.some((tool) => tool.name === "drop-collection")).toBe(false);
-        });
-    });
-});

package/tests/integration/telemetry.test.ts

@@ -1,28 +0,0 @@
-import { createHmac } from "crypto";
-import { Telemetry } from "../../src/telemetry/telemetry.js";
-import { Session } from "../../src/session.js";
-import { config } from "../../src/config.js";
-import nodeMachineId from "node-machine-id";
-
-describe("Telemetry", () => {
-    it("should resolve the actual machine ID", async () => {
-        const actualId: string = await nodeMachineId.machineId(true);
-
-        const actualHashedId = createHmac("sha256", actualId.toUpperCase()).update("atlascli").digest("hex");
-
-        const telemetry = Telemetry.create(
-            new Session({
-                apiBaseUrl: "",
-            }),
-            config
-        );
-
-        expect(telemetry.getCommonProperties().device_id).toBe(undefined);
-        expect(telemetry["isBufferingEvents"]).toBe(true);
-
-        await telemetry.deviceIdPromise;
-
-        expect(telemetry.getCommonProperties().device_id).toBe(actualHashedId);
-        expect(telemetry["isBufferingEvents"]).toBe(false);
-    });
-});

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

@@ -1,98 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { describeWithAtlas, withProject } from "./atlasHelpers.js";
-import { expectDefined } from "../../helpers.js";
-
-function generateRandomIp() {
-    const randomIp: number[] = [192];
-    for (let i = 0; i < 3; i++) {
-        randomIp.push(Math.floor(Math.random() * 256));
-    }
-    return randomIp.join(".");
-}
-
-describeWithAtlas("ip access lists", (integration) => {
-    withProject(integration, ({ getProjectId }) => {
-        const ips = [generateRandomIp(), generateRandomIp()];
-        const cidrBlocks = [generateRandomIp() + "/16", generateRandomIp() + "/24"];
-        const values = [...ips, ...cidrBlocks];
-
-        beforeAll(async () => {
-            const apiClient = integration.mcpServer().session.apiClient;
-            const ipInfo = await apiClient.getIpInfo();
-            values.push(ipInfo.currentIpv4Address);
-        });
-
-        afterAll(async () => {
-            const apiClient = integration.mcpServer().session.apiClient;
-
-            const projectId = getProjectId();
-
-            for (const value of values) {
-                await apiClient.deleteProjectIpAccessList({
-                    params: {
-                        path: {
-                            groupId: projectId,
-                            entryValue: value,
-                        },
-                    },
-                });
-            }
-        });
-
-        describe("atlas-create-access-list", () => {
-            it("should have correct metadata", async () => {
-                const { tools } = await integration.mcpClient().listTools();
-                const createAccessList = tools.find((tool) => tool.name === "atlas-create-access-list");
-                expectDefined(createAccessList);
-                expect(createAccessList.inputSchema.type).toBe("object");
-                expectDefined(createAccessList.inputSchema.properties);
-                expect(createAccessList.inputSchema.properties).toHaveProperty("projectId");
-                expect(createAccessList.inputSchema.properties).toHaveProperty("ipAddresses");
-                expect(createAccessList.inputSchema.properties).toHaveProperty("cidrBlocks");
-                expect(createAccessList.inputSchema.properties).toHaveProperty("currentIpAddress");
-                expect(createAccessList.inputSchema.properties).toHaveProperty("comment");
-            });
-
-            it("should create an access list", async () => {
-                const projectId = getProjectId();
-
-                const response = (await integration.mcpClient().callTool({
-                    name: "atlas-create-access-list",
-                    arguments: {
-                        projectId,
-                        ipAddresses: ips,
-                        cidrBlocks: cidrBlocks,
-                        currentIpAddress: true,
-                    },
-                })) as CallToolResult;
-                expect(response.content).toBeArray();
-                expect(response.content).toHaveLength(1);
-                expect(response.content[0]?.text).toContain("IP/CIDR ranges added to access list");
-            });
-        });
-
-        describe("atlas-inspect-access-list", () => {
-            it("should have correct metadata", async () => {
-                const { tools } = await integration.mcpClient().listTools();
-                const inspectAccessList = tools.find((tool) => tool.name === "atlas-inspect-access-list");
-                expectDefined(inspectAccessList);
-                expect(inspectAccessList.inputSchema.type).toBe("object");
-                expectDefined(inspectAccessList.inputSchema.properties);
-                expect(inspectAccessList.inputSchema.properties).toHaveProperty("projectId");
-            });
-
-            it("returns access list data", async () => {
-                const projectId = getProjectId();
-
-                const response = (await integration
-                    .mcpClient()
-                    .callTool({ name: "atlas-inspect-access-list", arguments: { projectId } })) as CallToolResult;
-                expect(response.content).toBeArray();
-                expect(response.content).toHaveLength(1);
-                for (const value of values) {
-                    expect(response.content[0]?.text).toContain(value);
-                }
-            });
-        });
-    });
-});