add test

Author: sleepyStick

pymongo/asynchronous/client_session.py

@@ -518,6 +518,7 @@ 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.
@@ -705,10 +706,12 @@ 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

@@ -516,6 +516,7 @@ 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.
@@ -703,10 +704,12 @@ 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

@@ -16,6 +16,7 @@
 from __future__ import annotations
 
 import sys
+import time
 from io import BytesIO
 from test.asynchronous.utils_spec_runner import AsyncSpecRunner
 
@@ -36,7 +37,11 @@
 from bson.raw_bson import RawBSONDocument
 from pymongo import WriteConcern, _csot
 from pymongo.asynchronous import client_session
-from pymongo.asynchronous.client_session import TransactionOptions
+from pymongo.asynchronous.client_session import (
+    _BACKOFF_MAX,
+    TransactionOptions,
+    _set_backoff_initial,
+)
 from pymongo.asynchronous.command_cursor import AsyncCommandCursor
 from pymongo.asynchronous.cursor import AsyncCursor
 from pymongo.asynchronous.helpers import anext
@@ -602,6 +607,42 @@ 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(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": 3},
+                "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)
+
+        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)
+
 
 class TestOptionsInsideTransactionProse(AsyncTransactionsBase):
     @async_client_context.require_transactions

test/test_transactions.py

@@ -16,6 +16,7 @@
 from __future__ import annotations
 
 import sys
+import time
 from io import BytesIO
 from test.utils_spec_runner import SpecRunner
 
@@ -47,7 +48,11 @@
 from pymongo.read_concern import ReadConcern
 from pymongo.read_preferences import ReadPreference
 from pymongo.synchronous import client_session
-from pymongo.synchronous.client_session import TransactionOptions
+from pymongo.synchronous.client_session import (
+    _BACKOFF_MAX,
+    TransactionOptions,
+    _set_backoff_initial,
+)
 from pymongo.synchronous.command_cursor import CommandCursor
 from pymongo.synchronous.cursor import Cursor
 from pymongo.synchronous.helpers import next
@@ -590,6 +595,40 @@ 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(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": 3},
+                "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)
+
+        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)
+
 
 class TestOptionsInsideTransactionProse(TransactionsBase):
     @client_context.require_transactions