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)