Added more test

Author: eadwinCode

mypy.ini

@@ -21,6 +21,9 @@ implicit_reexport = False
 [mypy-ellar.compatible.*]
 ignore_errors = True
 
+[mypy-ellar.core.services.*]
+ignore_errors = True
+
 [mypy-ellar.cli.*]
 ignore_errors = True
 

tests/test_application/test_application_functions.py

@@ -17,12 +17,9 @@
 from ellar.core.connection import Request
 from ellar.core.context import IExecutionContext, IHostContext
 from ellar.core.events import EventHandler
-from ellar.core.exceptions.interfaces import (
-    IExceptionHandler,
-    IExceptionMiddlewareService,
-)
-from ellar.core.exceptions.service import ExceptionMiddlewareService
+from ellar.core.exceptions.interfaces import IExceptionHandler
 from ellar.core.modules import ModuleTemplateRef
+from ellar.core.services import CoreServiceRegistration
 from ellar.core.staticfiles import StaticFiles
 from ellar.core.templating import Environment
 from ellar.core.versioning import VERSIONING, DefaultAPIVersioning, UrlPathAPIVersioning
@@ -192,7 +189,6 @@ async def homepage(request: Request):
         response = client.get("/")
         assert response.status_code == 500
         assert "test_application_functions.py" in response.text
-        assert "line 185" in response.text
         assert app.debug
 
 
@@ -217,9 +213,7 @@ def test_app_staticfiles_route(self, tmpdir):
 
         config = Config(STATIC_DIRECTORIES=[tmpdir])
         injector = EllarInjector()
-        injector.container.register_singleton(
-            IExceptionMiddlewareService, ExceptionMiddlewareService
-        )
+        CoreServiceRegistration(injector).register_all()
         injector.container.register_instance(config)
         app = App(injector=injector, config=config)
         client = TestClient(app)
@@ -241,9 +235,7 @@ def test_app_staticfiles_with_different_static_path(self, tmpdir):
             STATIC_MOUNT_PATH="/static-modified", STATIC_DIRECTORIES=[tmpdir]
         )
         injector = EllarInjector()
-        injector.container.register_singleton(
-            IExceptionMiddlewareService, ExceptionMiddlewareService
-        )
+        CoreServiceRegistration(injector).register_all()
         injector.container.register_instance(config)
         app = App(injector=injector, config=config)
         client = TestClient(app)
@@ -293,9 +285,7 @@ def test_app_initialization_completion(self):
         injector = EllarInjector(
             auto_bind=False
         )  # will raise an exception is service is not registered
-        injector.container.register_singleton(
-            IExceptionMiddlewareService, ExceptionMiddlewareService
-        )
+        CoreServiceRegistration(injector).register_all()
         injector.container.register_instance(config)
 
         app = App(config=config, injector=injector)
