test: Split and extend get_bindings() tests

Author: davidparsson

injector_test.py

@@ -1589,59 +1589,82 @@ def test_binder_has_implicit_binding_for_implicitly_bound_type():
     assert not injector.binder.has_explicit_binding_for(int)
 
 
-def test_get_bindings():
+def test_gets_no_bindings_without_injection() -> None:
     def function1(a: int) -> None:
         pass
 
     assert get_bindings(function1) == {}
 
+
+def test_gets_bindings_with_inject_decorator() -> None:
     @inject
     def function2(a: int) -> None:
         pass
 
     assert get_bindings(function2) == {'a': int}
 
+
+def test_gets_multiple_bindings_with_inject_decorator() -> None:
+    @inject
+    def function2(a: int, b: str) -> None:
+        pass
+
+    assert get_bindings(function2) == {'a': int, 'b': str}
+
+
+def test_only_gets_injectable_bindings_without_noninjectable_decorator() -> None:
     @inject
     @noninjectable('b')
     def function3(a: int, b: str) -> None:
         pass
 
-    assert get_bindings(function3) == {'a': int}
-
     # Let's verify that the inject/noninjectable ordering doesn't matter
     @noninjectable('b')
     @inject
     def function3b(a: int, b: str) -> None:
         pass
 
-    assert get_bindings(function3b) == {'a': int}
+    assert get_bindings(function3) == {'a': int} == get_bindings(function3b)
 
-    # The simple case of no @inject but injection requested with Inject[...]
+
+def test_gets_bindings_with_inject_annotation() -> None:
     def function4(a: Inject[int], b: str) -> None:
         pass
 
     assert get_bindings(function4) == {'a': int}
 
-    # Using @inject with Inject is redundant but it should not break anything
+
+def test_gets_multiple_bindings_with_inject_annotation() -> None:
+    def function4(a: Inject[int], b: Inject[str]) -> None:
+        pass
+
+    assert get_bindings(function4) == {'a': int, 'b': str}
+
+
+def test_gets_bindings_inject_with_redundant_inject_annotation() -> None:
     @inject
     def function5(a: Inject[int], b: str) -> None:
         pass
 
     assert get_bindings(function5) == {'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:
         pass
 
     assert get_bindings(function6) == {'a': int}
 
-    # The presence of NoInject should not trigger anything on its own
+
+def test_gets_no_bindings_for_noinject_annotation_only() -> None:
     def function7(a: int, b: NoInject[str]) -> None:
         pass
 
     assert get_bindings(function7) == {}
 
+
+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.
@@ -1651,19 +1674,22 @@ def function8(a: NoInject[int], b: NoInject[int]) -> None:
 
     assert get_bindings(function8) == {}
 
-    # 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 function9(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 function10(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)
 
+
+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.