import string import sys from typing import Type import pytest from multidict import MultiMapping, MutableMultiMapping class TestMutableMultiDict: def test_copy( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d1 = case_sensitive_multidict_class(key="value", a="b") d2 = d1.copy() assert d1 == d2 assert d1 is not d2 def test__repr__( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() assert str(d) == "<%s()>" % case_sensitive_multidict_class.__name__ d = case_sensitive_multidict_class([("key", "one"), ("key", "two")]) expected = ( f"<{case_sensitive_multidict_class.__name__}" "('key': 'one', 'key': 'two')>" ) assert str(d) == expected def test_getall( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class([("key", "value1")], key="value2") assert len(d) == 2 assert d.getall("key") == ["value1", "value2"] with pytest.raises(KeyError, match="some_key"): d.getall("some_key") default = object() assert d.getall("some_key", default) is default def test_add( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() assert d == {} d["key"] = "one" assert d == {"key": "one"} assert d.getall("key") == ["one"] d["key"] = "two" assert d == {"key": "two"} assert d.getall("key") == ["two"] d.add("key", "one") assert 2 == len(d) assert d.getall("key") == ["two", "one"] d.add("foo", "bar") assert 3 == len(d) assert d.getall("foo") == ["bar"] def test_extend( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() assert d == {} d.extend([("key", "one"), ("key", "two")], key=3, foo="bar") assert d != {"key": "one", "foo": "bar"} assert 4 == len(d) itms = d.items() # we can't guarantee order of kwargs assert ("key", "one") in itms assert ("key", "two") in itms assert ("key", 3) in itms assert ("foo", "bar") in itms other = case_sensitive_multidict_class(bar="baz") assert other == {"bar": "baz"} d.extend(other) assert ("bar", "baz") in d.items() d.extend({"foo": "moo"}) assert ("foo", "moo") in d.items() d.extend() assert 6 == len(d) with pytest.raises(TypeError): d.extend("foo", "bar") def test_extend_from_proxy( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], case_sensitive_multidict_proxy_class: Type[MultiMapping[str]], ) -> None: d = case_sensitive_multidict_class([("a", "a"), ("b", "b")]) proxy = case_sensitive_multidict_proxy_class(d) d2 = case_sensitive_multidict_class() d2.extend(proxy) assert [("a", "a"), ("b", "b")] == list(d2.items()) def test_clear( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class([("key", "one")], key="two", foo="bar") d.clear() assert d == {} assert list(d.items()) == [] def test_del( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class([("key", "one"), ("key", "two")], foo="bar") assert list(d.keys()) == ["key", "key", "foo"] del d["key"] assert d == {"foo": "bar"} assert list(d.items()) == [("foo", "bar")] with pytest.raises(KeyError, match="key"): del d["key"] def test_set_default( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class([("key", "one"), ("key", "two")], foo="bar") assert "one" == d.setdefault("key", "three") assert "three" == d.setdefault("otherkey", "three") assert "otherkey" in d assert "three" == d["otherkey"] def test_popitem( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() d.add("key", "val1") d.add("key", "val2") assert ("key", "val1") == d.popitem() assert [("key", "val2")] == list(d.items()) def test_popitem_empty_multidict( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() with pytest.raises(KeyError): d.popitem() def test_pop( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() d.add("key", "val1") d.add("key", "val2") assert "val1" == d.pop("key") assert {"key": "val2"} == d def test_pop2( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() d.add("key", "val1") d.add("key2", "val2") d.add("key", "val3") assert "val1" == d.pop("key") assert [("key2", "val2"), ("key", "val3")] == list(d.items()) def test_pop_default( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class(other="val") assert "default" == d.pop("key", "default") assert "other" in d def test_pop_raises( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class(other="val") with pytest.raises(KeyError, match="key"): d.pop("key") assert "other" in d def test_replacement_order( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() d.add("key1", "val1") d.add("key2", "val2") d.add("key1", "val3") d.add("key2", "val4") d["key1"] = "val" expected = [("key1", "val"), ("key2", "val2"), ("key2", "val4")] assert expected == list(d.items()) def test_nonstr_key( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() with pytest.raises(TypeError): d[1] = "val" def test_istr_key( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], case_insensitive_str_class: Type[str], ) -> None: d = case_sensitive_multidict_class() d[case_insensitive_str_class("1")] = "val" assert type(list(d.keys())[0]) is case_insensitive_str_class def test_str_derived_key( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: class A(str): pass d = case_sensitive_multidict_class() d[A("1")] = "val" assert type(list(d.keys())[0]) is A def test_istr_key_add( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], case_insensitive_str_class: Type[str], ) -> None: d = case_sensitive_multidict_class() d.add(case_insensitive_str_class("1"), "val") assert type(list(d.keys())[0]) is case_insensitive_str_class def test_str_derived_key_add( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: class A(str): pass d = case_sensitive_multidict_class() d.add(A("1"), "val") assert type(list(d.keys())[0]) is A def test_popall( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() d.add("key1", "val1") d.add("key2", "val2") d.add("key1", "val3") ret = d.popall("key1") assert ["val1", "val3"] == ret assert {"key2": "val2"} == d def test_popall_default( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() assert "val" == d.popall("key", "val") def test_popall_key_error( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_sensitive_multidict_class() with pytest.raises(KeyError, match="key"): d.popall("key") def test_large_multidict_resizing( self, case_sensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: SIZE = 1024 d = case_sensitive_multidict_class() for i in range(SIZE): d["key" + str(i)] = i for i in range(SIZE - 1): del d["key" + str(i)] assert {"key" + str(SIZE - 1): SIZE - 1} == d class TestCIMutableMultiDict: def test_getall( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class([("KEY", "value1")], KEY="value2") assert d != {"KEY": "value1"} assert len(d) == 2 assert d.getall("key") == ["value1", "value2"] with pytest.raises(KeyError, match="some_key"): d.getall("some_key") def test_ctor( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class(k1="v1") assert "v1" == d["K1"] assert ("k1", "v1") in d.items() def test_setitem( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() d["k1"] = "v1" assert "v1" == d["K1"] assert ("k1", "v1") in d.items() def test_delitem( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() d["k1"] = "v1" assert "K1" in d del d["k1"] assert "K1" not in d def test_copy( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d1 = case_insensitive_multidict_class(key="KEY", a="b") d2 = d1.copy() assert d1 == d2 assert d1.items() == d2.items() assert d1 is not d2 def test__repr__( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() assert str(d) == "<%s()>" % case_insensitive_multidict_class.__name__ d = case_insensitive_multidict_class([("KEY", "one"), ("KEY", "two")]) expected = ( f"<{case_insensitive_multidict_class.__name__}" "('KEY': 'one', 'KEY': 'two')>" ) assert str(d) == expected def test_add( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() assert d == {} d["KEY"] = "one" assert ("KEY", "one") in d.items() assert d == case_insensitive_multidict_class({"Key": "one"}) assert d.getall("key") == ["one"] d["KEY"] = "two" assert ("KEY", "two") in d.items() assert d == case_insensitive_multidict_class({"Key": "two"}) assert d.getall("key") == ["two"] d.add("KEY", "one") assert ("KEY", "one") in d.items() assert 2 == len(d) assert d.getall("key") == ["two", "one"] d.add("FOO", "bar") assert ("FOO", "bar") in d.items() assert 3 == len(d) assert d.getall("foo") == ["bar"] d.add(key="test", value="test") assert ("test", "test") in d.items() assert 4 == len(d) assert d.getall("test") == ["test"] def test_extend( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() assert d == {} d.extend([("KEY", "one"), ("key", "two")], key=3, foo="bar") assert 4 == len(d) itms = d.items() # we can't guarantee order of kwargs assert ("KEY", "one") in itms assert ("key", "two") in itms assert ("key", 3) in itms assert ("foo", "bar") in itms other = case_insensitive_multidict_class(Bar="baz") assert other == {"Bar": "baz"} d.extend(other) assert ("Bar", "baz") in d.items() assert "bar" in d d.extend({"Foo": "moo"}) assert ("Foo", "moo") in d.items() assert "foo" in d d.extend() assert 6 == len(d) with pytest.raises(TypeError): d.extend("foo", "bar") def test_extend_from_proxy( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], case_insensitive_multidict_proxy_class: Type[MultiMapping[str]], ) -> None: d = case_insensitive_multidict_class([("a", "a"), ("b", "b")]) proxy = case_insensitive_multidict_proxy_class(d) d2 = case_insensitive_multidict_class() d2.extend(proxy) assert [("a", "a"), ("b", "b")] == list(d2.items()) def test_clear( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class([("KEY", "one")], key="two", foo="bar") d.clear() assert d == {} assert list(d.items()) == [] def test_del( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class( [("KEY", "one"), ("key", "two")], foo="bar", ) del d["key"] assert d == {"foo": "bar"} assert list(d.items()) == [("foo", "bar")] with pytest.raises(KeyError, match="key"): del d["key"] def test_set_default( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class( [("KEY", "one"), ("key", "two")], foo="bar", ) assert "one" == d.setdefault("key", "three") assert "three" == d.setdefault("otherkey", "three") assert "otherkey" in d assert ("otherkey", "three") in d.items() assert "three" == d["OTHERKEY"] def test_popitem( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() d.add("KEY", "val1") d.add("key", "val2") pair = d.popitem() assert ("KEY", "val1") == pair assert isinstance(pair[0], str) assert [("key", "val2")] == list(d.items()) def test_popitem_empty_multidict( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() with pytest.raises(KeyError): d.popitem() def test_pop( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() d.add("KEY", "val1") d.add("key", "val2") assert "val1" == d.pop("KEY") assert {"key": "val2"} == d def test_pop_lowercase( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class() d.add("KEY", "val1") d.add("key", "val2") assert "val1" == d.pop("key") assert {"key": "val2"} == d def test_pop_default( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class(OTHER="val") assert "default" == d.pop("key", "default") assert "other" in d def test_pop_raises( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d = case_insensitive_multidict_class(OTHER="val") with pytest.raises(KeyError, match="KEY"): d.pop("KEY") assert "other" in d def test_extend_with_istr( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], case_insensitive_str_class: Type[str], ) -> None: us = case_insensitive_str_class("aBc") d = case_insensitive_multidict_class() d.extend([(us, "val")]) assert [("aBc", "val")] == list(d.items()) def test_copy_istr( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], case_insensitive_str_class: Type[str], ) -> None: d = case_insensitive_multidict_class({case_insensitive_str_class("Foo"): "bar"}) d2 = d.copy() assert d == d2 def test_eq( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: d1 = case_insensitive_multidict_class(Key="val") d2 = case_insensitive_multidict_class(KEY="val") assert d1 == d2 @pytest.mark.skipif( sys.implementation.name == "pypy", reason="getsizeof() is not implemented on PyPy", ) def test_sizeof( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: md = case_insensitive_multidict_class() s1 = sys.getsizeof(md) for i in string.ascii_lowercase: for j in string.ascii_uppercase: md[i + j] = i + j # multidict should be resized s2 = sys.getsizeof(md) assert s2 > s1 @pytest.mark.skipif( sys.implementation.name == "pypy", reason="getsizeof() is not implemented on PyPy", ) def test_min_sizeof( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: md = case_insensitive_multidict_class() assert sys.getsizeof(md) < 1024 def test_issue_620_items( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: # https://github.com/aio-libs/multidict/issues/620 d = case_insensitive_multidict_class({"a": "123, 456", "b": "789"}) before_mutation_items = d.items() d["c"] = "000" # This causes an error on pypy. list(before_mutation_items) def test_issue_620_keys( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: # https://github.com/aio-libs/multidict/issues/620 d = case_insensitive_multidict_class({"a": "123, 456", "b": "789"}) before_mutation_keys = d.keys() d["c"] = "000" # This causes an error on pypy. list(before_mutation_keys) def test_issue_620_values( self, case_insensitive_multidict_class: Type[MutableMultiMapping[str]], ) -> None: # https://github.com/aio-libs/multidict/issues/620 d = case_insensitive_multidict_class({"a": "123, 456", "b": "789"}) before_mutation_values = d.values() d["c"] = "000" # This causes an error on pypy. list(before_mutation_values)