Amending ellar exception module refactor and added more test for new exception module implementation

Author: eadwinCode

tests/test_application/sample.py

@@ -98,13 +98,13 @@ def runtime_error(self, request: Request):
 )
 class ApplicationModule:
     @exception_handler(405)
-    async def method_not_allow_exception(self, request, exec):
+    async def method_not_allow_exception(self, ctx, exec):
         return JSONResponse({"detail": "Custom message"}, status_code=405)
 
     @exception_handler(500)
-    async def error_500(self, request, exec):
+    async def error_500(self, ctx, exec):
         return JSONResponse({"detail": "Server Error"}, status_code=500)
 
     @exception_handler(HTTPException)
-    async def http_exception(self, request, exc):
+    async def http_exception(self, ctx, exc):
         return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)

tests/test_application/test_application_functions.py

@@ -1,6 +1,7 @@
 import os
+import typing as t
 
-from starlette.responses import JSONResponse
+from starlette.responses import JSONResponse, Response
 
 from ellar.common import Module, get, template_filter, template_global
 from ellar.compatible import asynccontextmanager
@@ -15,6 +16,11 @@
 from ellar.core.connection import Request
 from ellar.core.context import IExecutionContext
 from ellar.core.events import EventHandler
+from ellar.core.exceptions.interfaces import (
+    IExceptionHandler,
+    IExceptionMiddlewareService,
+)
+from ellar.core.exceptions.service import ExceptionMiddlewareService
 from ellar.core.modules import ModuleTemplateRef
 from ellar.core.staticfiles import StaticFiles
 from ellar.core.templating import Environment
@@ -179,7 +185,12 @@ def test_app_staticfiles_route(self, tmpdir):
             file.write("<file content>")
 
         config = Config(STATIC_DIRECTORIES=[tmpdir])
-        app = App(injector=EllarInjector(), config=config)
+        injector = EllarInjector()
+        injector.container.register_singleton(
+            IExceptionMiddlewareService, ExceptionMiddlewareService
+        )
+        injector.container.register_instance(config)
+        app = App(injector=injector, config=config)
         client = TestClient(app)
 
         response = client.get("/static/example.txt")
@@ -198,7 +209,12 @@ def test_app_staticfiles_with_different_static_path(self, tmpdir):
         config = Config(
             STATIC_MOUNT_PATH="/static-modified", STATIC_DIRECTORIES=[tmpdir]
         )
-        app = App(injector=EllarInjector(), config=config)
+        injector = EllarInjector()
+        injector.container.register_singleton(
+            IExceptionMiddlewareService, ExceptionMiddlewareService
+        )
+        injector.container.register_instance(config)
+        app = App(injector=injector, config=config)
         client = TestClient(app)
 
         response = client.get("/static-modified/example.txt")
@@ -246,6 +262,10 @@ 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
+        )
+        injector.container.register_instance(config)
 
         app = App(config=config, injector=injector)
         assert injector.get(Reflector)
@@ -258,16 +278,24 @@ def test_app_exception_handler(self):
         class CustomException(Exception):
             pass
 
+        class CustomExceptionHandler(IExceptionHandler):
+            exception_type_or_code = CustomException
+
+            async def catch(
+                self, ctx: IExecutionContext, exc: t.Union[t.Any, Exception]
+            ) -> t.Union[Response, t.Any]:
+                return JSONResponse(dict(detail=str(exc)), status_code=404)
+
         config = Config()
         injector = EllarInjector(
             auto_bind=False
         )  # will raise an exception is service is not registered
-
+        injector.container.register_singleton(
+            IExceptionMiddlewareService, ExceptionMiddlewareService
+        )
+        injector.container.register_instance(config)
         app = App(config=config, injector=injector)
-
-        @app.exception_handler(CustomException)
-        async def exception_custom_exception(request, exc):
-            return JSONResponse(dict(detail=str(exc)), status_code=404)
+        app.add_exception_handler(CustomExceptionHandler())
 
         @get("/404")
         def raise_custom_exception():

tests/test_common/test_decorators/test_html.py

@@ -9,9 +9,9 @@
     TEMPLATE_GLOBAL_KEY,
 )
 from ellar.core.connection import Request
+from ellar.core.exceptions import ImproperConfiguration
 from ellar.core.response.model import HTMLResponseModel
 from ellar.core.templating import TemplateFunctionData
