test(retry): make timing tests deterministic under load

why: The five wall-clock assertions (`0.9 <= elapsed <= 1.1`) flaked under load
when run with --reruns 0 — nominal elapsed (~1.0s) sat ~100ms under the ceiling.
The two "succeeds after 3 calls" tests also raced their 1s budget: under load
only two of three calls fit, spuriously timing out.
what:
- Success cases: assert on behavior (call count + result) with a generous budget
  so all calls fit regardless of load; drop the wall-clock assertion
- Timeout cases: keep the raises/returns assertion and the deterministic lower
  bound (retry_until only times out once elapsed >= budget); drop the fragile
  upper bound

Author: tony

tests/test/test_retry.py

@@ -11,95 +11,98 @@
 
 
 def test_retry_three_times() -> None:
-    """Test retry_until()."""
-    ini = time()
+    """retry_until retries until the callable succeeds."""
+    calls = 0
     value = 0
 
     def call_me_three_times() -> bool:
-        nonlocal value
-        sleep(0.3)  # Sleep for 0.3 seconds to simulate work
+        nonlocal value, calls
+        calls += 1
+        sleep(0.3)  # simulate work
 
         if value == 2:
             return True
 
         value += 1
         return False
 
-    retry_until(call_me_three_times, 1)
-
-    end = time()
-
-    assert 0.9 <= (end - ini) <= 1.1  # Allow for small timing variations
+    # Generous budget so all three calls fit even under load; assert on behavior
+    # (call count + success), not wall-clock, to stay deterministic.
+    assert retry_until(call_me_three_times, 5) is True
+    assert calls == 3
 
 
 def test_function_times_out() -> None:
-    """Test time outs with retry_until()."""
+    """retry_until raises WaitTimeout after exhausting its budget."""
     ini = time()
+    calls = 0
 
     def never_true() -> bool:
-        sleep(
-            0.1,
-        )  # Sleep for 0.1 seconds to simulate work (called ~10 times in 1 second)
+        nonlocal calls
+        calls += 1
+        sleep(0.1)  # simulate work
         return False
 
     with pytest.raises(exc.WaitTimeout):
         retry_until(never_true, 1)
 
-    end = time()
-
-    assert 0.9 <= (end - ini) <= 1.1  # Allow for small timing variations
+    # It retried for the full budget before timing out. The lower bound is
+    # deterministic (retry_until only times out once elapsed >= the budget);
+    # no fragile upper bound that load can blow past.
+    assert (time() - ini) >= 0.9
+    assert calls > 1
 
 
 def test_function_times_out_no_raise() -> None:
-    """Tests retry_until() with exception raising disabled."""
+    """retry_until returns instead of raising when raises=False."""
     ini = time()
+    calls = 0
 
     def never_true() -> bool:
-        sleep(
-            0.1,
-        )  # Sleep for 0.1 seconds to simulate work (called ~10 times in 1 second)
+        nonlocal calls
+        calls += 1
+        sleep(0.1)  # simulate work
         return False
 
     retry_until(never_true, 1, raises=False)
 
-    end = time()
-    assert 0.9 <= (end - ini) <= 1.1  # Allow for small timing variations
+    assert (time() - ini) >= 0.9
+    assert calls > 1
 
 
 def test_function_times_out_no_raise_assert() -> None:
-    """Tests retry_until() with exception raising disabled, returning False."""
+    """retry_until returns False on timeout when raises=False."""
     ini = time()
+    calls = 0
 
     def never_true() -> bool:
-        sleep(
-            0.1,
-        )  # Sleep for 0.1 seconds to simulate work (called ~10 times in 1 second)
+        nonlocal calls
+        calls += 1
+        sleep(0.1)  # simulate work
         return False
 
     assert not retry_until(never_true, 1, raises=False)
 
-    end = time()
-    assert 0.9 <= (end - ini) <= 1.1  # Allow for small timing variations
+    assert (time() - ini) >= 0.9
+    assert calls > 1
 
 
 def test_retry_three_times_no_raise_assert() -> None:
-    """Tests retry_until() with exception raising disabled, with closure variable."""
-    ini = time()
+    """retry_until returns True on success even with raises=False."""
+    calls = 0
     value = 0
 
     def call_me_three_times() -> bool:
-        nonlocal value
-        sleep(
-            0.3,
-        )  # Sleep for 0.3 seconds to simulate work (called 3 times in ~0.9 seconds)
+        nonlocal value, calls
+        calls += 1
+        sleep(0.3)  # simulate work
 
         if value == 2:
             return True
 
         value += 1
         return False
 
-    assert retry_until(call_me_three_times, 1, raises=False)
-
-    end = time()
-    assert 0.9 <= (end - ini) <= 1.1  # Allow for small timing variations
+    # Behavior-based, generous budget: deterministic even under load.
+    assert retry_until(call_me_three_times, 5, raises=False) is True
+    assert calls == 3