chore: add integration tests for collection-indexes

Author: nirinchev

src/tools/mongodb/read/collectionIndexes.ts

@@ -13,12 +13,36 @@ export class CollectionIndexesTool extends MongoDBToolBase {
         const indexes = await provider.getIndexes(database, collection);
 
         return {
-            content: indexes.map((indexDefinition) => {
-                return {
-                    text: `Field: ${indexDefinition.name}: ${JSON.stringify(indexDefinition.key)}`,
+            content: [
+                {
+                    text: `Found ${indexes.length} indexes in the collection "${collection}":`,
                     type: "text",
-                };
-            }),
+                },
+                ...(indexes.map((indexDefinition) => {
+                    return {
+                        text: `Name "${indexDefinition.name}", definition: ${JSON.stringify(indexDefinition.key)}`,
+                        type: "text",
+                    };
+                }) as { text: string; type: "text" }[]),
+            ],
         };
     }
+
+    protected handleError(
+        error: unknown,
+        args: ToolArgs<typeof this.argsShape>
+    ): Promise<CallToolResult> | CallToolResult {
+        if (error instanceof Error && "codeName" in error && error.codeName === "NamespaceNotFound") {
+            return {
+                content: [
+                    {
+                        text: `The indexes for "${args.database}.${args.collection}" cannot be determined because the collection does not exist.`,
+                        type: "text",
+                    },
+                ],
+            };
+        }
+
+        return super.handleError(error, args);
+    }
 }

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

@@ -1,6 +1,4 @@
-import { pipeline } from "stream";
 import {
-    getResponseContent,
     databaseCollectionParameters,
     setupIntegrationTest,
     validateToolMetadata,
@@ -92,7 +90,11 @@ describe("aggregate tool", () => {
 
     validateAutoConnectBehavior(integration, "aggregate", () => {
         return {
-            args: { database: integration.randomDbName(), collection: "coll1" },
+            args: {
+                database: integration.randomDbName(),
+                collection: "coll1",
+                pipeline: [{ $match: { name: "Liva" } }],
+            },
             expectedResponse: 'Found 0 documents in the collection "coll1"',
         };
     });

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

@@ -0,0 +1,101 @@
+import { IndexDirection } from "mongodb";
+import {
+    databaseCollectionParameters,
+    setupIntegrationTest,
+    validateToolMetadata,
+    validateAutoConnectBehavior,
+    validateThrowsForInvalidArguments,
+    getResponseElements,
+    databaseCollectionInvalidArgs,
+} from "../../../helpers.js";
+
+describe("collectionIndexes tool", () => {
+    const integration = setupIntegrationTest();
+
+    validateToolMetadata(
+        integration,
+        "collection-indexes",
+        "Describe the indexes for a collection",
+        databaseCollectionParameters
+    );
+
+    validateThrowsForInvalidArguments(integration, "collection-indexes", databaseCollectionInvalidArgs);
+
+    it("can inspect indexes on non-existent database", async () => {
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "collection-indexes",
+            arguments: { database: "non-existent", collection: "people" },
+        });
+
+        const elements = getResponseElements(response.content);
+        expect(elements).toHaveLength(1);
+        expect(elements[0].text).toEqual(
+            'The indexes for "non-existent.people" cannot be determined because the collection does not exist.'
+        );
+    });
+
+    it("returns the _id index for a new collection", async () => {
+        await integration.mongoClient().db(integration.randomDbName()).createCollection("people");
+
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "collection-indexes",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "people",
+            },
+        });
+
+        const elements = getResponseElements(response.content);
+        expect(elements).toHaveLength(2);
+        expect(elements[0].text).toEqual('Found 1 indexes in the collection "people":');
+        expect(elements[1].text).toEqual('Name "_id_", definition: {"_id":1}');
+    });
+
+    it("returns all indexes for a collection", async () => {
+        await integration.mongoClient().db(integration.randomDbName()).createCollection("people");
+
+        const indexTypes: IndexDirection[] = [-1, 1, "2d", "2dsphere", "text", "hashed"];
+        for (const indexType of indexTypes) {
+            await integration
+                .mongoClient()
+                .db(integration.randomDbName())
+                .collection("people")
+                .createIndex({ [`prop_${indexType}`]: indexType });
+        }
+
+        await integration.connectMcpClient();
+        const response = await integration.mcpClient().callTool({
+            name: "collection-indexes",
+            arguments: {
+                database: integration.randomDbName(),
+                collection: "people",
+            },
+        });
+
+        const elements = getResponseElements(response.content);
+        expect(elements).toHaveLength(indexTypes.length + 2);
+        expect(elements[0].text).toEqual(`Found ${indexTypes.length + 1} indexes in the collection "people":`);
+        expect(elements[1].text).toEqual('Name "_id_", definition: {"_id":1}');
+
+        for (const indexType of indexTypes) {
+            const index = elements.find((element) => element.text.includes(`prop_${indexType}`));
+            expect(index).toBeDefined();
+
+            let expectedDefinition = JSON.stringify({ [`prop_${indexType}`]: indexType });
+            if (indexType === "text") {
+                expectedDefinition = '{"_fts":"text"';
+            }
+
+            expect(index!.text).toContain(`definition: ${expectedDefinition}`);
+        }
+    });
+
+    validateAutoConnectBehavior(integration, "collection-indexes", () => {
+        return {
+            args: { database: integration.randomDbName(), collection: "coll1" },
+            expectedResponse: `The indexes for "${integration.randomDbName()}.coll1" cannot be determined because the collection does not exist.`,
+        };
+    });
+});