mongodb-mcp-server 0.2.0 → 0.3.0

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

@@ -1,118 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { describeWithAtlas, withProject } from "./atlasHelpers.js";
-import { expectDefined } from "../../helpers.js";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { ensureCurrentIpInAccessList } from "../../../../src/common/atlas/accessListUtils.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).toBeInstanceOf(Array);
-                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).toBeInstanceOf(Array);
-                expect(response.content).toHaveLength(1);
-                for (const value of values) {
-                    expect(response.content[0]?.text).toContain(value);
-                }
-            });
-        });
-
-        describe("ensureCurrentIpInAccessList helper", () => {
-            it("should add the current IP to the access list and be idempotent", async () => {
-                const apiClient = integration.mcpServer().session.apiClient;
-                const projectId = getProjectId();
-                const ipInfo = await apiClient.getIpInfo();
-                // First call should add the IP
-                await expect(ensureCurrentIpInAccessList(apiClient, projectId)).resolves.not.toThrow();
-                // Second call should be a no-op (idempotent)
-                await expect(ensureCurrentIpInAccessList(apiClient, projectId)).resolves.not.toThrow();
-                // Check that the IP is present in the access list
-                const accessList = await apiClient.listProjectIpAccessLists({
-                    params: { path: { groupId: projectId } },
-                });
-                const found = accessList.results?.some((entry) => entry.ipAddress === ipInfo.currentIpv4Address);
-                expect(found).toBe(true);
-            });
-        });
-    });
-});

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

@@ -1,43 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { expectDefined } from "../../helpers.js";
-import { parseTable, describeWithAtlas, withProject } from "./atlasHelpers.js";
-import { describe, expect, it } from "vitest";
-
-describeWithAtlas("alerts", (integration) => {
-    describe("atlas-list-alerts", () => {
-        it("should have correct metadata", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const listAlerts = tools.find((tool) => tool.name === "atlas-list-alerts");
-            expectDefined(listAlerts);
-            expect(listAlerts.inputSchema.type).toBe("object");
-            expectDefined(listAlerts.inputSchema.properties);
-            expect(listAlerts.inputSchema.properties).toHaveProperty("projectId");
-        });
-
-        withProject(integration, ({ getProjectId }) => {
-            it("returns alerts in table format", async () => {
-                const response = (await integration.mcpClient().callTool({
-                    name: "atlas-list-alerts",
-                    arguments: { projectId: getProjectId() },
-                })) as CallToolResult;
-
-                expect(response.content).toBeInstanceOf(Array);
-                expect(response.content).toHaveLength(1);
-
-                const data = parseTable(response.content[0]?.text as string);
-                expect(data).toBeInstanceOf(Array);
-
-                // Since we can't guarantee alerts will exist, we just verify the table structure
-                if (data.length > 0) {
-                    const alert = data[0];
-                    expect(alert).toHaveProperty("Alert ID");
-                    expect(alert).toHaveProperty("Status");
-                    expect(alert).toHaveProperty("Created");
-                    expect(alert).toHaveProperty("Updated");
-                    expect(alert).toHaveProperty("Type");
-                    expect(alert).toHaveProperty("Comment");
-                }
-            });
-        });
-    });
-});

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

