chore: make tests less flaky

Author: kmruiz

tests/integration/tools/mongodb/mongodbHelpers.ts

@@ -19,6 +19,7 @@ import { EJSON } from "bson";
 import { GenericContainer } from "testcontainers";
 import type { StartedTestContainer } from "testcontainers";
 import { ShellWaitStrategy } from "testcontainers/build/wait-strategies/shell-wait-strategy.js";
+import { execSync } from "node:child_process";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -71,7 +72,8 @@ export function describeWithMongoDB(
     downloadOptions: MongoClusterOptions["downloadOptions"] | MongoSearchConfiguration = { enterprise: false },
     serverArgs: string[] = []
 ): void {
-    describe(name, () => {
+    describe(name, ({ skipIf }) => {
+        skipIf(!isMongoDBEnvSupported(downloadOptions));
         const mdbIntegration = setupMongoDBIntegrationTest(downloadOptions, serverArgs);
         const integration = setupIntegrationTest(
             () => ({
@@ -110,6 +112,19 @@ function isTestContainersCluster(
     return !!(cluster as StartedTestContainer)?.stop;
 }
 
+function isMongoDBEnvSupported(downloadOptions: MongoClusterOptions["downloadOptions"] | MongoSearchConfiguration) {
+    if (isSearchOptions(downloadOptions)) {
+        try {
+            execSync("docker --version");
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 export function setupMongoDBIntegrationTest(
     downloadOptions: MongoClusterOptions["downloadOptions"] | MongoSearchConfiguration,
     serverArgs: string[]

tests/integration/tools/mongodb/search/listSearchIndexes.test.ts

@@ -1,5 +1,5 @@
 import { describeWithMongoDB, getSingleDocFromUntrustedContent } from "../mongodbHelpers.js";
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, beforeAll, afterAll } from "vitest";
 import {
     getResponseContent,
     databaseCollectionParameters,
@@ -11,6 +11,9 @@ import {
 import type { NodeDriverServiceProvider } from "@mongosh/service-provider-node-driver";
 import type { SearchIndexStatus } from "../../../../../src/tools/mongodb/search/listSearchIndexes.js";
 
+const SEARCH_RETRIES = 10_000;
+const SEARCH_TIMEOUT = 20_000;
+
 describeWithMongoDB("list search indexes tool in local MongoDB", (integration) => {
     validateToolMetadata(
         integration,
@@ -62,11 +65,7 @@ describeWithMongoDB(
                 await provider.createSearchIndexes("any", "foo", [{ definition: { mappings: { dynamic: true } } }]);
             });
 
-            afterEach(async () => {
-                await provider.dropCollection("any", "foo");
-            });
-
-            it("returns the list of existing indexes", async () => {
+            it("returns the list of existing indexes", { timeout: SEARCH_TIMEOUT }, async () => {
                 const response = await integration.mcpClient().callTool({
                     name: "list-search-indexes",
                     arguments: { database: "any", collection: "foo" },
@@ -79,31 +78,34 @@ describeWithMongoDB(
                 expect(indexDefinition?.latestDefinition).toEqual({ mappings: { dynamic: true, fields: {} } });
             });
 
-            it("returns the list of existing indexes and detects if they are queryable", async ({ signal }) => {
-                await waitUntilIndexIsQueryable(provider, "any", "foo", "default", signal);
-
-                const response = await integration.mcpClient().callTool({
-                    name: "list-search-indexes",
-                    arguments: { database: "any", collection: "foo" },
-                });
-
-                const content = getResponseContent(response.content);
-                const indexDefinition = getSingleDocFromUntrustedContent<SearchIndexStatus>(content);
-
-                expect(indexDefinition?.name).toEqual("default");
-                expect(indexDefinition?.type).toEqual("search");
-                expect(indexDefinition?.latestDefinition).toEqual({ mappings: { dynamic: true, fields: {} } });
-                expect(indexDefinition?.queryable).toEqual(true);
-                expect(indexDefinition?.status).toEqual("READY");
-            });
+            it(
+                "returns the list of existing indexes and detects if they are queryable",
+                { timeout: SEARCH_TIMEOUT },
+                async ({ signal }) => {
+                    await waitUntilIndexIsQueryable(provider, "any", "foo", "default", signal);
+
+                    const response = await integration.mcpClient().callTool({
+                        name: "list-search-indexes",
+                        arguments: { database: "any", collection: "foo" },
+                    });
+
+                    const content = getResponseContent(response.content);
+                    const indexDefinition = getSingleDocFromUntrustedContent<SearchIndexStatus>(content);
+
+                    expect(indexDefinition?.name).toEqual("default");
+                    expect(indexDefinition?.type).toEqual("search");
+                    expect(indexDefinition?.latestDefinition).toEqual({ mappings: { dynamic: true, fields: {} } });
+                    expect(indexDefinition?.queryable).toEqual(true);
+                    expect(indexDefinition?.status).toEqual("READY");
+                }
+            );
         });
     },
     undefined, // default user config
     undefined, // default driver config
     { search: true } // use a search cluster
 );
 
-const SEARCH_RETRIES = 10_000;
 async function waitUntilSearchIsReady(provider: NodeDriverServiceProvider, abortSignal: AbortSignal): Promise<void> {
     let success = true;
     let lastError: unknown = false;
@@ -153,7 +155,7 @@ async function waitUntilIndexIsQueryable(
 
     if (!success) {
         throw new Error(
-            `Index ${indexName} in ${database}.${collection} is not ready: \nlastIndexStatus: ${lastIndexStatus}\nlastError: ${lastError}`
+            `Index ${indexName} in ${database}.${collection} is not ready: \nlastIndexStatus: ${JSON.stringify(lastIndexStatus)}\nlastError: ${lastError}`
         );
     }
 }