Expand wait-helper bytes-like rate-limit fetch coverage

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

hyperbrowser/client/polling.py

@@ -174,25 +174,27 @@ def _is_executor_shutdown_runtime_error(exc: Exception) -> bool:
     )
 
 
+def _decode_ascii_bytes_like(value: object) -> Optional[str]:
+    try:
+        return memoryview(value).tobytes().decode("ascii")
+    except (TypeError, ValueError, UnicodeDecodeError):
+        return None
+
+
 def _normalize_status_code_for_retry(status_code: object) -> Optional[int]:
     if isinstance(status_code, bool):
         return None
     if isinstance(status_code, int):
         return status_code
     status_text: Optional[str] = None
     if isinstance(status_code, memoryview):
-        status_bytes = status_code.tobytes()
-        try:
-            status_text = status_bytes.decode("ascii")
-        except UnicodeDecodeError:
-            return None
+        status_text = _decode_ascii_bytes_like(status_code)
     elif isinstance(status_code, (bytes, bytearray)):
-        try:
-            status_text = bytes(status_code).decode("ascii")
-        except UnicodeDecodeError:
-            return None
+        status_text = _decode_ascii_bytes_like(status_code)
     elif isinstance(status_code, str):
         status_text = status_code
+    else:
+        status_text = _decode_ascii_bytes_like(status_code)
 
     if status_text is not None:
         normalized_status = status_text.strip()

tests/test_polling.py

@@ -1,4 +1,5 @@
 import asyncio
+from array import array
 from concurrent.futures import BrokenExecutor as ConcurrentBrokenExecutor
 from concurrent.futures import CancelledError as ConcurrentCancelledError
 from concurrent.futures import InvalidStateError as ConcurrentInvalidStateError
@@ -168,6 +169,29 @@ def get_status() -> str:
     assert attempts["count"] == 1
 
 
+def test_poll_until_terminal_status_does_not_retry_bytes_like_client_errors():
+    attempts = {"count": 0}
+
+    def get_status() -> str:
+        attempts["count"] += 1
+        raise HyperbrowserError(
+            "client failure",
+            status_code=array("B", [52, 48, 48]),  # type: ignore[arg-type]
+        )
+
+    with pytest.raises(HyperbrowserError, match="client failure"):
+        poll_until_terminal_status(
+            operation_name="sync poll bytes-like client error",
+            get_status=get_status,
+            is_terminal_status=lambda value: value == "completed",
+            poll_interval_seconds=0.0001,
+            max_wait_seconds=1.0,
+            max_status_failures=5,
+        )
+
+    assert attempts["count"] == 1
+
+
 def test_poll_until_terminal_status_retries_overlong_numeric_status_codes():
     attempts = {"count": 0}
 
@@ -778,6 +802,29 @@ def operation() -> str:
     assert attempts["count"] == 3
 
 
+def test_retry_operation_retries_bytes_like_rate_limit_errors():
+    attempts = {"count": 0}
+
+    def operation() -> str:
+        attempts["count"] += 1
+        if attempts["count"] < 3:
+            raise HyperbrowserError(
+                "rate limited",
+                status_code=array("B", [52, 50, 57]),  # type: ignore[arg-type]
+            )
+        return "ok"
+
+    result = retry_operation(
+        operation_name="sync retry bytes-like rate limit",
+        operation=operation,
+        max_attempts=5,
+        retry_delay_seconds=0.0001,
+    )
+
+    assert result == "ok"
+    assert attempts["count"] == 3
+
+
 def test_retry_operation_does_not_retry_numeric_bytes_client_errors():
     attempts = {"count": 0}
 
@@ -1261,6 +1308,32 @@ async def get_status() -> str:
     asyncio.run(run())
 
 
