add second test?

sleepyStick · sleepyStick · commit 96c4d3fa26c4 · 2025-11-25T10:05:09.000-08:00
diff --git a/pymongo/asynchronous/client_session.py b/pymongo/asynchronous/client_session.py
@@ -481,6 +481,11 @@ def _within_time_limit(start_time: float) -> bool:
     return time.monotonic() - start_time < _WITH_TRANSACTION_RETRY_TIME_LIMIT
 
 
+def _would_exceed_time_limit(start_time: float, backoff: float) -> bool:
+    """Is the backoff within the with_transaction retry limit?"""
+    return time.monotonic() + backoff - start_time >= _WITH_TRANSACTION_RETRY_TIME_LIMIT
+
+
 _T = TypeVar("_T")
 
 if TYPE_CHECKING:
@@ -708,12 +713,13 @@ async def callback(session, custom_arg, custom_kwarg=None):
         """
         start_time = time.monotonic()
         retry = 0
-        self._transaction_retry_backoffs = []
+        last_error = None
         while True:
             if retry:  # Implement exponential backoff on retry.
                 jitter = random.random()  # noqa: S311
                 backoff = jitter * min(_BACKOFF_INITIAL * (1.25**retry), _BACKOFF_MAX)
-                self._transaction_retry_backoffs.append(backoff)
+                if _would_exceed_time_limit(start_time, backoff):
+                    raise last_error
                 await asyncio.sleep(backoff)
             retry += 1
             await self.start_transaction(
@@ -723,6 +729,7 @@ async def callback(session, custom_arg, custom_kwarg=None):
                 ret = await callback(self)
             # Catch KeyboardInterrupt, CancelledError, etc. and cleanup.
             except BaseException as exc:
+                last_error = exc
                 if self.in_transaction:
                     await self.abort_transaction()
                 if (
diff --git a/pymongo/synchronous/client_session.py b/pymongo/synchronous/client_session.py
@@ -479,6 +479,11 @@ def _within_time_limit(start_time: float) -> bool:
     return time.monotonic() - start_time < _WITH_TRANSACTION_RETRY_TIME_LIMIT
 
 
+def _would_exceed_time_limit(start_time: float, backoff: float) -> bool:
+    """Is the backoff within the with_transaction retry limit?"""
+    return time.monotonic() + backoff - start_time >= _WITH_TRANSACTION_RETRY_TIME_LIMIT
+
+
 _T = TypeVar("_T")
 
 if TYPE_CHECKING:
@@ -706,17 +711,21 @@ def callback(session, custom_arg, custom_kwarg=None):
         """
         start_time = time.monotonic()
         retry = 0
+        last_error = None
         while True:
             if retry:  # Implement exponential backoff on retry.
                 jitter = random.random()  # noqa: S311
                 backoff = jitter * min(_BACKOFF_INITIAL * (1.25**retry), _BACKOFF_MAX)
+                if _would_exceed_time_limit(start_time, backoff):
+                    raise last_error
                 time.sleep(backoff)
             retry += 1
             self.start_transaction(read_concern, write_concern, read_preference, max_commit_time_ms)
             try:
                 ret = callback(self)
             # Catch KeyboardInterrupt, CancelledError, etc. and cleanup.
             except BaseException as exc:
+                last_error = exc
                 if self.in_transaction:
                     self.abort_transaction()
                 if (
diff --git a/test/asynchronous/test_transactions.py b/test/asynchronous/test_transactions.py
@@ -16,6 +16,7 @@
 from __future__ import annotations
 
 import asyncio
+import random
 import sys
 import time
 from io import BytesIO
@@ -45,6 +46,7 @@
 )
 from pymongo.asynchronous.command_cursor import AsyncCommandCursor
 from pymongo.asynchronous.cursor import AsyncCursor
