list search index tests working on atlas

Author: baileympearson

.evergreen/config.in.yml

@@ -45,15 +45,6 @@ functions:
       params:
         file: src/expansion.yml
 
-  "run search index management tests":
-    - command: subprocess.exec
-      params:
-        binary: bash
-        working_dir: src
-        add_expansions_to_env: true
-        args:
-          - .evergreen/run-search-index-management-tests.sh
-
   "bootstrap mongo-orchestration":
     - command: subprocess.exec
       params:
@@ -1273,6 +1264,19 @@ tasks:
             TEST_LAMBDA_DIRECTORY: ${PROJECT_DIRECTORY}/test/lambda
             AWS_REGION: us-east-1
 
+  - name: test-search-index-helpers
+    commands:
+      - func: install dependencies
+        vars:
+          NODE_LTS_VERSION: 20
+      - command: subprocess.exec
+        params:
+          working_dir: src
+          binary: bash
+          add_expansions_to_env: true
+          args:
+            - .evergreen/run-search-index-management-tests.sh
+
 task_groups:
   - name: serverless_task_group
     setup_group_can_fail_task: true
@@ -1412,6 +1416,8 @@ task_groups:
           working_dir: src
           binary: bash
           add_expansions_to_env: true
+          env:
+            MONGODB_VERSION: "7.0"
           args:
             - ${DRIVERS_TOOLS}/.evergreen/atlas/setup-atlas-cluster.sh
       - command: expansions.update
@@ -1429,6 +1435,7 @@ task_groups:
     setup_group_timeout_secs: 1800
     tasks:
       - test-aws-lambda-deployed
+      - test-search-index-helpers
 
 pre:
   - func: "fetch source"

.evergreen/config.yml

@@ -25,14 +25,6 @@ functions:
     - command: expansions.update
       params:
         file: src/expansion.yml
-  run search index management tests:
-    - command: subprocess.exec
-      params:
-        binary: bash
-        working_dir: src
-        add_expansions_to_env: true
-        args:
-          - .evergreen/run-search-index-management-tests.sh
   bootstrap mongo-orchestration:
     - command: subprocess.exec
       params:
@@ -1196,6 +1188,18 @@ tasks:
           env:
             TEST_LAMBDA_DIRECTORY: ${PROJECT_DIRECTORY}/test/lambda
             AWS_REGION: us-east-1
+  - name: test-search-index-helpers
+    commands:
+      - func: install dependencies
+        vars:
+          NODE_LTS_VERSION: 20
+      - command: subprocess.exec
+        params:
+          working_dir: src
+          binary: bash
+          add_expansions_to_env: true
+          args:
+            - .evergreen/run-search-index-management-tests.sh
   - name: test-latest-server
     tags:
       - latest
@@ -2643,17 +2647,6 @@ tasks:
         variant: '*'
         status: '*'
         patch_optional: true
-  - name: test-search-index-helpers
-    tags: []
-    commands:
-      - func: install dependencies
-        vars:
-          NODE_LTS_NAME: 20
-      - func: bootstrap mongo-orchestration
-        vars:
-          VERSION: latest
-          TOPOLOGY: replica_set
-      - func: run search index management tests
   - name: run-custom-csfle-tests-5.0-pinned-commit
     tags:
       - run-custom-dependency-tests
@@ -3465,6 +3458,8 @@ task_groups:
           working_dir: src
           binary: bash
           add_expansions_to_env: true
+          env:
+            MONGODB_VERSION: '7.0'
           args:
             - ${DRIVERS_TOOLS}/.evergreen/atlas/setup-atlas-cluster.sh
       - command: expansions.update
@@ -3482,6 +3477,7 @@ task_groups:
     setup_group_timeout_secs: 1800
     tasks:
       - test-aws-lambda-deployed
+      - test-search-index-helpers
 pre:
   - func: fetch source
   - func: windows fix
@@ -4110,8 +4106,3 @@ buildvariants:
     tasks:
       - test-lambda-example
       - test-lambda-aws-auth-example
-  - name: rhel8-test-seach-index-management-helpers
-    display_name: Search Index Management Helpers Tests
-    run_on: rhel80-large
-    tasks:
-      - test-search-index-helpers

.evergreen/generate_evergreen_tasks.js

@@ -690,26 +690,6 @@ const coverageTask = {
 };
 
 SINGLETON_TASKS.push(coverageTask);
