Merge branch 'master' into multibind-for-plugins

Author: eirikur-nc

.github/workflows/ci.yml

@@ -42,4 +42,6 @@ jobs:
         if which black; then black --check . ; fi
         check-manifest
     - name: Report coverage to Codecov
-      uses: codecov/codecov-action@v1
+      uses: codecov/codecov-action@v5
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}

injector/__init__.py

@@ -1263,6 +1263,16 @@ def _is_injection_annotation(annotation: Any) -> bool:
             _inject_marker in annotation.__metadata__ or _noinject_marker in annotation.__metadata__
         )
 
+    def _recreate_annotated_origin(annotated_type: Any) -> Any:
+        # Creates `Annotated[type, annotation]` from `Inject[Annotated[type, annotation]]`,
+        # to support the injection of annotated types with the `Inject[]` annotation.
+        origin = annotated_type.__origin__
+        for metadata in annotated_type.__metadata__:  # pragma: no branch
+            if metadata in (_inject_marker, _noinject_marker):
+                break
+            origin = Annotated[origin, metadata]
+        return origin
+
     spec = inspect.getfullargspec(callable)
 
     try:
@@ -1295,7 +1305,7 @@ def _is_injection_annotation(annotation: Any) -> bool:
     for k, v in list(bindings.items()):
         # extract metadata only from Inject and NonInject
         if _is_injection_annotation(v):
-            v, metadata = v.__origin__, v.__metadata__
+            v, metadata = _recreate_annotated_origin(v), v.__metadata__
             bindings[k] = v
         else:
             metadata = tuple()

injector_test.py

@@ -1654,89 +1654,176 @@ def test_binder_has_implicit_binding_for_implicitly_bound_type():
     assert not injector.binder.has_explicit_binding_for(int)
 
 
-def test_get_bindings():
-    def function1(a: int) -> None:
+def test_gets_no_bindings_without_injection() -> None:
+    def function(a: int) -> None:
         pass
 
-    assert get_bindings(function1) == {}
+    assert get_bindings(function) == {}
 
+
+def test_gets_bindings_with_inject_decorator() -> None:
     @inject
-    def function2(a: int) -> None:
+    def function(a: int) -> None:
         pass
 
-    assert get_bindings(function2) == {'a': int}
+    assert get_bindings(function) == {'a': int}
+
 
+def test_gets_multiple_bindings_with_inject_decorator() -> None:
     @inject
-    @noninjectable('b')
-    def function3(a: int, b: str) -> None:
+    def function(a: int, b: str) -> None:
         pass
 
-    assert get_bindings(function3) == {'a': int}
+    assert get_bindings(function) == {'a': int, 'b': str}
+
+
+def test_only_gets_injectable_bindings_without_noninjectable_decorator() -> None:
+    @inject
+    @noninjectable('b')
+    def function1(a: int, b: str) -> None:
+        pass
 
     # Let's verify that the inject/noninjectable ordering doesn't matter
     @noninjectable('b')
     @inject
-    def function3b(a: int, b: str) -> None:
+    def function2(a: int, b: str) -> None:
         pass
 
-    assert get_bindings(function3b) == {'a': int}
+    assert get_bindings(function1) == {'a': int} == get_bindings(function2)
+
 
-    # The simple case of no @inject but injection requested with Inject[...]
-    def function4(a: Inject[int], b: str) -> None:
+def test_gets_bindings_with_inject_annotation() -> None:
+    def function(a: Inject[int], b: str) -> None:
         pass
 
-    assert get_bindings(function4) == {'a': int}
+    assert get_bindings(function) == {'a': int}
+
+
+def test_gets_multiple_bindings_with_inject_annotation() -> None:
+    def function(a: Inject[int], b: Inject[str]) -> None:
+        pass
+
+    assert get_bindings(function) == {'a': int, 'b': str}
+
 
-    # Using @inject with Inject is redundant but it should not break anything
+def test_gets_bindings_inject_with_redundant_inject_annotation() -> None:
     @inject