@@ -1,111 +0,0 @@
-import { ObjectId } from "mongodb";
-import { Group } from "../../../../src/common/atlas/openapi.js";
-import { ApiClient } from "../../../../src/common/atlas/apiClient.js";
-import { setupIntegrationTest, IntegrationTest, defaultTestConfig } from "../../helpers.js";
-import { afterAll, beforeAll, describe } from "vitest";
-
-export type IntegrationTestFunction = (integration: IntegrationTest) => void;
-
-export function describeWithAtlas(name: string, fn: IntegrationTestFunction) {
-    const testDefinition = () => {
-        const integration = setupIntegrationTest(() => ({
-            ...defaultTestConfig,
-            apiClientId: process.env.MDB_MCP_API_CLIENT_ID,
-            apiClientSecret: process.env.MDB_MCP_API_CLIENT_SECRET,
-        }));
-
-        describe(name, () => {
-            fn(integration);
-        });
-    };
-
-    if (!process.env.MDB_MCP_API_CLIENT_ID?.length || !process.env.MDB_MCP_API_CLIENT_SECRET?.length) {
-        // eslint-disable-next-line vitest/valid-describe-callback
-        return describe.skip("atlas", testDefinition);
-    }
-    // eslint-disable-next-line vitest/no-identical-title, vitest/valid-describe-callback
-    return describe("atlas", testDefinition);
-}
-
-interface ProjectTestArgs {
-    getProjectId: () => string;
-}
-
-type ProjectTestFunction = (args: ProjectTestArgs) => void;
-
-export function withProject(integration: IntegrationTest, fn: ProjectTestFunction) {
-    return describe("project", () => {
-        let projectId: string = "";
-
-        beforeAll(async () => {
-            const apiClient = integration.mcpServer().session.apiClient;
-
-            const group = await createProject(apiClient);
-            projectId = group.id || "";
-        });
-
-        afterAll(async () => {
-            const apiClient = integration.mcpServer().session.apiClient;
-
-            await apiClient.deleteProject({
-                params: {
-                    path: {
-                        groupId: projectId,
-                    },
-                },
-            });
-        });
-
-        const args = {
-            getProjectId: () => projectId,
-        };
-
-        describe("with project", () => {
-            fn(args);
-        });
-    });
-}
-
-export function parseTable(text: string): Record<string, string>[] {
-    const data = text
-        .split("\n")
-        .filter((line) => line.trim() !== "")
-        .map((line) => line.split("|").map((cell) => cell.trim()));
-
-    const headers = data[0];
-    return data
-        .filter((_, index) => index >= 2)
-        .map((cells) => {
-            const row: Record<string, string> = {};
-            cells.forEach((cell, index) => {
-                if (headers) {
-                    row[headers[index] ?? ""] = cell;
-                }
-            });
-            return row;
-        });
-}
-
-export const randomId = new ObjectId().toString();
-
-async function createProject(apiClient: ApiClient): Promise<Group> {
-    const projectName: string = `testProj-` + randomId;
-
-    const orgs = await apiClient.listOrganizations();
-    if (!orgs?.results?.length || !orgs.results[0]?.id) {
-        throw new Error("No orgs found");
-    }
-
-    const group = await apiClient.createProject({
-        body: {
-            name: projectName,
-            orgId: orgs.results[0]?.id ?? "",
-        } as Group,
-    });
-
-    if (!group?.id) {
-        throw new Error("Failed to create project");
-    }
-
-    return group;
-}

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

