mongodb-mcp-server 0.0.4 → 0.0.5

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

@@ -1,17 +1,15 @@
 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";
+import { parseTable, describeWithAtlas } from "./atlasHelpers.js";
+import { expectDefined } from "../../helpers.js";
 
 const randomId = new ObjectId().toString();
 
-describeAtlas("projects", (integration) => {
+describeWithAtlas("projects", (integration) => {
     const projName = "testProj-" + randomId;
 
     afterAll(async () => {
-        const session: Session = integration.mcpServer().session;
-        session.ensureAuthenticated();
+        const session = integration.mcpServer().session;
 
         const projects = await session.apiClient.listProjects();
         for (const project of projects?.results || []) {
@@ -31,10 +29,10 @@ describeAtlas("projects", (integration) => {
     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();
+            const createProject = tools.find((tool) => tool.name === "atlas-create-project");
+            expectDefined(createProject);
             expect(createProject.inputSchema.type).toBe("object");
-            expect(createProject.inputSchema.properties).toBeDefined();
+            expectDefined(createProject.inputSchema.properties);
             expect(createProject.inputSchema.properties).toHaveProperty("projectName");
             expect(createProject.inputSchema.properties).toHaveProperty("organizationId");
         });
@@ -51,10 +49,10 @@ describeAtlas("projects", (integration) => {
     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();
+            const listProjects = tools.find((tool) => tool.name === "atlas-list-projects");
+            expectDefined(listProjects);
             expect(listProjects.inputSchema.type).toBe("object");
-            expect(listProjects.inputSchema.properties).toBeDefined();
+            expectDefined(listProjects.inputSchema.properties);
             expect(listProjects.inputSchema.properties).toHaveProperty("orgId");
         });
 

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

@@ -1,50 +1,22 @@
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
 import {
     getResponseContent,
-    validateParameters,
-    dbOperationParameters,
-    setupIntegrationTest,
+    databaseCollectionParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    databaseCollectionInvalidArgs,
 } 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."
-        );
+describeWithMongoDB("createCollection tool", (integration) => {
+    validateToolMetadata(
+        integration,
+        "create-collection",
+        "Creates a new collection in a database. If the database doesn't exist, it will be created automatically.",
+        databaseCollectionParameters
+    );
 
-        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");
-                }
-            });
-        }
-    });
+    validateThrowsForInvalidArguments(integration, "create-collection", databaseCollectionInvalidArgs);
 
     describe("with non-existent database", () => {
         it("creates a new collection", async () => {
@@ -114,25 +86,10 @@ describe("createCollection tool", () => {
         });
     });
 
-    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.");
-        });
+    validateAutoConnectBehavior(integration, "create-collection", () => {
+        return {
+            args: { database: integration.randomDbName(), collection: "new-collection" },
+            expectedResponse: `Collection "new-collection" created in database "${integration.randomDbName()}".`,
+        };
     });
 });

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

@@ -1,63 +1,38 @@
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
 import {
     getResponseContent,
-    validateParameters,
-    dbOperationParameters,
-    setupIntegrationTest,
+    databaseCollectionParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    expectDefined,
 } from "../../../helpers.js";
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
 import { IndexDirection } from "mongodb";
