Don't special-case negative max_tries

Signed-off-by: Hauke Daempfling <haukex@zero-g.net>

Author: haukex

tests/test_asyncio/test_pipeline.py

@@ -343,16 +343,33 @@ async def my_transaction(pipe):
             pipe.multi()
             await r.set("a", a_value + 1)  # force WatchError
 
+        # without max_tries (infinite loop)
         with pytest.raises(RuntimeError) as ex:
             await r.transaction(my_transaction, "a")
         assert str(ex.value).startswith("Run too many times")
         assert run_count == 11
+
         run_count = 0
+        # with max_tries
         with pytest.raises(valkey.ValkeyError) as ex:
             await r.transaction(my_transaction, "a", max_tries=3)
         assert str(ex.value).startswith("Bailing out of transaction after 3 tries")
         assert run_count == 3
 
+        run_count = 0
+        # with max_tries=0 (same as without; infinite loop)
+        with pytest.raises(RuntimeError) as ex:
+            await r.transaction(my_transaction, "a", max_tries=0)
+        assert str(ex.value).startswith("Run too many times")
+        assert run_count == 11
+
+        run_count = 0
+        # with negative max_tries (immediate error)
+        with pytest.raises(valkey.ValkeyError) as ex:
+            await r.transaction(my_transaction, "a", max_tries=-3)
+        assert str(ex.value).startswith("Bailing out of transaction after 0 tries")
+        assert run_count == 0
+
     @pytest.mark.onlynoncluster
     async def test_transaction_callable_returns_value_from_callable(self, r):
         async def callback(pipe):

tests/test_pipeline.py

@@ -344,16 +344,33 @@ def my_transaction(pipe):
             pipe.multi()
             r.set("a", a_value + 1)  # force WatchError
 
+        # without max_tries (infinite loop)
         with pytest.raises(RuntimeError) as ex:
             r.transaction(my_transaction, "a")
         assert str(ex.value).startswith("Run too many times")
         assert run_count == 11
+
         run_count = 0
+        # with max_tries
         with pytest.raises(valkey.ValkeyError) as ex:
             r.transaction(my_transaction, "a", max_tries=3)
         assert str(ex.value).startswith("Bailing out of transaction after 3 tries")
         assert run_count == 3
 
+        run_count = 0
+        # with max_tries=0 (same as without; infinite loop)
+        with pytest.raises(RuntimeError) as ex:
+            r.transaction(my_transaction, "a", max_tries=0)
+        assert str(ex.value).startswith("Run too many times")
+        assert run_count == 11
+
+        run_count = 0
+        # with negative max_tries (immediate error)
+        with pytest.raises(valkey.ValkeyError) as ex:
+            r.transaction(my_transaction, "a", max_tries=-3)
+        assert str(ex.value).startswith("Bailing out of transaction after 0 tries")
+        assert run_count == 0
+
     @pytest.mark.onlynoncluster
     def test_transaction_callable_returns_value_from_callable(self, r):
         def callback(pipe):

valkey/asyncio/client.py

@@ -448,14 +448,14 @@ async def transaction(
             `WatchError` before the transaction is retried. Default is no delay.
         :param max_tries: Lets you specify the maximum number of times the
             transaction is retried. If the limit is reached, a `ValkeyError`
-            is raised. Default is an **infinite** number of retries!
+            is raised. Default is 0, meaning an **infinite** number of retries!
         """
         pipe: Pipeline
         async with self.pipeline(True, shard_hint) as pipe:
             tries = 0
             while True:
                 tries += 1
-                if max_tries and max_tries > 0 and tries > max_tries:
+                if max_tries and tries > max_tries:
                     raise ValkeyError(
                         f"Bailing out of transaction after {tries - 1} tries"
                     )

valkey/client.py

@@ -410,8 +410,8 @@ def transaction(
             is retried. Default is no delay.
         :param max_tries: This keyword-only argument lets you specify the
             maximum number to times the transaction should be retried. If the
-            limit is reached, a `ValkeyError` is raised. Default is an
-            **infinite** number of retries!
+            limit is reached, a `ValkeyError` is raised. Default is 0, meaning
+            an **infinite** number of retries!
         """
         shard_hint = kwargs.pop("shard_hint", None)
         value_from_callable = kwargs.pop("value_from_callable", False)
@@ -421,7 +421,7 @@ def transaction(
             tries = 0
             while True:
                 tries += 1
-                if max_tries and max_tries > 0 and tries > max_tries:
+                if max_tries and tries > max_tries:
                     raise ValkeyError(
                         f"Bailing out of transaction after {tries - 1} tries"
                     )