-    def function5(a: Inject[int], b: str) -> None:
+    def function(a: Inject[int], b: str) -> None:
         pass
 
-    assert get_bindings(function5) == {'a': int, 'b': str}
+    assert get_bindings(function) == {'a': int, 'b': str}
 
-    # We need to be able to exclude a parameter from injection with NoInject
+
+def test_only_gets_bindings_without_noinject_annotation() -> None:
     @inject
-    def function6(a: int, b: NoInject[str]) -> None:
+    def function(a: int, b: NoInject[str]) -> None:
         pass
 
-    assert get_bindings(function6) == {'a': int}
+    assert get_bindings(function) == {'a': int}
+
 
-    # The presence of NoInject should not trigger anything on its own
-    def function7(a: int, b: NoInject[str]) -> None:
+def test_gets_no_bindings_for_noinject_annotation_only() -> None:
+    def function(a: int, b: NoInject[str]) -> None:
         pass
 
-    assert get_bindings(function7) == {}
+    assert get_bindings(function) == {}
 
+
+def test_gets_no_bindings_for_multiple_noinject_annotations() -> None:
     # There was a bug where in case of multiple NoInject-decorated parameters only the first one was
     # actually made noninjectable and we tried to inject something we couldn't possibly provide
     # into the second one.
     @inject
-    def function8(a: NoInject[int], b: NoInject[int]) -> None:
+    def function(a: NoInject[int], b: NoInject[int]) -> None:
         pass
 
-    assert get_bindings(function8) == {}
+    assert get_bindings(function) == {}
+
 
-    # Default arguments to NoInject annotations should behave the same as noninjectable decorator w.r.t 'None'
+def test_get_bindings_noinject_with_default_should_behave_identically() -> None:
     @inject
     @noninjectable('b')
-    def function9(self, a: int, b: Optional[str] = None):
+    def function1(self, a: int, b: Optional[str] = None) -> None:
         pass
 
     @inject
-    def function10(self, a: int, b: NoInject[Optional[str]] = None):
-        # b:s type is Union[NoInject[Union[str, None]], None]
+    def function2(self, a: int, b: NoInject[Optional[str]] = None) -> None:
+        # b's type is Union[NoInject[Union[str, None]], None]
         pass
 
-    assert get_bindings(function9) == {'a': int} == get_bindings(function10)
+    assert get_bindings(function1) == {'a': int} == get_bindings(function2)
 
+
+def test_get_bindings_with_an_invalid_forward_reference_return_type() -> None:
     # If there's a return type annottion that contains an a forward reference that can't be
     # resolved (for whatever reason) we don't want that to break things for us – return types
     # don't matter for the purpose of dependency injection.
     @inject
-    def function11(a: int) -> 'InvalidForwardReference':
+    def function(a: int) -> 'InvalidForwardReference':
+        pass
+
+    assert get_bindings(function) == {'a': int}
+
+
+def test_gets_bindings_for_annotated_type_with_inject_decorator() -> None:
+    UserID = Annotated[int, 'user_id']
+
+    @inject
+    def function(a: UserID, b: str) -> None:
+        pass
+
+    assert get_bindings(function) == {'a': UserID, 'b': str}
+
+
+def test_gets_bindings_of_annotated_type_with_inject_annotation() -> None:
+    UserID = Annotated[int, 'user_id']
+
+    def function(a: Inject[UserID], b: Inject[str]) -> None:
+        pass
+
+    assert get_bindings(function) == {'a': UserID, 'b': str}
+
+
+def test_gets_bindings_of_new_type_with_inject_annotation() -> None:
+    Name = NewType('Name', str)
+
+    @inject
+    def function(a: Name, b: str) -> None:
+        pass
+
+    assert get_bindings(function) == {'a': Name, 'b': str}
+
+
+def test_gets_bindings_of_inject_annotation_with_new_type() -> None:
+    def function(a: Inject[Name], b: str) -> None:
+        pass
+
+    assert get_bindings(function) == {'a': Name}
+
+
+def test_get_bindings_of_nested_noinject_inject_annotation() -> None:
+    # This is not how this is intended to be used
+    def function(a: Inject[NoInject[int]], b: NoInject[Inject[str]]) -> None:
+        pass
+
+    assert get_bindings(function) == {}
+
+
+def test_get_bindings_of_nested_noinject_inject_annotation_and_inject_decorator() -> None:
+    # This is not how this is intended to be used
+    @inject
+    def function(a: Inject[NoInject[int]], b: NoInject[Inject[str]]) -> None:
         pass
 
