change test

Author: sleepyStick

pymongo/asynchronous/client_session.py

@@ -477,6 +477,11 @@ def _max_time_expired_error(exc: PyMongoError) -> bool:
 _BACKOFF_INITIAL = 0.001  # 1ms initial backoff
 
 
+def _set_backoff_initial(seconds: float) -> None:
+    global _BACKOFF_INITIAL  # noqa: PLW0603
+    _BACKOFF_INITIAL = seconds
+
+
 def _within_time_limit(start_time: float) -> bool:
     """Are we within the with_transaction retry limit?"""
     return time.monotonic() - start_time < _WITH_TRANSACTION_RETRY_TIME_LIMIT
@@ -518,7 +523,6 @@ def __init__(
         # Is this an implicitly created session?
         self._implicit = implicit
         self._transaction = _Transaction(None, client)
-        self._transaction_retry_backoffs: list[float] = []
 
     async def end_session(self) -> None:
         """Finish this session. If a transaction has started, abort it.
@@ -706,12 +710,10 @@ async def callback(session, custom_arg, custom_kwarg=None):
         """
         start_time = time.monotonic()
         retry = 0
-        self._transaction_retry_backoffs = []
         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)
                 await asyncio.sleep(backoff)
             retry += 1
             await self.start_transaction(

pymongo/synchronous/client_session.py

@@ -475,6 +475,11 @@ def _max_time_expired_error(exc: PyMongoError) -> bool:
 _BACKOFF_INITIAL = 0.001  # 1ms initial backoff
 
 
+def _set_backoff_initial(seconds: float) -> None:
+    global _BACKOFF_INITIAL  # noqa: PLW0603
+    _BACKOFF_INITIAL = seconds
+
+
 def _within_time_limit(start_time: float) -> bool:
     """Are we within the with_transaction retry limit?"""
     return time.monotonic() - start_time < _WITH_TRANSACTION_RETRY_TIME_LIMIT
@@ -516,7 +521,6 @@ def __init__(
         # Is this an implicitly created session?
         self._implicit = implicit
         self._transaction = _Transaction(None, client)
-        self._transaction_retry_backoffs: list[float] = []
 
     def end_session(self) -> None:
         """Finish this session. If a transaction has started, abort it.
@@ -704,12 +708,10 @@ def callback(session, custom_arg, custom_kwarg=None):
         """
         start_time = time.monotonic()
         retry = 0
-        self._transaction_retry_backoffs = []
         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)
                 time.sleep(backoff)
             retry += 1
             self.start_transaction(read_concern, write_concern, read_preference, max_commit_time_ms)

test/asynchronous/test_transactions.py

@@ -612,11 +612,15 @@ async def callback(session):
     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)
         # set fail point to trigger transaction failure and trigger backoff
         await self.set_fail_point(
             {
                 "configureFailPoint": "failCommand",
-                "mode": {"times": 3},
+                "mode": {
+                    "times": 30
+                },  # sufficiently high enough such that the time effect of backoff is noticeable
                 "data": {
                     "failCommands": ["commitTransaction"],
                     "errorCode": 24,
@@ -632,16 +636,11 @@ async def test_transaction_backoff(self):
         async def callback(session):
             await coll.insert_one({}, session=session)
 
-        total_backoff = 0
         async with self.client.start_session() as s:
             await s.with_transaction(callback)
-            self.assertEqual(len(s._transaction_retry_backoffs), 3)
-            for backoff in s._transaction_retry_backoffs:
-                self.assertGreater(backoff, 0)
-                total_backoff += backoff
 
         end = time.monotonic()
-        self.assertGreaterEqual(end - start, total_backoff)
+        self.assertGreaterEqual(end - start, 1.25)  # 1 second
 
 
 class TestOptionsInsideTransactionProse(AsyncTransactionsBase):

test/test_transactions.py

@@ -600,11 +600,15 @@ def callback(session):
     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)
         # set fail point to trigger transaction failure and trigger backoff
         self.set_fail_point(
             {
                 "configureFailPoint": "failCommand",
-                "mode": {"times": 3},
+                "mode": {
+                    "times": 30
+                },  # sufficiently high enough such that the time effect of backoff is noticeable
                 "data": {
                     "failCommands": ["commitTransaction"],
                     "errorCode": 24,
@@ -618,16 +622,11 @@ def test_transaction_backoff(self):
         def callback(session):
             coll.insert_one({}, session=session)
 
-        total_backoff = 0
         with self.client.start_session() as s:
             s.with_transaction(callback)
-            self.assertEqual(len(s._transaction_retry_backoffs), 3)
-            for backoff in s._transaction_retry_backoffs:
-                self.assertGreater(backoff, 0)
-                total_backoff += backoff
 
         end = time.monotonic()
-        self.assertGreaterEqual(end - start, total_backoff)
+        self.assertGreaterEqual(end - start, 1.25)  # 1 second
 
 
 class TestOptionsInsideTransactionProse(TransactionsBase):