Migrate dict provider tests

tests/unit/providers/test_dict_py2_py3.py

@@ -1,227 +1,245 @@
-"""Dependency injector dict provider unit tests."""
+"""Dict provider tests."""
 
 import sys
 
-import unittest
-
 from dependency_injector import providers
 
 
-class DictTests(unittest.TestCase):
+def test_is_provider():
+    assert providers.is_provider(providers.Dict()) is True
 
-    def test_is_provider(self):
-        assert providers.is_provider(providers.Dict()) is True
 
-    def test_provided_instance_provider(self):
+def test_provided_instance_provider():
-        provider = providers.Dict()
+    provider = providers.Dict()
-        assert isinstance(provider.provided, providers.ProvidedInstance)
+    assert isinstance(provider.provided, providers.ProvidedInstance)
 
-    def test_init_with_non_string_keys(self):
-        a1 = object()
-        a2 = object()
-        provider = providers.Dict({a1: "i1", a2: "i2"})
 
-        dict1 = provider()
+def test_init_with_non_string_keys():
-        dict2 = provider()
+    a1 = object()
+    a2 = object()
+    provider = providers.Dict({a1: "i1", a2: "i2"})
 
-        assert dict1 == {a1: "i1", a2: "i2"}
+    dict1 = provider()
-        assert dict2 == {a1: "i1", a2: "i2"}
+    dict2 = provider()
 
-        assert dict1 is not dict2
+    assert dict1 == {a1: "i1", a2: "i2"}
+    assert dict2 == {a1: "i1", a2: "i2"}
 
-    def test_init_with_string_and_non_string_keys(self):
+    assert dict1 is not dict2
-        a1 = object()
-        provider = providers.Dict({a1: "i1"}, a2="i2")
 
-        dict1 = provider()
-        dict2 = provider()
 
-        assert dict1 == {a1: "i1", "a2": "i2"}
+def test_init_with_string_and_non_string_keys():
-        assert dict2 == {a1: "i1", "a2": "i2"}
+    a1 = object()
+    provider = providers.Dict({a1: "i1"}, a2="i2")
 
-        assert dict1 is not dict2
+    dict1 = provider()
+    dict2 = provider()
 
-    def test_call_with_init_keyword_args(self):
+    assert dict1 == {a1: "i1", "a2": "i2"}
-        provider = providers.Dict(a1="i1", a2="i2")
+    assert dict2 == {a1: "i1", "a2": "i2"}
 
-        dict1 = provider()
+    assert dict1 is not dict2
-        dict2 = provider()
 
-        assert dict1 == {"a1": "i1", "a2": "i2"}
-        assert dict2 == {"a1": "i1", "a2": "i2"}
 
-        assert dict1 is not dict2
+def test_call_with_init_keyword_args():
+    provider = providers.Dict(a1="i1", a2="i2")
 
-    def test_call_with_context_keyword_args(self):
+    dict1 = provider()
-        provider = providers.Dict(a1="i1", a2="i2")
+    dict2 = provider()
-        assert provider(a3="i3", a4="i4") == {"a1": "i1", "a2": "i2", "a3": "i3", "a4": "i4"}
 
-    def test_call_with_provider(self):
+    assert dict1 == {"a1": "i1", "a2": "i2"}
-        provider = providers.Dict(
+    assert dict2 == {"a1": "i1", "a2": "i2"}
-            a1=providers.Factory(str, "i1"),
-            a2=providers.Factory(str, "i2"),
-        )
-        assert provider() == {"a1": "i1", "a2": "i2"}
 
-    def test_fluent_interface(self):
+    assert dict1 is not dict2
-        provider = providers.Dict() \
-            .add_kwargs(a1="i1", a2="i2")
-        assert provider() == {"a1": "i1", "a2": "i2"}
 
-    def test_add_kwargs(self):
-        provider = providers.Dict() \
-            .add_kwargs(a1="i1") \
-            .add_kwargs(a2="i2")
-        assert provider.kwargs == {"a1": "i1", "a2": "i2"}
 
