Intermediate changes

1 files changed, 46 insertions, 64 deletions

diff --git a/contrib/python/multidict/tests/test_update.py b/contrib/python/multidict/tests/test_update.py
index 4bacdbce777..f4553278571 100644
--- a/contrib/python/multidict/tests/test_update.py
+++ b/contrib/python/multidict/tests/test_update.py
@@ -1,97 +1,68 @@
 from collections import deque
+from typing import Type
 
-import pytest
+from multidict import MultiMapping
 
-from multidict._compat import USE_EXTENSIONS
-from multidict._multidict_py import CIMultiDict as PyCIMultiDict
-from multidict._multidict_py import MultiDict as PyMultiDict  # noqa: E402
 
-if USE_EXTENSIONS:
-    from multidict._multidict import CIMultiDict, MultiDict  # type: ignore
-
-
-@pytest.fixture(
-    params=([MultiDict, CIMultiDict] if USE_EXTENSIONS else [])
-    + [PyMultiDict, PyCIMultiDict],
-    ids=(["MultiDict", "CIMultiDict"] if USE_EXTENSIONS else [])
-    + ["PyMultiDict", "PyCIMultiDict"],
-)
-def cls(request):
-    return request.param
-
-
-@pytest.fixture
-def md_cls(_multidict):
-    return _multidict.MultiDict
-
-
-@pytest.fixture
-def ci_md_cls(_multidict):
-    return _multidict.CIMultiDict
-
-
-@pytest.fixture
-def istr(_multidict):
-    return _multidict.istr
-
-
-def test_update_replace(cls):
-    obj1 = cls([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
-    obj2 = cls([("a", 4), ("b", 5), ("a", 6)])
+def test_update_replace(any_multidict_class: Type[MultiMapping[str]]) -> None:
+    obj1 = any_multidict_class([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
+    obj2 = any_multidict_class([("a", 4), ("b", 5), ("a", 6)])
     obj1.update(obj2)
     expected = [("a", 4), ("b", 5), ("a", 6), ("c", 10)]
     assert list(obj1.items()) == expected
 
 
-def test_update_append(cls):
-    obj1 = cls([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
-    obj2 = cls([("a", 4), ("a", 5), ("a", 6)])
+def test_update_append(any_multidict_class: Type[MultiMapping[str]]) -> None:
+    obj1 = any_multidict_class([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
+    obj2 = any_multidict_class([("a", 4), ("a", 5), ("a", 6)])
     obj1.update(obj2)
     expected = [("a", 4), ("b", 2), ("a", 5), ("c", 10), ("a", 6)]
     assert list(obj1.items()) == expected
 
 
-def test_update_remove(cls):
-    obj1 = cls([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
-    obj2 = cls([("a", 4)])
+def test_update_remove(any_multidict_class: Type[MultiMapping[str]]) -> None:
+    obj1 = any_multidict_class([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
+    obj2 = any_multidict_class([("a", 4)])
     obj1.update(obj2)
     expected = [("a", 4), ("b", 2), ("c", 10)]
     assert list(obj1.items()) == expected
 
 
-def test_update_replace_seq(cls):
-    obj1 = cls([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
+def test_update_replace_seq(any_multidict_class: Type[MultiMapping[str]]) -> None:
+    obj1 = any_multidict_class([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
     obj2 = [("a", 4), ("b", 5), ("a", 6)]
     obj1.update(obj2)
     expected = [("a", 4), ("b", 5), ("a", 6), ("c", 10)]
     assert list(obj1.items()) == expected
 
 
-def test_update_replace_seq2(cls):
-    obj1 = cls([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
+def test_update_replace_seq2(any_multidict_class: Type[MultiMapping[str]]) -> None:
+    obj1 = any_multidict_class([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
     obj1.update([("a", 4)], b=5, a=6)
     expected = [("a", 4), ("b", 5), ("a", 6), ("c", 10)]
     assert list(obj1.items()) == expected
 
 
-def test_update_append_seq(cls):
-    obj1 = cls([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
+def test_update_append_seq(any_multidict_class: Type[MultiMapping[str]]) -> None:
+    obj1 = any_multidict_class([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
     obj2 = [("a", 4), ("a", 5), ("a", 6)]
     obj1.update(obj2)
     expected = [("a", 4), ("b", 2), ("a", 5), ("c", 10), ("a", 6)]
     assert list(obj1.items()) == expected
 
 
-def test_update_remove_seq(cls):
-    obj1 = cls([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
+def test_update_remove_seq(any_multidict_class: Type[MultiMapping[str]]) -> None:
+    obj1 = any_multidict_class([("a", 1), ("b", 2), ("a", 3), ("c", 10)])
     obj2 = [("a", 4)]
     obj1.update(obj2)
     expected = [("a", 4), ("b", 2), ("c", 10)]
     assert list(obj1.items()) == expected
 
 
-def test_update_md(md_cls):
-    d = md_cls()
+def test_update_md(
+    case_sensitive_multidict_class: Type[MultiMapping[str]],
+) -> None:
+    d = case_sensitive_multidict_class()
     d.add("key", "val1")
     d.add("key", "val2")
     d.add("key2", "val3")
@@ -101,19 +72,24 @@ def test_update_md(md_cls):
     assert [("key", "val"), ("key2", "val3")] == list(d.items())
 
 
-def test_update_istr_ci_md(ci_md_cls, istr):
-    d = ci_md_cls()
-    d.add(istr("KEY"), "val1")
+def test_update_istr_ci_md(
+    case_insensitive_multidict_class: Type[MultiMapping[str]],
+    case_insensitive_str_class: str,
+) -> None:
+    d = case_insensitive_multidict_class()
+    d.add(case_insensitive_str_class("KEY"), "val1")
     d.add("key", "val2")
     d.add("key2", "val3")
 
-    d.update({istr("key"): "val"})
+    d.update({case_insensitive_str_class("key"): "val"})
 
     assert [("key", "val"), ("key2", "val3")] == list(d.items())
 
 
-def test_update_ci_md(ci_md_cls):
-    d = ci_md_cls()
+def test_update_ci_md(
+    case_insensitive_multidict_class: Type[MultiMapping[str]],
+) -> None:
+    d = case_insensitive_multidict_class()
     d.add("KEY", "val1")
     d.add("key", "val2")
     d.add("key2", "val3")
@@ -123,24 +99,30 @@ def test_update_ci_md(ci_md_cls):
     assert [("Key", "val"), ("key2", "val3")] == list(d.items())
 
 
-def test_update_list_arg_and_kwds(cls):
-    obj = cls()
+def test_update_list_arg_and_kwds(
+    any_multidict_class: Type[MultiMapping[str]],
+) -> None:
+    obj = any_multidict_class()
     arg = [("a", 1)]
     obj.update(arg, b=2)
     assert list(obj.items()) == [("a", 1), ("b", 2)]
     assert arg == [("a", 1)]
 
 
-def test_update_tuple_arg_and_kwds(cls):
-    obj = cls()
+def test_update_tuple_arg_and_kwds(
+    any_multidict_class: Type[MultiMapping[str]],
+) -> None:
+    obj = any_multidict_class()
     arg = (("a", 1),)
     obj.update(arg, b=2)
     assert list(obj.items()) == [("a", 1), ("b", 2)]
     assert arg == (("a", 1),)
 
 
-def test_update_deque_arg_and_kwds(cls):
-    obj = cls()
+def test_update_deque_arg_and_kwds(
+    any_multidict_class: Type[MultiMapping[str]],
+) -> None:
+    obj = any_multidict_class()
     arg = deque([("a", 1)])
     obj.update(arg, b=2)
     assert list(obj.items()) == [("a", 1), ("b", 2)]