@@ -327,9 +317,7 @@ async def catch(
         injector = EllarInjector(
             auto_bind=False
         )  # will raise an exception is service is not registered
-        injector.container.register_singleton(
-            IExceptionMiddlewareService, ExceptionMiddlewareService
-        )
+        CoreServiceRegistration(injector).register_all()
         injector.container.register_instance(config)
         app = App(config=config, injector=injector)
         app.add_exception_handler(CustomExceptionHandler())

tests/test_application/test_replacing_app_services.py

@@ -0,0 +1,151 @@
+from starlette.exceptions import HTTPException
+from starlette.responses import PlainTextResponse
+
+from ellar.common import Controller, Module, exception_handler, get
+from ellar.constants import ASGI_CONTEXT_VAR
+from ellar.core import TestClientFactory
+from ellar.core.context import (
+    ExecutionContext,
+    HostContext,
+    IExecutionContext,
+    IExecutionContextFactory,
+    IHostContext,
+    IHostContextFactory,
+)
+from ellar.core.exceptions import IExceptionMiddlewareService
+from ellar.core.exceptions.service import ExceptionMiddlewareService
+from ellar.di import ProviderConfig, injectable
+from ellar.di.exceptions import ServiceUnavailable
+from ellar.services import Reflector
+
+
+@Controller
+class ExampleController:
+    @get()
+    def index(self):
+        return self.context.__class__.__name__
+
+    @get("/exception")
+    def exception(self):
+        raise HTTPException(status_code=400)
+
+
+class NewExecutionContext(ExecutionContext):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.instantiated = True
+        self.__class__.worked = True
+
+
+@injectable()
+class NewExecutionHostFactory(IExecutionContextFactory):
+    def __init__(self, reflector: Reflector):
+        self.reflector = reflector
+
+    def create_context(self, operation) -> IExecutionContext:
+        scoped_request_args = ASGI_CONTEXT_VAR.get()
+
+        if not scoped_request_args:
+            raise ServiceUnavailable()
+
+        scope, receive, send = scoped_request_args.get_args()
+        i_execution_context = NewExecutionContext(
+            scope=scope,
+            receive=receive,
+            send=send,
+            operation_handler=operation.endpoint,
+            reflector=self.reflector,
+        )
+        i_execution_context.get_service_provider().update_scoped_context(
+            IExecutionContext, i_execution_context
+        )
+
+        return i_execution_context
+
+
+@injectable()
+class NewHostContextFactory(IHostContextFactory):
+    def create_context(self) -> IHostContext:
+        scoped_request_args = ASGI_CONTEXT_VAR.get()
+
+        if not scoped_request_args:
+            raise ServiceUnavailable()
+
+        scope, receive, send = scoped_request_args.get_args()
+        host_context = NewHostContext(scope=scope, receive=receive, send=send)
+        host_context.get_service_provider().update_scoped_context(
+            IHostContext, host_context
+        )
+        return host_context
+
+
+class NewHostContext(HostContext):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.instantiated = True
+        self.__class__.worked = True
+
+
+@injectable()
+class NewExceptionMiddlewareService(ExceptionMiddlewareService):
+    def lookup_status_code_exception_handler(self, status_code: int):
+        self.__class__.worked = True
+        return self._status_handlers.get(status_code)
+
+
+def test_can_replace_host_context():
+    tm = TestClientFactory.create_test_module(controllers=[ExampleController])
+    tm.app.injector.container.register(IHostContextFactory, NewHostContextFactory)
+
+    assert hasattr(NewHostContext, "worked") is False
+    client = tm.get_client()
+    res = client.get("/example/")
+    assert res.status_code == 200
+    assert res.text == '"ExecutionContext"'
+
+    assert hasattr(NewHostContext, "worked") is True
+    assert NewHostContext.worked is True
+
+
+def test_can_replace_exception_service():
+    @Module(
+        controllers=[ExampleController],
+        providers=[
+            ProviderConfig(
+                IExceptionMiddlewareService, use_class=NewExceptionMiddlewareService
+            )
+        ],
+    )
+    class ExampleModule:
+        @exception_handler(400)
+        def exception_400(self, context: IHostContext, exc: Exception):
+            return PlainTextResponse(
+                "Exception 400 handled by ExampleModule.exception_400"
+            )
+
+    tm = TestClientFactory.create_test_module_from_module(ExampleModule)
+
+    assert hasattr(NewExceptionMiddlewareService, "worked") is False
+    client = tm.get_client()
+    res = client.get("/example/exception")
+    assert res.status_code == 200
+    assert res.text == "Exception 400 handled by ExampleModule.exception_400"
+
+    assert hasattr(NewExceptionMiddlewareService, "worked") is True
+    assert NewExceptionMiddlewareService.worked is True
+
+
+def test_can_replace_execution_context():
+    tm = TestClientFactory.create_test_module(controllers=[ExampleController])
+    tm.app.injector.container.register(
+        IExecutionContextFactory, NewExecutionHostFactory
+    )
+
+    assert hasattr(NewExecutionContext, "worked") is False
+    client = tm.get_client()
+    res = client.get("/example/")
+    assert res.status_code == 200
+    assert res.text == '"NewExecutionContext"'
+
+    assert hasattr(NewExecutionContext, "worked") is True
+    assert NewExecutionContext.worked is True

tests/test_di/test_injector.py

@@ -4,7 +4,7 @@
 from injector import Binder, Injector, UnsatisfiedRequirement
 
 from ellar.common import Module
-from ellar.constants import MODULE_REF_TYPES
+from ellar.constants import ASGI_CONTEXT_VAR, MODULE_REF_TYPES
 from ellar.core import Config, ModuleBase
 from ellar.core.modules.ref import create_module_ref_factor
 from ellar.di import Container, EllarInjector
@@ -62,40 +62,53 @@ def test_default_container_registration():
 
 
 @pytest.mark.asyncio
-async def test_request_service_provider():
+async def test_request_service_context():
     injector = EllarInjector(auto_bind=False)
     injector.container.register_scoped(Foo1)
     injector.container.register_exact_transient(Foo2)
 
-    def assert_attributes(provider, expected):
-        assert hasattr(provider, "parent") is expected
-        assert hasattr(provider, "injector") is expected
-        assert hasattr(provider, "_context") is expected
+    def assert_attributes():
+        asgi_context_var = ASGI_CONTEXT_VAR.get()
+        assert len(asgi_context_var.context) == 0
+        assert len(asgi_context_var.scope) == 0
+        assert asgi_context_var.receive is None
+        assert asgi_context_var.send is None
 
-    async with injector.create_request_service_provider() as request_provider:
-        assert_attributes(request_provider, True)
-        foo_instance = Foo()
-        request_provider.update_context(Foo, foo_instance)
-        request_provider.update_context(
-            Foo1, Foo1()
-        )  # overrides parent provider config for Foo1
+    async with injector.create_asgi_args({}, None, None):
+        assert_attributes()
+        asgi_context = ASGI_CONTEXT_VAR.get()
 
-        assert isinstance(
-            injector.container.get_binding(Foo1)[0].provider, ClassProvider
-        )
-        assert isinstance(
-            request_provider.get_binding(Foo1)[0].provider, InstanceProvider
-        )
+        foo1 = injector.get(Foo1)  # result will be tracked by asgi_context
+        injector.get(Foo2)  # registered as transient scoped
 
-        assert request_provider.get(Foo) is foo_instance
-        # request_provider defaults to parent when binding is not in its context
-        assert isinstance(request_provider.get(Foo2), Foo2)
+        assert isinstance(asgi_context.context[Foo1], InstanceProvider)
+        assert asgi_context.context.get(Foo2) is None
+
+        # transient scoped
+        foo2 = injector.get(Foo2)
+        assert isinstance(foo2, Foo2)
+        assert injector.get(Foo2) != foo2  # transient scoped
+
+        assert injector.get(Foo1) == foo1  # still within the context....
 
         with pytest.raises(UnsatisfiedRequirement):
-            # parent can not resolve bindings added to request service provider
             injector.get(Foo)
 
-    assert_attributes(request_provider, False)
+    assert injector.get(Foo1) != foo1
+
+
+@pytest.mark.asyncio
+async def test_injector_update_scoped_context():
+    injector = EllarInjector(auto_bind=False)
+
+    async with injector.create_asgi_args({}, None, None):
+        asgi_context = ASGI_CONTEXT_VAR.get()
+
+        injector.update_scoped_context(Foo1, Foo1())
+        injector.update_scoped_context(Foo, ClassProvider(Foo))
+
+        assert isinstance(asgi_context.context[Foo1], InstanceProvider)
+        assert isinstance(asgi_context.context[Foo], ClassProvider)
 
 
 class TestInjectorModuleFunctions:

tests/test_di/test_middleware.py

@@ -4,9 +4,10 @@
 
 from ellar.constants import SCOPE_SERVICE_PROVIDER
 from ellar.core.connection import HTTPConnection, Request, WebSocket
-from ellar.core.context import IHostContext
+from ellar.core.context import HostContextException, IHostContext
 from ellar.core.middleware import RequestServiceProviderMiddleware
 from ellar.core.response import Response
+from ellar.core.services import CoreServiceRegistration
 from ellar.di import EllarInjector
 
 from ..injector_module import Configuration, DummyModule
@@ -54,10 +55,10 @@ async def assert_iexecute_context_app(scope, receive, send):
     )
     assert service_provider is host_context.get_service_provider()
 
