chore: polish api by renaming dependency -> service, factory_args -> factory_kwargs, etc.

Author: runemalm

src/dependency_injection/container.py

@@ -6,21 +6,21 @@
 class Registration:
     def __init__(
         self,
-        dependency: Type,
+        service: Type,
         implementation: Optional[Type],
         scope: Scope,
         tags: Optional[set] = None,
-        constructor_args: Optional[Dict[str, Any]] = None,
+        constructor_kwargs: Optional[Dict[str, Any]] = None,
         factory: Optional[Callable[[Any], Any]] = None,
-        factory_args: Optional[Dict[str, Any]] = None,
+        factory_kwargs: Optional[Dict[str, Any]] = None,
     ):
-        self.dependency = dependency
+        self.service = service
         self.implementation = implementation
         self.scope = scope
         self.tags = tags or set()
-        self.constructor_args = constructor_args or {}
+        self.constructor_kwargs = constructor_kwargs or {}
         self.factory = factory
-        self.factory_args = factory_args or {}
+        self.factory_kwargs = factory_kwargs or {}
 
         if not any([self.implementation, self.factory]):
             raise Exception("There must be either an implementation or a factory.")

src/dependency_injection/registration.py

@@ -0,0 +1,151 @@
+import warnings
+
+import pytest
+
+from dependency_injection.container import DependencyContainer
+from unit_test.unit_test_case import UnitTestCase
+
+
+class TestRegisterDeprecations(UnitTestCase):
+    def test_register_transient_dependency_alias_warns_and_works(self):
+        # arrange
+        class IFoo:
+            pass
+
+        class Foo(IFoo):
+            pass
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        with pytest.warns(DeprecationWarning):
+            dependency_container.register_transient(dependency=IFoo, implementation=Foo)
+        resolved = dependency_container.resolve(IFoo)
+
+        # assert
+        self.assertIsInstance(resolved, Foo)
+
+    def test_register_transient_constructor_args_alias_warns_and_works(self):
+        # arrange
+        class Foo:
+            def __init__(self, x: int):
+                self.x = x
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        with pytest.warns(DeprecationWarning):
+            dependency_container.register_transient(Foo, constructor_args={"x": 123})
+        obj = dependency_container.resolve(Foo)
+
+        # assert
+        self.assertEqual(123, obj.x)
+
+    def test_register_transient_new_names_no_warning(self):
+        # arrange
+        class Foo:
+            def __init__(self, x: int):
+                self.x = x
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        with warnings.catch_warnings(record=True) as rec:
+            warnings.simplefilter("always", DeprecationWarning)
+            dependency_container.register_transient(Foo, constructor_kwargs={"x": 1})
+
+        obj = dependency_container.resolve(Foo)
+
+        # assert
+        dep_warnings = [w for w in rec if issubclass(w.category, DeprecationWarning)]
+        self.assertEqual([], dep_warnings)
+        self.assertEqual(1, obj.x)
+
+    def test_register_scoped_dependency_alias_warns_and_works(self):
+        # arrange
+        class IService:
+            pass
+
+        class Service(IService):
+            pass
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        with pytest.warns(DeprecationWarning):
+            dependency_container.register_scoped(
+                dependency=IService, implementation=Service
+            )
+        a1 = dependency_container.resolve(IService, scope_name="req-A")
+        a2 = dependency_container.resolve(IService, scope_name="req-A")
+        b1 = dependency_container.resolve(IService, scope_name="req-B")
+
+        # assert
+        self.assertIsInstance(a1, Service)
+        self.assertIs(a1, a2)  # same scope -> same instance
+        self.assertIsNot(a1, b1)  # different scope -> different instance
+
+    def test_register_singleton_dependency_alias_warns_and_works(self):
+        # arrange
+        class IService:
+            pass
+
+        class Service(IService):
+            pass
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        with pytest.warns(DeprecationWarning):
+            dependency_container.register_singleton(
+                dependency=IService, implementation=Service
+            )
+        s1 = dependency_container.resolve(IService)
+        s2 = dependency_container.resolve(IService)
+
+        # assert
+        self.assertIs(s1, s2)
+
+    def test_register_factory_factory_args_alias_warns_and_works(self):
+        # arrange
+        def build_cfg(*, env="prod"):
+            return {"env": env}
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        with pytest.warns(DeprecationWarning):
+            dependency_container.register_factory(
+                dependency=dict, factory=build_cfg, factory_args={"env": "dev"}
+            )
+        cfg = dependency_container.resolve(dict)
+
+        # assert
+        self.assertEqual("dev", cfg["env"])
+
+    def test_register_instance_dependency_alias_warns_and_works(self):
+        # arrange
+        class Foo:
+            pass
+
+        foo = Foo()
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        with pytest.warns(DeprecationWarning):
+            dependency_container.register_instance(dependency=Foo, instance=foo)
+        resolved = dependency_container.resolve(Foo)
+
+        # assert
+        self.assertIs(foo, resolved)
+
+    def test_register_transient_unexpected_kw_raises_type_error(self):
+        # arrange
+        class Foo:
+            pass
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act + assert
+        with pytest.raises(TypeError):
+            dependency_container.register_transient(Foo, unexpected_kw=1)

tests/unit_test/container/register/test_deprecations.py

@@ -28,7 +28,7 @@ def create(cls) -> Car:
         # assert
         # (no exception thrown)
 
