update prose tests

Author: tadjik1

test/integration/client-backpressure/client-backpressure.spec.test.ts

@@ -3,7 +3,7 @@ import { runUnifiedSuite } from '../../tools/unified-spec-runner/runner';
 import { type Test } from '../../tools/unified-spec-runner/schema';
 
 const skippedTests = {
-  'collection.dropIndexes retries at most maxAttempts=5 times':
+  'collection.dropIndexes retries at most maxAttempts=2 times':
     'TODO(NODE-6517): dropIndexes squashes all errors other than ns not found',
   'collection.dropIndexes (write) does not retry if retryWrites=false':
     'TODO(NODE-6517): dropIndexes squashes all errors other than ns not found'

test/integration/retryable-reads/retryable_reads.spec.prose.test.ts

@@ -151,17 +151,18 @@ describe('Retryable Reads Spec Prose', () => {
       requires: { mongodb: '>=4.4', topology: 'replicaset' }
     };
 
-    describe('Retryable Reads Caused by Overload Errors Are Retried on a Different Server', () => {
+    describe('Retryable Reads Caused by Overload Errors Are Retried on a Different Server When enableOverloadRetargeting is enabled', () => {
       let client: MongoClient;
       const commandFailedEvents: CommandFailedEvent[] = [];
       const commandSucceededEvents: CommandSucceededEvent[] = [];
 
       beforeEach(async function () {
-        // 1. Create a client `client` with `retryReads=true`, `readPreference=primaryPreferred`, and command event monitoring
-        //     enabled.
+        // 1. Create a client `client` with `retryReads=true`, `readPreference=primaryPreferred`,
+        //    `enableOverloadRetargeting=true`, and command event monitoring enabled.
         client = this.configuration.newClient({
           retryReads: true,
           readPreference: 'primaryPreferred',
+          enableOverloadRetargeting: true,
           monitorCommands: true
         });
 
@@ -278,5 +279,73 @@ describe('Retryable Reads Spec Prose', () => {
         expect(commandFailedEvents[0].address).to.equal(commandSucceededEvents[0].address);
       });
     });
+
+    describe('Retryable Reads Caused by Overload Errors Are Retried on Same Server When enableOverloadRetargeting is disabled', () => {
+      let client: MongoClient;
+      const commandFailedEvents: CommandFailedEvent[] = [];
+      const commandSucceededEvents: CommandSucceededEvent[] = [];
+
+      beforeEach(async function () {
+        // 1. Create a client `client` with `retryReads=true`, `readPreference=primaryPreferred`, and command event monitoring
+        //     enabled.
+        client = this.configuration.newClient({
+          retryReads: true,
+          readPreference: 'primaryPreferred',
+          monitorCommands: true
+        });
+
+        client.on('commandFailed', filterForCommands('find', commandFailedEvents));
+        client.on('commandSucceeded', filterForCommands('find', commandSucceededEvents));
+
+        await client.connect();
+
+        /*
+        * 2. Configure the following fail point for `client`:
+            {
+                configureFailPoint: "failCommand",
+                mode: { times: 1 },
+                data: {
+                    failCommands: ["find"],
+                    errorLabels: ["RetryableError", "SystemOverloadedError"]
+                    errorCode: 6
+                }
+            }
+        * */
+        await client.db('admin').command({
+          configureFailPoint: 'failCommand',
+          mode: { times: 1 },
+          data: {
+            failCommands: ['find'],
+            errorCode: 6,
+            errorLabels: ['RetryableError', 'SystemOverloadedError']
+          }
+        });
+
+        // 3. Reset the command event monitor to clear the failpoint command from its stored events.
+        commandFailedEvents.length = 0;
+        commandSucceededEvents.length = 0;
+      });
+
+      afterEach(async function () {
+        await client?.db('admin').command({ configureFailPoint: 'failCommand', mode: 'off' });
+        await client?.close();
+      });
+
+      it(
+        'retries on the same server when SystemOverloadedError and enableOverloadRetargeting is disabled',
+        TEST_METADATA,
+        async () => {
+          // 4. Execute a `find` command with `client`.
+          await client.db('test').collection('test').find().toArray();
+
+          // 5. Assert that one failed command event and one successful command event occurred.
+          expect(commandFailedEvents).to.have.lengthOf(1);
+          expect(commandSucceededEvents).to.have.lengthOf(1);
+
+          // 6. Assert that both events occurred on the same server.
+          expect(commandFailedEvents[0].address).to.equal(commandSucceededEvents[0].address);
+        }
+      );
+    });
   });
 });

test/integration/retryable-writes/retryable_writes.spec.prose.test.ts

@@ -479,7 +479,8 @@ describe('Retryable Writes Spec Prose', () => {
         //     server error. Assert that the error code of the server error is 91.
         const insertResult = await collection.insertOne({ _id: 1 }).catch(error => error);
 
-        expect(serverCommandStub.callCount).to.equal(6);
+        // maxAdaptiveRetries defaults to 2, so we expect 3 total attempts (1 initial + 2 retries).
+        expect(serverCommandStub.callCount).to.equal(3);
 
         expect(insertResult).to.be.instanceOf(MongoServerError);
         expect(insertResult).to.have.property('code', 91);