def test__resolve_many_lazy(self): class Base(object): pass class One(Base): pass class Two(Base): pass class Three(object): pass container = DIContainer({ 'one': {'type': One}, 'two': {'type': Two}, 'three': {'type': Three}, }) calls = 0 with mock.patch.object(container, 'resolve_many') as resolve_type_mock: lazy_type = container.resolve_many_lazy(Base) self.assertFalse(resolve_type_mock.called) lazy_type() self.assertTrue(resolve_type_mock.called)
def test__resolve_many(self): class Base(object): pass class One(Base): pass class Two(Base): pass class Three(object): pass container = DIContainer({ 'one': {'type': One}, 'two': {'type': Two}, 'three': {'type': Three}, }) calls = 0 for inst in container.resolve_many(Base): self.assertIsInstance(inst, Base) calls += 1 self.assertEqual(calls, 2)
def test__alias(self): test_instance_type = mock.Mock() container = DIContainer({ 'test_instance': { 'type': test_instance_type, 'args': { '': ["arg1", ], 'arg2': 'arg2', 'arg3': 'rel:inject_rel' }, 'properties': { 'prop1': 'prop1', 'prop2': 'prop2', 'prop3': 'rel:inject_alias' }, 'alias': ['alias_name'] }, 'inject_rel': { 'type': mock.Mock(), 'singleton': True, 'properties': { 'name': 'inject_rel' }, 'alias': ['inject_alias'] } }) instance = container.resolve("alias_name") inject_rel = container.resolve("inject_rel") test_instance_type.assert_called_with("arg1", arg2="arg2", arg3=inject_rel) self.assertEqual(instance.prop1, 'prop1') self.assertEqual(instance.prop2, 'prop2') self.assertEqual(instance.prop3, inject_rel)
def test__copy_config(self): """ Passes if the settings variable becomes copies and changes do not take effect. :return: """ conf = { 'a': { 'type': 'mock.Mock' } } container = DIContainer(conf) self.assertIn('a', container.settings) self.assertNotIn('b', container.settings) self.assertRaises(KeyError, lambda: container.resolve('b')) conf['b'] = { 'type': 'mock.MagicMock' } self.assertIn('a', container.settings) self.assertNotIn('b', container.settings) self.assertIsNotNone(container.resolve('a')) self.assertRaises(KeyError, lambda: container.resolve('b'))
def test__child_container(self): container = DIContainer({ 'one': { 'type': 'mock.Mock', 'properties': { 'source': 'parent' } }, 'two': { 'type': 'mock.Mock', 'properties': { 'source': 'parent' } } }) self.assertEqual(container.one.source, 'parent') self.assertEqual(container.two.source, 'parent') child_container = container.create_child_container({ 'two': { 'type': 'mock.Mock', 'properties': { 'source': 'child' } } }) self.assertEqual(child_container.one.source, 'parent') self.assertEqual(child_container.two.source, 'child') self.assertEqual(container.one.source, 'parent') self.assertEqual(container.two.source, 'parent')
def test__proxy_type_import_error(self): container = DIContainer( proxy_type_name='does.not.Exists', settings={ 'instance': DIConfig( type='mock.MagicMock') } ) self.assertRaises(ImportError, lambda: container.resolve_lazy("instance"))
def test__resolve_type(self): """ Passes if resolve type returns the configured type for key a. """ container = DIContainer({'a': { 'type': 'mock.Mock' }}) resolved_type = container.resolve_type('a') self.assertEqual(resolved_type, mock.Mock)
def test__resove_type_lazy(self): container = DIContainer({ 'instance': DIConfig( type='mock.MagicMock') }) with mock.patch.object(container, 'resolve_type') as resolve_type_mock: lazy_type = container.resolve_type_lazy('instance') self.assertFalse(resolve_type_mock.called) lazy_type() self.assertTrue(resolve_type_mock.called)
def test__resolve_lazy(self): container = DIContainer({ 'instance': DIConfig( type='mock.MagicMock') }) with mock.patch.object(container, 'resolve') as resolve_mock: lazy_instance = container.resolve_lazy('instance') self.assertFalse(resolve_mock.called) lazy_instance.some_function() self.assertTrue(resolve_mock.called) resolve_mock.assert_called_with('instance')
def inner_test(setting): container = DIContainer({ 'test_instance': DIConfig( type='mock.MagicMock', args={'serializer_constructor': setting}, properties={'serializer_property': setting}) }) instance = container.resolve('test_instance') self.assertEqual(instance.serializer_constructor, json) self.assertEqual(instance.serializer_property, json)
def inner_test(setting): container = DIContainer({ 'instance': DIConfig( type='mock.MagicMock', args={'attr_value_constructor': setting}, properties={'attr_value_property': setting}) }) instance = container.resolve('instance') self.assertEqual(instance.attr_value_constructor, ATTR_VALUE) self.assertEqual(instance.attr_value_property, ATTR_VALUE)
def inner_test(setting): container = DIContainer({ 'main_instance': DIConfig( type='mock.MagicMock', args={'python_version_construct': setting}, properties={'python_version_property': setting}) }) main = container.resolve('main_instance') self.assertEqual(main.python_version_construct, sys.version) self.assertEqual(main.python_version_property, sys.version)
def test_resolver_attr(self): container = DIContainer({}) container.register('python_sys', { 'type': 'mock.MagicMock', 'args': { 'version_info': attr('sys.version_info') } }) py_sys = container.resolve('python_sys') self.assertEqual(py_sys.version_info, sys.version_info)
def test__register_decorator(self): """ Passes if `MyService` becomes registered with the given settings. """ container = DIContainer({}) @container.register("my_service", settings=dict(properties={'foo': 'bar'})) class MyService(object): pass result = container.resolve("my_service") self.assertIsNotNone(result) self.assertEqual(result.foo, "bar")
def test__register_without_settings(self): """ Passes if `MyService` becomes registered without providing settings. """ container = DIContainer({}) @container.register("my_service") class MyService(object): pass result = container.resolve("my_service") self.assertIsNotNone(result) self.assertIsInstance(result, MyService)
def test__child_context(self): """ Passes if ... """ container = DIContainer({ 'one': { 'type': 'mock.Mock', 'properties': { 'source': 'outer_context', 'injected': 'rel:two' } }, 'two': { 'type': 'mock.Mock', 'properties': { 'source': 'outer_context' } } }) context_settings = { 'one': { 'type': 'mock.Mock', 'properties': { 'source': 'inner_context', 'injected': 'rel:three' } }, 'three': { 'type': 'mock.Mock', 'properties': { 'source': 'prelaced_context' } } } def inner_func(): return container.resolve("one") tbc = inner_func() self.assertEqual(tbc.source, 'outer_context') self.assertEqual(tbc.injected.source, 'outer_context') with container.context(context_settings): context_tbc = inner_func() self.assertEqual(context_tbc.source, 'inner_context') self.assertEqual(context_tbc.injected.source, 'prelaced_context') tbc = inner_func() self.assertEqual(tbc.source, 'outer_context') self.assertEqual(tbc.injected.source, 'outer_context')
def test__singleton(self): """ Passes if the singleton configuration works and the same instance if given if resolve is called twice. """ container = DIContainer({ 'singleton': DIConfig(type='mock.MagicMock', singleton=True) }) first = container.resolve('singleton') second = container.resolve('singleton') self.assertEqual(first, second) self.assertIn('singleton', container.singletons)
def test__resove_type_lazy_django(self): container = DIContainer( proxy_type_name='django.utils.functional.SimpleLazyObject', settings={ 'instance': DIConfig( type='mock.MagicMock') } ) with mock.patch.object(container, 'resolve_type') as resolve_type_mock: lazy_type = container.resolve_type_lazy('instance') self.assertFalse(resolve_type_mock.called) # Simple Lazy Object in not able to do so... self.assertRaises(Exception, lazy_type)
def test__resolve_lazy_django(self): container = DIContainer( proxy_type_name='django.utils.functional.SimpleLazyObject', settings={ 'instance': DIConfig( type='mock.MagicMock') } ) with mock.patch.object(container, 'resolve') as resolve_mock: lazy_instance = container.resolve_lazy('instance') self.assertFalse(resolve_mock.called) lazy_instance.some_function() self.assertTrue(resolve_mock.called) resolve_mock.assert_called_with('instance')
def inner_test(setting): container = DIContainer({ 'main_instance': DIConfig( type='mock.MagicMock', args={'referenced_instance_construct': setting}, properties={'referenced_instance_property': setting}), 'referenced_instance': DIConfig(type='mock.MagicMock', singleton=True) }) main = container.resolve('main_instance') referenced = container.resolve('referenced_instance') self.assertEqual(main.referenced_instance_construct, referenced) self.assertEqual(main.referenced_instance_property, referenced)
def test__non_singleton(self): """ Passes if the singleton configuration works and different instances are given if resolve is called twice. """ container = DIContainer({ 'non_singleton': DIConfig(type='mock.MagicMock', singleton=False) }) first = container.resolve('non_singleton') second = container.resolve('non_singleton') self.assertNotEqual(first, second) self.assertNotIn('non_singleton', container.singletons)
def test__extend_path(self): tmp_file = tempfile.NamedTemporaryFile(mode='w+b', suffix='.py', delete=False) tmp_file.write(bytes(b'# coding: utf-8\nclass DynamicDummy(object):\n pass')) tmp_file.close() basename = os.path.basename(tmp_file.name) filename, ext = os.path.splitext(basename) container = DIContainer({ 'dynamic': DIConfig(type='{0}:{1}.DynamicDummy'.format(tempfile.tempdir, filename)) }) instance = container.resolve('dynamic') self.assertIsNotNone(instance) module_ = sys.modules[filename] self.assertIsInstance(instance, module_.DynamicDummy) os.remove(tmp_file.name)
def test__del_singleton_on_register(self): """ Passes of the singletons instance becomes deleted on reregistering the name and replace it. """ type_conf = { "type": "mock.Mock", "singleton": True } container = DIContainer({ "test": type_conf }) t = container.resolve("test") self.assertTrue("test" in container.singletons) container.register("test", type_conf, replace=True) self.assertFalse("test" in container.singletons)
def test__inject(self): """ Passes if the instance with the key `service` becomes injected into a dummy function. """ container = DIContainer({'service': DIConfig(type=mock.Mock, singleton=True)}) @container.inject(service='service') def some_function(data, service): service.call_service_function(data) some_function('data') some_function(data='data', service=mock.Mock()) some_function('data', mock.Mock()) service = container.resolve('service') self.assertEqual(service.call_service_function.called, 1)
def test__assert_init_args(self): mock_types = mock.Mock() mock_types.ArgsCalledType = mock.Mock(name='ArgsCalledType') mock_types.KWargsCalledType = mock.Mock(name='KWargsCalledType') mock_types.MixedCalledType = mock.Mock(name='MixedCalledType') sys.modules['mock_types'] = mock_types args = [mock.Mock(), mock.Mock()] kwargs = {'a': mock.Mock(), 'b': mock.Mock()} mixed = {'': args} mixed.update(kwargs) container = DIContainer({ 'args_instance': DIConfig(type='mock_types.ArgsCalledType', args=args), 'kwargs_instance': DIConfig(type='mock_types.KWargsCalledType', args=kwargs), 'mixed_instance': DIConfig(type='mock_types.MixedCalledType', args=mixed) }) container.resolve('args_instance') self.assertEqual(mock_types.ArgsCalledType.called, 1) mock_types.ArgsCalledType.assert_called_with(*args) container.resolve('kwargs_instance') self.assertEqual(mock_types.KWargsCalledType.called, 1) mock_types.KWargsCalledType.assert_called_with(**kwargs) container.resolve('mixed_instance') self.assertEqual(mock_types.MixedCalledType.called, 1) mock_types.MixedCalledType.assert_called_with(*args, **kwargs)
def test__assert_type(self): """ Passes if the type resolution of `type_implemenation` works and the resolution of `no_type_implementation` raises a `ValueError`. :return: """ container = DIContainer({ 'type_implementation': DIConfig(type='mock.MagicMock', assert_type='mock.MagicMock'), 'no_type_implementation': DIConfig(type='object', assert_type='mock.MagicMock') }) resolved_instance = container.resolve('type_implementation') self.assertIsNotNone(resolved_instance) def raises(): container.resolve('no_type_implementation') self.assertRaises(TypeError, raises)
def test__simple_resolve(self): """ Passes if john is created with the given arguments and property settings. john must be resolvable by `resolve` method and by the containers __getitem__ method. """ john_config = self.get_john_doe_config() container = DIContainer({'john_doe': john_config}) john_resolve = container.resolve('john_doe') john_getitem = container.john_doe self.assertIsNotNone(john_resolve) self.assertIsNotNone(john_getitem) for john in (john_getitem, john_resolve): for key, value in john_config['args'].items(): self.assertEqual(getattr(john, key), value) for key, value in john_config['properties'].items(): self.assertEqual(getattr(john, key), value)
def test__constructor_args(self): """ Passes if the registered type becomes constructed with the overriding args and kwargs. """ mock_type = mock.Mock() container = DIContainer({ 'instance': { 'type': mock_type, 'args': {'arg1': 1, 'arg2': 'two'} } }) instance = container.resolve("instance") mock_type.assert_called_with(arg1=1, arg2='two') mock_type.reset_mock() instance = container.resolve("instance", arg1='one', arg2=2) mock_type.assert_called_with(arg1='one', arg2=2)
def test__register(self): """ Passes if `runtime_config` is not configured and is configured at the end of the test. the second registration raises an error. """ container = DIContainer({}) def raises_not_registred(): container.resolve('runtime_config') self.assertRaises(KeyError, raises_not_registred) container.register('runtime_config', {'type': 'mock.MagicMock'}) runtime_config = container.resolve('runtime_config') self.assertIsNotNone(runtime_config) def raises_already_registred(): container.register('runtime_config', {'type': 'mock.MagicMock'}) self.assertRaises(KeyError, raises_already_registred)
def test__mixin(self): """ Passes if the created instance is type of the basetype and the given mixins. """ base_type = type(str("BaseType"), (object,), {}) mixin_type = type(str("MixinType"), (object,), {}) other_type = type(str("OtherType"), (object,), {}) container = DIContainer({'a': { 'type': base_type, 'mixins': (mixin_type, 'mock.Mock') }}) a = container.resolve("a") self.assertIsInstance(a, base_type) self.assertIsInstance(a, mixin_type) self.assertIsInstance(a, mock.Mock) self.assertNotIsInstance(a, other_type)
app = Flask("Virtual lab manager") app.config.from_object('config.{}Config'.format(os.getenv('FLASK_ENV').capitalize())) CORS(app) authorizations = { 'Bearer Auth': { 'type': 'apiKey', 'in': 'header', 'name': 'Authorization' } } api = Api(app, doc='/api/', security='Bearer Auth', authorizations=authorizations) register_models(api) di = DIContainer(app.config) from service_interface.lab_controller import api as lab_ns from service_interface.workers_controller import api as worker_ns from service_interface.lab_types_controller import api as lab_types_ns from service_interface.auth_controller import api as auth_ns api.add_namespace(auth_ns, '/api/auth') api.add_namespace(lab_ns, '/api/labs') api.add_namespace(worker_ns, '/api/workers') api.add_namespace(lab_types_ns, '/api/lab-types') workers_observer_thread = worker_observer.start_workers_observer_thread(di.worker_repository)