test(encode): add regression coverage for edge cases and internals

Expand tests for key-path nodes, generator fallbacks, strict-null formatting, and callable-filter mutation safety.

Author: techouse

tests/unit/encode_internal_helpers_test.py

@@ -0,0 +1,40 @@
+import typing as t
+
+from qs_codec.encode import _identity_key, _next_path_for_sequence
+from qs_codec.models.key_path_node import KeyPathNode
+from qs_codec.models.weak_wrapper import WeakWrapper
+
+
+def test_identity_key_returns_int_unchanged() -> None:
+    assert _identity_key(42) == 42
+
+
+def test_identity_key_handles_collected_weak_wrapper() -> None:
+    wrapper = WeakWrapper({"a": "b"})
+    object.__setattr__(wrapper, "_wref", lambda: None)
+    assert _identity_key(wrapper) == id(wrapper)
+
+
+def test_identity_key_returns_object_id_for_non_wrapper_values() -> None:
+    value = {"a": "b"}
+    assert _identity_key(value) == id(value)
+
+
+def test_next_path_for_sequence_uses_custom_suffix_when_child_starts_with_parent() -> None:
+    root = KeyPathNode.from_materialized("root")
+
+    def custom_generator(prefix: str, key: t.Optional[str]) -> str:
+        return f"{prefix}<{key}>"
+
+    next_path = _next_path_for_sequence(root, custom_generator, "item")
+    assert next_path.materialize() == "root<item>"
+
+
+def test_next_path_for_sequence_rebuilds_when_child_is_not_prefixed() -> None:
+    root = KeyPathNode.from_materialized("root")
+
+    def custom_generator(prefix: str, key: t.Optional[str]) -> str:  # pylint: disable=W0613  # noqa: ARG001
+        return f"other[{key}]"
+
+    next_path = _next_path_for_sequence(root, custom_generator, "item")
+    assert next_path.materialize() == "other[item]"

tests/unit/encode_test.py

@@ -650,6 +650,12 @@ def test_encodes_a_complicated_map(self) -> None:
         [
             pytest.param({"a": ""}, None, "a=", id="empty-string"),
             pytest.param({"a": None}, EncodeOptions(strict_null_handling=True), "a", id="none-strict-null"),
+            pytest.param(
+                {"a b": None},
+                EncodeOptions(strict_null_handling=True, format=Format.RFC1738),
+                "a+b",
+                id="none-strict-null-rfc1738-space",
+            ),
             pytest.param({"a": "", "b": ""}, None, "a=&b=", id="multiple-empty"),
             pytest.param(
                 {"a": None, "b": ""},
@@ -967,6 +973,28 @@ def filter_func(prefix: str, value: t.Any) -> t.Any:
         assert encode(obj, options=EncodeOptions(filter=filter_func)) == "a=b&c=&e%5Bf%5D=1257894000"
         assert calls == 5
 
+    def test_callable_filter_does_not_mutate_root_list_elements(self) -> None:
+        data: t.List[t.Dict[str, str]] = [{"a": "b"}]
+
+        def filter_func(prefix: str, value: t.Any) -> t.Any:
+            if prefix == "":
+                value["0"]["a"] = "x"
+            return value
+
+        assert encode(data, options=EncodeOptions(filter=filter_func)) == "0%5Ba%5D=x"
+        assert data == [{"a": "b"}]
+
+    def test_callable_filter_does_not_mutate_root_tuple_elements(self) -> None:
+        data: t.Tuple[t.Dict[str, str], ...] = ({"a": "b"},)
+
+        def filter_func(prefix: str, value: t.Any) -> t.Any:
+            if prefix == "":
+                value["0"]["a"] = "x"
+            return value
+
+        assert encode(data, options=EncodeOptions(filter=filter_func)) == "0%5Ba%5D=x"
+        assert data[0]["a"] == "b"
+
     def test_encode_handles_mapping_get_exception(self) -> None:
         class ExplodingMapping(t.Mapping):
             def __iter__(self):

tests/unit/key_path_node_test.py

@@ -0,0 +1,53 @@
+import pytest
+
+from qs_codec.models.key_path_node import KeyPathNode
+
+
+class TestKeyPathNode:
+    def test_append_empty_segment_returns_same_node(self) -> None:
+        root = KeyPathNode.from_materialized("root")
+        assert root.append("") is root
+
+    def test_materialize_builds_nested_paths(self) -> None:
+        path = KeyPathNode.from_materialized("a").append("[b]").append("[c]")
+        assert path.materialize() == "a[b][c]"
+
+    def test_materialize_uses_cached_value(self) -> None:
+        path = KeyPathNode.from_materialized("a").append("[b]").append("[c]")
+        first = path.materialize()
+        second = path.materialize()
+        assert first == second == "a[b][c]"
+
+    def test_as_dot_encoded_replaces_literal_dots(self) -> None:
+        path = KeyPathNode.from_materialized("a.b").append("[c.d]")
+        encoded = path.as_dot_encoded()
+        assert encoded.materialize() == "a%2Eb[c%2Ed]"
+
+    def test_as_dot_encoded_reuses_cached_node(self) -> None:
+        path = KeyPathNode.from_materialized("a.b").append("[c]")
+        first = path.as_dot_encoded()
+        second = path.as_dot_encoded()
+        assert first is second
+
+    def test_as_dot_encoded_returns_self_when_no_segments_need_encoding(self) -> None:
+        path = KeyPathNode.from_materialized("a").append("[c]")
+        assert path.as_dot_encoded() is path
+
+    def test_as_dot_encoded_handles_deep_paths_without_recursion_error(self) -> None:
+        path = KeyPathNode.from_materialized("root")
+        for i in range(12_000):
+            path = path.append(f".k{i}")
+
+        encoded = path.as_dot_encoded().materialize()
+        assert encoded.startswith("root%2Ek0%2Ek1")
+
+    @pytest.mark.parametrize(
+        "path, expected",
+        [
+            (KeyPathNode.from_materialized("a"), "a"),
+            (KeyPathNode.from_materialized("a").append(".b"), "a.b"),
+            (KeyPathNode.from_materialized("a").append("[0]").append("[b]"), "a[0][b]"),
+        ],
+    )
+    def test_materialize_path_variants(self, path: KeyPathNode, expected: str) -> None:
+        assert path.materialize() == expected

tests/unit/list_format_test.py

@@ -0,0 +1,20 @@
+import typing as t
+
+import pytest
+
+from qs_codec.enums.list_format import ListFormatGenerator
+
+
+@pytest.mark.parametrize(
+    "generator, prefix, key, expected",
+    [
+        (ListFormatGenerator.brackets, "a", None, "a[]"),
+        (ListFormatGenerator.comma, "a", "0", "a"),
+        (ListFormatGenerator.indices, "a", "0", "a[0]"),
+        (ListFormatGenerator.repeat, "a", "0", "a"),
+    ],
+)
+def test_list_format_generators(
+    generator: t.Callable[[str, t.Optional[str]], str], prefix: str, key: t.Optional[str], expected: str
+) -> None:
+    assert generator(prefix, key) == expected