Harden response model operation-name and key display normalization

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

Author: cursoragent

hyperbrowser/client/managers/response_utils.py

@@ -11,10 +11,15 @@
 
 
 def _normalize_operation_name_for_error(operation_name: str) -> str:
-    normalized_name = "".join(
-        "?" if ord(character) < 32 or ord(character) == 127 else character
-        for character in operation_name
-    ).strip()
+    try:
+        normalized_name = "".join(
+            "?" if ord(character) < 32 or ord(character) == 127 else character
+            for character in operation_name
+        ).strip()
+        if not isinstance(normalized_name, str):
+            raise TypeError("normalized operation name must be a string")
+    except Exception:
+        return "operation"
     if not normalized_name:
         return "operation"
     if len(normalized_name) <= _MAX_OPERATION_NAME_DISPLAY_LENGTH:
@@ -28,10 +33,15 @@ def _normalize_operation_name_for_error(operation_name: str) -> str:
 
 
 def _normalize_response_key_for_error(key: str) -> str:
-    normalized_key = "".join(
-        "?" if ord(character) < 32 or ord(character) == 127 else character
-        for character in key
-    ).strip()
+    try:
+        normalized_key = "".join(
+            "?" if ord(character) < 32 or ord(character) == 127 else character
+            for character in key
+        ).strip()
+        if not isinstance(normalized_key, str):
+            raise TypeError("normalized response key must be a string")
+    except Exception:
+        return "<unreadable key>"
     if not normalized_key:
         return "<blank key>"
     if len(normalized_key) <= _MAX_KEY_DISPLAY_LENGTH:
@@ -48,7 +58,20 @@ def parse_response_model(
     model: Type[T],
     operation_name: str,
 ) -> T:
-    if not isinstance(operation_name, str) or not operation_name.strip():
+    if not isinstance(operation_name, str):
+        raise HyperbrowserError("operation_name must be a non-empty string")
+    try:
+        normalized_operation_name_input = operation_name.strip()
+        if not isinstance(normalized_operation_name_input, str):
+            raise TypeError("normalized operation_name must be a string")
+    except HyperbrowserError:
+        raise
+    except Exception as exc:
+        raise HyperbrowserError(
+            "Failed to normalize operation_name",
+            original_error=exc,
+        ) from exc
+    if not normalized_operation_name_input:
         raise HyperbrowserError("operation_name must be a non-empty string")
     normalized_operation_name = _normalize_operation_name_for_error(operation_name)
     if not isinstance(response_data, Mapping):

tests/test_response_utils.py

@@ -206,6 +206,56 @@ def test_parse_response_model_sanitizes_operation_name_in_errors():
         )
 
 
+def test_parse_response_model_wraps_operation_name_strip_failures():
+    class _BrokenOperationName(str):
+        def strip(self, chars=None):  # type: ignore[override]
+            _ = chars
+            raise RuntimeError("operation name strip exploded")
+
+    with pytest.raises(HyperbrowserError, match="Failed to normalize operation_name") as exc_info:
+        parse_response_model(
+            {"success": True},
+            model=BasicResponse,
+            operation_name=_BrokenOperationName("basic operation"),
+        )
+
+    assert isinstance(exc_info.value.original_error, RuntimeError)
+
+
+def test_parse_response_model_preserves_hyperbrowser_operation_name_strip_failures():
+    class _BrokenOperationName(str):
+        def strip(self, chars=None):  # type: ignore[override]
+            _ = chars
+            raise HyperbrowserError("custom operation name strip failure")
+
+    with pytest.raises(
+        HyperbrowserError, match="custom operation name strip failure"
+    ) as exc_info:
+        parse_response_model(
+            {"success": True},
+            model=BasicResponse,
+            operation_name=_BrokenOperationName("basic operation"),
+        )
+
+    assert exc_info.value.original_error is None
+
+
+def test_parse_response_model_wraps_non_string_operation_name_strip_results():
+    class _BrokenOperationName(str):
+        def strip(self, chars=None):  # type: ignore[override]
+            _ = chars
+            return object()
+
+    with pytest.raises(HyperbrowserError, match="Failed to normalize operation_name") as exc_info:
+        parse_response_model(
+            {"success": True},
+            model=BasicResponse,
+            operation_name=_BrokenOperationName("basic operation"),
+        )
+
+    assert isinstance(exc_info.value.original_error, TypeError)
+
+
 def test_parse_response_model_truncates_operation_name_in_errors():
     long_operation_name = "basic operation " + ("x" * 200)
 
@@ -223,6 +273,35 @@ def test_parse_response_model_truncates_operation_name_in_errors():
         )
 
 
+def test_parse_response_model_falls_back_for_unreadable_key_display():
+    class _BrokenKey(str):
+        def __iter__(self):
+            raise RuntimeError("key iteration exploded")
+
+    class _BrokenValueLookupMapping(Mapping[str, object]):
+        def __iter__(self):
+            yield _BrokenKey("success")
+
+        def __len__(self) -> int:
+            return 1
+
+        def __getitem__(self, key: str) -> object:
+            _ = key
+            raise RuntimeError("cannot read value")
+
+    with pytest.raises(
+        HyperbrowserError,
+        match="Failed to read basic operation response value for key '<unreadable key>'",
+    ) as exc_info:
+        parse_response_model(
+            _BrokenValueLookupMapping(),
+            model=BasicResponse,
+            operation_name="basic operation",
+        )
+
+    assert isinstance(exc_info.value.original_error, RuntimeError)
+
+
 def test_parse_response_model_wraps_mapping_read_failures():
     with pytest.raises(
         HyperbrowserError,