-    def test_register_with_factory_args(
+    def test_register_with_factory_kwargs(
         self,
     ):
         # arrange
@@ -51,7 +51,7 @@ def create(cls, color: str, mileage: int) -> Car:
         dependency_container.register_factory(
             Vehicle,
             factory=CarFactory.create,
-            factory_args={"color": "red", "mileage": 3800},
+            factory_kwargs={"color": "red", "mileage": 3800},
         )
 
     def test_register_with_lambda_method(

tests/unit_test/container/register/test_register_factory.py

@@ -16,11 +16,11 @@ class Car(Vehicle):
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
         implementation = Car
 
         # act
-        dependency_container.register_scoped(dependency, implementation)
+        dependency_container.register_scoped(service, implementation)
 
         # assert
         # (no exception thrown)
@@ -36,13 +36,13 @@ class Car(Vehicle):
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
         implementation = Car
-        dependency_container.register_scoped(dependency, implementation)
+        dependency_container.register_scoped(service, implementation)
 
         # act + assert
         with pytest.raises(ValueError, match="is already registered"):
-            dependency_container.register_scoped(dependency, implementation)
+            dependency_container.register_scoped(service, implementation)
 
     def test_register_scoped_when_dependency_and_implementation_being_the_same(
         self,
@@ -52,9 +52,9 @@ class Vehicle:
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
 
         # act
-        dependency_container.register_scoped(dependency)
+        dependency_container.register_scoped(service)
 
         # assert (no exception thrown)

tests/unit_test/container/register/test_register_scoped.py

@@ -16,11 +16,11 @@ class Car(Vehicle):
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
         implementation = Car
 
         # act
-        dependency_container.register_singleton(dependency, implementation)
+        dependency_container.register_singleton(service, implementation)
 
         # assert
         # (no exception thrown)
@@ -36,13 +36,13 @@ class Car(Vehicle):
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
         implementation = Car
-        dependency_container.register_singleton(dependency, implementation)
+        dependency_container.register_singleton(service, implementation)
 
         # act + assert
         with pytest.raises(ValueError, match="is already registered"):
-            dependency_container.register_singleton(dependency, implementation)
+            dependency_container.register_singleton(service, implementation)
 
     def test_register_singleton_when_dependency_and_implementation_being_the_same(
         self,
@@ -52,9 +52,9 @@ class Vehicle:
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
 
         # act
-        dependency_container.register_singleton(dependency)
+        dependency_container.register_singleton(service)
 
         # assert (no exception thrown)

tests/unit_test/container/register/test_register_singleton.py

@@ -16,11 +16,11 @@ class Car(Vehicle):
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
         implementation = Car
 
         # act
-        dependency_container.register_transient(dependency, implementation)
+        dependency_container.register_transient(service, implementation)
 
         # assert (no exception thrown)
 
@@ -35,13 +35,13 @@ class Car(Vehicle):
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
         implementation = Car
-        dependency_container.register_transient(dependency, implementation)
+        dependency_container.register_transient(service, implementation)
 
         # act + assert
         with pytest.raises(ValueError, match="is already registered"):
-            dependency_container.register_transient(dependency, implementation)
+            dependency_container.register_transient(service, implementation)
 
     def test_success_when_dependency_and_implementation_same(
         self,
@@ -51,10 +51,10 @@ class Vehicle:
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
 
         # act
-        dependency_container.register_transient(dependency)
+        dependency_container.register_transient(service)
 
         # assert (no exception thrown)
 

tests/unit_test/container/register/test_register_transient.py

@@ -3,7 +3,7 @@
 
 
 class TestRegisterWithArgs(UnitTestCase):
-    def test_register_with_constructor_args(
+    def test_register_with_constructor_kwargs(
         self,
     ):
         # arrange
@@ -14,12 +14,12 @@ class Car(Vehicle):
             pass
 
         dependency_container = DependencyContainer.get_instance()
-        dependency = Vehicle
+        service = Vehicle
         implementation = Car
 
         # act + assert (no exception)
         dependency_container.register_transient(
-            dependency,
+            service,
             implementation,
-            constructor_args={"color": "red", "mileage": 3800},
+            constructor_kwargs={"color": "red", "mileage": 3800},
         )

tests/unit_test/container/register/test_register_with_args.py

@@ -0,0 +1,41 @@
+import warnings
+
+import pytest
+
+from dependency_injection.container import DependencyContainer
+from unit_test.unit_test_case import UnitTestCase
+
+
+class TestResolveDeprecations(UnitTestCase):
+    def test_resolve_dependency_alias_warns_and_works(self):
+        # arrange
+        class Foo:
+            pass
+
+        dependency_container = DependencyContainer.get_instance()
+        dependency_container.register_transient(Foo)
+
+        # act
+        with pytest.warns(DeprecationWarning):
+            obj = dependency_container.resolve(dependency=Foo)
+
+        # assert
+        self.assertIsInstance(obj, Foo)
+
+    def test_resolve_new_name_no_warning(self):
+        # arrange
+        class Foo:
+            pass
+
+        dependency_container = DependencyContainer.get_instance()
+        dependency_container.register_transient(Foo)
+
+        # act
+        with warnings.catch_warnings(record=True) as rec:
+            warnings.simplefilter("always", DeprecationWarning)
+            obj = dependency_container.resolve(service=Foo)
+
+        # assert
+        dep_warnings = [w for w in rec if issubclass(w.category, DeprecationWarning)]
+        self.assertEqual([], dep_warnings)
+        self.assertIsInstance(obj, Foo)