@@ -1,237 +0,0 @@
-import { Session } from "../../../../src/common/session.js";
-import { expectDefined, getResponseElements } from "../../helpers.js";
-import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
-import { ClusterDescription20240805 } from "../../../../src/common/atlas/openapi.js";
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-
-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,
-            },
-        },
-    });
-    while (true) {
-        try {
-            await session.apiClient.getCluster({
-                params: {
-                    path: {
-                        groupId: projectId,
-                        clusterName,
-                    },
-                },
-            });
-            await sleep(1000);
-        } catch {
-            break;
-        }
-    }
-}
-
-async function waitCluster(
-    session: Session,
-    projectId: string,
-    clusterName: string,
-    check: (cluster: ClusterDescription20240805) => boolean | Promise<boolean>
-) {
-    while (true) {
-        const cluster = await session.apiClient.getCluster({
-            params: {
-                path: {
-                    groupId: projectId,
-                    clusterName,
-                },
-            },
-        });
-        if (await check(cluster)) {
-            return;
-        }
-        await sleep(1000);
-    }
-}
-
-describeWithAtlas("clusters", (integration) => {
-    withProject(integration, ({ getProjectId }) => {
-        const clusterName = "ClusterTest-" + randomId;
-
-        afterAll(async () => {
-            const projectId = getProjectId();
-
-            const session: Session = integration.mcpServer().session;
-
-            await deleteAndWaitCluster(session, projectId, clusterName);
-        });
-
-        describe("atlas-create-free-cluster", () => {
-            it("should have correct metadata", async () => {
-                const { tools } = await integration.mcpClient().listTools();
-                const createFreeCluster = tools.find((tool) => tool.name === "atlas-create-free-cluster");
-
-                expectDefined(createFreeCluster);
-                expect(createFreeCluster.inputSchema.type).toBe("object");
-                expectDefined(createFreeCluster.inputSchema.properties);
-                expect(createFreeCluster.inputSchema.properties).toHaveProperty("projectId");
-                expect(createFreeCluster.inputSchema.properties).toHaveProperty("name");
-                expect(createFreeCluster.inputSchema.properties).toHaveProperty("region");
-            });
-
-            it("should create a free cluster and add current IP to access list", async () => {
-                const projectId = getProjectId();
-                const session = integration.mcpServer().session;
-                const ipInfo = await session.apiClient.getIpInfo();
-
-                const response = (await integration.mcpClient().callTool({
-                    name: "atlas-create-free-cluster",
-                    arguments: {
-                        projectId,
-                        name: clusterName,
-                        region: "US_EAST_1",
-                    },
-                })) as CallToolResult;
-                expect(response.content).toBeInstanceOf(Array);
-                expect(response.content).toHaveLength(2);
-                expect(response.content[0]?.text).toContain("has been created");
-
-                // Check that the current IP is present in the access list
-                const accessList = await session.apiClient.listProjectIpAccessLists({
-                    params: { path: { groupId: projectId } },
-                });
-                const found = accessList.results?.some((entry) => entry.ipAddress === ipInfo.currentIpv4Address);
-                expect(found).toBe(true);
-            });
-        });
-
-        describe("atlas-inspect-cluster", () => {
-            it("should have correct metadata", async () => {
-                const { tools } = await integration.mcpClient().listTools();
-                const inspectCluster = tools.find((tool) => tool.name === "atlas-inspect-cluster");
-
-                expectDefined(inspectCluster);
-                expect(inspectCluster.inputSchema.type).toBe("object");
-                expectDefined(inspectCluster.inputSchema.properties);
-                expect(inspectCluster.inputSchema.properties).toHaveProperty("projectId");
-                expect(inspectCluster.inputSchema.properties).toHaveProperty("clusterName");
-            });
-
-            it("returns cluster data", async () => {
-                const projectId = getProjectId();
-
-                const response = (await integration.mcpClient().callTool({
-                    name: "atlas-inspect-cluster",
-                    arguments: { projectId, clusterName: clusterName },
-                })) as CallToolResult;
-                expect(response.content).toBeInstanceOf(Array);
-                expect(response.content).toHaveLength(1);
-                expect(response.content[0]?.text).toContain(`${clusterName} | `);
-            });
-        });
-
-        describe("atlas-list-clusters", () => {
-            it("should have correct metadata", async () => {
-                const { tools } = await integration.mcpClient().listTools();
-                const listClusters = tools.find((tool) => tool.name === "atlas-list-clusters");
-                expectDefined(listClusters);
-                expect(listClusters.inputSchema.type).toBe("object");
-                expectDefined(listClusters.inputSchema.properties);
-                expect(listClusters.inputSchema.properties).toHaveProperty("projectId");
-            });
-
-            it("returns clusters by project", async () => {
-                const projectId = getProjectId();
-
-                const response = (await integration
-                    .mcpClient()
-                    .callTool({ name: "atlas-list-clusters", arguments: { projectId } })) as CallToolResult;
-                expect(response.content).toBeInstanceOf(Array);
-                expect(response.content).toHaveLength(2);
-                expect(response.content[1]?.text).toContain(`${clusterName} | `);
-            });
-        });
-
-        describe("atlas-connect-cluster", () => {
-            beforeAll(async () => {
-                const projectId = getProjectId();
-                await waitCluster(integration.mcpServer().session, projectId, clusterName, (cluster) => {
-                    return (
-                        cluster.stateName === "IDLE" &&
-                        (cluster.connectionStrings?.standardSrv || cluster.connectionStrings?.standard) !== undefined
-                    );
-                });
-                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();
-
-                for (let i = 0; i < 10; i++) {
-                    const response = (await integration.mcpClient().callTool({
-                        name: "atlas-connect-cluster",
-                        arguments: { projectId, clusterName },
-                    })) as CallToolResult;
-                    expect(response.content).toBeInstanceOf(Array);
-                    expect(response.content.length).toBeGreaterThanOrEqual(1);
-                    expect(response.content[0]?.type).toEqual("text");
-                    const c = response.content[0] as { text: string };
-                    if (
-                        c.text.includes("Cluster is already connected.") ||
-                        c.text.includes(`Connected to cluster "${clusterName}"`)
-                    ) {
-                        break; // success
-                    } else {
-                        expect(response.content[0]?.text).toContain(
-                            `Attempting to connect to cluster "${clusterName}"...`
-                        );
-                    }
-                    await sleep(500);
-                }
-            });
-
-            describe("when not connected", () => {
-                it("prompts for atlas-connect-cluster when querying mongodb", async () => {
-                    const response = await integration.mcpClient().callTool({
-                        name: "find",
-                        arguments: { database: "some-db", collection: "some-collection" },
-                    });
-                    const elements = getResponseElements(response.content);
-                    expect(elements).toHaveLength(2);
-                    expect(elements[0]?.text).toContain(
-                        "You need to connect to a MongoDB instance before you can access its data."
-                    );
-                    expect(elements[1]?.text).toContain(
-                        'Please use one of the following tools: "atlas-connect-cluster", "connect" to connect to a MongoDB instance'
-                    );
-                });
-            });
-        });
-    });
-});

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

