def test_deepcopy_from_memo():
provider = providers.List(1, 2)
provider_copy_memo = providers.List(1, 2)
provider_copy = providers.deepcopy(provider,
memo={id(provider): provider_copy_memo})
assert provider_copy is provider_copy_memo
def test_deepcopy_from_memo(self):
provider = providers.List(1, 2)
provider_copy_memo = providers.List(1, 2)
provider_copy = providers.deepcopy(
provider, memo={id(provider): provider_copy_memo})
self.assertIs(provider_copy, provider_copy_memo)
def test_traverse_overridden(self):
provider1 = providers.Object('bar')
provider2 = providers.Object('baz')
provider3 = providers.List(provider1, provider2)
provider = providers.List('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.List(provider1, provider2)
provider = providers.List("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.List(1, 2)
overriding_provider1 = providers.List(2, 3)
overriding_provider2 = providers.List(3, 4)
provider.override(overriding_provider1)
provider.override(overriding_provider2)
instance1 = provider()
instance2 = provider()
assert instance1 is not instance2
assert instance1 == [3, 4]
assert instance2 == [3, 4]
def test_call_overridden(self):
provider = providers.List(1, 2)
overriding_provider1 = providers.List(2, 3)
overriding_provider2 = providers.List(3, 4)
provider.override(overriding_provider1)
provider.override(overriding_provider2)
instance1 = provider()
instance2 = provider()
self.assertIsNot(instance1, instance2)
self.assertEqual(instance1, [3, 4])
self.assertEqual(instance2, [3, 4])
class ApplicationContainer(containers.DeclarativeContainer):
"""Application container."""
config = providers.Configuration()
configure_logging = providers.Callable(
logging.basicConfig,
stream=sys.stdout,
level=config.log.level,
format=config.log.format,
)
http_client = providers.Factory(http.HttpClient)
example_monitor = providers.Factory(
monitors.HttpMonitor,
http_client=http_client,
options=config.monitors.example,
)
httpbin_monitor = providers.Factory(
monitors.HttpMonitor,
http_client=http_client,
options=config.monitors.httpbin,
)
dispatcher = providers.Factory(
dispatcher.Dispatcher,
monitors=providers.List(
example_monitor,
httpbin_monitor,
),
)
def test_repr(self):
provider = providers.List(1, 2)
self.assertEqual(
repr(provider), '<dependency_injector.providers.'
'List({0}) at {1}>'.format(repr(list(provider.args)),
hex(id(provider))))
class Container(containers.DeclarativeContainer):
config = providers.Configuration(yaml_files=["config.yml"])
logging = providers.Resource(
logging.basicConfig,
stream=sys.stdout,
level=config.log.level,
format=config.log.format,
)
http_client = providers.Factory(http.HttpClient)
example_monitor = providers.Factory(
monitors.HttpMonitor,
http_client=http_client,
options=config.monitors.example,
)
httpbin_monitor = providers.Factory(
monitors.HttpMonitor,
http_client=http_client,
options=config.monitors.httpbin,
)
dispatcher = providers.Factory(
dispatcher.Dispatcher,
monitors=providers.List(
example_monitor,
httpbin_monitor,
),
)
def test_puzzled(self):
service = providers.Singleton(Service, value='foo-bar')
dependency = providers.Object(
{
'a': {
'b': {
'c1': 10,
'c2': lambda arg: {'arg': arg}
},
},
},
)
test_list = providers.List(
dependency.provided['a']['b']['c1'],
dependency.provided['a']['b']['c2'].call(22)['arg'],
dependency.provided['a']['b']['c2'].call(service)['arg'],
dependency.provided['a']['b']['c2'].call(service)['arg'].value,
dependency.provided['a']['b']['c2'].call(service)['arg'].get_value.call(),
)
result = test_list()
self.assertEqual(
result,
[
10,
22,
service(),
'foo-bar',
'foo-bar',
],
)
def test_puzzled():
service = providers.Singleton(Service, value="foo-bar")
dependency = providers.Object(
{
"a": {
"b": {
"c1": 10,
"c2": lambda arg: {
"arg": arg
}
},
},
}, )
test_list = providers.List(
dependency.provided["a"]["b"]["c1"],
dependency.provided["a"]["b"]["c2"].call(22)["arg"],
dependency.provided["a"]["b"]["c2"].call(service)["arg"],
dependency.provided["a"]["b"]["c2"].call(service)["arg"].value,
dependency.provided["a"]["b"]["c2"].call(service)
["arg"].get_value.call(),
)
result = test_list()
assert result == [
10,
22,
service(),
"foo-bar",
"foo-bar",
]
class Container(containers.DeclarativeContainer):
config = providers.Configuration()
logging = providers.Resource(
logging.basicConfig,
stream=sys.stdout,
level=config.log.level,
format=config.log.format,
)
coloredlogs.install()
sessions = providers.Singleton(session_storage.SessionStorage,
config.telegram)
configurator = providers.Singleton(Configurator, sessions)
mqtt = providers.Singleton(Mosquitto, configurator, sessions, config.mqtt)
startup = providers.Singleton(Startup, sessions, mqtt)
dispatcher = providers.Factory(dispatcher.Dispatcher,
dispatchables=providers.List(
mqtt,
startup,
))
def test_deepcopy():
provider = providers.List(1, 2)
provider_copy = providers.deepcopy(provider)
assert provider is not provider_copy
assert provider.args == provider_copy.args
assert isinstance(provider, providers.List)
def test_required_as_(config):
provider = providers.List(
config.int_test.required().as_int(),
config.float_test.required().as_float(),
config._as_test.required().as_(decimal.Decimal),
)
config.from_dict({"int_test": "1", "float_test": "2.0", "_as_test": "3.0"})
assert provider() == [1, 2.0, decimal.Decimal("3.0")]
def test_deepcopy(self):
provider = providers.List(1, 2)
provider_copy = providers.deepcopy(provider)
self.assertIsNot(provider, provider_copy)
self.assertEqual(provider.args, provider_copy.args)
self.assertIsInstance(provider, providers.List)
def test_call_with_init_positional_args():
provider = providers.List("i1", "i2")
list1 = provider()
list2 = provider()
assert list1 == ["i1", "i2"]
assert list2 == ["i1", "i2"]
assert list1 is not list2
def test_required_as_(self):
provider = providers.List(
self.config.int_test.required().as_int(),
self.config.float_test.required().as_float(),
self.config._as_test.required().as_(decimal.Decimal),
)
self.config.from_dict({'int_test': '1', 'float_test': '2.0', '_as_test': '3.0'})
self.assertEqual(provider(), [1, 2.0, decimal.Decimal('3.0')])
def test_init_optional():
list_provider = providers.List(1, 2, 3)
provider = providers.Dependency()
provider.set_instance_of(list)
provider.set_default(list_provider)
assert provider.instance_of is list
assert provider.default is list_provider
assert provider() == [1, 2, 3]
class Container(containers.DeclarativeContainer):
dispatcher_factory = providers.Factory(
Dispatcher,
modules=providers.List(
providers.Factory(Module, name='m1'),
providers.Factory(Module, name='m2'),
),
)
def test_init_optional(self):
list_provider = providers.List(1, 2, 3)
provider = providers.Dependency()
provider.set_instance_of(list)
provider.set_default(list_provider)
self.assertIs(provider.instance_of, list)
self.assertIs(provider.default, list_provider)
self.assertEqual(provider(), [1, 2, 3])
def test_traverse_args(self):
provider1 = providers.Object('bar')
provider2 = providers.Object('baz')
provider = providers.List('foo', provider1, provider2)
all_providers = list(provider.traverse())
self.assertEqual(len(all_providers), 2)
self.assertIn(provider1, all_providers)
self.assertIn(provider2, all_providers)
def test_traverse_args():
provider1 = providers.Object("bar")
provider2 = providers.Object("baz")
provider = providers.List("foo", provider1, 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_init_positional_args(self):
provider = providers.List('i1', 'i2')
list1 = provider()
list2 = provider()
self.assertEqual(list1, ['i1', 'i2'])
self.assertEqual(list2, ['i1', 'i2'])
self.assertIsNot(list1, list2)
def test_deepcopy_with_sys_streams():
provider = providers.List()
provider.add_args(sys.stdin, sys.stdout, sys.stderr)
provider_copy = providers.deepcopy(provider)
assert provider is not provider_copy
assert isinstance(provider_copy, providers.List)
assert provider.args[0] is sys.stdin
assert provider.args[1] is sys.stdout
assert provider.args[2] is sys.stderr
def test_deepcopy_with_sys_streams(self):
provider = providers.List()
provider.add_args(sys.stdin, sys.stdout, sys.stderr)
provider_copy = providers.deepcopy(provider)
self.assertIsNot(provider, provider_copy)
self.assertIsInstance(provider_copy, providers.List)
self.assertIs(provider.args[0], sys.stdin)
self.assertIs(provider.args[1], sys.stdout)
self.assertIs(provider.args[2], sys.stderr)
class ApplicationContainer(containers.DeclarativeContainer):
app = aiohttp.Application(
web.Application,
middlewares=providers.List(
aiohttp.Middleware(middleware),
aiohttp.MiddlewareFactory(middleware_factory, text=' wink2'),
),
)
index_view = aiohttp.View(index)
test_view = aiohttp.View(test)
test_class_view = aiohttp.ClassBasedView(Test)
class ApplicationContainer(containers.DeclarativeContainer):
app = aiohttp.Application(
web.Application,
middlewares=providers.List(
aiohttp.Middleware(middleware),
aiohttp.MiddlewareFactory(middleware_factory, text=" wink2"),
),
)
index_view = aiohttp.View(index_view)
second_view = aiohttp.View(second_view)
other_class_based_view = aiohttp.ClassBasedView(OtherClassBasedView)
def test_deepcopy_overridden():
provider = providers.List()
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.args == provider_copy.args
assert isinstance(provider, providers.List)
assert object_provider is not object_provider_copy
assert isinstance(object_provider_copy, providers.Object)
def test_deepcopy_overridden(self):
provider = providers.List()
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.args, provider_copy.args)
self.assertIsInstance(provider, providers.List)
self.assertIsNot(object_provider, object_provider_copy)
self.assertIsInstance(object_provider_copy, providers.Object)
def test_deepcopy_args(self):
provider = providers.List()
dependent_provider1 = providers.Factory(list)
dependent_provider2 = providers.Factory(dict)
provider.add_args(dependent_provider1, dependent_provider2)
provider_copy = providers.deepcopy(provider)
dependent_provider_copy1 = provider_copy.args[0]
dependent_provider_copy2 = provider_copy.args[1]
self.assertNotEqual(provider.args, provider_copy.args)
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)
