Merge pull request #28 from techouse/chore/increase-coverage

✅ increase coverage

Author: techouse

tests/unit/decode_options_test.py

@@ -1,3 +1,4 @@
+import math
 import typing as t
 
 import pytest
@@ -110,6 +111,88 @@ def dec(s: t.Optional[str]) -> t.Optional[str]:
         with pytest.raises(TypeError):
             _ = opts.decoder("oops", Charset.UTF8, kind=DecodeKind.KEY)
 
+    def test_kwonly_charset_receives_keyword_argument(self) -> None:
+        calls: t.List[t.Dict[str, t.Any]] = []
+
+        def dec(s: t.Optional[str], *, charset: t.Optional[Charset], kind: str) -> t.Optional[str]:
+            calls.append({"charset": charset, "kind": kind})
+            return s
+
+        opts = DecodeOptions(decoder=dec)
+        assert opts.decoder("x", Charset.LATIN1, kind=DecodeKind.KEY) == "x"
+        assert calls == [{"charset": Charset.LATIN1, "kind": "key"}]
+
+    def test_positional_only_kind_receives_string(self) -> None:
+        seen: t.List[t.Any] = []
+
+        def dec(
+            s: t.Optional[str],
+            kind,  # type: ignore[no-untyped-def]
+            /,
+            *,
+            charset: t.Optional[Charset] = None,
+        ) -> t.Optional[str]:
+            seen.append((kind, charset))
+            return s
+
+        opts = DecodeOptions(decoder=dec)
+        assert opts.decoder("value", Charset.UTF8, kind=DecodeKind.VALUE) == "value"
+        assert seen == [("value", Charset.UTF8)]
+
+    def test_unannotated_kind_parameter_receives_string(self) -> None:
+        seen: t.List[t.Any] = []
+
+        def dec(s: t.Optional[str], charset: t.Optional[Charset], kind) -> t.Optional[str]:  # type: ignore[no-untyped-def]
+            seen.append(kind)
+            return s
+
+        opts = DecodeOptions(decoder=dec)
+        assert opts.decoder("q", Charset.UTF8, kind=DecodeKind.KEY) == "q"
+        assert seen == ["key"]
+
+    def test_literal_kind_annotation_prefers_string(self) -> None:
+        seen: t.List[t.Any] = []
+
+        def dec(
+            s: t.Optional[str],
+            charset: t.Optional[Charset],
+            kind: t.Literal["key", "value"],
+        ) -> t.Optional[str]:
+            seen.append(kind)
+            return s
+
+        opts = DecodeOptions(decoder=dec)
+        assert opts.decoder("ok", Charset.UTF8, kind=DecodeKind.VALUE) == "ok"
+        assert seen == ["value"]
+
+    def test_builtin_without_signature_raises_original_typeerror(self) -> None:
+        opts = DecodeOptions(decoder=math.hypot)  # type: ignore[arg-type]
+
+        with pytest.raises(TypeError):
+            _ = opts.decode_value("10")
+
+
+class TestDecodeOptionsFallbacks:
+    def test_legacy_decoder_selected_when_decoder_none(self) -> None:
+        calls: t.List[t.Tuple[t.Optional[str], t.Optional[Charset]]] = []
+
+        def legacy(value: t.Optional[str], charset: t.Optional[Charset]) -> t.Optional[str]:
+            calls.append((value, charset))
+            return "LEGACY" if value else None
+
+        opts = DecodeOptions(decoder=None, legacy_decoder=legacy)
+        assert opts.decode_value("foo", Charset.LATIN1) == "LEGACY"
+        assert calls == [("foo", Charset.LATIN1)]
+
+    def test_default_decoder_selected_when_all_none(self) -> None:
+        opts = DecodeOptions(decoder=None, legacy_decoder=None)
+        assert opts.decode_key("a%2Eb") == "a.b"
+
+    def test_decode_method_falls_back_when_decoder_missing(self) -> None:
+        opts = DecodeOptions()
+        opts.decoder = None
+        assert opts.decode_value("a%20b") == "a b"
+
 
 class TestParserStateIsolation:
     def test_parse_lists_toggle_does_not_leak_across_calls(self) -> None:

