test: deflake the persistent 429 stall test with a stopped throttler clock (#2331)

`test_persistent_429_raises_after_stall[retry_on_blocked]` failed on
ubuntu / Python 3.10
([run](https://github.com/apify/crawlee-python/actions/runs/38694178175/job/116286777865))
with `DID NOT RAISE PersistentRateLimitError`. The other 17 legs of the
same run passed.

The test put the domain into a 50 to 100 ms backoff and let real time
pass through a 1.2 s `max_domain_stall`. The crawler defers a 429 only
if `is_throttled()` still holds when it handles the error, and on a
loaded runner the backoff ran out first. With `max_request_retries=0`
the request then took the ordinary-error path, got marked as handled,
and the run ended without an error. A 120 ms delay injected into that
check reproduces the failure on every run.

The throttler now runs on a stopped `Mock` clock with a 1-minute
backoff, as in #2275. The clock moves one backoff forward each time the
idle crawler asks for a stall reason, and `max_domain_stall` sits
between one and two backoffs, so the domain stalls on the check after
its second 429. The assertions are unchanged, and the test still fails
when `_is_held_back` is forced to `False`. It also finishes in well
under a second.

The stall tests in the basic crawler suite keep the 50 ms backoff. They
run with the default three retries, so a lost race there only spends one
of the retries.

*✍️ Drafted by Claude Code*

Author: vdusek

tests/unit/crawlers/_http/test_http_crawler.py

@@ -2,7 +2,7 @@
 
 import json
 import logging
-from datetime import timedelta
+from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING, Any
 from unittest.mock import AsyncMock, Mock
 from urllib.parse import parse_qs, urlencode
@@ -13,7 +13,7 @@
 from crawlee.crawlers import HttpCrawler
 from crawlee.errors import PersistentRateLimitError
 from crawlee.http_clients import HttpClient, HttpCrawlingResult
-from crawlee.request_loaders import ThrottlingRequestManager
+from crawlee.request_loaders import ThrottlingRequestManager, _throttling_request_manager
 from crawlee.sessions import SessionPool
 from crawlee.statistics import Statistics
 from crawlee.storages import RequestQueue
@@ -750,18 +750,33 @@ async def handler(context: HttpCrawlingContext) -> None:
 async def test_persistent_429_raises_after_stall(
     server_url: URL,
     caplog: pytest.LogCaptureFixture,
+    monkeypatch: pytest.MonkeyPatch,
     *,
     retry_on_blocked: bool,
 ) -> None:
     """A domain that rate-limits every request for longer than `max_domain_stall` ends the run with an error."""
+    # The throttler runs on a stopped clock that moves one backoff forward on each stall check. The crawler checks for
+    # a stall only while idle, so a backoff can't run out before the crawler decides to defer a 429. The stall window
+    # sits between one and two backoffs, so the domain counts as stalled on the check after its second 429.
+    backoff = timedelta(minutes=1)
+    clock = Mock()
+    clock.now.return_value = datetime.now(timezone.utc)
+    monkeypatch.setattr(_throttling_request_manager, 'datetime', clock)
     throttler = ThrottlingRequestManager(
         await RequestQueue.open(alias='throttle-429-inner'),
         domains=[server_url.host or ''],
         request_manager_opener=RequestQueue.open,
-        base_delay=timedelta(milliseconds=50),
-        max_delay=timedelta(milliseconds=100),
-        max_domain_stall=timedelta(milliseconds=1200),
+        base_delay=backoff,
+        max_delay=backoff,
+        max_domain_stall=backoff * 1.5,
     )
+    get_stall_reason = throttler.get_stall_reason
+
+    async def get_stall_reason_after_backoff() -> str | None:
+        clock.now.return_value += backoff
+        return await get_stall_reason()
+
+    monkeypatch.setattr(throttler, 'get_stall_reason', get_stall_reason_after_backoff)
     failed_request_handler = AsyncMock()
     crawler = HttpCrawler(
         request_handler=AsyncMock(),