tests: strict type annotations for test_to_dict for 100% coveralls precision

Author: rodrigo.nogueira

tests/test_to_dict.py

@@ -1,8 +1,24 @@
 """Test to_dict functionality for all multidict types."""
 
-from typing import Any, Callable, Type
+from typing import Any, Callable, Type, Iterable
 from multidict import MultiMapping
 
+
+from typing import Protocol
+
+
+from typing import Protocol, Type
+from multidict import MultiDict, CIMultiDict, MultiDictProxy, CIMultiDictProxy
+
+class MultidictModule(Protocol):
+    MultiDict: Type[MultiDict[object]]
+    CIMultiDict: Type[CIMultiDict[object]]
+    MultiDictProxy: Type[MultiDictProxy[object]]
+    CIMultiDictProxy: Type[CIMultiDictProxy[object]]
+
+class DictFactory(Protocol):
+    def __call__(self, arg: Iterable[tuple[str, object]] | None = None) -> MultiMapping[object]: ...
+
 import pytest
 
 from multidict import CIMultiDict, CIMultiDictProxy, MultiDict, MultiDictProxy
@@ -11,26 +27,26 @@
 class BaseToDictTests:
     """Base tests for to_dict() method, inherited by all multidict type tests."""
 
-    def test_to_dict_simple(self, cls: Callable[..., MultiMapping[Any]]) -> None:
+    def test_to_dict_simple(self, cls: DictFactory) -> None:
         """Test basic conversion with unique keys."""
         d = cls([("a", 1), ("b", 2)])
         result = d.to_dict()
         assert result == {"a": [1], "b": [2]}
 
-    def test_to_dict_multi_values(self, cls: Callable[..., MultiMapping[Any]]) -> None:
+    def test_to_dict_multi_values(self, cls: DictFactory) -> None:
         """Test grouping multiple values under the same key."""
         d = cls([("a", 1), ("b", 2), ("a", 3)])
         result = d.to_dict()
         assert result == {"a": [1, 3], "b": [2]}
 
-    def test_to_dict_empty(self, cls: Callable[..., MultiMapping[Any]]) -> None:
+    def test_to_dict_empty(self, cls: DictFactory) -> None:
         """Test conversion of an empty multidict."""
         d = cls()
         result = d.to_dict()
         assert result == {}
 
     def test_to_dict_returns_new_dict(
-        self, cls: Callable[..., MultiMapping[Any]]
+        self, cls: DictFactory
     ) -> None:
         """Test that each call returns a new dictionary instance."""
         d = cls([("a", 1)])
