Fixed and added more test

Author: eadwinCode

tests/test_application/test_application_functions.py

@@ -1,7 +1,6 @@
 import os
 import typing as t
 
-import pytest
 from starlette.responses import JSONResponse, PlainTextResponse, Response
 
 from ellar.common import Module, get, template_filter, template_global
@@ -15,7 +14,7 @@
     TestClientFactory,
 )
 from ellar.core.connection import Request
-from ellar.core.context import IExecutionContext, IHostContext
+from ellar.core.context import IExecutionContext
 from ellar.core.events import EventHandler
 from ellar.core.exceptions.interfaces import IExceptionHandler
 from ellar.core.modules import ModuleTemplateRef
@@ -292,14 +291,6 @@ def test_app_initialization_completion(self):
         assert injector.get(Reflector)
         assert injector.get(Config) is config
         assert injector.get(Environment) is app.jinja_environment
-        with pytest.raises(
-            Exception, match="Service Unavailable at the current context."
-        ):
-            injector.get(IExecutionContext)
-        with pytest.raises(
-            Exception, match="Service Unavailable at the current context."
-        ):
-            injector.get(IHostContext)
 
     def test_app_exception_handler(self):
         class CustomException(Exception):

tests/test_application/test_replacing_app_services.py

@@ -2,7 +2,6 @@
 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,
@@ -15,7 +14,6 @@
 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
 
 
@@ -42,35 +40,23 @@ class NewExecutionHostFactory(IExecutionContextFactory):
     def __init__(self, reflector: Reflector):
         self.reflector = reflector
 
-    def create_context(self, operation, scope, receive, send) -> IExecutionContext:
-        scoped_request_args = ASGI_CONTEXT_VAR.get()
-
-        if not scoped_request_args:
-            raise ServiceUnavailable()
-
+    def create_context(
+        self, operation, scope, receive=None, send=None
+    ) -> IExecutionContext:
         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()
