mongodb-mcp-server 0.0.4 → 0.0.5

package/tests/integration/tools/mongodb/update/renameCollection.test.ts

@@ -0,0 +1,194 @@
+import {
+    getResponseContent,
+    databaseCollectionParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+} from "../../../helpers.js";
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
+describeWithMongoDB("renameCollection tool", (integration) => {
+    validateToolMetadata(integration, "rename-collection", "Renames a collection in a MongoDB database", [
+        ...databaseCollectionParameters,
+
+        {
+            name: "newName",
+            description: "The new name for the collection",
+            type: "string",
+            required: true,
+        },
+        {
+            name: "dropTarget",
+            description: "If true, drops the target collection if it exists",
+            type: "boolean",
+            required: false,
+        },
+    ]);
+
+    validateThrowsForInvalidArguments(integration, "rename-collection", [
+        {},
+        { database: 123, collection: "bar" },
+        { database: "test", collection: [], newName: "foo" },
+        { database: "test", collection: "bar", newName: 10 },
+        { database: "test", collection: "bar", newName: "foo", dropTarget: "true" },
+        { database: "test", collection: "bar", newName: "foo", dropTarget: 1 },
+    ]);
+
+    describe("with non-existing database", () => {
+        it("returns an error", async () => {
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "rename-collection",
+                arguments: { database: "non-existent", collection: "foos", newName: "bar" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(`Cannot rename "non-existent.foos" because it doesn't exist.`);
+        });
+    });
+
+    describe("with non-existing collection", () => {
+        it("returns an error", async () => {
+            await integration.mongoClient().db(integration.randomDbName()).collection("bar").insertOne({});
+
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "rename-collection",
+                arguments: { database: integration.randomDbName(), collection: "non-existent", newName: "foo" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `Cannot rename "${integration.randomDbName()}.non-existent" because it doesn't exist.`
+            );
+        });
+    });
+
+    describe("with existing collection", () => {
+        it("renames to non-existing collection", async () => {
+            await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("before")
+                .insertOne({ value: 42 });
+
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "rename-collection",
+                arguments: { database: integration.randomDbName(), collection: "before", newName: "after" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `Collection "before" renamed to "after" in database "${integration.randomDbName()}".`
+            );
+
+            const docsInBefore = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("before")
+                .find({})
+                .toArray();
+            expect(docsInBefore).toHaveLength(0);
+
+            const docsInAfter = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("after")
+                .find({})
+                .toArray();
+            expect(docsInAfter).toHaveLength(1);
+            expect(docsInAfter[0].value).toEqual(42);
+        });
+
+        it("returns an error when renaming to an existing collection", async () => {
+            await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("before")
+                .insertOne({ value: 42 });
+            await integration.mongoClient().db(integration.randomDbName()).collection("after").insertOne({ value: 84 });
+
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "rename-collection",
+                arguments: { database: integration.randomDbName(), collection: "before", newName: "after" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `Cannot rename "${integration.randomDbName()}.before" to "after" because the target collection already exists. If you want to overwrite it, set the "dropTarget" argument to true.`
+            );
+
+            // Ensure no data was lost
+            const docsInBefore = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("before")
+                .find({})
+                .toArray();
+            expect(docsInBefore).toHaveLength(1);
+            expect(docsInBefore[0].value).toEqual(42);
+
+            const docsInAfter = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("after")
+                .find({})
+                .toArray();
+            expect(docsInAfter).toHaveLength(1);
+            expect(docsInAfter[0].value).toEqual(84);
+        });
+
+        it("renames to existing collection with dropTarget", async () => {
+            await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("before")
+                .insertOne({ value: 42 });
+            await integration.mongoClient().db(integration.randomDbName()).collection("after").insertOne({ value: 84 });
+
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "rename-collection",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "before",
+                    newName: "after",
+                    dropTarget: true,
+                },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `Collection "before" renamed to "after" in database "${integration.randomDbName()}".`
+            );
+
+            // Ensure the data was moved
+            const docsInBefore = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("before")
+                .find({})
+                .toArray();
+            expect(docsInBefore).toHaveLength(0);
+
+            const docsInAfter = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("after")
+                .find({})
+                .toArray();
+            expect(docsInAfter).toHaveLength(1);
+            expect(docsInAfter[0].value).toEqual(42);
+        });
+    });
+
+    validateAutoConnectBehavior(
+        integration,
+        "rename-collection",
+        () => {
+            return {
+                args: { database: integration.randomDbName(), collection: "coll1", newName: "coll2" },
+                expectedResponse: `Collection "coll1" renamed to "coll2" in database "${integration.randomDbName()}".`,
+            };
+        },
+        async () => {
+            await integration.mongoClient().db(integration.randomDbName()).createCollection("coll1");
+        }
+    );
+});

package/tests/integration/tools/mongodb/update/updateMany.test.ts

