Merge pull request #60 from eadwinCode/injector_and_injectable

Resolvable Injectable Class

Author: eadwinCode

ellar/di/injector/container.py

@@ -1,7 +1,15 @@
 import typing as t
 from inspect import isabstract
 
-from injector import Binder as InjectorBinder, Binding, Module as InjectorModule
+from injector import (
+    AssistedBuilder,
+    Binder as InjectorBinder,
+    Binding,
+    Module as InjectorModule,
+    Scope as InjectorScope,
+    UnsatisfiedRequirement,
+    _is_specialization,
+)
 
 from ellar.constants import NOT_SET
 from ellar.helper import get_name
@@ -15,7 +23,7 @@
     SingletonScope,
     TransientScope,
 )
-from ..service_config import get_scope
+from ..service_config import get_scope, is_decorated_with_injectable
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.modules import ModuleBase
@@ -43,11 +51,36 @@ def create_binding(
         scope: t.Union[ScopeDecorator, t.Type[DIScope]] = None,
     ) -> Binding:
         provider = self.provider_for(interface, to)
-        scope = scope or getattr(to or interface, "__scope__", TransientScope)
+        scope = scope or get_scope(to or interface) or TransientScope
         if isinstance(scope, ScopeDecorator):
             scope = scope.scope
         return Binding(interface, provider, scope)
 
+    def get_binding(self, interface: type) -> t.Tuple[Binding, InjectorBinder]:
+        is_scope = isinstance(interface, type) and issubclass(interface, InjectorScope)
+        is_assisted_builder = _is_specialization(interface, AssistedBuilder)
+        try:
+            return self._get_binding(
+                interface, only_this_binder=is_scope or is_assisted_builder
+            )
+        except (KeyError, UnsatisfiedRequirement):
+            if is_scope:
+                scope = interface
+                self.bind(scope, to=scope(self.injector))
+                return self._get_binding(interface)
+            # The special interface is added here so that requesting a special
+            # interface with auto_bind disabled works
+            if (
+                self._auto_bind
+                or self._is_special_interface(interface)
+                or is_decorated_with_injectable(interface)
+            ):
+                binding = self.create_binding(interface)
+                self._bindings[interface] = binding
+                return binding, self
+
+        raise UnsatisfiedRequirement(None, interface)
+
     def register_binding(self, interface: t.Type, binding: Binding) -> None:
         self._bindings[interface] = binding
 

tests/test_di/test_injectable_resolving.py

@@ -0,0 +1,71 @@
+import pytest
+
+from ellar.di import (
+    EllarInjector,
+    injectable,
+    request_scope,
+    singleton_scope,
+    transient_scope,
+)
+from ellar.di.exceptions import UnsatisfiedRequirement
+
+
+@injectable(scope=transient_scope)
+class SampleInjectableA:
+    pass
+
+
+@injectable(scope=request_scope)
+class SampleInjectableB:
+    pass
+
+
+@injectable(scope=singleton_scope)
+class SampleInjectableC:
+    pass
+
+
+class MustBeRegisteredToResolve:
+    """This class must be registered to resolved or EllarInjector auto_bind must be true"""
+
+    pass
+
+
+def test_injectable_class_can_be_resolved_at_runtime_without_if_they_are_not_registered():
+    injector = EllarInjector(auto_bind=False)
+
+    assert isinstance(injector.get(SampleInjectableA), SampleInjectableA)
+    assert isinstance(injector.get(SampleInjectableB), SampleInjectableB)
+    assert isinstance(injector.get(SampleInjectableC), SampleInjectableC)
+
+    with pytest.raises(UnsatisfiedRequirement):
+        injector.get(MustBeRegisteredToResolve)
+
+    injector.container.register_scoped(MustBeRegisteredToResolve)
+    assert isinstance(
+        injector.get(MustBeRegisteredToResolve), MustBeRegisteredToResolve
+    )
+
+    injector = EllarInjector(auto_bind=True)
+    assert isinstance(
+        injector.get(MustBeRegisteredToResolve), MustBeRegisteredToResolve
+    )
+
+
+@pytest.mark.asyncio
+async def test_injectable_class_uses_defined_scope_during_runtime():
+    injector = EllarInjector(auto_bind=True)
+    # transient scope
+    assert injector.get(SampleInjectableA) != injector.get(SampleInjectableA)
+    # request scope outside request
+    assert injector.get(SampleInjectableB) != injector.get(SampleInjectableB)
+    # singleton scope
+    assert injector.get(SampleInjectableC) == injector.get(SampleInjectableC)
+    # transient scope by default
+    assert injector.get(MustBeRegisteredToResolve) != injector.get(
+        MustBeRegisteredToResolve
+    )
+
+    async with injector.create_asgi_args():
+        # request scope outside request
+        assert injector.get(SampleInjectableB) == injector.get(SampleInjectableB)

tests/test_di/test_provider_scopes.py

@@ -1,6 +1,8 @@
 import pytest
+from injector import inject
 
-from ellar.di import EllarInjector, ProviderConfig
+from ellar.di import EllarInjector, ProviderConfig, has_binding
+from ellar.di.exceptions import DIImproperConfiguration
 from ellar.di.scopes import RequestScope, SingletonScope, TransientScope
 
 from .examples import AnyContext, Foo, IContext
@@ -44,3 +46,20 @@ async def test_request_scope_instance():
     async with injector.create_asgi_args() as request_provider:
         # resolving RequestScope during request will behave like singleton
         assert request_provider.get(IContext) == request_provider.get(IContext)
+
+
+def test_invalid_use_of_provider_config():
+    with pytest.raises(DIImproperConfiguration):
+        ProviderConfig(IContext, use_class=AnyContext, use_value=AnyContext())
+
+
+def test_has_binding_works():
+    @inject
+    def inject_function(a: IContext):
+        pass
+
+    assert has_binding(IContext) is False
+    assert has_binding(AnyContext) is True
+
+    assert has_binding(lambda n: print("Hello")) is False
+    assert has_binding(inject_function) is True

tests/test_di/test_providers.py

@@ -1,9 +1,5 @@
 import pytest
-from injector import (
-    CircularDependency,
-    UnsatisfiedRequirement,
-    is_decorated_with_inject,
-)
+from injector import CircularDependency, is_decorated_with_inject
 
 from ellar.di import (
     EllarInjector,
@@ -99,25 +95,12 @@ def test_provider_advance_use_case():
     assert isinstance(db_context, AnyDBContext)
     assert repository.context == db_context  # service registered as singleton
 
-    with pytest.raises(UnsatisfiedRequirement):
-        injector.get(AnyDBContext)
-
-    with pytest.raises(UnsatisfiedRequirement):
-        injector.get(FooDBCatsRepository)
-
-    providers_advance.append(ProviderConfig(AnyDBContext))
-    providers_advance.append(ProviderConfig(FooDBCatsRepository))
-
-    injector = EllarInjector(auto_bind=False)
-
-    for provider in providers_advance:
-        provider.register(injector.container)
-
-    assert injector.get(AnyDBContext)
-    assert injector.get(FooDBCatsRepository)
-
-    assert isinstance(injector.get(IRepository), FooDBCatsRepository)
-    assert isinstance(injector.get(IDBContext), AnyDBContext)
+    assert isinstance(
+        injector.get(FooDBCatsRepository), FooDBCatsRepository
+    )  # only possible because they are decorated with injectable
+    assert isinstance(
+        injector.get(AnyDBContext), AnyDBContext
+    )  # only possible because they are decorated with injectable
 
 
 def test_module_provider_works():