Harden unreadable key display fallbacks across parsers and tools

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

Author: cursoragent

hyperbrowser/client/managers/extension_utils.py

@@ -21,11 +21,18 @@ def _safe_stringify_key(value: object) -> str:
 
 
 def _format_key_display(value: object) -> str:
-    normalized_key = _safe_stringify_key(value)
-    normalized_key = "".join(
-        "?" if ord(character) < 32 or ord(character) == 127 else character
-        for character in normalized_key
-    ).strip()
+    try:
+        normalized_key = _safe_stringify_key(value)
+        if not isinstance(normalized_key, str):
+            raise TypeError("normalized key display must be a string")
+        normalized_key = "".join(
+            "?" if ord(character) < 32 or ord(character) == 127 else character
+            for character in normalized_key
+        ).strip()
+        if not isinstance(normalized_key, str):
+            raise TypeError("normalized key display must be a string")
+    except Exception:
+        return "<unreadable key>"
     if not normalized_key:
         return "<blank key>"
     if len(normalized_key) <= _MAX_DISPLAYED_MISSING_KEY_LENGTH:

hyperbrowser/client/managers/session_utils.py

@@ -11,10 +11,15 @@
 
 
 def _format_recording_key_display(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 recording key display must be a string")
+    except Exception:
+        return "<unreadable key>"
     if not normalized_key:
         return "<blank key>"
     if len(normalized_key) <= _MAX_KEY_DISPLAY_LENGTH:

hyperbrowser/tools/__init__.py

@@ -53,10 +53,15 @@ def _has_declared_attribute(
 
 
 def _format_tool_param_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 tool key display must be a string")
+    except Exception:
+        return "<unreadable key>"
     if not normalized_key:
         return "<blank key>"
     if len(normalized_key) <= _MAX_KEY_DISPLAY_LENGTH:

tests/test_extension_utils.py

@@ -349,6 +349,37 @@ def __getitem__(self, key: str) -> object:
     assert exc_info.value.original_error is not None
 
 
+def test_parse_extension_list_response_data_falls_back_for_unreadable_value_read_keys():
+    class _BrokenKey(str):
+        class _BrokenRenderedKey(str):
+            def __iter__(self):
+                raise RuntimeError("cannot iterate rendered extension key")
+
+        def __str__(self) -> str:
+            return self._BrokenRenderedKey("name")
+
+    class _BrokenValueLookupMapping(Mapping[str, object]):
+        def __iter__(self) -> Iterator[str]:
+            yield _BrokenKey("name")
+
+        def __len__(self) -> int:
+            return 1
+
+        def __getitem__(self, key: str) -> object:
+            _ = key
+            raise RuntimeError("cannot read extension value")
+
+    with pytest.raises(
+        HyperbrowserError,
+        match="Failed to read extension object value for key '<unreadable key>' at index 0",
+    ) as exc_info:
+        parse_extension_list_response_data(
+            {"extensions": [_BrokenValueLookupMapping()]}
+        )
+
+    assert exc_info.value.original_error is not None
+
+
 def test_parse_extension_list_response_data_preserves_hyperbrowser_value_read_errors():
     class _BrokenValueLookupMapping(Mapping[str, object]):
         def __iter__(self) -> Iterator[str]:

tests/test_session_recording_utils.py

@@ -282,6 +282,34 @@ def __getitem__(self, key: str) -> object:
     assert exc_info.value.original_error is not None
 
 
+def test_parse_session_recordings_response_data_falls_back_for_unreadable_recording_keys():
+    class _BrokenKey(str):
+        def __iter__(self):
+            raise RuntimeError("cannot iterate recording key")
+
+    class _BrokenValueLookupMapping(Mapping[str, object]):
+        def __iter__(self) -> Iterator[str]:
+            yield _BrokenKey("type")
+
+        def __len__(self) -> int:
+            return 1
+
+        def __getitem__(self, key: str) -> object:
+            _ = key
+            raise RuntimeError("cannot read recording value")
+
+    with pytest.raises(
+        HyperbrowserError,
+        match=(
+            "Failed to read session recording object value "
+            "for key '<unreadable key>' at index 0"
+        ),
+    ) as exc_info:
+        parse_session_recordings_response_data([_BrokenValueLookupMapping()])
+
+    assert exc_info.value.original_error is not None
+
+
 def test_parse_session_recordings_response_data_preserves_hyperbrowser_value_read_errors():
     class _BrokenValueLookupMapping(Mapping[str, object]):
         def __iter__(self) -> Iterator[str]:

tests/test_tools_mapping_inputs.py

@@ -222,6 +222,39 @@ def __getitem__(self, key: str) -> object:
     assert exc_info.value.original_error is None
 
 
+@pytest.mark.parametrize("runner", [_run_scrape_tool_sync, _run_scrape_tool_async])
+def test_tool_wrappers_fall_back_for_unreadable_param_value_read_keys(runner):
+    class _BrokenKey(str):
+        def __new__(cls, value: str):
+            instance = super().__new__(cls, value)
+            instance._iteration_count = 0
+            return instance
+
+        def __iter__(self):
+            self._iteration_count += 1
+            if self._iteration_count > 1:
+                raise RuntimeError("cannot iterate param key")
+            return super().__iter__()
+
+    class _BrokenValueMapping(Mapping[str, object]):
+        def __iter__(self) -> Iterator[str]:
+            yield _BrokenKey("url")
+
+        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 tool param '<unreadable key>'"
+    ) as exc_info:
+        runner(_BrokenValueMapping())
+
+    assert isinstance(exc_info.value.original_error, RuntimeError)
+
+
 @pytest.mark.parametrize("runner", [_run_scrape_tool_sync, _run_scrape_tool_async])
 def test_tool_wrappers_wrap_param_key_strip_failures(runner):
     class _BrokenStripKey(str):