tests/unit/decode_test.py

@@ -7,6 +7,7 @@
 import pytest
 
 from qs_codec import Charset, DecodeOptions, Duplicates, decode, load, loads
+from qs_codec.decode import _parse_object
 from qs_codec.enums.decode_kind import DecodeKind
 from qs_codec.utils.decode_utils import DecodeUtils
 
@@ -1620,6 +1621,31 @@ def test_top_level_dot_to_bracket_guardrails_leading_trailing_double(self) -> No
         # as a literal dot in the parent key (no [] is created)
         assert decode("a..b=x", DecodeOptions(allow_dots=True, decode_dot_in_keys=False)) == {"a.": {"b": "x"}}
 
+    def test_regex_delimiter_without_limit_uses_regex_split(self) -> None:
+        options = DecodeOptions(parameter_limit=float("inf"), delimiter=re.compile(r"[;&]"))
+        assert decode("a=1;b=2", options) == {"a": "1", "b": "2"}
+
+    def test_regex_delimiter_with_limit_raises_when_exceeded(self) -> None:
+        options = DecodeOptions(parameter_limit=1, raise_on_limit_exceeded=True, delimiter=re.compile(r"[;&]"))
+        with pytest.raises(ValueError, match="Parameter limit exceeded"):
+            decode("a=1&b=2", options)
+
+    def test_decoder_skips_pairs_when_key_decode_returns_none(self) -> None:
+        def dropping_decoder(token: t.Optional[str], charset: t.Optional[Charset]) -> t.Optional[str]:
+            if token in {"dropNoEquals", "drop"}:
+                return None
+            return token
+
+        opts = DecodeOptions(decoder=None, legacy_decoder=dropping_decoder)
+        assert decode("dropNoEquals&drop=1&keep=2", opts) == {"keep": "2"}
+
+    def test_parse_object_estimates_list_length_for_numeric_parent(self) -> None:
+        options = DecodeOptions()
+        chain = ["0", "[]"]
+        val = [["x", "y"]]
+        result = _parse_object(chain, val, options, True)
+        assert result == {"0": [["x", "y"]]}
+
 
 class TestSplitKeySegmentationRemainder:
     def test_no_remainder_when_within_depth(self) -> None:

tests/unit/encode_options_test.py

@@ -0,0 +1,23 @@
+from qs_codec import EncodeOptions
+from qs_codec.utils.encode_utils import EncodeUtils
+
+
+class TestEncodeOptions:
+    def test_post_init_restores_default_encoder(self) -> None:
+        opts = EncodeOptions()
+        assert opts._encoder.__func__ is EncodeUtils.encode.__func__
+
+    def test_post_init_recovers_when_encoder_missing(self) -> None:
+        opts = EncodeOptions()
+        delattr(opts, "_encoder")
+        EncodeOptions.__post_init__(opts)
+        assert opts._encoder.__func__ is EncodeUtils.encode.__func__
+
+    def test_equality_with_other_type_returns_false(self) -> None:
+        opts = EncodeOptions()
+        assert opts != object()
+
+    def test_equality_detects_field_difference(self) -> None:
+        lhs = EncodeOptions()
+        rhs = EncodeOptions(allow_dots=True)
+        assert lhs != rhs

tests/unit/encode_test.py

@@ -5,12 +5,16 @@
 from decimal import Decimal
 from enum import Enum
 from urllib.parse import quote
+from weakref import WeakKeyDictionary
 
 import pytest
 
 from qs_codec import Charset, EncodeOptions, Format, ListFormat, dumps, encode
+from qs_codec.encode import _encode, _sentinel
 from qs_codec.models.undefined import Undefined
+from qs_codec.models.weak_wrapper import WeakWrapper
 from qs_codec.utils.encode_utils import EncodeUtils
+from qs_codec.utils.utils import Utils
 
 
 class TestEncode:
@@ -1691,3 +1695,113 @@ def test_encodes_non_string_keys(self) -> None:
             )
             == "a=b"
         )
