fix tests

Author: nirinchev

tests/integration/helpers.ts

@@ -29,13 +29,22 @@ export const driverOptions = setupDriverConfig({
 
 export const defaultDriverOptions: DriverOptions = { ...driverOptions };
 
-interface ParameterInfo {
+interface Parameter {
     name: string;
-    type: string;
     description: string;
     required: boolean;
 }
 
+interface SingleValueParameter extends Parameter {
+    type: string;
+}
+
+interface AnyOfParameter extends Parameter {
+    anyOf: { type: string }[];
+}
+
+type ParameterInfo = SingleValueParameter | AnyOfParameter;
+
 type ToolInfo = Awaited<ReturnType<Client["listTools"]>>["tools"][number];
 
 export interface IntegrationTest {
@@ -219,18 +228,38 @@ export function getParameters(tool: ToolInfo): ParameterInfo[] {
 
     return Object.entries(tool.inputSchema.properties)
         .sort((a, b) => a[0].localeCompare(b[0]))
-        .map(([key, value]) => {
-            expect(value).toHaveProperty("type");
+        .map(([name, value]) => {
             expect(value).toHaveProperty("description");
 
-            const typedValue = value as { type: string; description: string };
-            expect(typeof typedValue.type).toBe("string");
-            expect(typeof typedValue.description).toBe("string");
+            const description = (value as { description: string }).description;
+            const required = (tool.inputSchema.required as string[])?.includes(name) ?? false;
+            expect(typeof description).toBe("string");
+
+            if (value && typeof value === "object" && "anyOf" in value) {
+                const typedOptions = new Array<{ type: string }>();
+                for (const option of value.anyOf as { type: string }[]) {
+                    expect(option).toHaveProperty("type");
+
+                    typedOptions.push({ type: option.type });
+                }
+
+                return {
+                    name,
+                    anyOf: typedOptions,
+                    description: description,
+                    required,
+                };
+            }
+
+            expect(value).toHaveProperty("type");
+
+            const type = (value as { type: string }).type;
+            expect(typeof type).toBe("string");
             return {
-                name: key,
-                type: typedValue.type,
-                description: typedValue.description,
-                required: (tool.inputSchema.required as string[])?.includes(key) ?? false,
+                name,
+                type,
+                description,
+                required,
             };
         });
 }

tests/integration/tools/mongodb/create/createIndex.test.ts

@@ -14,9 +14,17 @@ describeWithMongoDB("createIndex tool", (integration) => {
     validateToolMetadata(integration, "create-index", "Create an index for a collection", [
         ...databaseCollectionParameters,
         {
-            name: "keys",
-            type: "object",
-            description: "The index definition",
+            name: "definition",
+            anyOf: [
+                {
+                    type: "object",
+                },
+                {
+                    type: "object",
+                },
+            ],
+            description:
+                "The index definition. Use 'classic' for standard indexes and 'vectorSearch' for vector search indexes",
             required: true,
         },
         {
@@ -32,7 +40,7 @@ describeWithMongoDB("createIndex tool", (integration) => {
         { collection: "bar", database: 123, definition: { type: "classic", keys: { foo: 1 } } },
         { collection: [], database: "test", definition: { type: "classic", keys: { foo: 1 } } },
         { collection: "bar", database: "test", definition: { type: "classic", keys: { foo: 1 } }, name: 123 },
-        { collection: "bar", database: "test", definition: { type: "classic", keys: { foo: 1 } }, name: "my-index" },
+        { collection: "bar", database: "test", definition: { type: "unknown", keys: { foo: 1 } }, name: "my-index" },
     ]);
 
     describe("with classic indexes", () => {