+    def create_context(self, scope, receive=None, send=None) -> IHostContext:
         host_context = NewHostContext(scope=scope, receive=receive, send=send)
         host_context.get_service_provider().update_scoped_context(
             IHostContext, host_context
@@ -98,9 +84,8 @@ def test_can_replace_host_context():
 
     assert hasattr(NewHostContext, "worked") is False
     client = tm.get_client()
-    res = client.get("/example/")
-    assert res.status_code == 200
-    assert res.text == '"ExecutionContext"'
+    res = client.get("/example/exception")
+    assert res.json() == {"detail": "Bad Request", "status_code": 400}
 
     assert hasattr(NewHostContext, "worked") is True
     assert NewHostContext.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 ASGI_CONTEXT_VAR, MODULE_REF_TYPES
+from ellar.constants import MODULE_REF_TYPES, SCOPED_CONTEXT_VAR
 from ellar.core import Config, ModuleBase
 from ellar.core.modules.ref import create_module_ref_factor
 from ellar.di import Container, EllarInjector
@@ -67,16 +67,8 @@ async def test_request_service_context():
     injector.container.register_scoped(Foo1)
     injector.container.register_exact_transient(Foo2)
 
-    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_asgi_args({}, None, None):
-        assert_attributes()
-        asgi_context = ASGI_CONTEXT_VAR.get()
+    async with injector.create_asgi_args():
+        asgi_context = SCOPED_CONTEXT_VAR.get()
 
         foo1 = injector.get(Foo1)  # result will be tracked by asgi_context
         injector.get(Foo2)  # registered as transient scoped
@@ -101,8 +93,8 @@ def assert_attributes():
 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()
+    async with injector.create_asgi_args():
+        asgi_context = SCOPED_CONTEXT_VAR.get()
 
         injector.update_scoped_context(Foo1, Foo1())
         injector.update_scoped_context(Foo, ClassProvider(Foo))
@@ -111,7 +103,7 @@ async def test_injector_update_scoped_context():
         assert isinstance(asgi_context.context[Foo], ClassProvider)
 
     injector.update_scoped_context(Foo1, Foo1())
-    assert ASGI_CONTEXT_VAR.get() is None
+    assert SCOPED_CONTEXT_VAR.get() is None
 
 
 class TestInjectorModuleFunctions:

tests/test_di/test_middleware.py

@@ -3,10 +3,8 @@
 import pytest
 
 from ellar.constants import SCOPE_SERVICE_PROVIDER
-from ellar.core.connection import HTTPConnection, Request, WebSocket
-from ellar.core.context import HostContextException, IHostContext
+from ellar.core.context import HostContextException, IHostContextFactory
 from ellar.core.middleware import RequestServiceProviderMiddleware
-from ellar.core.response import Response
 from ellar.core.services import CoreServiceRegistration
 from ellar.di import EllarInjector
 
@@ -40,27 +38,14 @@ async def assert_iexecute_context_app(scope, receive, send):
     assert scope[SCOPE_SERVICE_PROVIDER]
 
     service_provider = scope[SCOPE_SERVICE_PROVIDER]
-    host_context: IHostContext = service_provider.get(IHostContext)
-    assert (
-        service_provider.get(HTTPConnection)
-        is host_context.switch_to_http_connection().get_client()
+    host_context_factory: IHostContextFactory = service_provider.get(
+        IHostContextFactory
     )
-    assert (
-        service_provider.get(Request)
-        is host_context.switch_to_http_connection().get_request()
-    )
-    assert (
-        service_provider.get(Response)
-        is host_context.switch_to_http_connection().get_response()
-    )
-    assert service_provider is host_context.get_service_provider()
+    host_context = host_context_factory.create_context(scope, receive, send)
 
     with pytest.raises(HostContextException):
         host_context.switch_to_websocket()
 
-    with pytest.raises(HostContextException):
-        service_provider.get(WebSocket)
-
     await send(
         {
             "type": "http.response.start",
@@ -80,22 +65,19 @@ async def assert_iexecute_context_app_websocket(scope, receive, send):
     assert scope[SCOPE_SERVICE_PROVIDER]
 
     service_provider = scope[SCOPE_SERVICE_PROVIDER]
-    host_context: IHostContext = service_provider.get(IHostContext)
+    host_context_factory: IHostContextFactory = service_provider.get(
+        IHostContextFactory
+    )
+    host_context = host_context_factory.create_context(scope, receive, send)
 
     websocket = host_context.switch_to_websocket().get_client()
-    assert service_provider.get(WebSocket) is websocket
     assert service_provider is host_context.get_service_provider()
 
-    assert (
-        service_provider.get(HTTPConnection)
-        is host_context.switch_to_http_connection().get_client()
-    )
-
     with pytest.raises(HostContextException):
-        service_provider.get(Request)
+        host_context.switch_to_http_connection().get_request()
 
     with pytest.raises(HostContextException):
-        service_provider.get(Response)
+        host_context.switch_to_http_connection().get_response()
 
     await websocket.accept()
     await websocket.send_text("Hello, world!")

tests/test_di/test_provider_scopes.py

@@ -41,6 +41,6 @@ async def test_request_scope_instance():
     # resolving RequestScope Providers outside RequestServiceProvider will behave like TransientScope
     assert injector.get(IContext) != injector.get(IContext)
     assert isinstance(injector.get(IContext), AnyContext)
-    async with injector.create_asgi_args({}, None, None) as request_provider:
+    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)

tests/test_exceptions/test_validation_exception.py

@@ -1,7 +1,7 @@
 import pytest
 from pydantic.error_wrappers import ErrorWrapper
 
-from ellar.common import Ws, get, ws_route
+from ellar.common import Ws, WsBody, get, ws_route
 from ellar.core import TestClientFactory
 from ellar.core.exceptions.validation import (
     RequestValidationError,
@@ -20,12 +20,18 @@ def exception_http():
     _exception_runner.run()
 
 
-@ws_route("/exception-Ws", use_extra_handler=True)
+@ws_route("/exception-Ws", use_extra_handler=False)
 async def exception_ws(websocket=Ws()):
     _exception_runner.run()
 
 
-test_module.app.router.extend([exception_http, exception_ws])
+@ws_route("/exception-Ws-2", use_extra_handler=True)
+async def exception_ws_2(*, websocket=Ws(), data: dict = WsBody()):
+    assert data == {"hello": "world"}
+    _exception_runner.run()
+
+
+test_module.app.router.extend([exception_http, exception_ws_2, exception_ws])
 client = test_module.get_client()
 
 
@@ -81,3 +87,23 @@ def test_websocket_validation_error():
         {"loc": ("form",), "msg": "Invalid Request", "type": "value_error.exception"},
         {"loc": ("model",), "msg": "Invalid Request", "type": "value_error.exception"},
     ]
+
+
+def test_websocket_validation_error_2():
+    global _exception_runner
+    _exception_runner = ExceptionRunner(
+        WebSocketRequestValidationError,
+        errors=[
+            ErrorWrapper(Exception("Invalid Request"), loc="body"),
+            ErrorWrapper(Exception("Invalid Request"), loc="form"),
+            ErrorWrapper(Exception("Invalid Request"), loc="model"),
+        ],
+    )
+    with pytest.raises(WebSocketRequestValidationError) as wex:
+        with client.websocket_connect("/exception-Ws-2") as websocket:
+            websocket.send_json({"hello": "world"})
+    assert wex.value.errors() == [
+        {"loc": ("body",), "msg": "Invalid Request", "type": "value_error.exception"},
+        {"loc": ("form",), "msg": "Invalid Request", "type": "value_error.exception"},
+        {"loc": ("model",), "msg": "Invalid Request", "type": "value_error.exception"},
+    ]

tests/test_routing/test_extra_args.py

@@ -2,7 +2,7 @@
 
 from starlette.responses import Response
 
-from ellar.common import Provide, Query, get, set_metadata
+from ellar.common import Context, Query, Res, get, set_metadata
 from ellar.constants import EXTRA_ROUTE_ARGS_KEY
 from ellar.core import TestClientFactory
 from ellar.core.connection import Request
@@ -41,10 +41,10 @@ def _wrapper(*args, **kwargs):
 def add_extra_non_field_extra_args(func):
     # EXTRA ARGS SETUP
     context = ExtraEndpointArg(
-        name="context", annotation=IExecutionContext, default_value=Provide()
+        name="context", annotation=IExecutionContext, default_value=Context()
     )
     response = ExtraEndpointArg(
-        name="response", annotation=Response, default_value=Provide()
+        name="response", annotation=Response, default_value=Res()
     )
 
     set_metadata(EXTRA_ROUTE_ARGS_KEY, response)(func)