-    def test_add_kwargs_non_string_keys(self):
+def test_call_with_context_keyword_args():
-        a1 = object()
+    provider = providers.Dict(a1="i1", a2="i2")
-        a2 = object()
+    assert provider(a3="i3", a4="i4") == {"a1": "i1", "a2": "i2", "a3": "i3", "a4": "i4"}
-        provider = providers.Dict() \
-            .add_kwargs({a1: "i1"}) \
-            .add_kwargs({a2: "i2"})
-        assert provider.kwargs == {a1: "i1", a2: "i2"}
 
-    def test_add_kwargs_string_and_non_string_keys(self):
-        a2 = object()
-        provider = providers.Dict() \
-            .add_kwargs(a1="i1") \
-            .add_kwargs({a2: "i2"})
-        assert provider.kwargs == {"a1": "i1", a2: "i2"}
 
-    def test_set_kwargs(self):
+def test_call_with_provider():
-        provider = providers.Dict() \
+    provider = providers.Dict(
-            .add_kwargs(a1="i1", a2="i2") \
+        a1=providers.Factory(str, "i1"),
-            .set_kwargs(a3="i3", a4="i4")
+        a2=providers.Factory(str, "i2"),
-        assert provider.kwargs == {"a3": "i3", "a4": "i4"}
+    )
+    assert provider() == {"a1": "i1", "a2": "i2"}
 
-    def test_set_kwargs_non_string_keys(self):
-        a3 = object()
-        a4 = object()
-        provider = providers.Dict() \
-            .add_kwargs(a1="i1", a2="i2") \
-            .set_kwargs({a3: "i3", a4: "i4"})
-        assert provider.kwargs == {a3: "i3", a4: "i4"}
 
-    def test_set_kwargs_string_and_non_string_keys(self):
+def test_fluent_interface():
-        a3 = object()
+    provider = providers.Dict() \
-        provider = providers.Dict() \
+        .add_kwargs(a1="i1", a2="i2")
-            .add_kwargs(a1="i1", a2="i2") \
+    assert provider() == {"a1": "i1", "a2": "i2"}
-            .set_kwargs({a3: "i3"}, a4="i4")
-        assert provider.kwargs == {a3: "i3", "a4": "i4"}
 
-    def test_clear_kwargs(self):
-        provider = providers.Dict() \
-            .add_kwargs(a1="i1", a2="i2") \
-            .clear_kwargs()
-        assert provider.kwargs == {}
 
-    def test_call_overridden(self):
+def test_add_kwargs():
-        provider = providers.Dict(a1="i1", a2="i2")
+    provider = providers.Dict() \
-        overriding_provider1 = providers.Dict(a2="i2", a3="i3")
+        .add_kwargs(a1="i1") \
-        overriding_provider2 = providers.Dict(a3="i3", a4="i4")
+        .add_kwargs(a2="i2")
+    assert provider.kwargs == {"a1": "i1", "a2": "i2"}
 
-        provider.override(overriding_provider1)
-        provider.override(overriding_provider2)
 
-        instance1 = provider()
+def test_add_kwargs_non_string_keys():
-        instance2 = provider()
+    a1 = object()
+    a2 = object()
+    provider = providers.Dict() \
+        .add_kwargs({a1: "i1"}) \
+        .add_kwargs({a2: "i2"})
+    assert provider.kwargs == {a1: "i1", a2: "i2"}
 
-        assert instance1 is not instance2
-        assert instance1 == {"a3": "i3", "a4": "i4"}
-        assert instance2 == {"a3": "i3", "a4": "i4"}
 
-    def test_deepcopy(self):
+def test_add_kwargs_string_and_non_string_keys():
-        provider = providers.Dict(a1="i1", a2="i2")
+    a2 = object()
+    provider = providers.Dict() \
+        .add_kwargs(a1="i1") \
+        .add_kwargs({a2: "i2"})
+    assert provider.kwargs == {"a1": "i1", a2: "i2"}
 
-        provider_copy = providers.deepcopy(provider)
 
-        assert provider is not provider_copy
+def test_set_kwargs():
-        assert provider.kwargs == provider_copy.kwargs
+    provider = providers.Dict() \
-        assert isinstance(provider, providers.Dict)
+        .add_kwargs(a1="i1", a2="i2") \
+        .set_kwargs(a3="i3", a4="i4")
+    assert provider.kwargs == {"a3": "i3", "a4": "i4"}
 
