mongodb-mcp-server 0.0.4 → 0.0.6

package/tests/integration/tools/mongodb/metadata/collectionSchema.test.ts

@@ -0,0 +1,154 @@
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
+import {
+    getResponseElements,
+    getResponseContent,
+    databaseCollectionParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    databaseCollectionInvalidArgs,
+} from "../../../helpers.js";
+import { Document } from "bson";
+import { OptionalId } from "mongodb";
+import { SimplifiedSchema } from "mongodb-schema";
+
+describeWithMongoDB("collectionSchema tool", (integration) => {
+    validateToolMetadata(
+        integration,
+        "collection-schema",
+        "Describe the schema for a collection",
+        databaseCollectionParameters
+    );
+
+    validateThrowsForInvalidArguments(integration, "collection-schema", databaseCollectionInvalidArgs);
+
+    describe("with non-existent database", () => {
+        it("returns empty schema", async () => {
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "collection-schema",
+                arguments: { database: "non-existent", collection: "foo" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `Could not deduce the schema for "non-existent.foo". This may be because it doesn't exist or is empty.`
+            );
+        });
+    });
+
+    describe("with existing database", () => {
+        const testCases: Array<{
+            insertionData: OptionalId<Document>[];
+            name: string;
+            expectedSchema: SimplifiedSchema;
+        }> = [
+            {
+                name: "homogenous schema",
+                insertionData: [
+                    { name: "Alice", age: 30 },
+                    { name: "Bob", age: 25 },
+                ],
+                expectedSchema: {
+                    _id: {
+                        types: [{ bsonType: "ObjectId" }],
+                    },
+                    name: {
+                        types: [{ bsonType: "String" }],
+                    },
+                    age: {
+                        //@ts-expect-error This is a workaround
+                        types: [{ bsonType: "Number" }],
+                    },
+                },
+            },
+            {
+                name: "heterogenous schema",
+                insertionData: [
+                    { name: "Alice", age: 30 },
+                    { name: "Bob", age: "25", country: "UK" },
+                    { name: "Charlie", country: "USA" },
+                    { name: "Mims", age: 25, country: false },
+                ],
+                expectedSchema: {
+                    _id: {
+                        types: [{ bsonType: "ObjectId" }],
+                    },
+                    name: {
+                        types: [{ bsonType: "String" }],
+                    },
+                    age: {
+                        // @ts-expect-error This is a workaround
+                        types: [{ bsonType: "Number" }, { bsonType: "String" }],
+                    },
+                    country: {
+                        types: [{ bsonType: "String" }, { bsonType: "Boolean" }],
+                    },
+                },
+            },
+            {
+                name: "schema with nested documents",
+                insertionData: [
+                    { name: "Alice", address: { city: "New York", zip: "10001" }, ageRange: [18, 30] },
+                    { name: "Bob", address: { city: "Los Angeles" }, ageRange: "25-30" },
+                    { name: "Charlie", address: { city: "Chicago", zip: "60601" }, ageRange: [20, 35] },
+                ],
+                expectedSchema: {
+                    _id: {
+                        types: [{ bsonType: "ObjectId" }],
+                    },
+                    name: {
+                        types: [{ bsonType: "String" }],
+                    },
+                    address: {
+                        types: [
+                            {
+                                bsonType: "Document",
+                                fields: {
+                                    city: { types: [{ bsonType: "String" }] },
+                                    zip: { types: [{ bsonType: "String" }] },
+                                },
+                            },
+                        ],
+                    },
+                    ageRange: {
+                        // @ts-expect-error This is a workaround
+                        types: [{ bsonType: "Array", types: [{ bsonType: "Number" }] }, { bsonType: "String" }],
+                    },
+                },
+            },
+        ];
+
+        for (const testCase of testCases) {
+            it(`returns ${testCase.name}`, async () => {
+                const mongoClient = integration.mongoClient();
+                await mongoClient.db(integration.randomDbName()).collection("foo").insertMany(testCase.insertionData);
+
+                await integration.connectMcpClient();
+                const response = await integration.mcpClient().callTool({
+                    name: "collection-schema",
+                    arguments: { database: integration.randomDbName(), collection: "foo" },
+                });
+                const items = getResponseElements(response.content);
+                expect(items).toHaveLength(2);
+
+                // Expect to find _id, name, age
+                expect(items[0].text).toEqual(
+                    `Found ${Object.entries(testCase.expectedSchema).length} fields in the schema for "${integration.randomDbName()}.foo"`
+                );
+
+                const schema = JSON.parse(items[1].text) as SimplifiedSchema;
+                expect(schema).toEqual(testCase.expectedSchema);
+            });
+        }
+    });
+
+    validateAutoConnectBehavior(integration, "collection-schema", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "new-collection",
+            },
+            expectedResponse: `Could not deduce the schema for "${integration.randomDbName()}.new-collection". This may be because it doesn't exist or is empty.`,
+        };
+    });
+});

