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_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 __init__(self): injector = Injector(MyAppModule()) #connect_to_db() #read_config_files() self.server = injector.get_instance(Server) self.server.start()
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)
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 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_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_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_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 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)
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)
class test_provides_decorator(object): 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 test_the_location_was_injected(self): assert isinstance(self.location, ch.Beach)
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 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 when_asking_for_a_class_not_bound_by_a_module(self): injector = Injector([]) self.person = injector.get_instance(ch.Person)
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')