add prose tests and latest versions of tests

Author: baileympearson

src/operations/execute_operation.ts

@@ -280,7 +280,7 @@ async function executeOperationWithRetries<
         }
 
         // if we have exhausted overload retry attempts, throw.
-        if (systemOverloadRetryAttempt >= maxSystemOverloadRetryAttempts) {
+        if (systemOverloadRetryAttempt > maxSystemOverloadRetryAttempts) {
           throw previousOperationError;
         }
 

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

@@ -0,0 +1,60 @@
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+
+import { type Collection, type MongoClient, MongoServerError } from '../../../src';
+import { clearFailPoint, configureFailPoint, measureDuration } from '../../tools/utils';
+
+describe('Client Backpressure (Prose)', function () {
+  let client: MongoClient;
+  let collection: Collection;
+
+  beforeEach(async function () {
+    client = this.configuration.newClient();
+    await client.connect();
+
+    collection = client.db('foo').collection('bar');
+  });
+
+  afterEach(async function () {
+    await client.close();
+    await clearFailPoint(this.configuration);
+  });
+
+  it(
+    'Test 1: Operation Retry Uses Exponential Backoff',
+    {
+      requires: {
+        mongodb: '4.4'
+      }
+    },
+    async function () {
+      await configureFailPoint(this.configuration, {
+        configureFailPoint: 'failCommand',
+        mode: 'alwaysOn',
+        data: {
+          failCommands: ['insert'],
+          errorCode: 2,
+          errorLabels: ['SystemOverloadedError', 'RetryableError']
+        }
+      });
+
+      const stub = sinon.stub(Math, 'random');
+
+      stub.returns(0);
+
+      const { duration: durationNoBackoff } = await measureDuration(async () => {
+        const error = await collection.insertOne({ a: 1 }).catch(e => e);
+        expect(error).to.be.instanceof(MongoServerError);
+      });
+
+      stub.returns(1);
+
+      const { duration: durationBackoff } = await measureDuration(async () => {
+        const error = await collection.insertOne({ a: 1 }).catch(e => e);
+        expect(error).to.be.instanceof(MongoServerError);
+      });
+
+      expect(durationBackoff - durationNoBackoff).to.be.within(3100 - 1000, 3100 + 1000);
+    }
+  );
+});

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 times (maxAttempts=5)':
+  'collection.dropIndexes retries at most maxAttempts=5 times':
     'TODO(NODE-6517): dropIndexes squashes all errors other than ns not found'
 };
 

test/spec/client-backpressure/README.md

@@ -10,6 +10,51 @@ retryable reads. These tests utilize the [Unified Test Format](../../unified-tes
 Several prose tests, which are not easily expressed in YAML, are also presented in this file. Those tests will need to
 be manually implemented by each driver.
 
+### Prose Tests
+
+#### Test 1: Operation Retry Uses Exponential Backoff
+
+Drivers should test that retries do not occur immediately when a SystemOverloadedError is encountered.
+
+1. let `client` be a `MongoClient`
+2. let `collection` be a collection
+3. Now, run transactions without backoff:
+    1. Configure the random number generator used for jitter to always return `0` -- this effectively disables backoff.
+
+    2. Configure the following failPoint:
+
+        ```javascript
+            {
+                configureFailPoint: 'failCommand',
+                mode: 'alwaysOn',
+                data: {
+                failCommands: ['insert'],
+                errorCode: 2,
+                errorLabels: ['SystemOverloadedError', 'RetryableError']
+                }
+            }
+        ```
+
+    3. Execute the following command.  Expect that the command errors.  Measure the duration of the command execution.
+
+        ```javascript
+           const start = performance.now();
+           expect(
+            await coll.insertOne({ a: 1 }).catch(e => e)
+           ).to.be.an.instanceof(MongoServerError);
+           const end = performance.now();
+        ```
+    
+    4. Configure the random number generator used for jitter to always return `1`. 
+    5. Execute step 3 again.
+    6. Compare the two time between the two runs.
+    ```python
+    assertTrue(absolute_value(with_backoff_time - (no_backoff_time + 3.1 seconds)) < 1)
+    ```
+    The sum of 5 backoffs is 3.1 seconds. There is a 1-second window to account for potential variance between
+    the two runs.
+
+
 ## Changelog
 
 - 2025-XX-XX: Initial version.

test/spec/client-backpressure/backpressure-retry-loop.json

@@ -381,6 +381,9 @@
     },
     {
       "description": "client.clientBulkWrite retries using operation loop",
+      "runOnRequirements": {
+        "minServerVersion": "8.0"
+      },
       "operations": [
         {
           "object": "utilCollection",

test/spec/client-backpressure/backpressure-retry-loop.yml

@@ -223,6 +223,8 @@ tests:
 
   -
     description: 'client.clientBulkWrite retries using operation loop'
+    runOnRequirements:
+      minServerVersion: '8.0'
     operations:
       -
         object: *utilCollection

test/spec/client-backpressure/backpressure-retry-loop.yml.template

@@ -56,6 +56,10 @@ tests:
 {% for operation in operations %}
   -
     description: '{{operation.object}}.{{operation.operation_name}} retries using operation loop'
+    {%- if ((operation.operation_name == 'clientBulkWrite')) %}
+    runOnRequirements:
+      minServerVersion: '8.0'
+    {%- endif %}
     operations:
       -
         object: *utilCollection