-import config from "../../../../../src/config.js";
-
-describe("createIndex tool", () => {
-    const integration = setupIntegrationTest();
-
-    it("should have correct metadata", async () => {
-        const { tools } = await integration.mcpClient().listTools();
-        const createIndex = tools.find((tool) => tool.name === "create-index")!;
-        expect(createIndex).toBeDefined();
-        expect(createIndex.description).toBe("Create an index for a collection");
-
-        validateParameters(createIndex, [
-            ...dbOperationParameters,
-            {
-                name: "keys",
-                type: "object",
-                description: "The index definition",
-                required: true,
-            },
-            {
-                name: "name",
-                type: "string",
-                description: "The name of the index",
-                required: false,
-            },
-        ]);
-    });
 
-    describe("with invalid arguments", () => {
-        const args = [
-            {},
-            { collection: "bar", database: 123, keys: { foo: 1 } },
-            { collection: "bar", database: "test", keys: { foo: 5 } },
-            { collection: [], database: "test", keys: { foo: 1 } },
-            { collection: "bar", database: "test", keys: { foo: 1 }, name: 123 },
-            { collection: "bar", database: "test", keys: "foo", name: "my-index" },
-        ];
-        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-index", 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-index");
-                }
-            });
-        }
-    });
+describeWithMongoDB("createIndex tool", (integration) => {
+    validateToolMetadata(integration, "create-index", "Create an index for a collection", [
+        ...databaseCollectionParameters,
+        {
+            name: "keys",
+            type: "object",
+            description: "The index definition",
+            required: true,
+        },
+        {
+            name: "name",
+            type: "string",
+            description: "The name of the index",
+            required: false,
+        },
+    ]);
+
+    validateThrowsForInvalidArguments(integration, "create-index", [
+        {},
+        { collection: "bar", database: 123, keys: { foo: 1 } },
+        { collection: [], database: "test", keys: { foo: 1 } },
+        { collection: "bar", database: "test", keys: { foo: 1 }, name: 123 },
+        { collection: "bar", database: "test", keys: "foo", name: "my-index" },
+    ]);
 
     const validateIndex = async (collection: string, expected: { name: string; key: object }[]) => {
         const mongoClient = integration.mongoClient();
@@ -69,8 +44,8 @@ describe("createIndex tool", () => {
         expect(indexes[0].name).toEqual("_id_");
         for (const index of expected) {
             const foundIndex = indexes.find((i) => i.name === index.name);
-            expect(foundIndex).toBeDefined();
-            expect(foundIndex!.key).toEqual(index.key);
+            expectDefined(foundIndex);
+            expect(foundIndex.key).toEqual(index.key);
         }
     };
 
@@ -215,35 +190,14 @@ describe("createIndex tool", () => {
         });
     }
 
-    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-index",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    keys: { prop1: 1 },
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toEqual(
-                `Created the index "prop1_1" on collection "coll1" in database "${integration.randomDbName()}"`
-            );
-        });
-
-        it("throws an error if connection string is not configured", async () => {
-            const response = await integration.mcpClient().callTool({
-                name: "create-index",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    keys: { prop1: 1 },
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
-        });
+    validateAutoConnectBehavior(integration, "create-index", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                keys: { prop1: 1 },
+            },
+            expectedResponse: `Created the index "prop1_1" on collection "coll1" in database "${integration.randomDbName()}"`,
+        };
     });
 });

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