-from ellar.exceptions import ImproperConfiguration
 from ellar.reflect import reflect
 
 

tests/test_common/test_decorators/test_modules.py

@@ -2,8 +2,8 @@
 
 from ellar.common import Module
 from ellar.constants import MODULE_METADATA, MODULE_WATERMARK
+from ellar.core.exceptions import ImproperConfiguration
 from ellar.di import has_binding, is_decorated_with_injectable
-from ellar.exceptions import ImproperConfiguration
 from ellar.reflect import reflect
 
 

tests/test_conf/test_default_conf.py

@@ -8,7 +8,6 @@
 from ellar.core.conf import Config, ConfigDefaultTypesMixin
 from ellar.core.conf.config import ConfigRuntimeError
 from ellar.core.versioning import DefaultAPIVersioning, UrlPathAPIVersioning
-from ellar.exceptions import APIException, RequestValidationError
 
 
 class ConfigTesting(ConfigDefaultTypesMixin):
@@ -46,9 +45,6 @@ def test_default_configurations():
 
     assert config.MIDDLEWARE == []
 
-    assert RequestValidationError in config.EXCEPTION_HANDLERS
-    assert APIException in config.EXCEPTION_HANDLERS
-
     assert callable(config.DEFAULT_NOT_FOUND_HANDLER)
     assert config.DEFAULT_LIFESPAN_HANDLER is None
 

tests/test_exceptions/test_api_exception.py

@@ -2,7 +2,7 @@
 
 from ellar.common import get
 from ellar.core import TestClientFactory
