コード例 #1
0
 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
ファイル: decorators_test.py プロジェクト: zenweasel/pinject
 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')])
コード例 #4
0
 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')]))
コード例 #5
0
 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]))
コード例 #6
0
 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]))
コード例 #7
0
 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
ファイル: decorators_test.py プロジェクト: zenweasel/pinject
 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)])
コード例 #10
0
 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)])
コード例 #13
0
 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
ファイル: ServiceLoader.py プロジェクト: eastlondoner/pinject
        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
ファイル: decorators_test.py プロジェクト: zenweasel/pinject
 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)])
コード例 #16
0
 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())
コード例 #18
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())
コード例 #19
0
 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
ファイル: decorators_test.py プロジェクト: mzgcz/pinject
    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')])
コード例 #21
0
 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())
コード例 #22
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)
コード例 #23
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)
コード例 #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)
コード例 #26
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))
コード例 #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()))
コード例 #28
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(), [], {}))
コード例 #29
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_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)
コード例 #30
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')
     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
ファイル: ServiceLoader.py プロジェクト: eastlondoner/pinject
        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']))
コード例 #36
0
 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()))
コード例 #37
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))
コード例 #38
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']))
コード例 #39
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))
コード例 #40
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))
コード例 #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))
コード例 #42
0
 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))
コード例 #44
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')]))
コード例 #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
ファイル: decorators_test.py プロジェクト: zenweasel/pinject
 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
ファイル: decorators_test.py プロジェクト: zenweasel/pinject
 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')])