-SINGLETON_TASKS.push({
-  name: 'test-search-index-helpers',
-  tags: [],
-  commands: [
-    {
-      func: 'install dependencies',
-      vars: {
-        NODE_LTS_NAME: LATEST_LTS
-      }
-    },
-    {
-      func: 'bootstrap mongo-orchestration',
-      vars: {
-        VERSION: 'latest',
-        TOPOLOGY: 'replica_set'
-      }
-    },
-    { func: 'run search index management tests' }
-  ]
-})
 SINGLETON_TASKS.push(...oneOffFuncAsTasks);
 
 BUILD_VARIANTS.push({
@@ -777,13 +757,6 @@ BUILD_VARIANTS.push({
   tasks: ['test-lambda-example', 'test-lambda-aws-auth-example']
 });
 
-BUILD_VARIANTS.push({
-  name: 'rhel8-test-seach-index-management-helpers',
-  display_name: 'Search Index Management Helpers Tests',
-  run_on: DEFAULT_OS,
-  tasks: ['test-search-index-helpers']
-})
-
 // TODO(NODE-4575): unskip zstd and snappy on node 16
 for (const variant of BUILD_VARIANTS.filter(
   variant =>

package.json

@@ -129,7 +129,7 @@
     "check:tsd": "tsd --version && tsd",
     "check:dependencies": "mocha test/action/dependency.test.ts",
     "check:dts": "node ./node_modules/typescript/bin/tsc --noEmit mongodb.d.ts && tsd",
-    "check:search-indexes": "nyc mocha --config test/mocha_mongodb.json test/manual/search-index-management.spec.test.ts",
+    "check:search-indexes": "nyc mocha --config test/mocha_mongodb.json test/manual/search-index-management.prose.*",
     "check:test": "mocha --config test/mocha_mongodb.json test/integration",
     "check:unit": "mocha test/unit",
     "check:ts": "node ./node_modules/typescript/bin/tsc -v && node ./node_modules/typescript/bin/tsc --noEmit",

src/operations/search_indexes/drop.ts

@@ -1,6 +1,7 @@
 import type { Document } from 'bson';
 
 import type { Collection } from '../../collection';
+import { MONGODB_ERROR_CODES, MongoServerError } from '../../error';
 import type { Server } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
 import type { Callback } from '../../utils';
@@ -28,7 +29,9 @@ export class DropSearchIndexOperation extends AbstractCallbackOperation<void> {
     }
 
     server.command(namespace, command, { session }, err => {
-      if (err) {
+      const isNamespaceNotFoundError =
+        err instanceof MongoServerError && err.code === MONGODB_ERROR_CODES.NamespaceNotFound;
+      if (err && !isNamespaceNotFoundError) {
         callback(err);
         return;
       }

test/manual/search-index-management.prose.test.ts

@@ -0,0 +1,187 @@
+import { expect } from 'chai';
+import { lt } from 'semver';
+import { Readable } from 'stream';
+import { clearTimeout, setTimeout as setTimeoutCb } from 'timers';
+import { setInterval } from 'timers/promises';
+
+import { type Collection, type Document, type MongoClient, ObjectId } from '../mongodb';
+
+class TimeoutController extends AbortController {
+  constructor(private timeoutMS: number) {
+    super();
+
+    this.timeoutId = setTimeoutCb(() => {
+      this.abort(new Error(`Test timed out after ${timeoutMS} milliseconds.`));
+    }, timeoutMS);
+  }
+
+  clear(abort = false) {
+    if (abort) {
+      this.abort();
+    }
+    clearTimeout(this.timeoutId);
+  }
+}
+
+describe('Index Management Prose Tests', function () {
+  describe('Search Index Management Tests', function () {
+    this.timeout(300000); // set timeout at two minutes
+
+    let client: MongoClient;
+    let timeoutController: TimeoutController;
+
+    const interval = (interval: number, signal: AbortSignal) =>
+      Readable.from(setInterval(interval, undefined, { signal, ref: false }));
+
+    const waitForIndexes = (
+      collection: Collection,
+      predicate: (arg0: Array<Document>) => boolean,
+      indexName?: string
+    ): Promise<Array<Document>> =>
+      interval(5000, timeoutController.signal)
+        .map(() => collection.listSearchIndexes(indexName).toArray())
+        .find(predicate);
+
+    before(function () {
+      this.configuration = this.configuration.makeAtlasTestConfiguration();
+    });
+
+    beforeEach(function () {
+      if (lt(process.version, '18.0')) {
+        this.currentTest!.skipReason = 'Test requires Node18+';
+        this.skip();
+      }
+    });
+
+    beforeEach(async function () {
+      client = this.configuration.newClient();
+      await client.connect();
+
+      timeoutController = new TimeoutController(60 * 1000 * 4);
+    });
+
+    afterEach(async () => {
+      await client.close();
+      timeoutController.clear(false);
+    });
+
+    it('Case 1: Driver can successfully create and list search indexes', async function () {
+      const collection = await client.db('test-db').createCollection(new ObjectId().toHexString());
+
+      await collection.createSearchIndex({
+        name: 'test-search-index',
+        definition: {
+          mappings: { dynamic: false }
+        }
+      });
+
+      const [index] = await waitForIndexes(
+        collection,
+        indexes => indexes.every(index => index.queryable),
+        'test-search-index'
+      );
+
+      expect(index).to.exist;
+      expect(index)
+        .to.have.property('latestDefinition')
+        .to.deep.equal({ mappings: { dynamic: false } });
+    });
+
+    it('Case 2: Driver can successfully create multiple indexes in batch', async function () {
+      const collection = await client.db('test-db').createCollection(new ObjectId().toHexString());
+
+      const indexDefinitions = [
+        {
+          name: 'test-search-index-1',
+          definition: {
+            mappings: { dynamic: false }
+          }
+        },
+        {
+          name: 'test-search-index-2',
+          definition: {
+            mappings: { dynamic: false }
+          }
+        }
+      ];
+
+      await collection.createSearchIndexes(indexDefinitions);
+
+      const indexes = await waitForIndexes(collection, indexes =>
+        indexes.every(index => index.queryable)
+      );
+
+      for (const indexDescription of indexDefinitions) {
+        const index = indexes.find(({ name }) => name === indexDescription.name);
+        expect(index, `expected ${indexDescription.name} to exist`).to.exist;
+
+        expect(index)
+          .to.have.property('latestDefinition')
+          .to.deep.equal({ mappings: { dynamic: false } });
+      }
+    });
+
+    it('Case 3: Driver can successfully drop search indexes', async function () {
+      const collection = await client.db('test-db').createCollection(new ObjectId().toHexString());
+
+      await collection.createSearchIndex({
+        name: 'test-search-index',
+        definition: {
+          mappings: { dynamic: false }
+        }
+      });
+
+      await waitForIndexes(
+        collection,
+        indexes => indexes.every(index => index.queryable),
+        'test-search-index'
+      );
+
+      await collection.dropSearchIndex('test-search-index');
+
+      const indexes = await waitForIndexes(
+        collection,
+        indexes => indexes.length === 0,
+        'test-search-index'
+      );
+
+      expect(indexes).to.deep.equal([]);
+    });
+
+    it('Case 4: Driver can update a search index', async function () {
+      const collection = await client.db('test-db').createCollection(new ObjectId().toHexString());
+
+      await collection.createSearchIndex({
+        name: 'test-search-index',
+        definition: {
+          mappings: { dynamic: false }
+        }
+      });
+
+      await waitForIndexes(
+        collection,
+        indexes => indexes.every(index => index.queryable),
+        'test-search-index'
+      );
+
+      await collection.updateSearchIndex('test-search-index', { mappings: { dynamic: true } });
+
+      const [updatedIndex] = await waitForIndexes(
+        collection,
+        indexes => indexes.every(index => index.queryable && index.status === 'READY'),
+        'test-search-index'
+      );
+
+      expect(updatedIndex).to.have.property('name', 'test-search-index');
+      expect(updatedIndex)
+        .to.have.property('latestDefinition')
+        .to.deep.equal({ mappings: { dynamic: true } });
+    });
+
+    it('Case 5: `dropSearchIndex` suppresses namespace not found errors', async function () {
+      const collection = await client.db('test-db').collection(new ObjectId().toHexString());
+
+      await collection.dropSearchIndex('test-search-index');
+    });
+  });
+});

test/manual/search-index-management.spec.test.ts

@@ -4,5 +4,8 @@ import { loadSpecTests } from '../spec';
 import { runUnifiedSuite } from '../tools/unified-spec-runner/runner';
 
 describe('Search Index Management Tests (Unified)', function () {
+  before(function () {
+    this.configuration = this.configuration.makeAtlasTestConfiguration();
+  });
   runUnifiedSuite(loadSpecTests(join('index-management')));
 });