-    assert get_bindings(function11) == {'a': int}
+    assert get_bindings(function) == {}
+
+
+def test_get_bindings_of_nested_inject_annotations() -> None:
+    # This is not how this is intended to be used
+    def function(a: Inject[Inject[int]]) -> None:
+        pass
+
+    assert get_bindings(function) == {'a': int}
 
 
 # Tests https://github.com/alecthomas/injector/issues/202
@@ -1824,19 +1911,78 @@ def configure(binder):
 
 def test_annotated_integration_with_annotated():
     UserID = Annotated[int, 'user_id']
+    UserAge = Annotated[int, 'user_age']
 
     @inject
     class TestClass:
-        def __init__(self, user_id: UserID):
+        def __init__(self, user_id: UserID, user_age: UserAge):
             self.user_id = user_id
+            self.user_age = user_age
 
     def configure(binder):
         binder.bind(UserID, to=123)
+        binder.bind(UserAge, to=32)
 
     injector = Injector([configure])
 
     test_class = injector.get(TestClass)
     assert test_class.user_id == 123
+    assert test_class.user_age == 32
+
+
+def test_inject_annotation_with_annotated_type():
+    UserID = Annotated[int, 'user_id']
+    UserAge = Annotated[int, 'user_age']
+
+    class TestClass:
+        def __init__(self, user_id: Inject[UserID], user_age: Inject[UserAge]):
+            self.user_id = user_id
+            self.user_age = user_age
+
+    def configure(binder):
+        binder.bind(UserID, to=123)
+        binder.bind(UserAge, to=32)
+        binder.bind(int, to=456)
+
+    injector = Injector([configure])
+
+    test_class = injector.get(TestClass)
+    assert test_class.user_id == 123
+    assert test_class.user_age == 32
+
+
+def test_inject_annotation_with_nested_annotated_type():
+    UserID = Annotated[int, 'user_id']
+    SpecialUserID = Annotated[UserID, 'special_user_id']
+
+    class TestClass:
+        def __init__(self, user_id: Inject[SpecialUserID]):
+            self.user_id = user_id
+
+    def configure(binder):
+        binder.bind(SpecialUserID, to=123)
+
+    injector = Injector([configure])
+
+    test_class = injector.get(TestClass)
+    assert test_class.user_id == 123
+
+
+def test_noinject_annotation_with_annotated_type():
+    UserID = Annotated[int, 'user_id']
+
+    @inject
+    class TestClass:
+        def __init__(self, user_id: NoInject[UserID] = None):
+            self.user_id = user_id
+
+    def configure(binder):
+        binder.bind(UserID, to=123)
+
+    injector = Injector([configure])
+
+    test_class = injector.get(TestClass)
+    assert test_class.user_id is None
 
 
 def test_newtype_integration_with_annotated():
@@ -1856,6 +2002,22 @@ def configure(binder):
     assert test_class.user_id == 123
 
 
+def test_newtype_with_injection_annotation():
+    UserID = NewType('UserID', int)
+
+    class TestClass:
+        def __init__(self, user_id: Inject[UserID]):
+            self.user_id = user_id
+
+    def configure(binder):
+        binder.bind(UserID, to=123)
+
+    injector = Injector([configure])
+
+    test_class = injector.get(TestClass)
+    assert test_class.user_id == 123
+
+
 def test_dataclass_annotated_parameter():
     Foo = Annotated[int, object()]