Fixed test due to refactor

Author: eadwinCode

tests/test_application/test_application_functions.py

@@ -1,7 +1,7 @@
 import os
 import typing as t
 
-from starlette.responses import JSONResponse, Response
+from starlette.responses import JSONResponse, PlainTextResponse, Response
 
 from ellar.common import Module, get, template_filter, template_global
 from ellar.compatible import asynccontextmanager
@@ -196,6 +196,19 @@ async def homepage(request: Request):
 
 
 class TestEllarApp:
+    def test_ellar_as_asgi_app(self):
+        @get("/")
+        async def homepage(request: Request, ctx: IExecutionContext):
+            res = PlainTextResponse("Ellar Route Handler as an ASGI app")
+            await res(*ctx.get_args())
+
+        app = AppFactory.create_app()
+        app.router.append(homepage)
+        client = TestClient(app)
+        response = client.get("/")
+        assert response.status_code == 200
+        assert response.text == "Ellar Route Handler as an ASGI app"
+
     def test_app_staticfiles_route(self, tmpdir):
         path = os.path.join(tmpdir, "example.txt")
         with open(path, "w") as file:

tests/test_application/test_functional_middleware.py

@@ -3,7 +3,7 @@
 
 from ellar.common import Module, ModuleRouter, middleware
 from ellar.core import TestClientFactory
-from ellar.core.context import IExecutionContext
+from ellar.core.context import IHostContext
 
 mr = ModuleRouter()
 
@@ -21,22 +21,22 @@ def homepage(request: Request):
 @Module(routers=[mr])
 class ModuleMiddleware:
     @middleware()
-    async def middleware_modify_response(cls, context: IExecutionContext, call_next):
-        response = context.get_response()
+    async def middleware_modify_response(cls, context: IHostContext, call_next):
+        response = context.switch_to_http_connection().get_response()
         response.headers.setdefault("modified-header", "Ellar")
         await call_next()
 
     @middleware()
-    async def middleware_modify_request(cls, context: IExecutionContext, call_next):
-        request = context.switch_to_request()
+    async def middleware_modify_request(cls, context: IHostContext, call_next):
+        request = context.switch_to_http_connection().get_request()
         request.state.user = None
         if request.headers.get("set-user"):
             request.state.user = dict(username="Ellar")
         await call_next()
 
     @middleware()
-    async def middleware_return_response(cls, context: IExecutionContext, call_next):
-        request = context.switch_to_request()
+    async def middleware_return_response(cls, context: IHostContext, call_next):
+        request = context.switch_to_http_connection().get_request()
         if request.headers.get("ellar"):
             return PlainTextResponse("middleware_return_response returned a response")
         await call_next()

tests/test_common/test_decorators/test_controller.py