package/tests/integration/tools/mongodb/metadata/collectionStorageSize.test.ts

@@ -0,0 +1,86 @@
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
+import {
+    getResponseContent,
+    databaseCollectionParameters,
+    databaseCollectionInvalidArgs,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    expectDefined,
+} from "../../../helpers.js";
+import * as crypto from "crypto";
+
+describeWithMongoDB("collectionStorageSize tool", (integration) => {
+    validateToolMetadata(
+        integration,
+        "collection-storage-size",
+        "Gets the size of the collection",
+        databaseCollectionParameters
+    );
+
+    validateThrowsForInvalidArguments(integration, "collection-storage-size", databaseCollectionInvalidArgs);
+
+    describe("with non-existent database", () => {
+        it("returns an error", async () => {
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "collection-storage-size",
+                arguments: { database: integration.randomDbName(), collection: "foo" },
+            });
+            const content = getResponseContent(response.content);
+            expect(content).toEqual(
+                `The size of "${integration.randomDbName()}.foo" cannot be determined because the collection does not exist.`
+            );
+        });
+    });
+
+    describe("with existing database", () => {
+        const testCases = [
+            {
+                expectedScale: "bytes",
+                bytesToInsert: 1,
+            },
+            {
+                expectedScale: "KB",
+                bytesToInsert: 1024,
+            },
+            {
+                expectedScale: "MB",
+                bytesToInsert: 1024 * 1024,
+            },
+        ];
+        for (const test of testCases) {
+            it(`returns the size of the collection in ${test.expectedScale}`, async () => {
+                await integration
+                    .mongoClient()
+                    .db(integration.randomDbName())
+                    .collection("foo")
+                    .insertOne({ data: crypto.randomBytes(test.bytesToInsert) });
+
+                await integration.connectMcpClient();
+                const response = await integration.mcpClient().callTool({
+                    name: "collection-storage-size",
+                    arguments: { database: integration.randomDbName(), collection: "foo" },
+                });
+                const content = getResponseContent(response.content);
+                expect(content).toContain(`The size of "${integration.randomDbName()}.foo" is`);
+                const size = /is `(\d+\.\d+) ([a-zA-Z]*)`/.exec(content);
+
+                expectDefined(size?.[1]);
+                expectDefined(size?.[2]);
+                expect(parseFloat(size?.[1] || "")).toBeGreaterThan(0);
+                expect(size?.[2]).toBe(test.expectedScale);
+            });
+        }
+    });
+
+    validateAutoConnectBehavior(integration, "collection-storage-size", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "foo",
+            },
+            expectedResponse: `The size of "${integration.randomDbName()}.foo" cannot be determined because the collection does not exist.`,
+        };
+    });
+});

package/tests/integration/tools/mongodb/metadata/connect.test.ts

@@ -1,137 +1,132 @@
-import { getResponseContent, validateParameters, setupIntegrationTest } from "../../../helpers.js";
+import { describeWithMongoDB } from "../mongodbHelpers.js";
+import { getResponseContent, validateThrowsForInvalidArguments, validateToolMetadata } from "../../../helpers.js";
+import { config } from "../../../../../src/config.js";
 
