def describe_compositing_GuiceData_instances(): class GrandDaddy(object): pass g_data = GuiceData.from_class(GrandDaddy) g_data.init = object() g_data.methods = {'g_method': object(),'method': object()} class Daddy(GrandDaddy): pass d_data = GuiceData.from_class(Daddy) d_data.init = object() d_data.methods = {'d_method': object(),'method': object()} class Son(Daddy): pass s_data = GuiceData.from_class(Son) s_data.init = object() s_data.methods = {'s_method': object()} data = GuiceData.composite_from_class(Son) def should_have_create_a_new_GuiceData_instance(): assert isinstance(data, GuiceData) assert data not in (g_data, d_data, s_data) def should_have_all_unique_methods(): assert data.methods['g_method'] == g_data.methods['g_method'] assert data.methods['d_method'] == d_data.methods['d_method'] assert data.methods['s_method'] == s_data.methods['s_method'] def should_use_the_last_method_defined(): assert data.methods['method'] == d_data.methods['method']
def describe_when_using_builtin_types(): data0 = GuiceData.from_class(object) data1 = GuiceData.from_class(object) def should_have_gotten_GuiceData_instances(): assert isinstance(data0, GuiceData) assert isinstance(data1, GuiceData) def should_return_new_instance_each_time(): assert data0 is not data1 def should_not_be_storing_instance(): assert not hasattr(object, '__guice__')
def get(self): kwargs = {} method_name = method.__name__ guice_data = _GuiceData.from_class(module.__class__) injectable_args = guice_data.methods.get(method_name, {}) for name, guicearg in injectable_args.items(): kwargs[name] = self._injector.get_instance( guicearg.datatype, guicearg.annotation) return method(**kwargs)
def describe_with_instance_attached(): existing_data = GuiceData() class Dummy(object): __guice__ = existing_data data = GuiceData.from_class(Dummy) def should_return_existing_instance(): assert existing_data is data
def describe_without_instance_attached(): class Dummy(object): pass data = GuiceData.from_class(Dummy) def should_return_a_GuiceData_instance(): assert isinstance(data, GuiceData) def should_save_create_class_attribute(): assert Dummy.__guice__ is data
def AssistProvider(cls): guice_data = GuiceData.from_class(cls) if not getattr(guice_data, 'assisted', False): raise AssistError('AssistProvider can only by used on ' '@assisted_inject-ed classes') class _AssistProvider(object): @inject(injector=Injector) def __init__(self, injector): self._injector = injector def get(self): return build_factory(self._injector, cls) return _AssistProvider
def build_factory(injector, cls): guice_data = GuiceData.from_class(cls) providers = {} for name, guicearg in guice_data.init.items(): providers[name] = injector.get_provider(guicearg.datatype, guicearg.annotation) all_args = inspect.getargspec(cls.__init__).args[1:] needed_args = set(all_args) - set(providers.keys()) class DynamicFactory(object): def create(self, **kwargs): if set(kwargs.keys()) - needed_args: raise TypeError( 'TODO: error message here about too many values') for name, provider in providers.items(): kwargs[name] = provider.get() return cls(**kwargs) return DynamicFactory()
def build_factory(injector, cls): guice_data = GuiceData.from_class(cls) providers = {} for name, guicearg in guice_data.init.items(): providers[name] = injector.get_provider(guicearg.datatype, guicearg.annotation) all_args = inspect.getargspec(cls.__init__).args[1:] needed_args = set(all_args) - set(providers.keys()) class DynamicFactory(object): def create(self, **kwargs): if set(kwargs.keys()) - needed_args: raise TypeError('TODO: error message here about too many values') for name, provider in providers.items(): kwargs[name] = provider.get() return cls(**kwargs) return DynamicFactory()