@@ -0,0 +1,238 @@
+import {
+    databaseCollectionParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    getResponseContent,
+} from "../../../helpers.js";
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
+describeWithMongoDB("updateMany tool", (integration) => {
+    validateToolMetadata(
+        integration,
+        "update-many",
+        "Updates all documents that match the specified filter for a collection",
+        [
+            ...databaseCollectionParameters,
+
+            {
+                name: "filter",
+                description:
+                    "The selection criteria for the update, matching the syntax of the filter argument of db.collection.updateOne()",
+                type: "object",
+                required: false,
+            },
+            {
+                name: "update",
+                description:
+                    "An update document describing the modifications to apply using update operator expressions",
+                type: "object",
+                required: true,
+            },
+            {
+                name: "upsert",
+                description: "Controls whether to insert a new document if no documents match the filter",
+                type: "boolean",
+                required: false,
+            },
+        ]
+    );
+
+    validateThrowsForInvalidArguments(integration, "update-many", [
+        {},
+        { database: 123, collection: "bar", update: {} },
+        { database: [], collection: "bar", update: {} },
+        { database: "test", collection: "bar", update: [] },
+        { database: "test", collection: "bar", update: {}, filter: 123 },
+        { database: "test", collection: "bar", update: {}, upsert: "true" },
+        { database: "test", collection: "bar", update: {}, filter: {}, upsert: "true" },
+        { database: "test", collection: "bar", update: {}, filter: "TRUEPREDICATE", upsert: false },
+    ]);
+
+    describe("with non-existent database", () => {
+        it("doesn't update any documents", async () => {
+            await integration.connectMcpClient();
+
+            const response = await integration.mcpClient().callTool({
+                name: "update-many",
+                arguments: {
+                    database: "non-existent-db",
+                    collection: "coll1",
+                    update: { $set: { name: "new-name" } },
+                },
+            });
+
+            const content = getResponseContent(response.content);
+            expect(content).toEqual("No documents matched the filter.");
+        });
+    });
+
+    describe("with non-existent collection", () => {
+        it("doesn't update any documents", async () => {
+            await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("coll1")
+                .insertOne({ name: "old-name" });
+            await integration.connectMcpClient();
+
+            const response = await integration.mcpClient().callTool({
+                name: "update-many",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "non-existent",
+                    update: { $set: { name: "new-name" } },
+                },
+            });
+
+            const content = getResponseContent(response.content);
+            expect(content).toEqual("No documents matched the filter.");
+        });
+    });
+
+    describe("with existing collection", () => {
+        beforeEach(async () => {
+            await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("coll1")
+                .insertMany([
+                    { name: "old-name", value: 1 },
+                    { name: "old-name", value: 2 },
+                    { name: "old-name", value: 3 },
+                ]);
+        });
+        it("updates all documents without filter", async () => {
+            await integration.connectMcpClient();
+
+            const response = await integration.mcpClient().callTool({
+                name: "update-many",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "coll1",
+                    update: { $set: { name: "new-name" } },
+                },
+            });
+
+            const content = getResponseContent(response.content);
+            expect(content).toEqual("Matched 3 document(s). Modified 3 document(s).");
+
+            const docs = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("coll1")
+                .find({})
+                .toArray();
+
+            expect(docs).toHaveLength(3);
+            for (const doc of docs) {
+                expect(doc.name).toEqual("new-name");
+            }
+        });
+
+        it("updates all documents that match the filter", async () => {
+            await integration.connectMcpClient();
+
+            const response = await integration.mcpClient().callTool({
+                name: "update-many",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "coll1",
+                    update: { $set: { name: "new-name" } },
+                    filter: { value: { $gt: 1 } },
+                },
+            });
+
+            const content = getResponseContent(response.content);
+            expect(content).toEqual("Matched 2 document(s). Modified 2 document(s).");
+
+            const docs = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("coll1")
+                .find({})
+                .toArray();
+            expect(docs).toHaveLength(3);
+            for (const doc of docs) {
+                if (doc.value > 1) {
+                    expect(doc.name).toEqual("new-name");
+                } else {
+                    expect(doc.name).toEqual("old-name");
+                }
+            }
+        });
+
+        it("upserts a new document if no documents match the filter", async () => {
+            await integration.connectMcpClient();
+
+            const response = await integration.mcpClient().callTool({
+                name: "update-many",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "coll1",
+                    update: { $set: { name: "new-name" } },
+                    filter: { value: 4 },
+                    upsert: true,
+                },
+            });
+
+            const content = getResponseContent(response.content);
+            expect(content).toContain("Matched 0 document(s). Upserted 1 document with id:");
+
+            const docs = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("coll1")
+                .find({})
+                .toArray();
+
+            expect(docs).toHaveLength(4);
+            for (const doc of docs) {
+                if (doc.value === 4) {
+                    expect(doc.name).toEqual("new-name");
+                } else {
+                    expect(doc.name).toEqual("old-name");
+                }
+            }
+        });
+
+        it("doesn't upsert a new document if no documents match the filter and upsert is false", async () => {
+            await integration.connectMcpClient();
+
+            const response = await integration.mcpClient().callTool({
+                name: "update-many",
+                arguments: {
+                    database: integration.randomDbName(),
+                    collection: "coll1",
+                    update: { $set: { name: "new-name" } },
+                    filter: { value: 4 },
+                },
+            });
+
+            const content = getResponseContent(response.content);
+            expect(content).toContain("No documents matched the filter.");
+
+            const docs = await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("coll1")
+                .find({})
+                .toArray();
+
+            expect(docs).toHaveLength(3);
+            for (const doc of docs) {
+                expect(doc.name).toEqual("old-name");
+            }
+        });
+    });
+
+    validateAutoConnectBehavior(integration, "update-many", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                update: { $set: { name: "new-name" } },
+            },
+            expectedResponse: "No documents matched the filter.",
+        };
+    });
+});

package/tsconfig.jest.json

@@ -4,7 +4,8 @@
     "module": "esnext",
     "target": "esnext",
     "isolatedModules": true,
-    "allowSyntheticDefaultImports": true
+    "allowSyntheticDefaultImports": true,
+    "types": ["jest", "jest-extended"]
   },
   "include": ["src/**/*.ts", "tests/**/*.ts"]
 }

package/tsconfig.json

@@ -8,7 +8,7 @@
     "strict": true,
     "strictNullChecks": true,
     "esModuleInterop": true,
-    "types": ["node"],
+    "types": ["node", "jest"],
     "sourceMap": true,
     "skipLibCheck": true,
     "resolveJsonModule": true,

package/tsconfig.lint.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "types": ["jest"]
+  },
+  "include": ["**/*"]
+}