mongodb-mcp-server 0.0.4

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

@@ -0,0 +1,122 @@
+import { Session } from "../../../../src/session.js";
+import { describeAtlas, withProject, sleep, randomId } from "./atlasHelpers.js";
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+
+async function deleteAndWaitCluster(session: Session, projectId: string, clusterName: string) {
+    session.ensureAuthenticated();
+
+    await session.apiClient.deleteCluster({
+        params: {
+            path: {
+                groupId: projectId,
+                clusterName: clusterName,
+            },
+        },
+    });
+    while (true) {
+        try {
+            await session.apiClient.getCluster({
+                params: {
+                    path: {
+                        groupId: projectId,
+                        clusterName: clusterName,
+                    },
+                },
+            });
+            await sleep(1000);
+        } catch {
+            break;
+        }
+    }
+}
+
+describeAtlas("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")!;
+
+                expect(createFreeCluster).toBeDefined();
+                expect(createFreeCluster.inputSchema.type).toBe("object");
+                expect(createFreeCluster.inputSchema.properties).toBeDefined();
+                expect(createFreeCluster.inputSchema.properties).toHaveProperty("projectId");
+                expect(createFreeCluster.inputSchema.properties).toHaveProperty("name");
+                expect(createFreeCluster.inputSchema.properties).toHaveProperty("region");
+            });
+
+            it("should create a free cluster", async () => {
+                const projectId = getProjectId();
+
+                const response = (await integration.mcpClient().callTool({
+                    name: "atlas-create-free-cluster",
+                    arguments: {
+                        projectId,
+                        name: clusterName,
+                        region: "US_EAST_1",
+                    },
+                })) as CallToolResult;
+                expect(response.content).toBeArray();
+                expect(response.content).toHaveLength(1);
+                expect(response.content[0].text).toContain("has been created");
+            });
+        });
+
+        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")!;
+
+                expect(inspectCluster).toBeDefined();
+                expect(inspectCluster.inputSchema.type).toBe("object");
+                expect(inspectCluster.inputSchema.properties).toBeDefined();
+                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).toBeArray();
+                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")!;
+                expect(listClusters).toBeDefined();
+                expect(listClusters.inputSchema.type).toBe("object");
+                expect(listClusters.inputSchema.properties).toBeDefined();
+                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).toBeArray();
+                expect(response.content).toHaveLength(2);
+                expect(response.content[1].text).toContain(`${clusterName} | `);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,80 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { Session } from "../../../../src/session.js";
+import { describeAtlas, withProject, randomId } from "./atlasHelpers.js";
+
+describeAtlas("db users", (integration) => {
+    const userName = "testuser-" + randomId;
+    withProject(integration, ({ getProjectId }) => {
+        afterAll(async () => {
+            const projectId = getProjectId();
+
+            const session: Session = integration.mcpServer().session;
+            session.ensureAuthenticated();
+            await session.apiClient.deleteDatabaseUser({
+                params: {
+                    path: {
+                        groupId: projectId,
+                        username: userName,
+                        databaseName: "admin",
+                    },
+                },
+            });
+        });
+
+        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")!;
+                expect(createDbUser).toBeDefined();
+                expect(createDbUser.inputSchema.type).toBe("object");
+                expect(createDbUser.inputSchema.properties).toBeDefined();
+                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", async () => {
+                const projectId = getProjectId();
+
+                const response = (await integration.mcpClient().callTool({
+                    name: "atlas-create-db-user",
+                    arguments: {
+                        projectId,
+                        username: userName,
+                        password: "testpassword",
+                        roles: [
+                            {
+                                roleName: "readWrite",
+                                databaseName: "admin",
+                            },
+                        ],
+                    },
+                })) as CallToolResult;
+                expect(response.content).toBeArray();
+                expect(response.content).toHaveLength(1);
+                expect(response.content[0].text).toContain("created sucessfully");
+            });
+        });
+        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")!;
+                expect(listDbUsers).toBeDefined();
+                expect(listDbUsers.inputSchema.type).toBe("object");
+                expect(listDbUsers.inputSchema.properties).toBeDefined();
+                expect(listDbUsers.inputSchema.properties).toHaveProperty("projectId");
+            });
+            it("returns database users by project", async () => {
+                const projectId = getProjectId();
+
+                const response = (await integration
+                    .mcpClient()
+                    .callTool({ name: "atlas-list-db-users", arguments: { projectId } })) as CallToolResult;
+                expect(response.content).toBeArray();
+                expect(response.content).toHaveLength(1);
+                expect(response.content[0].text).toContain(userName);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,24 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { setupIntegrationTest } from "../../helpers.js";
+import { parseTable, describeAtlas } from "./atlasHelpers.js";
+
+describeAtlas("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");
+            expect(listOrgs).toBeDefined();
+        });
+
+        it("returns org names", async () => {
+            const response = (await integration
+                .mcpClient()
+                .callTool({ name: "atlas-list-orgs", arguments: {} })) as CallToolResult;
+            expect(response.content).toBeArray();
+            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");
+        });
+    });
+});

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

