Add support for registering with factory.

Author: runemalm

src/dependency_injection/container.py

@@ -1,6 +1,6 @@
 import inspect
 
-from typing import Any, Dict, List, Optional, TypeVar, Type
+from typing import Any, Callable, Dict, List, Optional, TypeVar, Type
 
 from dependency_injection.registration import Registration
 from dependency_injection.scope import DEFAULT_SCOPE_NAME, Scope
@@ -50,6 +50,11 @@ def register_singleton(self, dependency: Type, implementation: Optional[Type] =
             raise ValueError(f"Dependency {dependency} is already registered.")
         self._registrations[dependency] = Registration(dependency, implementation, Scope.SINGLETON, tags, constructor_args)
 
+    def register_factory(self, dependency: Type, factory: Callable[[Any], Any], factory_args: Optional[Dict[str, Any]] = None, tags: Optional[set] = None) -> None:
+        if dependency in self._registrations:
+            raise ValueError(f"Dependency {dependency} is already registered.")
+        self._registrations[dependency] = Registration(dependency, None, Scope.FACTORY, None, tags, factory, factory_args)
+
     def register_instance(self, dependency: Type, instance: Any, tags: Optional[set] = None) -> None:
         if dependency in self._registrations:
             raise ValueError(f"Dependency {dependency} is already registered.")
@@ -93,11 +98,15 @@ def resolve(self, dependency: Type, scope_name: str = DEFAULT_SCOPE_NAME) -> Typ
                     )
                 )
             return self._singleton_instances[dependency]
+        elif scope == Scope.FACTORY:
+            factory = registration.factory
+            factory_args = registration.factory_args or {}
+            return factory(**factory_args)
 
         raise ValueError(f"Invalid dependency scope: {scope}")
 
     def resolve_all(self, tags: Optional[set] = None) -> List[Any]:
-        tags = [] if not tags else tags
+        tags = tags or []
         resolved_dependencies = []
         for registration in self._registrations.values():
             if not len(tags) or tags.intersection(registration.tags):

src/dependency_injection/registration.py

@@ -1,13 +1,18 @@
-from typing import Any, Dict, Optional, Type
+from typing import Any, Callable, Dict, Optional, Type
 
 from dependency_injection.scope import Scope
 
 
 class Registration():
 
-    def __init__(self, dependency: Type, implementation: Type, scope: Scope, tags: Optional[set] = None, constructor_args: Optional[Dict[str, Any]] = None):
+    def __init__(self, dependency: Type, implementation: Optional[Type], scope: Scope, tags: Optional[set] = None, constructor_args: Optional[Dict[str, Any]] = None, factory: Optional[Callable[[Any], Any]] = None, factory_args: Optional[Dict[str, Any]] = None):
         self.dependency = dependency
         self.implementation = implementation
         self.scope = scope
         self.tags = tags or set()
         self.constructor_args = constructor_args or {}
+        self.factory = factory
+        self.factory_args = factory_args or {}
+
+        if not any([self.implementation, self.factory]):
+            raise Exception("There must be either an implementation or a factory.")

src/dependency_injection/scope.py

@@ -7,3 +7,4 @@ class Scope(Enum):
     TRANSIENT = "transient"
     SCOPED = "scoped"
     SINGLETON = "singleton"
+    FACTORY = "factory"

tests/unit_test/container/register/test_register_factory.py

@@ -0,0 +1,76 @@
+import pytest
+
+from dependency_injection.container import DependencyContainer
+from unit_test.unit_test_case import UnitTestCase
+
+
+class TestRegisterFactory(UnitTestCase):
+
+    def test_register_factory_succeeds_when_not_previously_registered(
+        self,
+    ):
+        # arrange
+        class Vehicle:
+            pass
+
+        class Car(Vehicle):
+            pass
+
+        class CarFactory:
+            @classmethod
+            def create(cls) -> Car:
+                return Car()
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        dependency_container.register_factory(Vehicle, factory=CarFactory.create)
+
+        # assert
+        # (no exception thrown)
+
+    def test_register_with_factory_args(
+        self,
+    ):
+        # arrange
+        class Vehicle:
+            pass
+
+        class Car(Vehicle):
+            def __init__(self, color: str, mileage: int):
+                self.color = color
+                self.mileage = mileage
+
+        class CarFactory:
+            @classmethod
+            def create(cls, color: str, mileage: int) -> Car:
+                return Car(color=color, mileage=mileage)
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act + assert (no exception)
+        dependency_container.register_factory(Vehicle, factory=CarFactory.create, factory_args={"color": "red", "mileage": 3800})
+
+    def test_register_instance_fails_when_already_registered(
+        self,
+    ):
+        # arrange
+        class Vehicle:
+            pass
+
+        class Car(Vehicle):
+            pass
+
+        class CarFactory:
+            @classmethod
+            def create(cls) -> Car:
+                return Car()
+
+        dependency_container = DependencyContainer.get_instance()
+
+        # act
+        dependency_container.register_factory(Vehicle, factory=CarFactory.create)
+
+        # act + assert
+        with pytest.raises(ValueError, match="is already registered"):
+            dependency_container.register_factory(Vehicle, factory=CarFactory.create)

tests/unit_test/container/resolve/test_resolve_factory.py

@@ -0,0 +1,82 @@
+from dependency_injection.container import DependencyContainer
+from unit_test.unit_test_case import UnitTestCase
+
+
+class TestResolveTransient(UnitTestCase):
+
+    def test_resolve_factory_returns_an_instance(
+        self,
+    ):
+        # arrange
+        class Vehicle:
+            pass
+
+        class Car(Vehicle):
+            pass
+
+        class CarFactory:
+            @classmethod
+            def create(cls) -> Car:
+                return Car()
+
+        dependency_container = DependencyContainer.get_instance()
+        dependency_container.register_factory(Vehicle, factory=CarFactory.create)
+
+        # act
+        resolved_dependency = dependency_container.resolve(Vehicle)
+
+        # assert
+        self.assertIsInstance(resolved_dependency, Car)
+
+    def test_resolve_factory_twice_returns_different_instances(
+        self,
+    ):
+        # arrange
+        class Vehicle:
+            pass
+
+        class Car(Vehicle):
+            pass
+
+        class CarFactory:
+            @classmethod
+            def create(cls) -> Car:
+                return Car()
+
+        dependency_container = DependencyContainer.get_instance()
+        dependency_container.register_factory(Vehicle, factory=CarFactory.create)
+
+        # act
+        resolved_dependency_1 = dependency_container.resolve(Vehicle)
+        resolved_dependency_2 = dependency_container.resolve(Vehicle)
+
+        # assert
+        self.assertNotEqual(resolved_dependency_1, resolved_dependency_2)
+
+    def test_resolve_factory_with_args_passes_args(
+        self,
+    ):
+        # arrange
+        class Vehicle:
+            pass
+
+        class Car(Vehicle):
+            def __init__(self, color: str, mileage: int):
+                self.color = color
+                self.mileage = mileage
+
+        class CarFactory:
+            @classmethod
+            def create(cls, color: str, mileage: int) -> Car:
+                return Car(color=color, mileage=mileage)
+
+        dependency_container = DependencyContainer.get_instance()
+        dependency_container.register_factory(Vehicle, factory=CarFactory.create, factory_args={"color": "red", "mileage": 6327})
+
+        # act
+        resolved_dependency = dependency_container.resolve(Vehicle)
+
+        # assert
+        self.assertIsInstance(resolved_dependency, Car)
+        self.assertEqual("red", resolved_dependency.color)
+        self.assertEqual(6327, resolved_dependency.mileage)