-    def test_deepcopy_from_memo(self):
-        provider = providers.Dict(a1="i1", a2="i2")
-        provider_copy_memo = providers.Dict(a1="i1", a2="i2")
 
-        provider_copy = providers.deepcopy(
+def test_set_kwargs_non_string_keys():
-            provider,
+    a3 = object()
-            memo={id(provider): provider_copy_memo},
+    a4 = object()
-        )
+    provider = providers.Dict() \
+        .add_kwargs(a1="i1", a2="i2") \
+        .set_kwargs({a3: "i3", a4: "i4"})
+    assert provider.kwargs == {a3: "i3", a4: "i4"}
 
-        assert provider_copy is provider_copy_memo
 
-    def test_deepcopy_kwargs(self):
+def test_set_kwargs_string_and_non_string_keys():
-        provider = providers.Dict()
+    a3 = object()
-        dependent_provider1 = providers.Factory(list)
+    provider = providers.Dict() \
-        dependent_provider2 = providers.Factory(dict)
+        .add_kwargs(a1="i1", a2="i2") \
+        .set_kwargs({a3: "i3"}, a4="i4")
+    assert provider.kwargs == {a3: "i3", "a4": "i4"}
 
-        provider.add_kwargs(d1=dependent_provider1, d2=dependent_provider2)
 
-        provider_copy = providers.deepcopy(provider)
+def test_clear_kwargs():
-        dependent_provider_copy1 = provider_copy.kwargs["d1"]
+    provider = providers.Dict() \
-        dependent_provider_copy2 = provider_copy.kwargs["d2"]
+        .add_kwargs(a1="i1", a2="i2") \
+        .clear_kwargs()
+    assert provider.kwargs == {}
 
-        assert provider.kwargs != provider_copy.kwargs
 
-        assert dependent_provider1.cls is dependent_provider_copy1.cls
+def test_call_overridden():
-        assert dependent_provider1 is not dependent_provider_copy1
+    provider = providers.Dict(a1="i1", a2="i2")
+    overriding_provider1 = providers.Dict(a2="i2", a3="i3")
+    overriding_provider2 = providers.Dict(a3="i3", a4="i4")
 
-        assert dependent_provider2.cls is dependent_provider_copy2.cls
+    provider.override(overriding_provider1)
-        assert dependent_provider2 is not dependent_provider_copy2
+    provider.override(overriding_provider2)
 
-    def test_deepcopy_kwargs_non_string_keys(self):
+    instance1 = provider()
-        a1 = object()
+    instance2 = provider()
-        a2 = object()
 
-        dependent_provider1 = providers.Factory(list)
+    assert instance1 is not instance2
-        dependent_provider2 = providers.Factory(dict)
+    assert instance1 == {"a3": "i3", "a4": "i4"}
+    assert instance2 == {"a3": "i3", "a4": "i4"}
 
-        provider = providers.Dict({a1: dependent_provider1, a2: dependent_provider2})
 
-        provider_copy = providers.deepcopy(provider)
+def test_deepcopy():
-        dependent_provider_copy1 = provider_copy.kwargs[a1]
+    provider = providers.Dict(a1="i1", a2="i2")
-        dependent_provider_copy2 = provider_copy.kwargs[a2]
 
-        assert provider.kwargs != provider_copy.kwargs
+    provider_copy = providers.deepcopy(provider)
 
-        assert dependent_provider1.cls is dependent_provider_copy1.cls
+    assert provider is not provider_copy
-        assert dependent_provider1 is not dependent_provider_copy1
+    assert provider.kwargs == provider_copy.kwargs
+    assert isinstance(provider, providers.Dict)
 
-        assert dependent_provider2.cls is dependent_provider_copy2.cls
-        assert dependent_provider2 is not dependent_provider_copy2
 
-    def test_deepcopy_overridden(self):
+def test_deepcopy_from_memo():
-        provider = providers.Dict()
+    provider = providers.Dict(a1="i1", a2="i2")
-        object_provider = providers.Object(object())
+    provider_copy_memo = providers.Dict(a1="i1", a2="i2")
 
-        provider.override(object_provider)
+    provider_copy = providers.deepcopy(
+        provider,
+        memo={id(provider): provider_copy_memo},
+    )
 