@@ -1,118 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { describeWithAtlas, withProject, randomId } from "./atlasHelpers.js";
-import { expectDefined, getResponseElements } from "../../helpers.js";
-import { ApiClientError } from "../../../../src/common/atlas/apiClientError.js";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-
-describeWithAtlas("db users", (integration) => {
-    withProject(integration, ({ getProjectId }) => {
-        let userName: string;
-        beforeEach(() => {
-            userName = "testuser-" + randomId;
-        });
-
-        const createUserWithMCP = async (password?: string): Promise<unknown> => {
-            return await integration.mcpClient().callTool({
-                name: "atlas-create-db-user",
-                arguments: {
-                    projectId: getProjectId(),
-                    username: userName,
-                    password,
-                    roles: [
-                        {
-                            roleName: "readWrite",
-                            databaseName: "admin",
-                        },
-                    ],
-                },
-            });
-        };
-
-        afterEach(async () => {
-            try {
-                await integration.mcpServer().session.apiClient.deleteDatabaseUser({
-                    params: {
-                        path: {
-                            groupId: getProjectId(),
-                            username: userName,
-                            databaseName: "admin",
-                        },
-                    },
-                });
-            } catch (error) {
-                // Ignore 404 errors when deleting the user
-                if (!(error instanceof ApiClientError) || error.response?.status !== 404) {
-                    throw error;
-                }
-            }
-        });
-
-        describe("atlas-create-db-user", () => {
-            it("should have correct metadata", async () => {
-                const { tools } = await integration.mcpClient().listTools();
-                const createDbUser = tools.find((tool) => tool.name === "atlas-create-db-user");
-                expectDefined(createDbUser);
-                expect(createDbUser.inputSchema.type).toBe("object");
-                expectDefined(createDbUser.inputSchema.properties);
-                expect(createDbUser.inputSchema.properties).toHaveProperty("projectId");
-                expect(createDbUser.inputSchema.properties).toHaveProperty("username");
-                expect(createDbUser.inputSchema.properties).toHaveProperty("password");
-                expect(createDbUser.inputSchema.properties).toHaveProperty("roles");
-                expect(createDbUser.inputSchema.properties).toHaveProperty("clusters");
-            });
-
-            it("should create a database user with supplied password", async () => {
-                const response = await createUserWithMCP("testpassword");
-
-                const elements = getResponseElements(response);
-                expect(elements).toHaveLength(1);
-                expect(elements[0]?.text).toContain("created successfully");
-                expect(elements[0]?.text).toContain(userName);
-                expect(elements[0]?.text).not.toContain("testpassword");
-            });
-
-            it("should create a database user with generated password", async () => {
-                const response = await createUserWithMCP();
-                const elements = getResponseElements(response);
-                expect(elements).toHaveLength(1);
-                expect(elements[0]?.text).toContain("created successfully");
-                expect(elements[0]?.text).toContain(userName);
-                expect(elements[0]?.text).toContain("with password: `");
-            });
-
-            it("should add current IP to access list when creating a database user", async () => {
-                const projectId = getProjectId();
-                const session = integration.mcpServer().session;
-                const ipInfo = await session.apiClient.getIpInfo();
-                await createUserWithMCP();
-                const accessList = await session.apiClient.listProjectIpAccessLists({
-                    params: { path: { groupId: projectId } },
-                });
-                const found = accessList.results?.some((entry) => entry.ipAddress === ipInfo.currentIpv4Address);
-                expect(found).toBe(true);
-            });
-        });
-        describe("atlas-list-db-users", () => {
-            it("should have correct metadata", async () => {
-                const { tools } = await integration.mcpClient().listTools();
-                const listDbUsers = tools.find((tool) => tool.name === "atlas-list-db-users");
-                expectDefined(listDbUsers);
-                expect(listDbUsers.inputSchema.type).toBe("object");
-                expectDefined(listDbUsers.inputSchema.properties);
-                expect(listDbUsers.inputSchema.properties).toHaveProperty("projectId");
-            });
-            it("returns database users by project", async () => {
-                const projectId = getProjectId();
-
-                await createUserWithMCP();
-
-                const response = (await integration
-                    .mcpClient()
-                    .callTool({ name: "atlas-list-db-users", arguments: { projectId } })) as CallToolResult;
-                expect(response.content).toBeInstanceOf(Array);
-                expect(response.content).toHaveLength(1);
-                expect(response.content[0]?.text).toContain(userName);
-            });
-        });
-    });
-});

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

@@ -1,25 +0,0 @@
-import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { expectDefined } from "../../helpers.js";
-import { parseTable, describeWithAtlas } from "./atlasHelpers.js";
-import { describe, expect, it } from "vitest";
-
-describeWithAtlas("orgs", (integration) => {
-    describe("atlas-list-orgs", () => {
-        it("should have correct metadata", async () => {
-            const { tools } = await integration.mcpClient().listTools();
-            const listOrgs = tools.find((tool) => tool.name === "atlas-list-orgs");
-            expectDefined(listOrgs);
-        });
-
-        it("returns org names", async () => {
-            const response = (await integration
-                .mcpClient()
-                .callTool({ name: "atlas-list-orgs", arguments: {} })) as CallToolResult;
-            expect(response.content).toBeInstanceOf(Array);
-            expect(response.content).toHaveLength(1);
-            const data = parseTable(response.content[0]?.text as string);
-            expect(data).toHaveLength(1);
-            expect(data[0]?.["Organization Name"]).toEqual("MongoDB MCP Test");
-        });
-    });
-});