+
+
+class TestEncodeInternals:
+    def test_encode_cycle_detection_raises_on_same_step(self) -> None:
+        value: t.Dict[str, t.Any] = {"loop": {}}
+        side_channel: WeakKeyDictionary = WeakKeyDictionary()
+        parent_channel: WeakKeyDictionary = WeakKeyDictionary()
+        wrapper = WeakWrapper(value)
+        parent_channel[wrapper] = 1
+        side_channel[_sentinel] = parent_channel
+
+        with pytest.raises(ValueError, match="Circular reference detected"):
+            _encode(
+                value=value,
+                is_undefined=False,
+                side_channel=side_channel,
+                prefix="root",
+                comma_round_trip=False,
+                encoder=EncodeUtils.encode,
+                serialize_date=EncodeUtils.serialize_date,
+                sort=None,
+                filter=None,
+                formatter=Format.RFC3986.formatter,
+                format=Format.RFC3986,
+                generate_array_prefix=ListFormat.INDICES.generator,
+                allow_empty_lists=False,
+                strict_null_handling=False,
+                skip_nulls=False,
+                encode_dot_in_keys=False,
+                allow_dots=False,
+                encode_values_only=False,
+                charset=Charset.UTF8,
+            )
+
+    def test_encode_cycle_detection_marks_prior_visit_without_raising(self) -> None:
+        value: t.Dict[str, t.Any] = {"child": "value"}
+        side_channel: WeakKeyDictionary = WeakKeyDictionary()
+        parent_channel: WeakKeyDictionary = WeakKeyDictionary()
+        wrapper = WeakWrapper(value)
+        parent_channel[wrapper] = 99
+        side_channel[_sentinel] = parent_channel
+
+        tokens = _encode(
+            value=value,
+            is_undefined=False,
+            side_channel=side_channel,
+            prefix="root",
+            comma_round_trip=False,
+            encoder=EncodeUtils.encode,
+            serialize_date=EncodeUtils.serialize_date,
+            sort=None,
+            filter=None,
+            formatter=Format.RFC3986.formatter,
+            format=Format.RFC3986,
+            generate_array_prefix=ListFormat.INDICES.generator,
+            allow_empty_lists=False,
+            strict_null_handling=False,
+            skip_nulls=False,
+            encode_dot_in_keys=False,
+            allow_dots=False,
+            encode_values_only=False,
+            charset=Charset.UTF8,
+        )
+
+        assert tokens == ["root%5Bchild%5D=value"]
+
+    def test_encode_handles_iterable_filter_for_indexable_object(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        class Indexable:
+            def __getitem__(self, key: str) -> str:
+                if key != "foo":
+                    raise KeyError(key)
+                return "bar"
+
+        original = Utils.is_non_nullish_primitive
+
+        def fake_is_non_nullish_primitive(val: t.Any, skip_nulls: bool = False) -> bool:
+            if isinstance(val, Indexable):
+                return False
+            return original(val, skip_nulls)
+
+        monkeypatch.setattr(Utils, "is_non_nullish_primitive", staticmethod(fake_is_non_nullish_primitive))
+
+        tokens = _encode(
+            value=Indexable(),
+            is_undefined=False,
+            side_channel=WeakKeyDictionary(),
+            prefix="root",
+            comma_round_trip=False,
+            encoder=EncodeUtils.encode,
+            serialize_date=EncodeUtils.serialize_date,
+            sort=None,
+            filter=["foo"],
+            formatter=Format.RFC3986.formatter,
+            format=Format.RFC3986,
+            generate_array_prefix=ListFormat.INDICES.generator,
+            allow_empty_lists=False,
+            strict_null_handling=False,
+            skip_nulls=False,
+            encode_dot_in_keys=False,
+            allow_dots=False,
+            encode_values_only=False,
+            charset=Charset.UTF8,
+        )
+
+        assert tokens == ["root%5Bfoo%5D=bar"]
+
+    def test_encode_comma_format_serializes_datetime_without_custom_callable(self) -> None:
+        dt = datetime(2024, 1, 1)
+        options = EncodeOptions(list_format=ListFormat.COMMA, serialize_date="iso")
+        assert encode({"a": [dt]}, options) == f"a={dt.isoformat().replace(':', '%3A')}"