def test_all_arg_names_bound(self): self.assertEqual([], arg_binding_keys.get_unbound_arg_names( ['bound1', 'bound2'], [ arg_binding_keys.new('bound1'), arg_binding_keys.new('bound2') ]))
def test_fn_with_mixed_args_returns_mixed_binding_keys(self): @decorators.annotate_arg('foo', 'an-annotation') def fn(foo, bar, baz='baz'): pass self.assert_fn_has_injectable_arg_binding_keys( fn, [arg_binding_keys.new('foo', 'an-annotation'), arg_binding_keys.new('bar')])
def test_all_arg_names_bound(self): self.assertEqual( [], arg_binding_keys.get_unbound_arg_names( ['bound1', 'bound2'], [arg_binding_keys.new('bound1'), arg_binding_keys.new('bound2')]))
def test_doesnt_conflict_with_any_binding_key(self): arg_binding_key = arg_binding_keys.new( 'an-arg-name', 'unused-binding-key') non_conflicting_arg_binding_key = arg_binding_keys.new( 'other-arg-name', 'unused-binding-key') self.assertFalse(arg_binding_key.conflicts_with_any_arg_binding_key( [non_conflicting_arg_binding_key]))
def test_doesnt_conflict_with_any_binding_key(self): arg_binding_key = arg_binding_keys.new('an-arg-name', 'unused-binding-key') non_conflicting_arg_binding_key = arg_binding_keys.new( 'other-arg-name', 'unused-binding-key') self.assertFalse( arg_binding_key.conflicts_with_any_arg_binding_key( [non_conflicting_arg_binding_key]))
def test_conflicts_with_some_arg_binding_key(self): arg_binding_key = arg_binding_keys.new( 'an-arg-name', 'unused-binding-key') non_conflicting_arg_binding_key = arg_binding_keys.new( 'other-arg-name', 'unused-binding-key') conflicting_arg_binding_key = arg_binding_keys.new( 'an-arg-name', 'unused-binding-key') self.assertTrue(arg_binding_key.conflicts_with_any_arg_binding_key( [non_conflicting_arg_binding_key, conflicting_arg_binding_key]))
def test_reuses_wrapper_fn_when_multiple_decorators_decorators(self): @decorators.annotate_arg('foo', 'an-annotation') @decorators.annotate_arg('bar', 'an-annotation') def some_function(foo, bar): return foo + bar self.assertEqual([arg_binding_keys.new('bar', 'an-annotation'), arg_binding_keys.new('foo', 'an-annotation')], [binding_key for binding_key in getattr(some_function, decorators._ARG_BINDING_KEYS_ATTR)])
def test_reuses_wrapper_fn_when_multiple_decorators_decorators(self): @decorators.annotate_arg('foo', 'an-annotation') @decorators.annotate_arg('bar', 'an-annotation') def some_function(foo, bar): return foo + bar self.assertEqual( [arg_binding_keys.new('bar', 'an-annotation'), arg_binding_keys.new('foo', 'an-annotation')], [binding_key for binding_key in getattr(some_function, decorators._ARG_BINDING_KEYS_ATTR)])
def test_conflicts_with_some_arg_binding_key(self): arg_binding_key = arg_binding_keys.new('an-arg-name', 'unused-binding-key') non_conflicting_arg_binding_key = arg_binding_keys.new( 'other-arg-name', 'unused-binding-key') conflicting_arg_binding_key = arg_binding_keys.new( 'an-arg-name', 'unused-binding-key') self.assertTrue( arg_binding_key.conflicts_with_any_arg_binding_key( [non_conflicting_arg_binding_key, conflicting_arg_binding_key]))
def test_provides_class_with_init_as_method_wrapper_successfully(self): class Foo(object): pass arg_binding_key = arg_binding_keys.new('unused') obj_provider = new_test_obj_provider(arg_binding_key, 'unused') self.assertIsInstance( obj_provider.provide_class(Foo, new_injection_context()), Foo)
def test_adds_binding_in_pinject_decorated_fn(self): @decorators.annotate_arg('foo', 'an-annotation') def some_function(foo): return foo self.assertEqual([arg_binding_keys.new('foo', 'an-annotation')], [binding_key for binding_key in getattr( some_function, decorators._ARG_BINDING_KEYS_ATTR)])
def test_provides_from_arg_binding_key_successfully(self): arg_binding_key = arg_binding_keys.new('an-arg-name') obj_provider = new_test_obj_provider(arg_binding_key, 'an-instance') self.assertEqual( 'an-instance', obj_provider.provide_from_arg_binding_key(arg_binding_key, new_injection_context()))
def provide_class(self, clazz, *args, **kwargs): isclass = inspect.isclass(clazz) assert isclass arg_binding_key = arg_binding_keys.new(convert(clazz.__name__)) injection_context = self._injection_context_factory.new( clazz.__init__) super_classes = [ c for c in inspect.getmro(clazz) if (inspect.isclass(c) and inspect.ismethod(c.__init__)) ] super_kwargs = dict() for c in super_classes: print c, inspect.isclass(c) __, k = self._obj_provider.get_injection_pargs_kwargs( c.__init__, injection_context, (), {}) super_kwargs.update(k) super_kwargs.update(kwargs) c = self._obj_provider.provide_from_arg_binding_key( clazz, arg_binding_key, injection_context, pargs=args, kwargs=super_kwargs) return c #self._obj_provider.provide_class(c, injection_context, direct_init_pargs=args, direct_init_kwargs=kwargs)
def test_adds_binding_in_pinject_decorated_fn(self): @decorators.annotate_arg('foo', 'an-annotation') def some_function(foo): return foo self.assertEqual([arg_binding_keys.new('foo', 'an-annotation')], [binding_key for binding_key in getattr(some_function, decorators._ARG_BINDING_KEYS_ATTR)])
def test_can_provide_none_from_arg_binding_key_when_allowed(self): arg_binding_key = arg_binding_keys.new('an-arg-name') obj_provider = new_obj_provider(arg_binding_key, None) self.assertIsNone( obj_provider.provide_from_arg_binding_key( _UNUSED_INJECTION_SITE_FN, arg_binding_key, new_injection_context()))
def test_provides_provider_fn_from_arg_binding_key_successfully(self): arg_binding_key = arg_binding_keys.new('provide_foo') obj_provider = new_obj_provider(arg_binding_key, 'an-instance') provide_fn = obj_provider.provide_from_arg_binding_key( _UNUSED_INJECTION_SITE_FN, arg_binding_key, new_injection_context()) self.assertEqual('an-instance', provide_fn())
def test_cannot_provide_none_from_binding_key_when_disallowed(self): arg_binding_key = arg_binding_keys.new('an-arg-name') obj_provider = new_test_obj_provider( arg_binding_key, None, allow_injecting_none=False) self.assertRaises(errors.InjectingNoneDisallowedError, obj_provider.provide_from_arg_binding_key, arg_binding_key, new_injection_context())
def test_fn_with_annotated_arg_returns_annotated_binding_key(self): @decorators.annotate_arg('foo', 'an-annotation') def fn(foo): pass self.assert_fn_has_injectable_arg_binding_keys( fn, [arg_binding_keys.new('foo', 'an-annotation')])
def test_cannot_provide_none_from_binding_key_when_disallowed(self): arg_binding_key = arg_binding_keys.new('an-arg-name') obj_provider = new_test_obj_provider(arg_binding_key, None, allow_injecting_none=False) self.assertRaises(errors.InjectingNoneDisallowedError, obj_provider.provide_from_arg_binding_key, _UNUSED_INJECTION_SITE_FN, arg_binding_key, new_injection_context())
def test_provides_class_with_init_as_method_injects_args_successfully(self): class Foo(object): def __init__(self, bar): self.bar = bar arg_binding_key = arg_binding_keys.new('bar') obj_provider = new_test_obj_provider(arg_binding_key, 'a-bar') foo = obj_provider.provide_class(Foo, new_injection_context(), [], {}) self.assertEqual('a-bar', foo.bar)
def test_provides_class_with_init_as_method_wrapper_successfully(self): class Foo(object): pass arg_binding_key = arg_binding_keys.new('unused') obj_provider = new_test_obj_provider(arg_binding_key, 'unused') self.assertIsInstance( obj_provider.provide_class(Foo, new_injection_context(), [], {}), Foo)
def test_calls_with_injection_successfully(self): def foo(bar): return 'a-foo-and-' + bar arg_binding_key = arg_binding_keys.new('bar') obj_provider = new_test_obj_provider(arg_binding_key, 'a-bar') self.assertEqual('a-foo-and-a-bar', obj_provider.call_with_injection( foo, new_injection_context()))
def test_provides_class_with_init_as_method_injects_args_successfully(self): class Foo(object): def __init__(self, bar): self.bar = bar arg_binding_key = arg_binding_keys.new('bar') obj_provider = new_test_obj_provider(arg_binding_key, 'a-bar') foo = obj_provider.provide_class(Foo, new_injection_context()) self.assertEqual('a-bar', foo.bar)
def test_returns_provided_value_for_arg(self): def ProviderFn(arg_binding_key): return ('an-arg-value' if arg_binding_key == arg_binding_keys.new('an-arg') else None) self.assertEqual({'an-arg': 'an-arg-value'}, arg_binding_keys.create_kwargs( [arg_binding_keys.new('an-arg')], ProviderFn))
def test_gets_injection_kwargs_successfully(self): def foo(bar): pass arg_binding_key = arg_binding_keys.new('bar') obj_provider = new_test_obj_provider(arg_binding_key, 'a-bar') self.assertEqual({'bar': 'a-bar'}, obj_provider.get_injection_kwargs( foo, new_injection_context()))
def test_calls_with_injection_successfully(self): def foo(bar): return 'a-foo-and-' + bar arg_binding_key = arg_binding_keys.new('bar') obj_provider = new_test_obj_provider(arg_binding_key, 'a-bar') self.assertEqual('a-foo-and-a-bar', obj_provider.call_with_injection( foo, new_injection_context(), [], {}))
def test_provides_class_with_direct_pargs_and_kwargs(self): class SomeClass(object): @decorators.inject(['baz']) def __init__(self, foo, bar, baz): self.foobarbaz = foo + bar + baz obj_provider = new_test_obj_provider(arg_binding_keys.new('baz'), 'baz') some_class = obj_provider.provide_class( SomeClass, new_injection_context(), ['foo'], {'bar': 'bar'}) self.assertEqual('foobarbaz', some_class.foobarbaz)
def test_gets_injection_kwargs_successfully(self): def foo(bar): pass arg_binding_key = arg_binding_keys.new('bar') obj_provider = new_test_obj_provider(arg_binding_key, 'a-bar') pargs, kwargs = obj_provider.get_injection_pargs_kwargs( foo, new_injection_context(), [], {}) self.assertEqual([], pargs) self.assertEqual({'bar': 'a-bar'}, kwargs)
def test_provides_class_with_direct_pargs_and_kwargs(self): class SomeClass(object): @decorators.inject(['baz']) def __init__(self, foo, bar, baz): self.foobarbaz = foo + bar + baz obj_provider = new_obj_provider(arg_binding_keys.new('baz'), 'baz') some_class = obj_provider.provide_class( SomeClass, new_injection_context(), ['foo'], {'bar': 'bar'}) self.assertEqual('foobarbaz', some_class.foobarbaz)
def test_returns_provided_value_for_arg(self): def ProviderFn(arg_binding_key): return ('an-arg-value' if arg_binding_key == arg_binding_keys.new('an-arg') else None) self.assertEqual( {'an-arg': 'an-arg-value'}, arg_binding_keys.create_kwargs([arg_binding_keys.new('an-arg')], ProviderFn))
def provide_class(self, clazz, *args, **kwargs): isclass = inspect.isclass(clazz) assert isclass arg_binding_key = arg_binding_keys.new(convert(clazz.__name__)) injection_context = self._injection_context_factory.new(clazz.__init__) super_classes = [c for c in inspect.getmro(clazz) if (inspect.isclass(c) and inspect.ismethod(c.__init__))] super_kwargs = dict() for c in super_classes: print c, inspect.isclass(c) __, k = self._obj_provider.get_injection_pargs_kwargs(c.__init__, injection_context, (), {}) super_kwargs.update(k) super_kwargs.update(kwargs) c = self._obj_provider.provide_from_arg_binding_key(clazz, arg_binding_key, injection_context, pargs=args, kwargs=super_kwargs) return c #self._obj_provider.provide_class(c, injection_context, direct_init_pargs=args, direct_init_kwargs=kwargs)
def test_fn_with_unannotated_arg_returns_unannotated_binding_key(self): self.assert_fn_has_injectable_arg_binding_keys( lambda foo: None, [arg_binding_keys.new('foo')])
def test_cannot_apply_to_one_of_arg_names(self): arg_binding_key = arg_binding_keys.new( 'an-arg-name', 'unused-binding-key') self.assertFalse(arg_binding_key.can_apply_to_one_of_arg_names( ['foo', 'other-arg-name', 'bar']))
def test_can_provide_none_from_arg_binding_key_when_allowed(self): arg_binding_key = arg_binding_keys.new('an-arg-name') obj_provider = new_test_obj_provider(arg_binding_key, None) self.assertIsNone( obj_provider.provide_from_arg_binding_key(arg_binding_key, new_injection_context()))
def test_as_provider_fn(self): arg_binding_key = arg_binding_keys.new('provide_foo') self.assertEqual('the arg named "provide_foo" unannotated', str(arg_binding_key))
def test_cannot_apply_to_one_of_arg_names(self): arg_binding_key = arg_binding_keys.new('an-arg-name', 'unused-binding-key') self.assertFalse( arg_binding_key.can_apply_to_one_of_arg_names( ['foo', 'other-arg-name', 'bar']))
def test_with_no_bells_or_whistles(self): arg_binding_key = arg_binding_keys.new('an-arg-name') self.assertEqual('the arg named "an-arg-name" unannotated', str(arg_binding_key))
def test_with_annotation(self): arg_binding_key = arg_binding_keys.new('an-arg-name', 'an-annotation') self.assertEqual( 'the arg named "an-arg-name" annotated with "an-annotation"', str(arg_binding_key))
def ProviderFn(arg_binding_key): return ('an-arg-value' if arg_binding_key == arg_binding_keys.new('an-arg') else None)
def test_some_arg_name_unbound(self): self.assertEqual(['unbound'], arg_binding_keys.get_unbound_arg_names( ['bound', 'unbound'], [arg_binding_keys.new('bound')]))
def test_some_arg_name_unbound(self): self.assertEqual( ['unbound'], arg_binding_keys.get_unbound_arg_names( ['bound', 'unbound'], [arg_binding_keys.new('bound')]))