@@ -39,22 +55,22 @@ def test_to_dict_returns_new_dict(
         assert result1 == result2
         assert result1 is not result2
 
-    def test_to_dict_list_is_fresh(self, cls: Callable[..., MultiMapping[Any]]) -> None:
+    def test_to_dict_list_is_fresh(self, cls: DictFactory) -> None:
         """Test that value lists are independent between calls."""
         d = cls([("a", 1)])
         result1 = d.to_dict()
         result2 = d.to_dict()
         assert result1["a"] is not result2["a"]
 
     def test_to_dict_order_preservation(
-        self, cls: Callable[..., MultiMapping[Any]]
+        self, cls: DictFactory
     ) -> None:
         """Test that value lists maintain insertion order."""
         d = cls([("x", 3), ("x", 1), ("x", 2)])
         result = d.to_dict()
         assert result["x"] == [3, 1, 2]
 
-    def test_to_dict_large_data(self, cls: Callable[..., MultiMapping[Any]]) -> None:
+    def test_to_dict_large_data(self, cls: DictFactory) -> None:
         """Test to_dict with a large number of entries for performance."""
         items = [(f"key{i % 100}", i) for i in range(10000)]
         d = cls(items)
@@ -63,7 +79,7 @@ def test_to_dict_large_data(self, cls: Callable[..., MultiMapping[Any]]) -> None
         assert all(len(v) == 100 for v in result.values())
 
     def test_to_dict_mixed_value_types(
-        self, cls: Callable[..., MultiMapping[Any]]
+        self, cls: DictFactory
     ) -> None:
         """Test to_dict with mixed value types (str, int) to verify generic _V."""
         d = cls([("a", 1), ("a", "two"), ("b", 3.14)])
@@ -76,19 +92,19 @@ class TestMultiDictToDict(BaseToDictTests):
     """Tests for MultiDict.to_dict()."""
 
     @pytest.fixture
-    def cls(self, multidict_module: Any) -> Type[MultiDict[Any]]:
-        return multidict_module.MultiDict  # type: ignore[no-any-return]
+    def cls(self, multidict_module: MultidictModule) -> Type[MultiDict[object]]:
+        return multidict_module.MultiDict
 
 
 class TestCIMultiDictToDict(BaseToDictTests):
     """Tests for CIMultiDict.to_dict()."""
 
     @pytest.fixture
-    def cls(self, multidict_module: Any) -> Type[CIMultiDict[Any]]:
-        return multidict_module.CIMultiDict  # type: ignore[no-any-return]
+    def cls(self, multidict_module: MultidictModule) -> Type[CIMultiDict[object]]:
+        return multidict_module.CIMultiDict
 
     def test_to_dict_case_insensitive_grouping(
-        self, cls: Callable[..., MultiMapping[Any]]
+        self, cls: DictFactory
     ) -> None:
         """Test that case variants are grouped under the same key."""
         d = cls([("A", 1), ("a", 2), ("B", 3)])
@@ -106,19 +122,19 @@ class TestMultiDictProxyToDict(BaseToDictTests):
     """Tests for MultiDictProxy.to_dict()."""
 
     @pytest.fixture
-    def cls(self, multidict_module: Any) -> Any:
-        def make_proxy(*args: Any, **kwargs: Any) -> MultiDictProxy[Any]:
-            md = multidict_module.MultiDict(*args, **kwargs)
-            return multidict_module.MultiDictProxy(md)  # type: ignore[no-any-return]
+    def cls(self, multidict_module: MultidictModule) -> DictFactory:
+        def make_proxy(arg: Iterable[tuple[str, object]] | None = None) -> MultiMapping[object]:
+            md: MultiDict[object] = multidict_module.MultiDict(arg) if arg else multidict_module.MultiDict()
+            return multidict_module.MultiDictProxy(md)
 
         return make_proxy
 
     def test_to_dict_proxy_mutation_isolation(
-        self, cls: Callable[..., MultiMapping[Any]], multidict_module: Any
+        self, cls: DictFactory, multidict_module: MultidictModule
     ) -> None:
         """Test that modifying returned dict does not affect the proxy."""
-        md = multidict_module.MultiDict([("a", 1)])
-        proxy = multidict_module.MultiDictProxy(md)
+        md: MultiDict[object] = multidict_module.MultiDict([("a", 1)])
+        proxy: MultiMapping[object] = multidict_module.MultiDictProxy(md)
         result = proxy.to_dict()
         result["a"].append(999)
         assert proxy.getall("a") == [1]
@@ -128,15 +144,15 @@ class TestCIMultiDictProxyToDict(BaseToDictTests):
     """Tests for CIMultiDictProxy.to_dict()."""
 
     @pytest.fixture
-    def cls(self, multidict_module: Any) -> Any:
-        def make_proxy(*args: Any, **kwargs: Any) -> CIMultiDictProxy[Any]:
-            md = multidict_module.CIMultiDict(*args, **kwargs)
-            return multidict_module.CIMultiDictProxy(md)  # type: ignore[no-any-return]
+    def cls(self, multidict_module: MultidictModule) -> DictFactory:
+        def make_proxy(arg: Iterable[tuple[str, object]] | None = None) -> MultiMapping[object]:
+            md: CIMultiDict[object] = multidict_module.CIMultiDict(arg) if arg else multidict_module.CIMultiDict()
+            return multidict_module.CIMultiDictProxy(md)
 
         return make_proxy
 
     def test_to_dict_case_insensitive_grouping(
-        self, cls: Callable[..., MultiMapping[Any]]
+        self, cls: DictFactory
     ) -> None:
         """Test that case variants are grouped under the same key."""
         d = cls([("A", 1), ("a", 2), ("B", 3)])
@@ -150,11 +166,11 @@ def test_to_dict_case_insensitive_grouping(
         assert result[key_b] == [3]
 
     def test_to_dict_proxy_mutation_isolation(
-        self, cls: Callable[..., MultiMapping[Any]], multidict_module: Any
+        self, cls: DictFactory, multidict_module: MultidictModule
     ) -> None:
         """Test that modifying returned dict does not affect the proxy."""
-        md = multidict_module.CIMultiDict([("a", 1)])
-        proxy = multidict_module.CIMultiDictProxy(md)
+        md: CIMultiDict[object] = multidict_module.CIMultiDict([("a", 1)])
+        proxy: MultiMapping[object] = multidict_module.CIMultiDictProxy(md)
         result = proxy.to_dict()
         result["a"].append(999)
         assert proxy.getall("a") == [1]