-from ellar.exceptions import (
+from ellar.core.exceptions import (
     APIException,
     AuthenticationFailed,
     MethodNotAllowed,

tests/test_exceptions/test_custom_exceptions.py

@@ -0,0 +1,191 @@
+import typing as t
+
+import pytest
+from pydantic.error_wrappers import ValidationError
+from starlette.exceptions import HTTPException
+from starlette.responses import JSONResponse, Response
+
+from ellar.common import get
+from ellar.core import Config, TestClientFactory
+from ellar.core.context import IExecutionContext
+from ellar.core.exceptions.callable_exceptions import CallableExceptionHandler
+from ellar.core.exceptions.handlers import APIException, APIExceptionHandler
+from ellar.core.exceptions.interfaces import IExceptionHandler
+from ellar.core.exceptions.service import ExceptionMiddlewareService
+from ellar.core.middleware import ExceptionMiddleware
+
+
+class InvalidExceptionHandler:
+    pass
+
+
+class NewException(Exception):
+    pass
+
+
+class NewExceptionHandler(IExceptionHandler):
+    exception_type_or_code = NewException
+
+    async def catch(
+        self, ctx: IExecutionContext, 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]
+    ) -> t.Union[Response, t.Any]:
+        return JSONResponse({"detail": str(exc)}, status_code=404)
+
+
+class ServerErrorHandler(IExceptionHandler):
+    exception_type_or_code = 500
+
+    async def catch(
+        self, ctx: IExecutionContext, 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)
+    return JSONResponse({"detail": "Server Error"}, status_code=500)
+
+
+def test_invalid_handler_raise_exception():
+    with pytest.raises(ValidationError) as ex:
+        Config(EXCEPTION_HANDLERS=[InvalidExceptionHandler])
+
+    assert ex.value.errors() == [
+        {
+            "loc": ("EXCEPTION_HANDLERS", 0),
+            "msg": "Expected TExceptionHandler, received: <class 'tests.test_exceptions.test_custom_exceptions.InvalidExceptionHandler'>",
+            "type": "value_error",
+        }
+    ]
+
+    with pytest.raises(ValidationError) as ex:
+        Config(EXCEPTION_HANDLERS=[InvalidExceptionHandler()])
+
+    assert ex.value.errors() == [
+        {
+            "loc": ("EXCEPTION_HANDLERS", 0),
+            "msg": "Expected TExceptionHandler, received: "
+            "<class 'tests.test_exceptions.test_custom_exceptions.InvalidExceptionHandler'>",
+            "type": "value_error",
+        }
+    ]
+
+
+def test_invalid_iexception_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]:
+                pass
+
+    assert "exception_type_or_code must be defined" in str(ex.value)
+
+
+def test_custom_exception_works():
+    @get()
+    def homepage():
+        raise NewException("New Exception")
+
+    tm = TestClientFactory.create_test_module()
+    tm.app.router.append(homepage)
+    tm.app.config.EXCEPTION_HANDLERS += [NewExceptionHandler()]
+    tm.app.rebuild_middleware_stack()
+
+    client = tm.get_client()
+    res = client.get("/")
+    assert res.status_code == 400
+    assert res.json() == {"detail": "New Exception"}
+
+
+def test_exception_override_works():
+    @get()
+    def homepage():
+        raise APIException("New APIException")
+
+    tm = TestClientFactory.create_test_module()
+    tm.app.router.append(homepage)
+    tm.app.config.EXCEPTION_HANDLERS += [OverrideAPIExceptionHandler()]
+    tm.app.rebuild_middleware_stack()
+
+    client = tm.get_client()
+    res = client.get("/")
+    assert res.status_code == 404
+    assert res.json() == {"detail": "New APIException"}
+
+
+@pytest.mark.parametrize(
+    "exception_handler",
+    [
+        CallableExceptionHandler(
+            exc_class_or_status_code=500, callable_exception_handler=error_500
+        ),
+        ServerErrorHandler(),
+    ],
+)
+def test_500_error_as_a_function(exception_handler):
+    @get()
+    def homepage():
+        raise RuntimeError("Server Error")
+
+    tm = TestClientFactory.create_test_module()
+    tm.app.router.append(homepage)
+    tm.app.config.EXCEPTION_HANDLERS += [exception_handler]
+    tm.app.rebuild_middleware_stack()
+
+    client = tm.get_client(raise_server_exceptions=False)
+    res = client.get("/")
+    assert res.status_code == 500
+    assert res.json() == {"detail": "Server Error"}
+
+
+def test_raise_default_http_exception():
+    @get()
+    def homepage():
+        raise HTTPException(detail="Bad Request", status_code=400)
+
+    tm = TestClientFactory.create_test_module()
+    tm.app.router.append(homepage)
+    client = tm.get_client()
+    res = client.get("/")
+    assert res.status_code == 400
+    assert res.text == "Bad Request"
+
+
+@pytest.mark.parametrize("status_code", [204, 304])
+def test_raise_default_http_exception_for_204_and_304(status_code):
+    @get()
+    def homepage():
+        raise HTTPException(detail="Server Error", status_code=status_code)
+
+    tm = TestClientFactory.create_test_module()
+    tm.app.router.append(homepage)
+
+    client = tm.get_client()
+    res = client.get("/")
+    assert res.status_code == status_code
+    assert res.text == ""
+
+
+def test_debug_after_response_sent(test_client_factory):
+    async def app(scope, receive, send):
+        response = Response(b"", status_code=204)
+        await response(scope, receive, send)
+        raise RuntimeError("Something went wrong")
+
+    app = ExceptionMiddleware(
+        app,
+        debug=True,
+        exception_middleware_service=ExceptionMiddlewareService(config=Config()),
+    )
+    client = test_client_factory(app)
+    with pytest.raises(RuntimeError):
+        client.get("/")

tests/test_exceptions/test_error_details.py

@@ -1,4 +1,4 @@
-from ellar.exceptions.base import ErrorDetail
+from ellar.core.exceptions.base import ErrorDetail
 
 
 class TestErrorDetail:

tests/test_exceptions/test_validation_exception.py

@@ -3,7 +3,7 @@
 
 from ellar.common import Ws, get, ws_route
 from ellar.core import TestClientFactory
-from ellar.exceptions.validation import (
+from ellar.core.exceptions.validation import (
     RequestValidationError,
     WebSocketRequestValidationError,
 )

tests/test_guard.py

@@ -3,6 +3,7 @@
 
 from ellar.common import Req, get, guards
 from ellar.core import AppFactory, TestClient
+from ellar.core.exceptions import APIException
 from ellar.core.guard import (
     APIKeyCookie,
     APIKeyHeader,
@@ -11,7 +12,6 @@
     HttpBearerAuth,
     HttpDigestAuth,
 )
-from ellar.exceptions import APIException
 from ellar.openapi import OpenAPIDocumentBuilder
 from ellar.serializer import serialize_object