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(
provider,
memo={id(provider): provider_copy_memo},
)
self.assertIs(provider_copy, provider_copy_memo)
def test_deepcopy_from_memo():
provider = providers.Dict(a1="i1", a2="i2")
provider_copy_memo = providers.Dict(a1="i1", a2="i2")
provider_copy = providers.deepcopy(
provider,
memo={id(provider): provider_copy_memo},
)
assert provider_copy is provider_copy_memo
def test_traverse_overridden(self):
provider1 = providers.Object('bar')
provider2 = providers.Object('baz')
provider3 = providers.Dict(bar=provider1, baz=provider2)
provider = providers.Dict(foo='foo')
provider.override(provider3)
all_providers = list(provider.traverse())
self.assertEqual(len(all_providers), 3)
self.assertIn(provider1, all_providers)
self.assertIn(provider2, all_providers)
self.assertIn(provider3, all_providers)
def test_traverse_overridden():
provider1 = providers.Object("bar")
provider2 = providers.Object("baz")
provider3 = providers.Dict(bar=provider1, baz=provider2)
provider = providers.Dict(foo="foo")
provider.override(provider3)
all_providers = list(provider.traverse())
assert len(all_providers) == 3
assert provider1 in all_providers
assert provider2 in all_providers
assert provider3 in all_providers
def test_call_overridden():
provider = providers.Dict(a1="i1", a2="i2")
overriding_provider1 = providers.Dict(a2="i2", a3="i3")
overriding_provider2 = providers.Dict(a3="i3", a4="i4")
provider.override(overriding_provider1)
provider.override(overriding_provider2)
instance1 = provider()
instance2 = provider()
assert instance1 is not instance2
assert instance1 == {"a3": "i3", "a4": "i4"}
assert instance2 == {"a3": "i3", "a4": "i4"}
def test_call_overridden(self):
provider = providers.Dict(a1='i1', a2='i2')
overriding_provider1 = providers.Dict(a2='i2', a3='i3')
overriding_provider2 = providers.Dict(a3='i3', a4='i4')
provider.override(overriding_provider1)
provider.override(overriding_provider2)
instance1 = provider()
instance2 = provider()
self.assertIsNot(instance1, instance2)
self.assertEqual(instance1, {'a3': 'i3', 'a4': 'i4'})
self.assertEqual(instance2, {'a3': 'i3', 'a4': 'i4'})
def test_set_kwargs_non_string_keys():
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_non_string_keys(self):
a3 = object()
a4 = object()
provider = providers.Dict() \
.add_kwargs(a1='i1', a2='i2') \
.set_kwargs({a3: 'i3', a4: 'i4'})
self.assertEqual(provider.kwargs, {a3: 'i3', a4: 'i4'})
def test_add_kwargs_non_string_keys():
a1 = object()
a2 = object()
provider = providers.Dict() \
.add_kwargs({a1: "i1"}) \
.add_kwargs({a2: "i2"})
assert provider.kwargs == {a1: "i1", a2: "i2"}
def test_repr(self):
provider = providers.Dict(a1=1, a2=2)
self.assertEqual(repr(provider),
'<dependency_injector.providers.'
'Dict({0}) at {1}>'.format(
repr(provider.kwargs),
hex(id(provider))))
def test_add_kwargs_non_string_keys(self):
a1 = object()
a2 = object()
provider = providers.Dict() \
.add_kwargs({a1: 'i1'}) \
.add_kwargs({a2: 'i2'})
self.assertEqual(provider.kwargs, {a1: 'i1', a2: 'i2'})
def test_deepcopy(self):
provider = providers.Dict(a1='i1', a2='i2')
provider_copy = providers.deepcopy(provider)
self.assertIsNot(provider, provider_copy)
self.assertEqual(provider.kwargs, provider_copy.kwargs)
self.assertIsInstance(provider, providers.Dict)
def test_deepcopy():
provider = providers.Dict(a1="i1", a2="i2")
provider_copy = providers.deepcopy(provider)
assert provider is not provider_copy
assert provider.kwargs == provider_copy.kwargs
assert isinstance(provider, providers.Dict)
class Container(containers.DeclarativeContainer):
dispatcher_factory = providers.Factory(
Dispatcher,
command_handlers=providers.Dict({
CommandA: providers.Factory(HandlerA),
CommandB: providers.Factory(HandlerB),
}),
)
class Container(containers.DeclarativeContainer):
dispatcher_factory = providers.Factory(
Dispatcher,
modules=providers.Dict(
module1=providers.Factory(Module, name='m1'),
module2=providers.Factory(Module, name='m2'),
),
)
def test_call_with_init_keyword_args(self):
provider = providers.Dict(a1='i1', a2='i2')
dict1 = provider()
dict2 = provider()
self.assertEqual(dict1, {'a1': 'i1', 'a2': 'i2'})
self.assertEqual(dict2, {'a1': 'i1', 'a2': 'i2'})
self.assertIsNot(dict1, dict2)
def test_traverse_kwargs(self):
provider1 = providers.Object('bar')
provider2 = providers.Object('baz')
provider = providers.Dict(foo='foo', bar=provider1, baz=provider2)
all_providers = list(provider.traverse())
self.assertEqual(len(all_providers), 2)
self.assertIn(provider1, all_providers)
self.assertIn(provider2, all_providers)
def test_call_with_init_keyword_args():
provider = providers.Dict(a1="i1", a2="i2")
dict1 = provider()
dict2 = provider()
assert dict1 == {"a1": "i1", "a2": "i2"}
assert dict2 == {"a1": "i1", "a2": "i2"}
assert dict1 is not dict2
def test_traverse_kwargs():
provider1 = providers.Object("bar")
provider2 = providers.Object("baz")
provider = providers.Dict(foo="foo", bar=provider1, baz=provider2)
all_providers = list(provider.traverse())
assert len(all_providers) == 2
assert provider1 in all_providers
assert provider2 in all_providers
def test_call_with_context_keyword_args(self):
provider = providers.Dict(a1='i1', a2='i2')
self.assertEqual(
provider(a3='i3', a4='i4'),
{
'a1': 'i1',
'a2': 'i2',
'a3': 'i3',
'a4': 'i4'
},
)
def test_init_with_string_and_non_string_keys(self):
a1 = object()
provider = providers.Dict({a1: 'i1'}, a2='i2')
dict1 = provider()
dict2 = provider()
self.assertEqual(dict1, {a1: 'i1', 'a2': 'i2'})
self.assertEqual(dict2, {a1: 'i1', 'a2': 'i2'})
self.assertIsNot(dict1, dict2)
def test_init_with_string_and_non_string_keys():
a1 = object()
provider = providers.Dict({a1: "i1"}, a2="i2")
dict1 = provider()
dict2 = provider()
assert dict1 == {a1: "i1", "a2": "i2"}
assert dict2 == {a1: "i1", "a2": "i2"}
assert dict1 is not dict2
def test_deepcopy_with_sys_streams(self):
provider = providers.Dict()
provider.add_kwargs(stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr)
provider_copy = providers.deepcopy(provider)
self.assertIsNot(provider, provider_copy)
self.assertIsInstance(provider_copy, providers.Dict)
self.assertIs(provider.kwargs['stdin'], sys.stdin)
self.assertIs(provider.kwargs['stdout'], sys.stdout)
self.assertIs(provider.kwargs['stderr'], sys.stderr)
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_init_with_non_string_keys():
a1 = object()
a2 = object()
provider = providers.Dict({a1: "i1", a2: "i2"})
dict1 = provider()
dict2 = provider()
assert dict1 == {a1: "i1", a2: "i2"}
assert dict2 == {a1: "i1", a2: "i2"}
assert dict1 is not dict2
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_overridden(self):
provider = providers.Dict()
object_provider = providers.Object(object())
provider.override(object_provider)
provider_copy = providers.deepcopy(provider)
object_provider_copy = provider_copy.overridden[0]
self.assertIsNot(provider, provider_copy)
self.assertEqual(provider.kwargs, provider_copy.kwargs)
self.assertIsInstance(provider, providers.Dict)
self.assertIsNot(object_provider, object_provider_copy)
self.assertIsInstance(object_provider_copy, providers.Object)
def test_deepcopy_kwargs(self):
provider = providers.Dict()
dependent_provider1 = providers.Factory(list)
dependent_provider2 = providers.Factory(dict)
provider.add_kwargs(d1=dependent_provider1, d2=dependent_provider2)
provider_copy = providers.deepcopy(provider)
dependent_provider_copy1 = provider_copy.kwargs['d1']
dependent_provider_copy2 = provider_copy.kwargs['d2']
self.assertNotEqual(provider.kwargs, provider_copy.kwargs)
self.assertIs(dependent_provider1.cls, dependent_provider_copy1.cls)
self.assertIsNot(dependent_provider1, dependent_provider_copy1)
self.assertIs(dependent_provider2.cls, dependent_provider_copy2.cls)
self.assertIsNot(dependent_provider2, dependent_provider_copy2)
def test_deepcopy_kwargs():
provider = providers.Dict()
dependent_provider1 = providers.Factory(list)
dependent_provider2 = providers.Factory(dict)
provider.add_kwargs(d1=dependent_provider1, d2=dependent_provider2)
provider_copy = providers.deepcopy(provider)
dependent_provider_copy1 = provider_copy.kwargs["d1"]
dependent_provider_copy2 = provider_copy.kwargs["d2"]
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_kwargs_non_string_keys(self):
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]
self.assertNotEqual(provider.kwargs, provider_copy.kwargs)
self.assertIs(dependent_provider1.cls, dependent_provider_copy1.cls)
self.assertIsNot(dependent_provider1, dependent_provider_copy1)
self.assertIs(dependent_provider2.cls, dependent_provider_copy2.cls)
self.assertIsNot(dependent_provider2, dependent_provider_copy2)
