add more tests

Author: nirinchev

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

@@ -120,7 +120,7 @@ describeWithMongoDB(
                 name: "definition",
                 type: "array",
                 description:
-                    "The index definition. Use 'classic' for standard indexes and 'vectorSearch' for vector search indexes",
+                    "The index definition. Use 'classic' for standard indexes, 'vectorSearch' for vector search indexes, and 'search' for Atlas Search (lexical) indexes.",
                 required: true,
             },
             {

tests/integration/tools/mongodb/delete/dropIndex.test.ts

@@ -53,10 +53,12 @@ function setupForClassicIndexes(integration: MongoDBIntegrationTestCase): {
 
 function setupForVectorSearchIndexes(integration: MongoDBIntegrationTestCase): {
     getMoviesCollection: () => Collection;
-    getIndexName: () => string;
+    getSearchIndexName: () => string;
+    getVectorIndexName: () => string;
 } {
     let moviesCollection: Collection;
     const indexName = "searchIdx";
+    const vectorIndexName = "vectorIdx";
     beforeEach(async () => {
         await integration.connectMcpClient();
         const mongoClient = integration.mongoClient();
@@ -65,14 +67,24 @@ function setupForVectorSearchIndexes(integration: MongoDBIntegrationTestCase): {
             {
                 name: "Movie1",
                 plot: "This is a horrible movie about a database called BongoDB and how it tried to copy the OG MangoDB.",
+                embeddings: [0.1, 0.2, 0.3, 0.4],
             },
         ]);
         await waitUntilSearchIsReady(mongoClient);
         await moviesCollection.createSearchIndex({
             name: indexName,
-            definition: { mappings: { dynamic: true } },
+            definition: { mappings: { fields: { plot: { type: "string" } } } },
+            type: "search",
+        });
+        await moviesCollection.createSearchIndex({
+            name: vectorIndexName,
+            definition: {
+                fields: [{ path: "embeddings", type: "vector", numDimensions: 4, similarity: "euclidean" }],
+            },
+            type: "vectorSearch",
         });
         await waitUntilSearchIndexIsListed(moviesCollection, indexName);
+        await waitUntilSearchIndexIsListed(moviesCollection, vectorIndexName);
     });
 
     afterEach(async () => {
@@ -82,7 +94,8 @@ function setupForVectorSearchIndexes(integration: MongoDBIntegrationTestCase): {
 
     return {
         getMoviesCollection: () => moviesCollection,
-        getIndexName: () => indexName,
+        getSearchIndexName: () => indexName,
+        getVectorIndexName: () => vectorIndexName,
     };
 }
 
@@ -341,7 +354,8 @@ describe.each([{ vectorSearchEnabled: false }, { vectorSearchEnabled: true }])(
                 describeWithMongoDB(
                     "when connected to MongoDB with search support",
                     (integration) => {
-                        const { getIndexName } = setupForVectorSearchIndexes(integration);
+                        const { getSearchIndexName, getVectorIndexName, getMoviesCollection } =
+                            setupForVectorSearchIndexes(integration);
 
                         describe.each([
                             {
@@ -362,35 +376,39 @@ describe.each([{ vectorSearchEnabled: false }, { vectorSearchEnabled: true }])(
                                 collection: "movies",
                                 indexName: "non-existent-index",
                             },
-                        ])(
-                            "and attempting to delete $title (namespace - $database $collection)",
-                            ({ database, collection, indexName }) => {
-                                it("should fail with appropriate error", async () => {
-                                    const response = await integration.mcpClient().callTool({
-                                        name: "drop-index",
-                                        arguments: { database, collection, indexName, type: "search" },
-                                    });
-                                    expect(response.isError).toBe(true);
-                                    const content = getResponseContent(response.content);
-                                    expect(content).toContain("Index does not exist in the provided namespace.");
+                        ])("and attempting to delete $title", ({ database, collection, indexName }) => {
+                            it("should fail with appropriate error", async () => {
+                                const response = await integration.mcpClient().callTool({
+                                    name: "drop-index",
+                                    arguments: { database, collection, indexName, type: "search" },
+                                });
+                                expect(response.isError).toBe(true);
+                                const content = getResponseContent(response.content);
+                                expect(content).toContain("Index does not exist in the provided namespace.");
 
-                                    const data = getDataFromUntrustedContent(content);
-                                    expect(JSON.parse(data)).toMatchObject({
-                                        indexName,
-                                        namespace: `${database}.${collection}`,
-                                    });
+                                const data = getDataFromUntrustedContent(content);
+                                expect(JSON.parse(data)).toMatchObject({
+                                    indexName,
+                                    namespace: `${database}.${collection}`,
                                 });
-                            }
-                        );
+                            });
+                        });
 
-                        describe("and attempting to delete an existing index", () => {
+                        describe.each([
+                            { description: "search", indexName: getSearchIndexName() },
+                            { description: "vector search", indexName: getVectorIndexName() },
+                        ])("and attempting to delete an existing $description index", ({ indexName }) => {
                             it("should succeed in deleting the index", async () => {
+                                const collection = getMoviesCollection();
+                                let indexes = await collection.listSearchIndexes().toArray();
+                                expect(indexes.find((idx) => idx.name === indexName)).toBeDefined();
+
                                 const response = await integration.mcpClient().callTool({
                                     name: "drop-index",
                                     arguments: {
-                                        database: "mflix",
-                                        collection: "movies",
-                                        indexName: getIndexName(),
+                                        database: collection.dbName,
+                                        collection: collection.collectionName,
+                                        indexName,
                                         type: "search",
                                     },
                                 });
@@ -401,9 +419,12 @@ describe.each([{ vectorSearchEnabled: false }, { vectorSearchEnabled: true }])(
 
                                 const data = getDataFromUntrustedContent(content);
                                 expect(JSON.parse(data)).toMatchObject({
-                                    indexName: getIndexName(),
+                                    indexName,
                                     namespace: "mflix.movies",
                                 });
+
+                                indexes = await collection.listSearchIndexes().toArray();
+                                expect(indexes.find((idx) => idx.name === indexName)).toBeUndefined();
                             });
                         });
                     },
@@ -417,7 +438,7 @@ describe.each([{ vectorSearchEnabled: false }, { vectorSearchEnabled: true }])(
                 describeWithMongoDB(
                     "when invoked via an elicitation enabled client",
                     (integration) => {
-                        const { getIndexName } = setupForVectorSearchIndexes(integration);
+                        const { getSearchIndexName: getIndexName } = setupForVectorSearchIndexes(integration);
                         let dropSearchIndexSpy: MockInstance;
 
                         beforeEach(() => {