Normalize transport status code handling across response paths

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

Author: cursoragent

hyperbrowser/transport/async_transport.py

@@ -37,6 +37,20 @@ def __init__(self, api_key: str, headers: Optional[Mapping[str, str]] = None):
         self.client = httpx.AsyncClient(headers=merged_headers)
         self._closed = False
 
+    def _normalize_response_status_code(self, response: httpx.Response) -> int:
+        try:
+            status_code = response.status_code
+            if isinstance(status_code, bool):
+                raise TypeError("boolean status code is invalid")
+            return int(status_code)
+        except HyperbrowserError:
+            raise
+        except Exception as exc:
+            raise HyperbrowserError(
+                "Failed to process response status code",
+                original_error=exc,
+            ) from exc
+
     async def close(self) -> None:
         if not self._closed:
             await self.client.aclose()
@@ -51,21 +65,12 @@ async def __aexit__(self, exc_type, exc_val, exc_tb):
     async def _handle_response(self, response: httpx.Response) -> APIResponse:
         try:
             response.raise_for_status()
+            normalized_status_code = self._normalize_response_status_code(response)
             try:
                 if not response.content:
-                    return APIResponse.from_status(response.status_code)
+                    return APIResponse.from_status(normalized_status_code)
                 return APIResponse(response.json())
             except Exception as e:
-                try:
-                    status_code = response.status_code
-                    if isinstance(status_code, bool):
-                        raise TypeError("boolean status code is invalid")
-                    normalized_status_code = int(status_code)
-                except Exception as status_exc:
-                    raise HyperbrowserError(
-                        "Failed to process response status code",
-                        original_error=status_exc,
-                    ) from status_exc
                 if normalized_status_code >= 400:
                     try:
                         response_text = response.text
@@ -80,9 +85,10 @@ async def _handle_response(self, response: httpx.Response) -> APIResponse:
                 return APIResponse.from_status(normalized_status_code)
         except httpx.HTTPStatusError as e:
             message = extract_error_message(response, fallback_error=e)
+            normalized_status_code = self._normalize_response_status_code(response)
             raise HyperbrowserError(
                 message,
-                status_code=response.status_code,
+                status_code=normalized_status_code,
                 response=response,
                 original_error=e,
             )

hyperbrowser/transport/sync.py

@@ -36,24 +36,29 @@ def __init__(self, api_key: str, headers: Optional[Mapping[str, str]] = None):
         )
         self.client = httpx.Client(headers=merged_headers)
 
+    def _normalize_response_status_code(self, response: httpx.Response) -> int:
+        try:
+            status_code = response.status_code
+            if isinstance(status_code, bool):
+                raise TypeError("boolean status code is invalid")
+            return int(status_code)
+        except HyperbrowserError:
+            raise
+        except Exception as exc:
+            raise HyperbrowserError(
+                "Failed to process response status code",
+                original_error=exc,
+            ) from exc
+
     def _handle_response(self, response: httpx.Response) -> APIResponse:
         try:
             response.raise_for_status()
+            normalized_status_code = self._normalize_response_status_code(response)
             try:
                 if not response.content:
-                    return APIResponse.from_status(response.status_code)
+                    return APIResponse.from_status(normalized_status_code)
                 return APIResponse(response.json())
             except Exception as e:
-                try:
-                    status_code = response.status_code
-                    if isinstance(status_code, bool):
-                        raise TypeError("boolean status code is invalid")
-                    normalized_status_code = int(status_code)
-                except Exception as status_exc:
-                    raise HyperbrowserError(
-                        "Failed to process response status code",
-                        original_error=status_exc,
-                    ) from status_exc
                 if normalized_status_code >= 400:
                     try:
                         response_text = response.text
@@ -68,9 +73,10 @@ def _handle_response(self, response: httpx.Response) -> APIResponse:
                 return APIResponse.from_status(normalized_status_code)
         except httpx.HTTPStatusError as e:
             message = extract_error_message(response, fallback_error=e)
+            normalized_status_code = self._normalize_response_status_code(response)
             raise HyperbrowserError(
                 message,
-                status_code=response.status_code,
+                status_code=normalized_status_code,
                 response=response,
                 original_error=e,
             )

tests/test_transport_response_handling.py

@@ -66,6 +66,34 @@ def json(self):
         raise RuntimeError("broken json")
 
 
+class _BooleanStatusNoContentResponse:
+    status_code = True
+    content = b""
+    text = ""
+
+    def raise_for_status(self) -> None:
+        return None
+
+    def json(self):
+        return {}
+
+
+class _BrokenStatusCodeHttpErrorResponse:
+    content = b""
+    text = "status error"
+
+    def raise_for_status(self) -> None:
+        request = httpx.Request("GET", "https://example.com/status-error")
+        raise httpx.HTTPStatusError("status failure", request=request, response=self)
+
+    @property
+    def status_code(self) -> int:
+        raise RuntimeError("broken status code")
+
+    def json(self):
+        return {"message": "status failure"}
+
+
 def test_sync_handle_response_with_non_json_success_body_returns_status_only():
     transport = SyncTransport(api_key="test-key")
     try:
@@ -117,6 +145,32 @@ def test_sync_handle_response_with_broken_status_code_raises_hyperbrowser_error(
         transport.close()
 
 
+def test_sync_handle_response_with_boolean_status_no_content_raises_hyperbrowser_error():
+    transport = SyncTransport(api_key="test-key")
+    try:
+        with pytest.raises(
+            HyperbrowserError, match="Failed to process response status code"
+        ):
+            transport._handle_response(
+                _BooleanStatusNoContentResponse()  # type: ignore[arg-type]
+            )
+    finally:
+        transport.close()
+
+
+def test_sync_handle_response_with_http_status_error_and_broken_status_code():
+    transport = SyncTransport(api_key="test-key")
+    try:
+        with pytest.raises(
+            HyperbrowserError, match="Failed to process response status code"
+        ):
+            transport._handle_response(
+                _BrokenStatusCodeHttpErrorResponse()  # type: ignore[arg-type]
+            )
+    finally:
+        transport.close()
+
+
 def test_sync_handle_response_with_request_error_includes_method_and_url():
     transport = SyncTransport(api_key="test-key")
     try:
@@ -236,6 +290,38 @@ async def run() -> None:
     asyncio.run(run())
 
 
+def test_async_handle_response_with_boolean_status_no_content_raises_hyperbrowser_error():
+    async def run() -> None:
+        transport = AsyncTransport(api_key="test-key")
+        try:
+            with pytest.raises(
+                HyperbrowserError, match="Failed to process response status code"
+            ):
+                await transport._handle_response(
+                    _BooleanStatusNoContentResponse()  # type: ignore[arg-type]
+                )
+        finally:
+            await transport.close()
+
+    asyncio.run(run())
+
+
+def test_async_handle_response_with_http_status_error_and_broken_status_code():
+    async def run() -> None:
+        transport = AsyncTransport(api_key="test-key")
+        try:
+            with pytest.raises(
+                HyperbrowserError, match="Failed to process response status code"
+            ):
+                await transport._handle_response(
+                    _BrokenStatusCodeHttpErrorResponse()  # type: ignore[arg-type]
+                )
+        finally:
+            await transport.close()
+
+    asyncio.run(run())
+
+
 def test_async_handle_response_with_request_error_includes_method_and_url():
     async def run() -> None:
         transport = AsyncTransport(api_key="test-key")