chore: tests for collection-indexes tool

Author: himanshusinghs

src/tools/mongodb/read/collectionIndexes.ts

@@ -2,6 +2,44 @@ import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import { DbOperationArgs, MongoDBToolBase } from "../mongodbTool.js";
 import { ToolArgs, OperationType } from "../../tool.js";
 
+export function collectionIndexesResponse({
+    database,
+    collection,
+    indexes = [],
+    namespaceNotFound,
+}: {
+    database: string;
+    collection: string;
+    indexes?: { name: string; key: string }[];
+    namespaceNotFound?: boolean;
+}): CallToolResult {
+    if (namespaceNotFound) {
+        return {
+            content: [
+                {
+                    text: `The indexes for "${database}.${collection}" cannot be determined because the collection does not exist.`,
+                    type: "text",
+                },
+            ],
+        };
+    }
+
+    return {
+        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" }[]),
+        ],
+    };
+}
+
 export class CollectionIndexesTool extends MongoDBToolBase {
     protected name = "collection-indexes";
     protected description = "Describe the indexes for a collection";
@@ -11,36 +49,26 @@ export class CollectionIndexesTool extends MongoDBToolBase {
     protected async execute({ database, collection }: ToolArgs<typeof DbOperationArgs>): Promise<CallToolResult> {
         const provider = await this.ensureConnected();
         const indexes = await provider.getIndexes(database, collection);
-
-        return {
-            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" }[]),
-            ],
-        };
+        return collectionIndexesResponse({
+            database,
+            collection,
+            indexes: indexes.map((index) => ({
+                name: `${index.name}`,
+                key: JSON.stringify(index.key),
+            })),
+        });
     }
 
     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 collectionIndexesResponse({
+                database: args.database,
+                collection: args.collection,
+                namespaceNotFound: true,
+            });
         }
 
         return super.handleError(error, args);

tests/accuracy/collection-indexes.test.ts

@@ -0,0 +1,42 @@
+import { describeAccuracyTests } from "./sdk/describe-accuracy-tests.js";
+import { getAvailableModels } from "./sdk/models.js";
+import { AccuracyTestConfig } from "./sdk/describe-accuracy-tests.js";
+import { collectionIndexesResponse } from "../../src/tools/mongodb/read/collectionIndexes.js";
+
+function callsCollectionIndexes(prompt: string): AccuracyTestConfig {
+    return {
+        injectConnectedAssumption: true,
+        prompt: prompt,
+        mockedTools: {
+            "collection-indexes": function collectionIndexes() {
+                return collectionIndexesResponse({
+                    database: "db1",
+                    collection: "coll1",
+                    indexes: [
+                        {
+                            name: "year",
+                            key: JSON.stringify({ _id: 1 }),
+                        },
+                    ],
+                });
+            },
+        },
+        expectedToolCalls: [
+            {
+                toolName: "collection-indexes",
+                parameters: {
+                    database: "db1",
+                    collection: "coll1",
+                },
+            },
+        ],
+    };
+}
+
+describeAccuracyTests("collection-indexes", getAvailableModels(), [
+    callsCollectionIndexes("How many indexes do I have in 'db1.coll1' namespace?"),
+    callsCollectionIndexes("List all the indexes in coll1 collection in db1 database"),
+    callsCollectionIndexes(
+        `Will this query: ${JSON.stringify({ year: 1994 })} on the namespace 'db1.coll1' be a collection scan?`
+    ),
+]);