@@ -1,60 +1,36 @@
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
 import {
     getResponseContent,
-    validateParameters,
-    dbOperationParameters,
-    setupIntegrationTest,
+    databaseCollectionParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    expectDefined,
 } from "../../../helpers.js";
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
-import config from "../../../../../src/config.js";
-
-describe("insertMany tool", () => {
-    const integration = setupIntegrationTest();
-
-    it("should have correct metadata", async () => {
-        const { tools } = await integration.mcpClient().listTools();
-        const insertMany = tools.find((tool) => tool.name === "insert-many")!;
-        expect(insertMany).toBeDefined();
-        expect(insertMany.description).toBe("Insert an array of documents into a MongoDB collection");
-
-        validateParameters(insertMany, [
-            ...dbOperationParameters,
-            {
-                name: "documents",
-                type: "array",
-                description:
-                    "The array of documents to insert, matching the syntax of the document argument of db.collection.insertMany()",
-                required: true,
-            },
-        ]);
-    });
 
-    describe("with invalid arguments", () => {
-        const args = [
-            {},
-            { collection: "bar", database: 123, documents: [] },
-            { collection: [], database: "test", documents: [] },
-            { collection: "bar", database: "test", documents: "my-document" },
-            { collection: "bar", database: "test", documents: { name: "Peter" } },
-        ];
-        for (const arg of args) {
-            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
-                await integration.connectMcpClient();
-                try {
-                    await integration.mcpClient().callTool({ name: "insert-many", 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 insert-many");
-                }
-            });
-        }
-    });
+describeWithMongoDB("insertMany tool", (integration) => {
+    validateToolMetadata(integration, "insert-many", "Insert an array of documents into a MongoDB collection", [
+        ...databaseCollectionParameters,
+        {
+            name: "documents",
+            type: "array",
+            description:
+                "The array of documents to insert, matching the syntax of the document argument of db.collection.insertMany()",
+            required: true,
+        },
+    ]);
+
+    validateThrowsForInvalidArguments(integration, "insert-many", [
+        {},
+        { collection: "bar", database: 123, documents: [] },
+        { collection: [], database: "test", documents: [] },
+        { collection: "bar", database: "test", documents: "my-document" },
+        { collection: "bar", database: "test", documents: { name: "Peter" } },
+    ]);
 
     const validateDocuments = async (collection: string, expectedDocuments: object[]) => {
         const collections = await integration.mongoClient().db(integration.randomDbName()).listCollections().toArray();
-        expect(collections.find((c) => c.name === collection)).toBeDefined();
+        expectDefined(collections.find((c) => c.name === collection));
 
         const docs = await integration
             .mongoClient()
@@ -109,33 +85,14 @@ describe("insertMany tool", () => {
         expect(content).toContain(insertedIds[0].toString());
     });
 
-    describe("when not connected", () => {
-        it("connects automatically if connection string is configured", async () => {
-            config.connectionString = integration.connectionString();
-
-            const response = await integration.mcpClient().callTool({
-                name: "insert-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    documents: [{ prop1: "value1" }],
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain('Inserted `1` document(s) into collection "coll1"');
-        });
-
-        it("throws an error if connection string is not configured", async () => {
-            const response = await integration.mcpClient().callTool({
-                name: "insert-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    documents: [{ prop1: "value1" }],
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
-        });
+    validateAutoConnectBehavior(integration, "insert-many", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                documents: [{ prop1: "value1" }],
+            },
+            expectedResponse: 'Inserted `1` document(s) into collection "coll1"',
+        };
     });
 });

package/tests/integration/tools/mongodb/delete/deleteMany.test.ts

@@ -1,23 +1,19 @@
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
 import {
     getResponseContent,
-    validateParameters,
-    dbOperationParameters,
-    setupIntegrationTest,
+    databaseCollectionParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
 } from "../../../helpers.js";
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
-import config from "../../../../../src/config.js";
-
-describe("deleteMany tool", () => {
-    const integration = setupIntegrationTest();
 
-    it("should have correct metadata", async () => {
-        const { tools } = await integration.mcpClient().listTools();
-        const deleteMany = tools.find((tool) => tool.name === "delete-many")!;
-        expect(deleteMany).toBeDefined();
-        expect(deleteMany.description).toBe("Removes all documents that match the filter from a MongoDB collection");
-
-        validateParameters(deleteMany, [
-            ...dbOperationParameters,
+describeWithMongoDB("deleteMany tool", (integration) => {
+    validateToolMetadata(
+        integration,
+        "delete-many",
+        "Removes all documents that match the filter from a MongoDB collection",
+        [
+            ...databaseCollectionParameters,
             {
                 name: "filter",
                 type: "object",
@@ -25,31 +21,17 @@ describe("deleteMany tool", () => {
                     "The query filter, specifying the deletion criteria. Matches the syntax of the filter argument of db.collection.deleteMany()",
                 required: false,
             },
-        ]);
-    });
+        ]
+    );
 
     describe("with invalid arguments", () => {
-        const args = [
+        validateThrowsForInvalidArguments(integration, "delete-many", [
             {},
             { collection: "bar", database: 123, filter: {} },
             { collection: [], database: "test", filter: {} },
             { collection: "bar", database: "test", filter: "my-document" },
             { collection: "bar", database: "test", filter: [{ name: "Peter" }] },
-        ];
-        for (const arg of args) {
-            it(`throws a schema error for: ${JSON.stringify(arg)}`, async () => {
-                await integration.connectMcpClient();
-                try {
-                    await integration.mcpClient().callTool({ name: "delete-many", 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 delete-many");
-                }
-            });
-        }
+        ]);
     });
 
     it("doesn't create the collection if it doesn't exist", async () => {
@@ -159,33 +141,14 @@ describe("deleteMany tool", () => {
         await validateDocuments([]);
     });
 
-    describe("when not connected", () => {
-        it("connects automatically if connection string is configured", async () => {
-            config.connectionString = integration.connectionString();
-
-            const response = await integration.mcpClient().callTool({
-                name: "delete-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    filter: {},
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain('Deleted `0` document(s) from collection "coll1"');
-        });
-
-        it("throws an error if connection string is not configured", async () => {
-            const response = await integration.mcpClient().callTool({
-                name: "delete-many",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                    filter: {},
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
-        });
+    validateAutoConnectBehavior(integration, "delete-many", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                filter: {},
+            },
+            expectedResponse: 'Deleted `0` document(s) from collection "coll1"',
+        };
     });
 });

package/tests/integration/tools/mongodb/delete/dropCollection.test.ts

@@ -1,48 +1,22 @@
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
 import {
     getResponseContent,
-    validateParameters,
-    dbOperationParameters,
-    setupIntegrationTest,
+    databaseCollectionParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    databaseCollectionInvalidArgs,
 } from "../../../helpers.js";
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
-import config from "../../../../../src/config.js";
-
-describe("dropCollection tool", () => {
-    const integration = setupIntegrationTest();
 
-    it("should have correct metadata", async () => {
-        const { tools } = await integration.mcpClient().listTools();
-        const dropCollection = tools.find((tool) => tool.name === "drop-collection")!;
-        expect(dropCollection).toBeDefined();
-        expect(dropCollection.description).toBe(
-            "Removes a collection or view from the database. The method also removes any indexes associated with the dropped collection."
-        );
+describeWithMongoDB("dropCollection tool", (integration) => {
+    validateToolMetadata(
+        integration,
+        "drop-collection",
+        "Removes a collection or view from the database. The method also removes any indexes associated with the dropped collection.",
+        databaseCollectionParameters
+    );
 
-        validateParameters(dropCollection, [...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: "drop-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 drop-collection");
-                }
-            });
-        }
-    });
+    validateThrowsForInvalidArguments(integration, "drop-collection", databaseCollectionInvalidArgs);
 
     it("can drop non-existing collection", async () => {
         await integration.connectMcpClient();
@@ -83,36 +57,13 @@ describe("dropCollection tool", () => {
         expect(collections[0].name).toBe("coll2");
     });
 
-    describe("when not connected", () => {
-        it("connects automatically if connection string is configured", async () => {
-            await integration.connectMcpClient();
-            await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
-
-            config.connectionString = integration.connectionString();
-
-            const response = await integration.mcpClient().callTool({
-                name: "drop-collection",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain(
-                `Successfully dropped collection "coll1" from database "${integration.randomDbName()}"`
-            );
-        });
-
-        it("throws an error if connection string is not configured", async () => {
-            const response = await integration.mcpClient().callTool({
-                name: "drop-collection",
-                arguments: {
-                    database: integration.randomDbName(),
-                    collection: "coll1",
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
-        });
+    validateAutoConnectBehavior(integration, "drop-collection", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+            },
+            expectedResponse: `Successfully dropped collection "coll1" from database "${integration.randomDbName()}"`,
+        };
     });
 });