+def test_poll_until_terminal_status_async_does_not_retry_bytes_like_client_errors():
+    async def run() -> None:
+        attempts = {"count": 0}
+
+        async def get_status() -> str:
+            attempts["count"] += 1
+            raise HyperbrowserError(
+                "client failure",
+                status_code=array("B", [52, 48, 52]),  # type: ignore[arg-type]
+            )
+
+        with pytest.raises(HyperbrowserError, match="client failure"):
+            await poll_until_terminal_status_async(
+                operation_name="async poll bytes-like client error",
+                get_status=get_status,
+                is_terminal_status=lambda value: value == "completed",
+                poll_interval_seconds=0.0001,
+                max_wait_seconds=1.0,
+                max_status_failures=5,
+            )
+
+        assert attempts["count"] == 1
+
+    asyncio.run(run())
+
+
 def test_poll_until_terminal_status_async_retries_overlong_numeric_status_codes():
     async def run() -> None:
         attempts = {"count": 0}
@@ -1568,6 +1641,32 @@ async def operation() -> str:
     asyncio.run(run())
 
 
+def test_retry_operation_async_retries_bytes_like_rate_limit_errors():
+    async def run() -> None:
+        attempts = {"count": 0}
+
+        async def operation() -> str:
+            attempts["count"] += 1
+            if attempts["count"] < 3:
+                raise HyperbrowserError(
+                    "rate limited",
+                    status_code=array("B", [52, 50, 57]),  # type: ignore[arg-type]
+                )
+            return "ok"
+
+        result = await retry_operation_async(
+            operation_name="async retry bytes-like rate limit",
+            operation=operation,
+            max_attempts=5,
+            retry_delay_seconds=0.0001,
+        )
+
+        assert result == "ok"
+        assert attempts["count"] == 3
+
+    asyncio.run(run())
+
+
 def test_retry_operation_async_retries_numeric_bytes_rate_limit_errors():
     async def run() -> None:
         attempts = {"count": 0}
@@ -4198,6 +4297,34 @@ def fetch_result() -> dict:
     assert fetch_attempts["count"] == 3
 
 
+def test_wait_for_job_result_retries_bytes_like_rate_limit_fetch_errors():
+    fetch_attempts = {"count": 0}
+
+    def fetch_result() -> dict:
+        fetch_attempts["count"] += 1
+        if fetch_attempts["count"] < 3:
+            raise HyperbrowserError(
+                "rate limited",
+                status_code=array("B", [52, 50, 57]),  # type: ignore[arg-type]
+            )
+        return {"ok": True}
+
+    result = wait_for_job_result(
+        operation_name="sync wait helper fetch bytes-like rate limit",
+        get_status=lambda: "completed",
+        is_terminal_status=lambda value: value == "completed",
+        fetch_result=fetch_result,
+        poll_interval_seconds=0.0001,
+        max_wait_seconds=1.0,
+        max_status_failures=5,
+        fetch_max_attempts=5,
+        fetch_retry_delay_seconds=0.0001,
+    )
+
+    assert result == {"ok": True}
+    assert fetch_attempts["count"] == 3
+
+
 def test_wait_for_job_result_retries_request_timeout_fetch_errors():
     fetch_attempts = {"count": 0}
 
@@ -5037,6 +5164,37 @@ async def fetch_result() -> dict:
     asyncio.run(run())
 
 
+def test_wait_for_job_result_async_retries_bytes_like_rate_limit_fetch_errors():
+    async def run() -> None:
+        fetch_attempts = {"count": 0}
+
+        async def fetch_result() -> dict:
+            fetch_attempts["count"] += 1
+            if fetch_attempts["count"] < 3:
+                raise HyperbrowserError(
+                    "rate limited",
+                    status_code=array("B", [52, 50, 57]),  # type: ignore[arg-type]
+                )
+            return {"ok": True}
+
+        result = await wait_for_job_result_async(
+            operation_name="async wait helper fetch bytes-like rate limit",
+            get_status=lambda: asyncio.sleep(0, result="completed"),
+            is_terminal_status=lambda value: value == "completed",
+            fetch_result=fetch_result,
+            poll_interval_seconds=0.0001,
+            max_wait_seconds=1.0,
+            max_status_failures=5,
+            fetch_max_attempts=5,
+            fetch_retry_delay_seconds=0.0001,
+        )
+
+        assert result == {"ok": True}
+        assert fetch_attempts["count"] == 3
+
+    asyncio.run(run())
+
+
 def test_wait_for_job_result_async_retries_request_timeout_fetch_errors():
     async def run() -> None:
         fetch_attempts = {"count": 0}