def test_inject_value_list(self):
processor = processors.ConstructorInjection()
processor.container = IocContainer()
event = sample_event('tests.watson.di.support.SampleDependencyAware')
event.target['init'] = ['test']
instance = processor(event)
assert instance.first_arg == 'test'
def test_definition_item_doesnt_exist(self):
container = IocContainer({
'definitions': {
'test': {}
}
})
container.get('test')
def test_get_item(self):
container = IocContainer({
'definitions': {
'test': {
'item': 'tests.watson.di.support.SampleDependency',
'type': 'singleton',
},
'test2': {
'item': 'tests.watson.di.support.sample_dependency',
'type': 'singleton',
},
'test3': {
'item': 'tests.watson.di.support.sample_dependency_with_args',
'type': 'singleton',
'init': {
'arg': 'some arg'
}
}
}
})
container.add('def', lambda container: 'something')
assert isinstance(container.get('test'), SampleDependency)
assert container.get('test2') == 'test'
assert container.get('def') == 'something'
assert container.get('def') == 'something'
assert container.get('test3') == 'some arg'
def test_create_container(self):
container = IocContainer()
assert repr(
container
) == '<watson.di.container.IocContainer: 0 param(s), 0 definition(s)>'
assert container.params == {}
assert container.definitions == {}
def test_set_from_str(self):
processor = processors.SetterInjection()
processor.container = IocContainer()
event = sample_event('tests.watson.di.support.SampleDependencyAware')
event.params['definition']['setter'] = {'basic_setter': 'arg'}
event.target = SampleDependencyAware()
processor(event)
assert event.target.value == 'arg'
def test_forward_no_method(self):
controller = SampleActionController()
controller.container = IocContainer()
request = Request.from_environ(sample_environ())
context = {'request': request}
controller.event = types.Event('test', params={'context': context})
controller.__action__ = 'do_method_forward'
assert controller.do_method_forward() == 'Another Response'
def test_inject_container(self):
container = IocContainer()
processor = processors.ContainerAware()
processor.container = container
event = sample_event('tests.watson.di.support.SampleDependencyAware')
event.target = SampleDependencyAware()
processor(event)
assert event.target.container == container
def test_inject_property(self):
processor = processors.AttributeInjection()
processor.container = IocContainer()
event = sample_event('tests.watson.di.support.SampleDependencyAware')
event.params['definition']['property'] = {'basic_property': 'test value'}
event.target = SampleDependencyAware()
processor(event)
assert event.target.basic_property == 'test value'
def test_set_from_dict(self):
processor = processors.SetterInjection()
processor.container = IocContainer()
event = sample_event('tests.watson.di.support.SampleDependencyAware')
event.params['definition']['setter'] = {'basic_dict_setter': {'kw1': 'one', 'kw2': 'two'}}
event.target = SampleDependencyAware()
processor(event)
assert event.target.kw1 == 'one'
assert event.target.kw2 == 'two'
def container(self):
"""Returns the applications IocContainer.
If no container has been created, a new container will be created
based on the dependencies within the application configuration.
"""
if not self._container:
self.container = IocContainer(self.config['dependencies'])
return self._container
def __init__(self):
self.container = IocContainer({
'definitions': {
'application.config': {
'item': {
'cache': {
'type': 'watson.cache.storage.Memory'
}
}
}
}
})
def test_prototype(self):
container = IocContainer({
'definitions': {
'test': {
'item': 'tests.watson.di.support.SampleDependency',
'type': 'prototype'
}
}
})
test1 = container.get('test')
test2 = container.get('test')
assert test1 != test2
def test_short_circuit(self):
environ = sample_environ()
route = LiteralRoute(
'test',
path='/',
options={'controller': 'tests.watson.framework.support.ShortCircuitedController'})
match = RouteMatch(route, {})
context = {'request': Request.from_environ(environ), 'route_match': match}
event = Event(
'something',
params={'container': IocContainer(), 'context': context})
listener = listeners.DispatchExecute({'404': 'page/404'})
response, view_model = listener(event)
assert isinstance(response, Response)
def test_overriden_template(self):
environ = sample_environ()
route = LiteralRoute(
'test',
path='/',
options={'controller': 'tests.watson.framework.support.SampleActionController'})
match = RouteMatch(route, {'action': 'view_model_template'})
context = {'request': Request.from_environ(environ), 'route_match': match}
event = Event(
'something',
params={'container': IocContainer(), 'context': context})
listener = listeners.DispatchExecute({'404': 'page/500'})
response, view_model = listener(event)
assert isinstance(view_model, views.Model)
assert view_model.template == 'sampleactioncontroller/404'
def test_short_circuit(self):
environ = sample_environ()
route = Route('test',
path='/',
options={
'controller':
'tests.watson.mvc.support.ShortCircuitedController'
})
match = RouteMatch(route, {
'controller':
'tests.watson.mvc.support.ShortCircuitedController'
})
event = Event('something',
params={
'route_match': match,
'container': IocContainer(),
'request': create_request_from_environ(environ)
})
listener = listeners.DispatchExecute({'404': 'page/404'})
response = listener(event)
assert isinstance(response, Response)
def test_initialized_invalid_dependency(self):
processor = processors.ConstructorInjection()
processor.container = IocContainer()
event = sample_event('tests.watson.di.support.DoesNotExist')
processor(event)
def test_add_item(self):
container = IocContainer()
container.add('dep', lambda container: 'something')
assert container.get('dep') == 'something'
def test_attach_invalid_processor(self):
container = IocContainer()
container.attach_processor('event.container.pre', 'test')
def test_add_instantiated(self):
container = IocContainer()
dep = SampleDependency()
container.add('dep', dep)
assert container.get('dep') == dep
def test_definition_doesnt_exist(self):
container = IocContainer()
container.get('test')
def test_add_dict(self):
container = IocContainer()
dep = {'something': 'test'}
container.add('dep', dep)
assert container.get('dep') == dep