@@ -0,0 +1,85 @@
+from ellar.common import Controller
+from ellar.constants import CONTROLLER_METADATA, NOT_SET
+from ellar.reflect import reflect
+
+
+@Controller(
+    prefix="/decorator",
+    description="Some description",
+    external_doc_description="external",
+    guards=[],
+    version=("v1",),
+    tag="dec",
+    external_doc_url="https://example.com",
+    name="test",
+)
+class ControllerDecorationTest:
+    pass
+
+
+@Controller
+class ControllerDefaultTest:
+    pass
+
+
+def test_controller_decoration_default():
+    assert (
+        reflect.get_metadata(CONTROLLER_METADATA.NAME, ControllerDefaultTest)
+        == "defaulttest"
+    )
+
+    assert reflect.get_metadata(CONTROLLER_METADATA.OPENAPI, ControllerDefaultTest) == {
+        "tag": NOT_SET,
+        "description": None,
+        "external_doc_description": None,
+        "external_doc_url": None,
+    }
+    assert reflect.get_metadata(CONTROLLER_METADATA.GUARDS, ControllerDefaultTest) == []
+    assert (
+        reflect.get_metadata(CONTROLLER_METADATA.VERSION, ControllerDefaultTest)
+        == set()
+    )
+    assert (
+        reflect.get_metadata(CONTROLLER_METADATA.PATH, ControllerDefaultTest)
+        == "/defaulttest"
+    )
+    assert (
+        reflect.get_metadata(
+            CONTROLLER_METADATA.INCLUDE_IN_SCHEMA, ControllerDefaultTest
+        )
+        is True
+    )
+
+
+def test_controller_decoration_test():
+    assert (
+        reflect.get_metadata(CONTROLLER_METADATA.NAME, ControllerDecorationTest)
+        == "test"
+    )
+
+    assert reflect.get_metadata(
+        CONTROLLER_METADATA.OPENAPI, ControllerDecorationTest
+    ) == {
+        "tag": "dec",
+        "description": "Some description",
+        "external_doc_description": "external",
+        "external_doc_url": "https://example.com",
+    }
+    assert (
+        reflect.get_metadata(CONTROLLER_METADATA.GUARDS, ControllerDecorationTest) == []
+    )
+    assert reflect.get_metadata(
+        CONTROLLER_METADATA.VERSION, ControllerDecorationTest
+    ) == {
+        "v1",
+    }
+    assert (
+        reflect.get_metadata(CONTROLLER_METADATA.PATH, ControllerDecorationTest)
+        == "/decorator"
+    )
+    assert (
+        reflect.get_metadata(
+            CONTROLLER_METADATA.INCLUDE_IN_SCHEMA, ControllerDecorationTest
+        )
+        is True
+    )

tests/test_di/test_middleware.py

@@ -4,7 +4,7 @@
 
 from ellar.constants import SCOPE_SERVICE_PROVIDER
 from ellar.core.connection import HTTPConnection, Request, WebSocket
-from ellar.core.context import IExecutionContext
+from ellar.core.context import IHostContext
 from ellar.core.middleware import RequestServiceProviderMiddleware
 from ellar.core.response import Response
 from ellar.di import EllarInjector
@@ -39,17 +39,23 @@ async def assert_iexecute_context_app(scope, receive, send):
     assert scope[SCOPE_SERVICE_PROVIDER]
 
     service_provider = scope[SCOPE_SERVICE_PROVIDER]
-    execution_context: IExecutionContext = service_provider.get(IExecutionContext)
+    host_context: IHostContext = service_provider.get(IHostContext)
     assert (
         service_provider.get(HTTPConnection)
-        is execution_context.switch_to_http_connection()
+        is host_context.switch_to_http_connection().get_client()
     )
-    assert service_provider.get(Request) is execution_context.switch_to_request()
-    assert service_provider.get(Response) is execution_context.get_response()
-    assert service_provider is execution_context.get_service_provider()
+    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()
 
     with pytest.raises(Exception):
-        execution_context.switch_to_websocket()
+        host_context.switch_to_websocket()
 
     with pytest.raises(Exception):
         service_provider.get(WebSocket)
@@ -69,6 +75,32 @@ async def assert_iexecute_context_app(scope, receive, send):
     )
 
 
+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)
+
+    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(Exception):
+        service_provider.get(Request)
+
+    with pytest.raises(Exception):
+        service_provider.get(Response)
+
+    await websocket.accept()
+    await websocket.send_text("Hello, world!")
+    await websocket.close()
+
+
 def test_di_middleware(test_client_factory):
     injector_ = EllarInjector()
     injector_.container.install(DummyModule)
@@ -96,3 +128,14 @@ def test_di_middleware_execution_context_initialization(test_client_factory):
     assert response.status_code == 200
     data = response.json()
     assert data["message"] == "execution context work"
+
+
+def test_di_middleware_execution_context_initialization_websocket(test_client_factory):
+    asgi_app = RequestServiceProviderMiddleware(
+        assert_iexecute_context_app_websocket, debug=False, injector=EllarInjector()
+    )
+
+    client = test_client_factory(asgi_app)
+    with client.websocket_connect("/") as session:
+        text = session.receive_text()
+        assert text == "Hello, world!"

tests/test_exceptions/test_custom_exceptions.py