@@ -0,0 +1,80 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+import { setupIntegrationTest } from "../../helpers.js";
+import { Session } from "../../../../src/session.js";
+import { ObjectId } from "mongodb";
+import { parseTable, describeAtlas } from "./atlasHelpers.js";
+
+const randomId = new ObjectId().toString();
+
+describeAtlas("projects", (integration) => {
+    const projName = "testProj-" + randomId;
+
+    afterAll(async () => {
+        const session: Session = integration.mcpServer().session;
+        session.ensureAuthenticated();
+
+        const projects = await session.apiClient.listProjects();
+        for (const project of projects?.results || []) {
+            if (project.name === projName) {
+                await session.apiClient.deleteProject({
+                    params: {
+                        path: {
+                            groupId: project.id || "",
+                        },
+                    },
+                });
+                break;
+            }
+        }
+    });
+
+    describe("atlas-create-project", () => {
+        it("should have correct metadata", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const createProject = tools.find((tool) => tool.name === "atlas-create-project")!;
+            expect(createProject).toBeDefined();
+            expect(createProject.inputSchema.type).toBe("object");
+            expect(createProject.inputSchema.properties).toBeDefined();
+            expect(createProject.inputSchema.properties).toHaveProperty("projectName");
+            expect(createProject.inputSchema.properties).toHaveProperty("organizationId");
+        });
+        it("should create a project", async () => {
+            const response = (await integration.mcpClient().callTool({
+                name: "atlas-create-project",
+                arguments: { projectName: projName },
+            })) as CallToolResult;
+            expect(response.content).toBeArray();
+            expect(response.content).toHaveLength(1);
+            expect(response.content[0].text).toContain(projName);
+        });
+    });
+    describe("atlas-list-projects", () => {
+        it("should have correct metadata", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const listProjects = tools.find((tool) => tool.name === "atlas-list-projects")!;
+            expect(listProjects).toBeDefined();
+            expect(listProjects.inputSchema.type).toBe("object");
+            expect(listProjects.inputSchema.properties).toBeDefined();
+            expect(listProjects.inputSchema.properties).toHaveProperty("orgId");
+        });
+
+        it("returns project names", async () => {
+            const response = (await integration
+                .mcpClient()
+                .callTool({ name: "atlas-list-projects", arguments: {} })) as CallToolResult;
+            expect(response.content).toBeArray();
+            expect(response.content).toHaveLength(1);
+            expect(response.content[0].text).toContain(projName);
+            const data = parseTable(response.content[0].text as string);
+            expect(data).toBeArray();
+            expect(data.length).toBeGreaterThan(0);
+            let found = false;
+            for (const project of data) {
+                if (project["Project Name"] === projName) {
+                    found = true;
+                }
+            }
+            expect(found).toBe(true);
+        });
+    });
+});

package/tests/integration/tools/mongodb/create/createCollection.test.ts