-import config from "../../../../../src/config.js";
-
-describe("Connect tool", () => {
-    const integration = setupIntegrationTest();
-
-    it("should have correct metadata", async () => {
-        const { tools } = await integration.mcpClient().listTools();
-        const connectTool = tools.find((tool) => tool.name === "connect")!;
-        expect(connectTool).toBeDefined();
-        expect(connectTool.description).toBe("Connect to a MongoDB instance");
+// These tests are temporarily skipped because the connect tool is disabled for the initial release.
+// TODO: https://github.com/mongodb-js/mongodb-mcp-server/issues/141 - reenable when the connect tool is reenabled
+describeWithMongoDB(
+    "switchConnection tool",
+    (integration) => {
+        beforeEach(() => {
+            integration.mcpServer().userConfig.connectionString = integration.connectionString();
+        });
 
-        validateParameters(connectTool, [
-            {
-                name: "options",
-                description:
-                    "Options for connecting to MongoDB. If not provided, the connection string from the config://connection-string resource will be used. If the user hasn't specified Atlas cluster name or a connection string explicitly and the `config://connection-string` resource is present, always invoke this with no arguments.",
-                type: "array",
-                required: false,
-            },
-        ]);
-    });
+        validateToolMetadata(
+            integration,
+            "switch-connection",
+            "Switch to a different MongoDB connection. If the user has configured a connection string or has previously called the connect tool, a connection is already established and there's no need to call this tool unless the user has explicitly requested to switch to a new instance.",
+            [
+                {
+                    name: "connectionString",
+                    description: "MongoDB connection string to switch to (in the mongodb:// or mongodb+srv:// format)",
+                    type: "string",
+                    required: false,
+                },
+            ]
+        );
 
-    describe("with default config", () => {
-        describe("without connection string", () => {
-            it("prompts for connection string", async () => {
-                const response = await integration.mcpClient().callTool({ name: "connect", arguments: {} });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("No connection details provided");
-            });
-        });
+        validateThrowsForInvalidArguments(integration, "switch-connection", [{ connectionString: 123 }]);
 
-        describe("with connection string", () => {
+        describe("without arguments", () => {
             it("connects to the database", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: {
-                        options: [
-                            {
-                                connectionString: integration.connectionString(),
-                            },
-                        ],
-                    },
-                });
+                const response = await integration.mcpClient().callTool({ name: "switch-connection" });
                 const content = getResponseContent(response.content);
                 expect(content).toContain("Successfully connected");
-                expect(content).toContain(integration.connectionString());
-            });
-        });
-
-        describe("with invalid connection string", () => {
-            it("returns error message", async () => {
-                const response = await integration.mcpClient().callTool({
-                    name: "connect",
-                    arguments: { options: [{ connectionString: "mongodb://localhost:12345" }] },
-                });
-                const content = getResponseContent(response.content);
-                expect(content).toContain("Error running connect");
-
-                // Should not suggest using the config connection string (because we don't have one)
-                expect(content).not.toContain("Your config lists a different connection string");
             });
         });
-    });
 
-    describe("with connection string in config", () => {
-        beforeEach(async () => {
-            config.connectionString = integration.connectionString();
+        it("doesn't have the connect tool registered", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const tool = tools.find((tool) => tool.name === "connect");
+            expect(tool).toBeUndefined();
         });
 
-        it("uses the connection string from config", async () => {
-            const response = await integration.mcpClient().callTool({ name: "connect", arguments: {} });
+        it("defaults to the connection string from config", async () => {
+            const response = await integration.mcpClient().callTool({ name: "switch-connection", arguments: {} });
             const content = getResponseContent(response.content);
             expect(content).toContain("Successfully connected");
-            expect(content).toContain(integration.connectionString());
         });
 
-        it("prefers connection string from arguments", async () => {
+        it("switches to the connection string from the arguments", async () => {
             const newConnectionString = `${integration.connectionString()}?appName=foo-bar`;
             const response = await integration.mcpClient().callTool({
-                name: "connect",
+                name: "switch-connection",
                 arguments: {
-                    options: [
-                        {
-                            connectionString: newConnectionString,
-                        },
-                    ],
+                    connectionString: newConnectionString,
                 },
             });
             const content = getResponseContent(response.content);
             expect(content).toContain("Successfully connected");
-            expect(content).toContain(newConnectionString);
         });
 
         describe("when the arugment connection string is invalid", () => {
-            it("suggests the config connection string if set", async () => {
+            it("returns error message", async () => {
                 const response = await integration.mcpClient().callTool({
-                    name: "connect",
+                    name: "switch-connection",
                     arguments: {
-                        options: [
-                            {
-                                connectionString: "mongodb://localhost:12345",
-                            },
-                        ],
+                        connectionString: "mongodb://localhost:12345",
                     },
                 });
+
                 const content = getResponseContent(response.content);
-                expect(content).toContain("Failed to connect to MongoDB at 'mongodb://localhost:12345'");
-                expect(content).toContain(
-                    `Your config lists a different connection string: '${config.connectionString}' - do you want to try connecting to it instead?`
-                );
+
+                expect(content).toContain("Error running switch-connection");
             });
+        });
+    },
+    (mdbIntegration) => ({
+        ...config,
+        connectionString: mdbIntegration.connectionString(),
+    }),
+    describe.skip
+);
+describeWithMongoDB(
+    "Connect tool",
+    (integration) => {
+        validateToolMetadata(integration, "connect", "Connect to a MongoDB instance", [
+            {
+                name: "connectionString",
+                description: "MongoDB connection string (in the mongodb:// or mongodb+srv:// format)",
+                type: "string",
+                required: true,
+            },
+        ]);
+
+        validateThrowsForInvalidArguments(integration, "connect", [{}, { connectionString: 123 }]);
 
-            it("returns error message if the config connection string matches the argument", async () => {
-                config.connectionString = "mongodb://localhost:12345";
+        it("doesn't have the switch-connection tool registered", async () => {
+            const { tools } = await integration.mcpClient().listTools();
+            const tool = tools.find((tool) => tool.name === "switch-connection");
+            expect(tool).toBeUndefined();
+        });
+
+        describe("with connection string", () => {
+            it("connects to the database", async () => {
                 const response = await integration.mcpClient().callTool({
                     name: "connect",
                     arguments: {
-                        options: [
-                            {
-                                connectionString: "mongodb://localhost:12345",
-                            },
-                        ],
+                        connectionString: integration.connectionString(),
                     },
                 });
-
                 const content = getResponseContent(response.content);
+                expect(content).toContain("Successfully connected");
+            });
+        });
 
-                // Should be handled by default error handler and not suggest the config connection string
-                // because it matches the argument connection string
+        describe("with invalid connection string", () => {
+            it("returns error message", async () => {
+                const response = await integration.mcpClient().callTool({
+                    name: "connect",
+                    arguments: { connectionString: "mongodb://localhost:12345" },
+                });
+                const content = getResponseContent(response.content);
                 expect(content).toContain("Error running connect");
+
+                // Should not suggest using the config connection string (because we don't have one)
                 expect(content).not.toContain("Your config lists a different connection string");
             });
         });
-    });
-});
+    },
+    () => config,
+    describe.skip
+);

package/tests/integration/tools/mongodb/metadata/dbStats.test.ts

@@ -0,0 +1,104 @@
+import { ObjectId } from "bson";
+import {
+    databaseParameters,
+    validateToolMetadata,
+    validateThrowsForInvalidArguments,
+    databaseInvalidArgs,
+    getResponseElements,
+} from "../../../helpers.js";
+import * as crypto from "crypto";
+import { describeWithMongoDB, validateAutoConnectBehavior } from "../mongodbHelpers.js";
+
+describeWithMongoDB("dbStats tool", (integration) => {
+    validateToolMetadata(
+        integration,
+        "db-stats",
+        "Returns statistics that reflect the use state of a single database",
+        databaseParameters
+    );
+
+    validateThrowsForInvalidArguments(integration, "db-stats", databaseInvalidArgs);
+
+    describe("with non-existent database", () => {
+        it("returns an error", async () => {
+            await integration.connectMcpClient();
+            const response = await integration.mcpClient().callTool({
+                name: "db-stats",
+                arguments: { database: integration.randomDbName() },
+            });
+            const elements = getResponseElements(response.content);
+            expect(elements).toHaveLength(2);
+            expect(elements[0].text).toBe(`Statistics for database ${integration.randomDbName()}`);
+
+            const stats = JSON.parse(elements[1].text) as {
+                db: string;
+                collections: number;
+                storageSize: number;
+            };
+            expect(stats.db).toBe(integration.randomDbName());
+            expect(stats.collections).toBe(0);
+            expect(stats.storageSize).toBe(0);
+        });
+    });
+
+    describe("with existing database", () => {
+        const testCases = [
+            {
+                collections: {
+                    foos: 3,
+                },
+                name: "single collection",
+            },
+            {
+                collections: {
+                    foos: 2,
+                    bars: 5,
+                },
+                name: "multiple collections",
+            },
+        ];
+        for (const test of testCases) {
+            it(`returns correct stats for ${test.name}`, async () => {
+                for (const [name, count] of Object.entries(test.collections)) {
+                    const objects = Array(count)
+                        .fill(0)
+                        .map(() => {
+                            return { data: crypto.randomBytes(1024), _id: new ObjectId() };
+                        });
+                    await integration.mongoClient().db(integration.randomDbName()).collection(name).insertMany(objects);
+                }
+
+                await integration.connectMcpClient();
+                const response = await integration.mcpClient().callTool({
+                    name: "db-stats",
+                    arguments: { database: integration.randomDbName() },
+                });
+                const elements = getResponseElements(response.content);
+                expect(elements).toHaveLength(2);
+                expect(elements[0].text).toBe(`Statistics for database ${integration.randomDbName()}`);
+
+                const stats = JSON.parse(elements[1].text) as {
+                    db: string;
+                    collections: unknown;
+                    storageSize: unknown;
+                    objects: unknown;
+                };
+                expect(stats.db).toBe(integration.randomDbName());
+                expect(stats.collections).toBe(Object.entries(test.collections).length);
+                expect(stats.storageSize).toBeGreaterThan(1024);
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                expect(stats.objects).toBe(Object.values(test.collections).reduce((a, b) => a + b, 0));
+            });
+        }
+    });
+
+    validateAutoConnectBehavior(integration, "db-stats", () => {
+        return {
+            args: {
+                database: integration.randomDbName(),
+                collection: "foo",
+            },
+            expectedResponse: `Statistics for database ${integration.randomDbName()}`,
+        };
+    });
+});