@@ -8,7 +8,7 @@
 
 from ellar.common import get
 from ellar.core import Config, TestClientFactory
-from ellar.core.context import IExecutionContext
+from ellar.core.context import IHostContext
 from ellar.core.exceptions.callable_exceptions import CallableExceptionHandler
 from ellar.core.exceptions.handlers import APIException, APIExceptionHandler
 from ellar.core.exceptions.interfaces import IExceptionHandler
@@ -28,14 +28,14 @@ class NewExceptionHandler(IExceptionHandler):
     exception_type_or_code = NewException
 
     async def catch(
-        self, ctx: IExecutionContext, exc: t.Union[t.Any, Exception]
+        self, ctx: IHostContext, exc: t.Union[t.Any, Exception]
     ) -> t.Union[Response, t.Any]:
         return JSONResponse({"detail": str(exc)}, status_code=400)
 
 
 class OverrideAPIExceptionHandler(APIExceptionHandler):
     async def catch(
-        self, ctx: IExecutionContext, exc: t.Union[t.Any, Exception]
+        self, ctx: IHostContext, exc: t.Union[t.Any, Exception]
     ) -> t.Union[Response, t.Any]:
         return JSONResponse({"detail": str(exc)}, status_code=404)
 
@@ -44,7 +44,7 @@ class OverrideHTTPException(IExceptionHandler):
     exception_type_or_code = HTTPException
 
     async def catch(
-        self, ctx: IExecutionContext, exc: t.Union[t.Any, Exception]
+        self, ctx: IHostContext, exc: t.Union[t.Any, Exception]
     ) -> t.Union[Response, t.Any]:
         return JSONResponse({"detail": "HttpException Override"}, status_code=400)
 
@@ -53,13 +53,13 @@ class ServerErrorHandler(IExceptionHandler):
     exception_type_or_code = 500
 
     async def catch(
-        self, ctx: IExecutionContext, exc: t.Union[t.Any, Exception]
+        self, ctx: IHostContext, exc: t.Union[t.Any, Exception]
     ) -> t.Union[Response, t.Any]:
         return JSONResponse({"detail": "Server Error"}, status_code=500)
 
 
-def error_500(ctx: IExecutionContext, exc: Exception):
-    assert isinstance(ctx, IExecutionContext)
+def error_500(ctx: IHostContext, exc: Exception):
+    assert isinstance(ctx, IHostContext)
     return JSONResponse({"detail": "Server Error"}, status_code=500)
 
 
@@ -92,9 +92,7 @@ def test_invalid_exception_handler_setup_raise_exception():
     with pytest.raises(AssertionError) as ex:
 
         class InvalidExceptionSetup(IExceptionHandler):
-            def catch(
-                self, ctx: IExecutionContext, exc: t.Any
-            ) -> t.Union[Response, t.Any]:
+            def catch(self, ctx: IHostContext, exc: t.Any) -> t.Union[Response, t.Any]:
                 pass
 
     assert "'exception_type_or_code' must be defined" in str(ex.value)
@@ -106,9 +104,7 @@ def test_invalid_exception_type_setup_raise_exception():
         class InvalidExceptionSetup(IExceptionHandler):
             exception_type_or_code = ""
 
-            def catch(
-                self, ctx: IExecutionContext, exc: t.Any
-            ) -> t.Union[Response, t.Any]:
+            def catch(self, ctx: IHostContext, exc: t.Any) -> t.Union[Response, t.Any]:
                 pass
 
         assert "'exception_type_or_code' must be defined" in str(ex.value)
@@ -118,9 +114,7 @@ def catch(
         class InvalidExceptionSetup2(IExceptionHandler):
             exception_type_or_code = InvalidExceptionHandler
 
-            def catch(
-                self, ctx: IExecutionContext, exc: t.Any
-            ) -> t.Union[Response, t.Any]:
+            def catch(self, ctx: IHostContext, exc: t.Any) -> t.Union[Response, t.Any]:
                 pass
 
         assert "'exception_type_or_code' is not a valid type" in str(ex.value)