+from pymongo.asynchronous.helpers import anext
 from pymongo.errors import (
     AutoReconnect,
     CollectionInvalid,
@@ -618,13 +620,51 @@ async def callback(session):
             await s.with_transaction(callback)
             self.assertFalse(s.in_transaction)
 
+    @async_client_context.require_test_commands
+    @async_client_context.require_transactions
+    async def test_transaction_backoff_is_random(self):
+        client = async_client_context.client
+        coll = client[self.db.name].test
+        # set fail point to trigger transaction failure and trigger backoff
+        await self.set_fail_point(
+            {
+                "configureFailPoint": "failCommand",
+                "mode": {
+                    "times": 30
+                },  # sufficiently high enough such that the time effect of backoff is noticeable
+                "data": {
+                    "failCommands": ["commitTransaction"],
+                    "errorCode": 24,
+                },
+            }
+        )
+        self.addAsyncCleanup(
+            self.set_fail_point, {"configureFailPoint": "failCommand", "mode": "off"}
+        )
+
+        start = time.monotonic()
+
+        async def callback(session):
+            await coll.insert_one({}, session=session)
+
+        async with self.client.start_session() as s:
+            await s.with_transaction(callback)
+
+        end = time.monotonic()
+        self.assertLess(end - start, 5)  # backoff alone is ~3.5 seconds
+
     @async_client_context.require_test_commands
     @async_client_context.require_transactions
     async def test_transaction_backoff(self):
         client = async_client_context.client
         coll = client[self.db.name].test
-        # optionally set _backoff_initial to a higher value
-        _set_backoff_initial(client_session._BACKOFF_MAX)
+        # patch random to make it deterministic
+        _original_random_random = random.random
+
+        def always_one():
+            return 1
+
+        random.random = always_one
         # set fail point to trigger transaction failure and trigger backoff
         await self.set_fail_point(
             {
@@ -651,7 +691,11 @@ async def callback(session):
             await s.with_transaction(callback)
 
         end = time.monotonic()
-        self.assertGreaterEqual(end - start, 1.25)  # 1 second
+        self.assertGreaterEqual(
+            end - start, 3.5629515313825695
+        )  # sum of backoffs is 3.5629515313825695
+
+        random.random = _original_random_random
 
 
 class TestOptionsInsideTransactionProse(AsyncTransactionsBase):
diff --git a/test/test_transactions.py b/test/test_transactions.py
@@ -16,6 +16,7 @@
 from __future__ import annotations
 
 import asyncio
+import random
 import sys
 import time
 from io import BytesIO
@@ -56,6 +57,7 @@
 )
 from pymongo.synchronous.command_cursor import CommandCursor
 from pymongo.synchronous.cursor import Cursor
+from pymongo.synchronous.helpers import next
 
 _IS_SYNC = True
 
@@ -606,13 +608,49 @@ def callback(session):
             s.with_transaction(callback)
             self.assertFalse(s.in_transaction)
 
+    @client_context.require_test_commands
+    @client_context.require_transactions
+    def test_transaction_backoff_is_random(self):
+        client = client_context.client
+        coll = client[self.db.name].test
+        # set fail point to trigger transaction failure and trigger backoff
+        self.set_fail_point(
+            {
+                "configureFailPoint": "failCommand",
+                "mode": {
+                    "times": 30
+                },  # sufficiently high enough such that the time effect of backoff is noticeable
+                "data": {
+                    "failCommands": ["commitTransaction"],
+                    "errorCode": 24,
+                },
+            }
+        )
+        self.addCleanup(self.set_fail_point, {"configureFailPoint": "failCommand", "mode": "off"})
+
+        start = time.monotonic()
+
+        def callback(session):
+            coll.insert_one({}, session=session)
+
+        with self.client.start_session() as s:
+            s.with_transaction(callback)
+
+        end = time.monotonic()
+        self.assertLess(end - start, 5)  # backoff alone is ~3.5 seconds
+
     @client_context.require_test_commands
     @client_context.require_transactions
     def test_transaction_backoff(self):
         client = client_context.client
         coll = client[self.db.name].test
-        # optionally set _backoff_initial to a higher value
-        _set_backoff_initial(client_session._BACKOFF_MAX)
+        # patch random to make it deterministic
+        _original_random_random = random.random
+
+        def always_one():
+            return 1
+
+        random.random = always_one
         # set fail point to trigger transaction failure and trigger backoff
         self.set_fail_point(
             {
@@ -637,7 +675,11 @@ def callback(session):
             s.with_transaction(callback)
 
         end = time.monotonic()
-        self.assertGreaterEqual(end - start, 1.25)  # 1 second
+        self.assertGreaterEqual(
+            end - start, 3.5629515313825695
+        )  # sum of backoffs is 3.5629515313825695
+
+        random.random = _original_random_random
 
 
 class TestOptionsInsideTransactionProse(TransactionsBase):