-        provider_copy = providers.deepcopy(provider)
+    assert provider_copy is provider_copy_memo
-        object_provider_copy = provider_copy.overridden[0]
 
-        assert provider is not provider_copy
-        assert provider.kwargs == provider_copy.kwargs
-        assert isinstance(provider, providers.Dict)
 
-        assert object_provider is not object_provider_copy
+def test_deepcopy_kwargs():
-        assert isinstance(object_provider_copy, providers.Object)
+    provider = providers.Dict()
+    dependent_provider1 = providers.Factory(list)
+    dependent_provider2 = providers.Factory(dict)
 
-    def test_deepcopy_with_sys_streams(self):
+    provider.add_kwargs(d1=dependent_provider1, d2=dependent_provider2)
-        provider = providers.Dict()
-        provider.add_kwargs(stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr)
 
-        provider_copy = providers.deepcopy(provider)
+    provider_copy = providers.deepcopy(provider)
+    dependent_provider_copy1 = provider_copy.kwargs["d1"]
+    dependent_provider_copy2 = provider_copy.kwargs["d2"]
 
-        assert provider is not provider_copy
+    assert provider.kwargs != provider_copy.kwargs
-        assert isinstance(provider_copy, providers.Dict)
-        assert provider.kwargs["stdin"] is sys.stdin
-        assert provider.kwargs["stdout"] is sys.stdout
-        assert provider.kwargs["stderr"] is sys.stderr
 
-    def test_repr(self):
+    assert dependent_provider1.cls is dependent_provider_copy1.cls
-        provider = providers.Dict(a1=1, a2=2)
+    assert dependent_provider1 is not dependent_provider_copy1
-        assert repr(provider) == (
+
-            "<dependency_injector.providers."
+    assert dependent_provider2.cls is dependent_provider_copy2.cls
-            "Dict({0}) at {1}>".format(repr(provider.kwargs), hex(id(provider)))
+    assert dependent_provider2 is not dependent_provider_copy2
-        )
+
+
+def test_deepcopy_kwargs_non_string_keys():
+    a1 = object()
+    a2 = object()
+
+    dependent_provider1 = providers.Factory(list)
+    dependent_provider2 = providers.Factory(dict)
+
+    provider = providers.Dict({a1: dependent_provider1, a2: dependent_provider2})
+
+    provider_copy = providers.deepcopy(provider)
+    dependent_provider_copy1 = provider_copy.kwargs[a1]
+    dependent_provider_copy2 = provider_copy.kwargs[a2]
+
+    assert provider.kwargs != provider_copy.kwargs
+
+    assert dependent_provider1.cls is dependent_provider_copy1.cls
+    assert dependent_provider1 is not dependent_provider_copy1
+
+    assert dependent_provider2.cls is dependent_provider_copy2.cls
+    assert dependent_provider2 is not dependent_provider_copy2
+
+
+def test_deepcopy_overridden():
+    provider = providers.Dict()
+    object_provider = providers.Object(object())
+
+    provider.override(object_provider)
+
+    provider_copy = providers.deepcopy(provider)
+    object_provider_copy = provider_copy.overridden[0]
+
+    assert provider is not provider_copy
+    assert provider.kwargs == provider_copy.kwargs
+    assert isinstance(provider, providers.Dict)
+
+    assert object_provider is not object_provider_copy
+    assert isinstance(object_provider_copy, providers.Object)
+
+
+def test_deepcopy_with_sys_streams():
+    provider = providers.Dict()
+    provider.add_kwargs(stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr)
+
+    provider_copy = providers.deepcopy(provider)
+
+    assert provider is not provider_copy
+    assert isinstance(provider_copy, providers.Dict)
+    assert provider.kwargs["stdin"] is sys.stdin
+    assert provider.kwargs["stdout"] is sys.stdout
+    assert provider.kwargs["stderr"] is sys.stderr
+
+
+def test_repr():
+    provider = providers.Dict(a1=1, a2=2)
+    assert repr(provider) == (
+        "<dependency_injector.providers."
+        "Dict({0}) at {1}>".format(repr(provider.kwargs), hex(id(provider)))
+    )

tests/unit/providers/test_list_py2_py3.py

@@ -1,4 +1,4 @@
-"""Dependency injector list provider unit tests."""
+"""List provider tests."""
 
 import sys