def __init__(self):
injector = Injector(MyAppModule())
#connect_to_db()
#read_config_files()
self.server = injector.get_instance(Server)
self.server.start()
def describe_injecting_a_class():
class IClass(object):
pass
class MyClass(object):
pass
class DomainObject(object):
@inject(class_=IClass)
def __init__(self, class_):
self.class_ = class_
class Module(object):
def configure(self, binder):
binder.bind(IClass, to_instance=MyClass)
injector = Injector(Module())
instance = injector.get_instance(DomainObject)
def a_class_object_should_have_been_injected():
assert instance.class_ is MyClass
def describe_injecting_a_subclass():
class SubDomainObject(DomainObject):
pass
def a_class_object_should_have_been_injected():
assert instance.class_ is MyClass
def describe_injecting_a_class():
class IClass(object):
pass
class MyClass(object):
pass
class DomainObject(object):
@inject(class_=IClass)
def __init__(self, class_):
self.class_ = class_
class Module(object):
def configure(self, binder):
binder.bind(IClass, to_instance=MyClass)
injector = Injector(Module())
instance = injector.get_instance(DomainObject)
def a_class_object_should_have_been_injected():
assert instance.class_ is MyClass
def describe_injecting_a_subclass():
class SubDomainObject(DomainObject):
pass
def a_class_object_should_have_been_injected():
assert instance.class_ is MyClass
def describe_providing_an_object_with_dependencies():
class SomeInterface(object): pass
class SomeImpl(object):
def __init__(self, other_dep):
self.other_dep = other_dep
class SomeOtherDependency(object): pass
class Module(object):
@provides(SomeInterface)
@inject(other_dep=SomeOtherDependency)
def aSomeInterfaceFactory(self, other_dep):
return SomeImpl(other_dep)
def configure(self, binder):
pass
injector = Injector(Module())
some_instance = injector.get_instance(SomeInterface)
def should_return_the_implementation():
assert isinstance(some_instance, SomeImpl)
def should_have_its_dependencies_injected():
assert isinstance(some_instance.other_dep, SomeOtherDependency)
def test_injector_simple():
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=ch.EvilPerson)
injector = Injector(MyModule())
person = injector.get_instance(ch.Person)
assert isinstance(person, ch.EvilPerson)
def test_injector_simple():
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=ch.EvilPerson)
injector = Injector(MyModule())
person = injector.get_instance(ch.Person)
assert isinstance(person, ch.EvilPerson)
def setup(self):
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=ch.EvilPerson)
binder.bind(ch.Logger, to_instance=ch.ConcreteLogger())
binder.bind(ch.Person, annotated_with='good', to=ch.GoodPerson)
binder.bind(ch.Person, annotated_with='evil', to=ch.EvilPerson)
self.injector = Injector(MyModule())
self.interceptor = ParameterInterceptor(self.injector)
def test_injector_injecting_from_a_provider():
class SimpleProvider(object):
def get(self):
return ch.GoodPerson()
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to_provider=SimpleProvider)
injector = Injector(MyModule())
person = injector.get_instance(ch.Person)
assert isinstance(person, ch.GoodPerson)
def test_injector_injecting_from_a_provider():
class SimpleProvider(object):
def get(self):
return ch.GoodPerson()
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to_provider=SimpleProvider)
injector = Injector(MyModule())
person = injector.get_instance(ch.Person)
assert isinstance(person, ch.GoodPerson)
def test_singleton_has_injector_scope(self):
class MyModule:
def configure(self, binder):
binder.bind(ch.Place, to=ch.Beach, in_scope=scopes.SINGLETON)
injector_a = Injector(MyModule())
injector_b = Injector(MyModule())
place_a = injector_a.get_instance(ch.Place)
place_b = injector_a.get_instance(ch.Place)
place_c = injector_b.get_instance(ch.Place)
assert place_a is place_b
assert place_b is not place_c
def describe_solving_the_robot_legs_problem():
injector = Injector(MyModule())
robot = injector.get_instance(IRobot)
def should_return_an_instance():
assert isinstance(robot, Robot)
def should_have_Leg_instances():
assert isinstance(robot.left_leg, Leg)
assert isinstance(robot.right_leg, Leg)
def should_have_the_correct_Feet_instances():
assert isinstance(robot.left_leg.foot, LeftFoot)
assert isinstance(robot.right_leg.foot, RightFoot)
def test_simple_singleton(self):
class MyModule:
def configure(self, binder):
binder.bind(ch.Place, to=ch.Beach,
in_scope=scopes.SINGLETON)
obj = Injector(MyModule()).get_instance(self.SimpleClass)
def setup(self):
class HappyPerson(object):
def get_home_location(self):
return ch.Beach()
class PeopleModule(object):
def configure(self, binder):
binder.bind(ch.Person, to=HappyPerson)
@provides(ch.Place)
@inject(person=ch.Person)
def provide_a_persons_home_location(self, person):
return person.get_home_location()
self.injector = Injector(PeopleModule())
self.location = self.injector.get_instance(ch.Place)
class TestMethodInterceptors(object):
def setup(self):
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=ch.EvilPerson)
binder.bind(ch.Logger, to_instance=ch.ConcreteLogger())
binder.bind(ch.Person, annotated_with='good', to=ch.GoodPerson)
binder.bind(ch.Person, annotated_with='evil', to=ch.EvilPerson)
self.injector = Injector(MyModule())
self.interceptor = ParameterInterceptor(self.injector)
def test_noargs(self):
class DomainObject(object):
@self.interceptor(person=ch.Person, annotation='evil')
def intercept_me(self, person):
assert isinstance(person, ch.EvilPerson)
obj = self.injector.get_instance(DomainObject)
obj.intercept_me()
def test_args(self):
class DomainObject(object):
@self.interceptor(person=ch.Person, annotation='evil')
def intercept_me(self,
arg0,
kwarg0=None,
kwarg1=None,
person=None):
assert arg0 == 0
assert kwarg0 == 1
assert kwarg1 is None
assert isinstance(person, ch.EvilPerson)
obj = self.injector.get_instance(DomainObject)
obj.intercept_me(0, kwarg0=1)
def test_stacking(self):
class DomainObject(object):
@self.interceptor(person0=ch.Person, annotation='good')
@self.interceptor(person1=ch.Person, annotation='evil')
def intercept_me(self, person0, person1):
assert isinstance(person0, ch.GoodPerson)
assert isinstance(person1, ch.EvilPerson)
obj = self.injector.get_instance(DomainObject)
obj.intercept_me()
def describe_providing_an_object_with_no_dependencies():
class SomeInterface(object): pass
class SomeImpl(object): pass
class Module(object):
@provides(SomeInterface)
def aSomeInterfaceFactory(self):
return SomeImpl()
def configure(self, binder):
pass
injector = Injector(Module())
some_instance = injector.get_instance(SomeInterface)
def should_return_the_implementation():
assert isinstance(some_instance, SomeImpl)
class TestMethodInterceptors(object):
def setup(self):
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=ch.EvilPerson)
binder.bind(ch.Logger, to_instance=ch.ConcreteLogger())
binder.bind(ch.Person, annotated_with='good', to=ch.GoodPerson)
binder.bind(ch.Person, annotated_with='evil', to=ch.EvilPerson)
self.injector = Injector(MyModule())
self.interceptor = ParameterInterceptor(self.injector)
def test_noargs(self):
class DomainObject(object):
@self.interceptor(person=ch.Person, annotation='evil')
def intercept_me(self, person):
assert isinstance(person, ch.EvilPerson)
obj = self.injector.get_instance(DomainObject)
obj.intercept_me()
def test_args(self):
class DomainObject(object):
@self.interceptor(person=ch.Person, annotation='evil')
def intercept_me(self, arg0,
kwarg0=None, kwarg1=None, person=None):
assert arg0 == 0
assert kwarg0 == 1
assert kwarg1 is None
assert isinstance(person, ch.EvilPerson)
obj = self.injector.get_instance(DomainObject)
obj.intercept_me(0, kwarg0=1)
def test_stacking(self):
class DomainObject(object):
@self.interceptor(person0=ch.Person, annotation='good')
@self.interceptor(person1=ch.Person, annotation='evil')
def intercept_me(self, person0, person1):
assert isinstance(person0, ch.GoodPerson)
assert isinstance(person1, ch.EvilPerson)
obj = self.injector.get_instance(DomainObject)
obj.intercept_me()
def setup(self):
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=ch.EvilPerson)
binder.bind(ch.Logger, to_instance=ch.ConcreteLogger())
binder.bind(ch.Person, annotated_with='good', to=ch.GoodPerson)
binder.bind(ch.Person, annotated_with='evil', to=ch.EvilPerson)
self.injector = Injector(MyModule())
self.interceptor = ParameterInterceptor(self.injector)
def test_inject_provider_with_args():
class PersonProvider(object):
def get(self, typ):
if typ == 'good':
return ch.GoodPerson
elif typ == 'evil':
return ch.EvilPerson
else:
return None
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=PersonProvider)
injector = Injector(MyModule())
person_provider = injector.get_instance(ch.Person)
assert person_provider.get('good') == ch.GoodPerson
assert person_provider.get('evil') == ch.EvilPerson
assert person_provider.get('clueless') is None
def test_annotated_injector():
class DomainObject(object):
@inject(person0=ch.Person, person1=ch.Person, person2=ch.Person)
@annotate(person0='good', person1='evil')
def __init__(self, person0, person1, person2):
self.person0 = person0
self.person1 = person1
self.person2 = person2
class MyModule:
def configure(self, binder):
binder.bind(DomainObject, to=DomainObject)
binder.bind(ch.Person, annotated_with='evil', to=ch.EvilPerson)
binder.bind(ch.Person, annotated_with='good', to=ch.GoodPerson)
injector = Injector(MyModule())
obj = injector.get_instance(DomainObject)
assert isinstance(obj.person0, ch.GoodPerson)
assert isinstance(obj.person1, ch.EvilPerson)
assert isinstance(obj.person2, ch.Person)
def test_inject_provider_with_args():
class PersonProvider(object):
def get(self, typ):
if typ == 'good':
return ch.GoodPerson
elif typ == 'evil':
return ch.EvilPerson
else:
return None
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=PersonProvider)
injector = Injector(MyModule())
person_provider = injector.get_instance(ch.Person)
assert person_provider.get('good') == ch.GoodPerson
assert person_provider.get('evil') == ch.EvilPerson
assert person_provider.get('clueless') is None
def test_to_instance(self):
class MyModule:
def configure(self, binder):
binder.bind(ch.Logger, to_instance=ch.ConcreteLogger())
binder.bind(ch.Place, annotated_with='hot',
to_instance=ch.Beach())
binder.bind(ch.Place, annotated_with='cold',
to_instance=ch.Glacier())
obj = Injector(MyModule()).get_instance(self.DomainObject)
self.assert_obj(obj)
def test_annotated_injector():
class DomainObject(object):
@inject(person0=ch.Person, person1=ch.Person, person2=ch.Person)
@annotate(person0='good', person1='evil')
def __init__(self, person0, person1, person2):
self.person0 = person0
self.person1 = person1
self.person2 = person2
class MyModule:
def configure(self, binder):
binder.bind(DomainObject, to=DomainObject)
binder.bind(ch.Person, annotated_with='evil', to=ch.EvilPerson)
binder.bind(ch.Person, annotated_with='good', to=ch.GoodPerson)
injector = Injector(MyModule())
obj = injector.get_instance(DomainObject)
assert isinstance(obj.person0, ch.GoodPerson)
assert isinstance(obj.person1, ch.EvilPerson)
assert isinstance(obj.person2, ch.Person)
def test_change_serie(self): """ undone yet""" injector = Injector(self.build_module()) series = injector.get_instance(SeriesData) series.current_serie = "ZPlop" self.assertTrue(series.current_serie.name == "ZPlop" ) series.current_serie = "Plop" self.assertTrue(series.current_serie.name == "Plop" ) series.current_serie.season.episode = 5 self.assertEquals(series.current_serie.season.episode.number, 5) series.current_serie.season = 10 self.assertEquals(series.current_serie.season.episode.number, 1)
def test_episode(self):
""" testing episode object """
injector = Injector(self.build_module())
datas = injector.get_instance(SeriesData)
serie = datas.current_serie
store = injector.get_instance(SeriesStore)
self.assertTrue(serie.name == "Plop")
next_episode = serie.season.episode
cur_episode = store.get_current_stored_episode(serie.name, 2)
print("current episode stored {}".format(cur_episode))
print("next ep number {}".format(next_episode.number))
self.assertTrue(cur_episode == next_episode.number)
self.assertTrue(cur_episode == 2)
self.assertTrue(len( next_episode.get_video_list() ) == 1)
self.assertTrue(len( serie.get_video_list() ) == 1)
def describe_injecting_configuration_with_the_default_adapter():
class MyWebService(object):
@inject(ipaddress=Config('config.ini:webservice:ipaddress'),
port=Config('config.ini:webservice:port'))
def __init__(self, ipaddress, port):
self.ipaddress = ipaddress
self.port = port
class ConfigModule(object):
def configure(self, binder):
config_loader = ConfigParserLoader('specs/config.ini')
config_loader.bind_configuration(binder)
injector = Injector(ConfigModule())
webservice = injector.get_instance(MyWebService)
def config_values_are_being_injected():
assert webservice.ipaddress == '127.0.0.1'
assert webservice.port == '9999'
def test_inject_decorator():
class DomainObject(object):
@inject(logger=ch.Logger)
def __init__(self, logger):
assert isinstance(logger, ch.ConcreteLogger)
@inject(person=ch.Person)
def do_something(self, person):
assert isinstance(person, ch.EvilPerson)
@inject(person=ch.Person, logger=ch.Logger)
def multipl(self, logger, person):
assert isinstance(person, ch.EvilPerson)
assert isinstance(logger, ch.ConcreteLogger)
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=ch.EvilPerson)
binder.bind(ch.Logger, to=ch.ConcreteLogger)
injector = Injector(MyModule())
o = injector.get_instance(DomainObject)
def test_annotations():
class DomainObject(object):
@inject(hero=ch.Person, villian=ch.Person, victim=ch.Person)
@annotate(hero='good', villian='evil')
def __init__(self, hero, villian, victim):
self.hero = hero
self.villian = villian
self.victim = victim
class ByStander(ch.Person):
pass
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, annotated_with='evil', to=ch.EvilPerson)
binder.bind(ch.Person, annotated_with='good', to=ch.GoodPerson)
binder.bind(ch.Person, to=ByStander)
injector = Injector(MyModule())
obj = injector.get_instance(DomainObject)
assert isinstance(obj.hero, ch.GoodPerson)
assert isinstance(obj.villian, ch.EvilPerson)
assert isinstance(obj.victim, ByStander)
def test_annotations():
class DomainObject(object):
@inject(hero=ch.Person, villian=ch.Person, victim=ch.Person)
@annotate(hero='good', villian='evil')
def __init__(self, hero, villian, victim):
self.hero = hero
self.villian = villian
self.victim = victim
class ByStander(ch.Person):
pass
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, annotated_with='evil', to=ch.EvilPerson)
binder.bind(ch.Person, annotated_with='good', to=ch.GoodPerson)
binder.bind(ch.Person, to=ByStander)
injector = Injector(MyModule())
obj = injector.get_instance(DomainObject)
assert isinstance(obj.hero, ch.GoodPerson)
assert isinstance(obj.villian, ch.EvilPerson)
assert isinstance(obj.victim, ByStander)
def test_inject_decorator():
class DomainObject(object):
@inject(logger=ch.Logger)
def __init__(self, logger):
assert isinstance(logger, ch.ConcreteLogger)
@inject(person=ch.Person)
def do_something(self, person):
assert isinstance(person, ch.EvilPerson)
@inject(person=ch.Person, logger=ch.Logger)
def multipl(self, logger, person):
assert isinstance(person, ch.EvilPerson)
assert isinstance(logger, ch.ConcreteLogger)
class MyModule:
def configure(self, binder):
binder.bind(ch.Person, to=ch.EvilPerson)
binder.bind(ch.Logger, to=ch.ConcreteLogger)
injector = Injector(MyModule())
o = injector.get_instance(DomainObject)
def _test_inject_into_singleton(self):
class MyLogger(object):
hot_place = inject(ch.Place, annotation='hot')
cold_place = inject(ch.Place, annotation='cold')
class MyModule:
def configure(self, binder):
binder.bind(ch.Logger, to=MyLogger, in_scope=scopes.SINGLETON)
binder.bind(ch.Place, annotated_with='hot',
to=ch.Beach, to_scope=scopes.SINGLETON)
binder.bind(ch.Place, annotated_with='cold',
to=ch.Glacier, to_scope=scopes.SINGLETON)
obj = Injector(MyModule()).get_instance(self.DomainObject)
self.assert_obj(obj)
assert obj.logger_a.hot_place is obj.place_a
assert obj.logger_a.cold_place is obj.place_c
def setup(self):
class HappyPerson(object):
def get_home_location(self):
return ch.Beach()
class PeopleModule(object):
def configure(self, binder):
binder.bind(ch.Person, to=HappyPerson)
@provides(ch.Place)
@inject(person=ch.Person)
def provide_a_persons_home_location(self, person):
return person.get_home_location()
self.injector = Injector(PeopleModule())
self.location = self.injector.get_instance(ch.Place)
def create_app():
""" Fake App factory function """
inj = Injector(TestAppModule())
return App(inj)
import cherrypy
from snakeguice import Injector
from controller import HelloWorld
from providers import UserProvider, RequestDataProvider
from scopes import CHERRYPY_REQUEST_SCOPE, CHERRYPY_SESSION_SCOPE
class Module(object):
def configure(self, binder):
binder.bind(UserProvider, to=UserProvider,
in_scope=CHERRYPY_SESSION_SCOPE)
binder.bind(RequestDataProvider, to=RequestDataProvider,
in_scope=CHERRYPY_REQUEST_SCOPE)
injector = Injector(Module())
controller = injector.get_instance(HelloWorld)
cherrypy.quickstart(controller, '/', 'config.ini')
def when_asking_for_a_class_not_bound_by_a_module(self):
injector = Injector([])
self.person = injector.get_instance(ch.Person)
def when_asking_for_a_class_not_bound_by_a_module(self):
injector = Injector([])
self.person = injector.get_instance(ch.Person)
