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)
