fix(NODE-5745): ignore Read/Write Concern in Atlas Search Index Helpe…

…rs (#4042)

src/collection.ts

@@ -1074,6 +1074,7 @@ export class Collection<TSchema extends Document = Document> {
   ): ListSearchIndexesCursor {
     options =
       typeof indexNameOrOptions === 'object' ? indexNameOrOptions : options == null ? {} : options;
+
     const indexName =
       indexNameOrOptions == null
         ? null

src/cursor/list_search_indexes_cursor.ts

@@ -3,7 +3,7 @@ import type { AggregateOptions } from '../operations/aggregate';
 import { AggregationCursor } from './aggregation_cursor';
 
 /** @public */
-export type ListSearchIndexesOptions = AggregateOptions;
+export type ListSearchIndexesOptions = Omit<AggregateOptions, 'readConcern' | 'writeConcern'>;
 
 /** @public */
 export class ListSearchIndexesCursor extends AggregationCursor<{ name: string }> {

test/integration/index-management/search-index-management.test.ts

@@ -0,0 +1,68 @@
+import { expect } from 'chai';
+
+import { type Collection, type CommandStartedEvent, type MongoClient } from '../../mongodb';
+
+describe('Search Index Management Integration Tests', function () {
+  describe('read concern and write concern ', function () {
+    let client: MongoClient;
+    let collection: Collection;
+    let commandStartedEvents: CommandStartedEvent[];
+
+    beforeEach(async function () {
+      client = this.configuration.newClient({}, { monitorCommands: true });
+      await client.connect();
+      collection = client.db('client').collection('searchIndexManagement');
+      commandStartedEvents = [];
+      client.on('commandStarted', e => commandStartedEvents.push(e));
+    });
+
+    afterEach(async function () {
+      await client.close();
+    });
+
+    context('when listSearchIndexes operation is run with causalConsistency', function () {
+      it('should not include write concern or read concern in command', {
+        metadata: {
+          requires: {
+            topology: '!single',
+            mongodb: '>=7.0',
+            serverless: 'forbid'
+          }
+        },
+        test: async function () {
+          await client.withSession({ causalConsistency: true }, async session => {
+            const res = collection.listSearchIndexes({ session });
+            await res.toArray().catch(e => expect(e.errmsg).to.match(/^.*Atlas.*$/));
+            expect(commandStartedEvents[0]).to.exist;
+            expect(commandStartedEvents[0]?.command?.readConcern).to.not.exist;
+            expect(commandStartedEvents[0]?.command?.writeConcern).to.not.exist;
+          });
+        }
+      });
+    });
+
+    context('when listSearchIndexes operation is run with snapshot on', function () {
+      // TODO(NODE-6047): Ignore read/write concern in applySession for Atlas Search Index Helpers
+      it('should include write concern or read concern in command - TODO(NODE-6047)', {
+        metadata: {
+          requires: {
+            topology: ['replicaset', 'sharded'],
+            mongodb: '>=7.0',
+            serverless: 'forbid'
+          }
+        },
+        test: async function () {
+          await client.withSession({ snapshot: true }, async session => {
+            const res = collection.listSearchIndexes({ session });
+            const error = await res.toArray().catch(e => e);
+            expect(error.errmsg).to.match(/^.*snapshot.*$/);
+            expect(commandStartedEvents[0]).to.exist;
+            // flip assertion after NODE-6047 implementation
+            expect(commandStartedEvents[0]?.command?.readConcern).to.exist;
+            expect(commandStartedEvents[0]?.command?.writeConcern).to.not.exist;
+          });
+        }
+      });
+    });
+  });
+});

test/spec/index-management/searchIndexIgnoresReadWriteConcern.json

@@ -0,0 +1,252 @@
+{
+  "description": "search index operations ignore read and write concern",
+  "schemaVersion": "1.4",
+  "createEntities": [
+    {
+      "client": {
+        "id": "client0",
+        "useMultipleMongoses": false,
+        "uriOptions": {
+          "readConcernLevel": "local",
+          "w": 1
+        },
+        "observeEvents": [
+          "commandStartedEvent"
+        ]
+      }
+    },
+    {
+      "database": {
+        "id": "database0",
+        "client": "client0",
+        "databaseName": "database0"
+      }
+    },
+    {
+      "collection": {
+        "id": "collection0",
+        "database": "database0",
+        "collectionName": "collection0"
+      }
+    }
+  ],
+  "runOnRequirements": [
+    {
+      "minServerVersion": "7.0.0",
+      "topologies": [
+        "replicaset",
+        "load-balanced",
+        "sharded"
+      ],
+      "serverless": "forbid"
+    }
+  ],
+  "tests": [
+    {
+      "description": "createSearchIndex ignores read and write concern",
+      "operations": [
+        {
+          "name": "createSearchIndex",
+          "object": "collection0",
+          "arguments": {
+            "model": {
+              "definition": {
+                "mappings": {
+                  "dynamic": true
+                }
+              }
+            }
+          },
+          "expectError": {
+            "isError": true,
+            "errorContains": "Atlas"
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client0",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "command": {
+                  "createSearchIndexes": "collection0",
+                  "indexes": [
+                    {
+                      "definition": {
+                        "mappings": {
+                          "dynamic": true
+                        }
+                      }
+                    }
+                  ],
+                  "$db": "database0",
+                  "writeConcern": {
+                    "$$exists": false
+                  },
+                  "readConcern": {
+                    "$$exists": false
+                  }
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "createSearchIndexes ignores read and write concern",
+      "operations": [
+        {
+          "name": "createSearchIndexes",
+          "object": "collection0",
+          "arguments": {
+            "models": []
+          },
+          "expectError": {
+            "isError": true,
+            "errorContains": "Atlas"
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client0",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "command": {
+                  "createSearchIndexes": "collection0",
+                  "indexes": [],
+                  "$db": "database0",
+                  "writeConcern": {
+                    "$$exists": false
+                  },
+                  "readConcern": {
+                    "$$exists": false
+                  }
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "dropSearchIndex ignores read and write concern",
+      "operations": [
+        {
+          "name": "dropSearchIndex",
+          "object": "collection0",
+          "arguments": {
+            "name": "test index"
+          },
+          "expectError": {
+            "isError": true,
+            "errorContains": "Atlas"
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client0",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "command": {
+                  "dropSearchIndex": "collection0",
+                  "name": "test index",
+                  "$db": "database0",
+                  "writeConcern": {
+                    "$$exists": false
+                  },
+                  "readConcern": {
+                    "$$exists": false
+                  }
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "listSearchIndexes ignores read and write concern",
+      "operations": [
+        {
+          "name": "listSearchIndexes",
+          "object": "collection0",
+          "expectError": {
+            "isError": true,
+            "errorContains": "Atlas"
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client0",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "command": {
+                  "aggregate": "collection0",
+                  "pipeline": [
+                    {
+                      "$listSearchIndexes": {}
+                    }
+                  ],
+                  "writeConcern": {
+                    "$$exists": false
+                  },
+                  "readConcern": {
+                    "$$exists": false
+                  }
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "description": "updateSearchIndex ignores the read and write concern",
+      "operations": [
+        {
+          "name": "updateSearchIndex",
+          "object": "collection0",
+          "arguments": {
+            "name": "test index",
+            "definition": {}
+          },
+          "expectError": {
+            "isError": true,
+            "errorContains": "Atlas"
+          }
+        }
+      ],
+      "expectEvents": [
+        {
+          "client": "client0",
+          "events": [
+            {
+              "commandStartedEvent": {
+                "command": {
+                  "updateSearchIndex": "collection0",
+                  "name": "test index",
+                  "definition": {},
+                  "$db": "database0",
+                  "writeConcern": {
+                    "$$exists": false
+                  },
+                  "readConcern": {
+                    "$$exists": false
+                  }
+                }
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}