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')
                          ]))
示例#2
0
 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')])
示例#3
0
 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]))
示例#8
0
 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)])
示例#9
0
 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]))
示例#11
0
 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)
示例#12
0
 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()))
示例#14
0
        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)
示例#15
0
 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()))
示例#17
0
 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_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())
示例#20
0
    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)
示例#24
0
 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()))
示例#25
0
 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))
示例#27
0
 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)
示例#31
0
 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)
示例#32
0
 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))
示例#33
0
        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)
示例#34
0
 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')])
示例#35
0
 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))
示例#41
0
 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 ProviderFn(arg_binding_key):
     return ('an-arg-value' if arg_binding_key
             == arg_binding_keys.new('an-arg') else None)
示例#43
0
 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 test_some_arg_name_unbound(self):
     self.assertEqual(['unbound'],
                      arg_binding_keys.get_unbound_arg_names(
                          ['bound', 'unbound'],
                          [arg_binding_keys.new('bound')]))
示例#45
0
 def test_some_arg_name_unbound(self):
     self.assertEqual(
         ['unbound'],
         arg_binding_keys.get_unbound_arg_names(
             ['bound', 'unbound'], [arg_binding_keys.new('bound')]))
示例#46
0
 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')])
示例#47
0
 def ProviderFn(arg_binding_key):
     return ('an-arg-value'
             if arg_binding_key == arg_binding_keys.new('an-arg')
             else None)
示例#48
0
 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))
示例#49
0
 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')])