@@ -0,0 +1,138 @@
+import {
+    getResponseContent,
+    validateParameters,
+    dbOperationParameters,
+    setupIntegrationTest,
+} from "../../../helpers.js";
+import { toIncludeSameMembers } from "jest-extended";
+import { McpError } from "@modelcontextprotocol/sdk/types.js";
+import { ObjectId } from "bson";
+import config from "../../../../../src/config.js";
+
+describe("createCollection tool", () => {
+    const integration = setupIntegrationTest();
+
+    it("should have correct metadata", async () => {
+        const { tools } = await integration.mcpClient().listTools();
+        const listCollections = tools.find((tool) => tool.name === "create-collection")!;
+        expect(listCollections).toBeDefined();
+        expect(listCollections.description).toBe(
+            "Creates a new collection in a database. If the database doesn't exist, it will be created automatically."
+        );
+
+        validateParameters(listCollections, dbOperationParameters);
+    });
+
+    describe("with invalid arguments", () => {
+        const args = [
+            {},
+            { database: 123, collection: "bar" },
+            { foo: "bar", database: "test", collection: "bar" },
+            { collection: [], database: "test" },
+        ];
+        for (const arg of args) {
+            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
+                await integration.connectMcpClient();
+                try {
+                    await integration.mcpClient().callTool({ name: "create-collection", arguments: arg });
+                    expect.fail("Expected an error to be thrown");
+                } catch (error) {
+                    expect(error).toBeInstanceOf(McpError);
+                    const mcpError = error as McpError;
+                    expect(mcpError.code).toEqual(-32602);
+                    expect(mcpError.message).toContain("Invalid arguments for tool create-collection");
+                }
+            });
+        }
+    });
+
+    describe("with non-existent database", () => {
+        it("creates a new collection", async () => {
+            const mongoClient = integration.mongoClient();
+            let collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
+            expect(collections).toHaveLength(0);
+
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "create-collection",
+                arguments: { database: integration.randomDbName(), collection: "bar" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(`Collection "bar" created in database "${integration.randomDbName()}".`);
+
+            collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
+            expect(collections).toHaveLength(1);
+            expect(collections[0].name).toEqual("bar");
+        });
+    });
+
+    describe("with existing database", () => {
+        it("creates new collection", async () => {
+            const mongoClient = integration.mongoClient();
+            await mongoClient.db(integration.randomDbName()).createCollection("collection1");
+            let collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
+            expect(collections).toHaveLength(1);
+
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "create-collection",
+                arguments: { database: integration.randomDbName(), collection: "collection2" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(`Collection "collection2" created in database "${integration.randomDbName()}".`);
+            collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
+            expect(collections).toHaveLength(2);
+            expect(collections.map((c) => c.name)).toIncludeSameMembers(["collection1", "collection2"]);
+        });
+
+        it("does nothing if collection already exists", async () => {
+            const mongoClient = integration.mongoClient();
+            await mongoClient.db(integration.randomDbName()).collection("collection1").insertOne({});
+            let collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
+            expect(collections).toHaveLength(1);
+            let documents = await mongoClient
+                .db(integration.randomDbName())
+                .collection("collection1")
+                .find({})
+                .toArray();
+            expect(documents).toHaveLength(1);
+
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "create-collection",
+                arguments: { database: integration.randomDbName(), collection: "collection1" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(`Collection "collection1" created in database "${integration.randomDbName()}".`);
+            collections = await mongoClient.db(integration.randomDbName()).listCollections().toArray();
+            expect(collections).toHaveLength(1);
+            expect(collections[0].name).toEqual("collection1");
+
+            // Make sure we didn't drop the existing collection
+            documents = await mongoClient.db(integration.randomDbName()).collection("collection1").find({}).toArray();
+            expect(documents).toHaveLength(1);
+        });
+    });
+
+    describe("when not connected", () => {
+        it("connects automatically if connection string is configured", async () => {
+            config.connectionString = integration.connectionString();
+
+            const response = await integration.mcpClient().callTool({
+                name: "create-collection",
+                arguments: { database: integration.randomDbName(), collection: "new-collection" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(`Collection "new-collection" created in database "${integration.randomDbName()}".`);
+        });
+
+        it("throws an error if connection string is not configured", async () => {
+            const response = await integration.mcpClient().callTool({
+                name: "create-collection",
+                arguments: { database: integration.randomDbName(), collection: "new-collection" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
+        });
+    });
+});