chore: add aggregate tests

Author: nirinchev

src/tools/mongodb/read/aggregate.ts

@@ -2,10 +2,10 @@ import { z } from "zod";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
+import { EJSON } from "bson";
 
 export const AggregateArgs = {
     pipeline: z.array(z.object({}).passthrough()).describe("An array of aggregation stages to execute"),
-    limit: z.number().optional().default(10).describe("The maximum number of documents to return"),
 };
 
 export class AggregateTool extends MongoDBToolBase {
@@ -27,12 +27,12 @@ export class AggregateTool extends MongoDBToolBase {
 
         const content: Array<{ text: string; type: "text" }> = [
             {
-                text: `Found ${documents.length} documents in the collection \`${collection}\`:`,
+                text: `Found ${documents.length} documents in the collection "${collection}":`,
                 type: "text",
             },
             ...documents.map((doc) => {
                 return {
-                    text: JSON.stringify(doc),
+                    text: EJSON.stringify(doc),
                     type: "text",
                 } as { text: string; type: "text" };
             }),

tests/integration/tools/mongodb/read/aggregate.test.ts

@@ -0,0 +1,99 @@
+import { pipeline } from "stream";
+import {
+    getResponseContent,
+    databaseCollectionParameters,
+    setupIntegrationTest,
+    validateToolMetadata,
+    validateAutoConnectBehavior,
+    validateThrowsForInvalidArguments,
+    getResponseElements,
+} from "../../../helpers.js";
+
+describe("aggregate tool", () => {
+    const integration = setupIntegrationTest();
+
+    validateToolMetadata(integration, "aggregate", "Run an aggregation against a MongoDB collection", [
+        ...databaseCollectionParameters,
+        {
+            name: "pipeline",
+            description: "An array of aggregation stages to execute",
+            type: "array",
+            required: true,
+        },
+    ]);
+
+    validateThrowsForInvalidArguments(integration, "aggregate", [
+        {},
+        { database: "test", collection: "foo" },
+        { database: test, pipeline: [] },
+        { database: "test", collection: "foo", pipeline: {} },
+        { database: "test", collection: "foo", pipeline: [], extra: "extra" },
+        { database: "test", collection: [], pipeline: [] },
+        { database: 123, collection: "foo", pipeline: [] },
+    ]);
+
+    it("can run aggragation on non-existent database", async () => {
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "aggregate",
+            arguments: { database: "non-existent", collection: "people", pipeline: [{ $match: { name: "Peter" } }] },
+        });
+
+        const elements = getResponseElements(response.content);
+        expect(elements).toHaveLength(1);
+        expect(elements[0].text).toEqual('Found 0 documents in the collection "people":');
+    });
+
+    it("can run aggragation on an empty collection", async () => {
+        await integration.mongoClient().db(integration.randomDbName()).createCollection("people");
+
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "aggregate",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "people",
+                pipeline: [{ $match: { name: "Peter" } }],
+            },
+        });
+
+        const elements = getResponseElements(response.content);
+        expect(elements).toHaveLength(1);
+        expect(elements[0].text).toEqual('Found 0 documents in the collection "people":');
+    });
+
+    it("can run aggragation on an existing collection", async () => {
+        const mongoClient = integration.mongoClient();
+        await mongoClient
+            .db(integration.randomDbName())
+            .collection("people")
+            .insertMany([
+                { name: "Peter", age: 5 },
+                { name: "Laura", age: 10 },
+                { name: "Søren", age: 15 },
+            ]);
+
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "aggregate",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "people",
+                pipeline: [{ $match: { age: { $gt: 8 } } }, { $sort: { name: -1 } }],
+            },
+        });
+
+        const elements = getResponseElements(response.content);
+        expect(elements).toHaveLength(3);
+        expect(elements[0].text).toEqual('Found 2 documents in the collection "people":');
+        expect(JSON.parse(elements[1].text)).toEqual({ _id: expect.any(Object), name: "Søren", age: 15 });
+        expect(JSON.parse(elements[2].text)).toEqual({ _id: expect.any(Object), name: "Laura", age: 10 });
+    });
+
+    validateAutoConnectBehavior(integration, "aggregate", () => {
+        return {
+            args: { database: integration.randomDbName(), collection: "coll1" },
+            expectedResponse: 'Found 0 documents in the collection "coll1"',
+        };
+    });
+});