mongodb-mcp-server 0.0.4 → 0.0.6

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()}"`,
+        };
     });
 });

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

@@ -1,46 +1,28 @@
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
 import {
     getResponseContent,
-    validateParameters,
-    dbOperationParameters,
-    setupIntegrationTest,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    databaseParameters,
+    databaseInvalidArgs,
+    expectDefined,
 } from "../../../helpers.js";
-import { McpError } from "@modelcontextprotocol/sdk/types.js";
-import config from "../../../../../src/config.js";
-
-describe("dropDatabase tool", () => {
-    const integration = setupIntegrationTest();
 
-    it("should have correct metadata", async () => {
-        const { tools } = await integration.mcpClient().listTools();
-        const dropDatabase = tools.find((tool) => tool.name === "drop-database")!;
-        expect(dropDatabase).toBeDefined();
-        expect(dropDatabase.description).toBe("Removes the specified database, deleting the associated data files");
+describeWithMongoDB("dropDatabase tool", (integration) => {
+    validateToolMetadata(
+        integration,
+        "drop-database",
+        "Removes the specified database, deleting the associated data files",
+        databaseParameters
+    );
 
-        validateParameters(dropDatabase, [dbOperationParameters.find((d) => d.name === "database")!]);
-    });
-
-    describe("with invalid arguments", () => {
-        const args = [{}, { database: 123 }, { foo: "bar", 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-database", 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-database");
-                }
-            });
-        }
-    });
+    validateThrowsForInvalidArguments(integration, "drop-database", databaseInvalidArgs);
 
     it("can drop non-existing database", async () => {
         let { databases } = await integration.mongoClient().db("").admin().listDatabases();
 
-        const preDropLength = databases.length;
+        expect(databases.find((db) => db.name === integration.randomDbName())).toBeUndefined();
 
         await integration.connectMcpClient();
         const response = await integration.mcpClient().callTool({
@@ -55,7 +37,6 @@ describe("dropDatabase tool", () => {
 
         ({ databases } = await integration.mongoClient().db("").admin().listDatabases());
 
-        expect(databases).toHaveLength(preDropLength);
         expect(databases.find((db) => db.name === integration.randomDbName())).toBeUndefined();
     });
 
@@ -65,7 +46,7 @@ describe("dropDatabase tool", () => {
         await integration.mongoClient().db(integration.randomDbName()).createCollection("coll2");
 
         let { databases } = await integration.mongoClient().db("").admin().listDatabases();
-        expect(databases.find((db) => db.name === integration.randomDbName())).toBeDefined();
+        expectDefined(databases.find((db) => db.name === integration.randomDbName()));
 
         const response = await integration.mcpClient().callTool({
             name: "drop-database",
@@ -83,32 +64,17 @@ describe("dropDatabase tool", () => {
         expect(collections).toHaveLength(0);
     });
 
-    describe("when not connected", () => {
-        it("connects automatically if connection string is configured", async () => {
-            await integration.connectMcpClient();
+    validateAutoConnectBehavior(
+        integration,
+        "drop-database",
+        () => {
+            return {
+                args: { database: integration.randomDbName() },
+                expectedResponse: `Successfully dropped database "${integration.randomDbName()}"`,
+            };
+        },
+        async () => {
             await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
-
-            config.connectionString = integration.connectionString();
-
-            const response = await integration.mcpClient().callTool({
-                name: "drop-database",
-                arguments: {
-                    database: integration.randomDbName(),
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain(`Successfully dropped database "${integration.randomDbName()}"`);
-        });
-
-        it("throws an error if connection string is not configured", async () => {
-            const response = await integration.mcpClient().callTool({
-                name: "drop-database",
-                arguments: {
-                    database: integration.randomDbName(),
-                },
-            });
-            const content = getResponseContent(response.content);
-            expect(content).toContain("You need to connect to a MongoDB instance before you can access its data.");
-        });
-    });
+        }
+    );
 });