-    with pytest.raises(Exception):
+    with pytest.raises(HostContextException):
         host_context.switch_to_websocket()
 
-    with pytest.raises(Exception):
+    with pytest.raises(HostContextException):
         service_provider.get(WebSocket)
 
     await send(
@@ -90,10 +91,10 @@ async def assert_iexecute_context_app_websocket(scope, receive, send):
         is host_context.switch_to_http_connection().get_client()
     )
 
-    with pytest.raises(Exception):
+    with pytest.raises(HostContextException):
         service_provider.get(Request)
 
-    with pytest.raises(Exception):
+    with pytest.raises(HostContextException):
         service_provider.get(Response)
 
     await websocket.accept()
@@ -107,7 +108,7 @@ def test_di_middleware(test_client_factory):
     asgi_app = RequestServiceProviderMiddleware(
         assert_service_provider_app, debug=False, injector=injector_
     )
-
+    CoreServiceRegistration(injector_).register_all()
     client = test_client_factory(asgi_app)
     response = client.get("/")
 
@@ -118,9 +119,11 @@ def test_di_middleware(test_client_factory):
 
 
 def test_di_middleware_execution_context_initialization(test_client_factory):
+    injector_ = EllarInjector()
     asgi_app = RequestServiceProviderMiddleware(
-        assert_iexecute_context_app, debug=False, injector=EllarInjector()
+        assert_iexecute_context_app, debug=False, injector=injector_
     )
+    CoreServiceRegistration(injector_).register_all()
 
     client = test_client_factory(asgi_app)
     response = client.get("/")
@@ -131,9 +134,11 @@ def test_di_middleware_execution_context_initialization(test_client_factory):
 
 
 def test_di_middleware_execution_context_initialization_websocket(test_client_factory):
+    injector_ = EllarInjector()
     asgi_app = RequestServiceProviderMiddleware(
-        assert_iexecute_context_app_websocket, debug=False, injector=EllarInjector()
+        assert_iexecute_context_app_websocket, debug=False, injector=injector_
     )
+    CoreServiceRegistration(injector_).register_all()
 
     client = test_client_factory(asgi_app)
     with client.websocket_connect("/") as session: