Moved TestClientFactory from core to testing package and refactored testing module

Author: eadwinCode

ellar/common/decorators/request.py

@@ -1,7 +1,7 @@
 import typing as t
 
 from ellar.constants import ON_REQUEST_SHUTDOWN_KEY, ON_REQUEST_STARTUP_KEY
-from ellar.core.events import EventHandler
+from ellar.events import EventHandler
 
 
 def set_attr_key(handle: t.Callable, key: str, value: t.Any) -> None:

ellar/core/conf/mixins.py

@@ -5,10 +5,10 @@
 from starlette.types import ASGIApp
 
 from ellar.constants import LOG_LEVELS as log_levels
-from ellar.core.events import EventHandler
 from ellar.core.exceptions.interfaces import IExceptionHandler
 from ellar.core.middleware import Middleware
 from ellar.core.versioning import BaseAPIVersioning
+from ellar.events import EventHandler
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core import App

ellar/core/_services_util.py renamed to ellar/core/core_service_registration.py

@@ -1,7 +1,8 @@
+import typing as t
+
 from ellar.di import EllarInjector
 from ellar.services.reflector import Reflector
 
-from .conf import Config
 from .context import (
     ExecutionContextFactory,
     HostContextFactory,
@@ -14,13 +15,16 @@
 from .exceptions.interfaces import IExceptionMiddlewareService
 from .exceptions.service import ExceptionMiddlewareService
 
+if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.core.conf import Config
+
 
-class _CoreServiceRegistration:
+class CoreServiceRegistration:
     """Create Binding for all application service"""
 
     __slots__ = ("injector", "config")
 
-    def __init__(self, injector: EllarInjector, config: Config) -> None:
+    def __init__(self, injector: EllarInjector, config: "Config") -> None:
         self.injector = injector
         self.config = config
 
@@ -42,4 +46,4 @@ def register_all(self) -> None:
             IWebSocketContextFactory, WebSocketContextFactory
         )
 
-        self.injector.container.register_instance(Reflector())
+        self.injector.container.register(Reflector)

ellar/core/exceptions/__init__.py

@@ -1,9 +1,16 @@
-import typing as t
-
-from starlette import status
 from starlette.exceptions import HTTPException, WebSocketException
 
 from .base import APIException
+from .exceptions_types import (
+    AuthenticationFailed,
+    ImproperConfiguration,
+    MethodNotAllowed,
+    NotAcceptable,
+    NotAuthenticated,
+    NotFound,
+    PermissionDenied,
+    UnsupportedMediaType,
+)
 from .interfaces import IExceptionHandler, IExceptionMiddlewareService
 from .validation import RequestValidationError, WebSocketRequestValidationError
 
@@ -24,49 +31,3 @@
     "UnsupportedMediaType",
     "WebSocketException",
 ]
-
-
-class ImproperConfiguration(Exception):
-    pass
-
-
-class AuthenticationFailed(APIException):
-    status_code = status.HTTP_401_UNAUTHORIZED
-    code = "authentication_failed"
-
-    def __init__(
-        self, detail: t.Union[t.List, t.Dict, str] = None, **kwargs: t.Any
-    ) -> None:
-        if detail is None:
-            detail = "Incorrect authentication credentials."
-        super(AuthenticationFailed, self).__init__(detail=detail, **kwargs)
-
-
-class NotAuthenticated(APIException):
-    status_code = status.HTTP_401_UNAUTHORIZED
-    code = "not_authenticated"
-
-
-class PermissionDenied(APIException):
-    status_code = status.HTTP_403_FORBIDDEN
-    code = "permission_denied"
-
-
-class NotFound(APIException):
-    status_code = status.HTTP_404_NOT_FOUND
-    code = "not_found"
-
-
-class MethodNotAllowed(APIException):
-    status_code = status.HTTP_405_METHOD_NOT_ALLOWED
-    code = "method_not_allowed"
-
-
-class NotAcceptable(APIException):
-    status_code = status.HTTP_406_NOT_ACCEPTABLE
-    code = "not_acceptable"
-
-
-class UnsupportedMediaType(APIException):
-    status_code = status.HTTP_415_UNSUPPORTED_MEDIA_TYPE
-    code = "unsupported_media_type"

ellar/core/exceptions/callable_exceptions.py

@@ -3,9 +3,9 @@
 from starlette.concurrency import run_in_threadpool
 from starlette.responses import Response
 
+from ellar.core.context import IHostContext
 from ellar.helper import is_async_callable
 
-from ..context import IHostContext
 from .interfaces import IExceptionHandler
 
 

ellar/core/exceptions/exceptions_types.py

@@ -0,0 +1,51 @@
+import typing as t
+
+from starlette import status
+
+from .base import APIException
+
+
+class ImproperConfiguration(Exception):
+    pass
+
+
+class AuthenticationFailed(APIException):
+    status_code = status.HTTP_401_UNAUTHORIZED
+    code = "authentication_failed"
+
+    def __init__(
+        self, detail: t.Union[t.List, t.Dict, str] = None, **kwargs: t.Any
+    ) -> None:
+        if detail is None:
+            detail = "Incorrect authentication credentials."
+        super(AuthenticationFailed, self).__init__(detail=detail, **kwargs)
+
+
+class NotAuthenticated(APIException):
+    status_code = status.HTTP_401_UNAUTHORIZED
+    code = "not_authenticated"
+
+
+class PermissionDenied(APIException):
+    status_code = status.HTTP_403_FORBIDDEN
+    code = "permission_denied"
+
+
+class NotFound(APIException):
+    status_code = status.HTTP_404_NOT_FOUND
+    code = "not_found"
+
+
+class MethodNotAllowed(APIException):
+    status_code = status.HTTP_405_METHOD_NOT_ALLOWED
+    code = "method_not_allowed"
+
+
+class NotAcceptable(APIException):
+    status_code = status.HTTP_406_NOT_ACCEPTABLE
+    code = "not_acceptable"
+
+
+class UnsupportedMediaType(APIException):
+    status_code = status.HTTP_415_UNSUPPORTED_MEDIA_TYPE
+    code = "unsupported_media_type"

ellar/core/exceptions/handlers.py

@@ -8,10 +8,11 @@
 from starlette.responses import Response
 
 from ellar.core.context import IHostContext
-from ellar.core.exceptions import APIException, RequestValidationError
 from ellar.serializer import serialize_object
 
+from .base import APIException
 from .interfaces import IExceptionHandler
+from .validation import RequestValidationError
 
 
 class HTTPExceptionHandler(IExceptionHandler):

ellar/core/factory.py

@@ -6,13 +6,13 @@
 from starlette.routing import Host, Mount
 
 from ellar.constants import MODULE_METADATA, MODULE_WATERMARK
-from ellar.core import Config
 from ellar.core.main import App
 from ellar.core.modules import DynamicModule, ModuleBase, ModuleSetup
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
 
-from ._services_util import _CoreServiceRegistration
+from .conf import Config
+from .core_service_registration import CoreServiceRegistration
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.commands import EllarTyper
@@ -65,7 +65,7 @@ def read_all_module(cls, module_config: ModuleSetup) -> t.Dict[t.Type, ModuleSet
     def _build_modules(
         cls,
         app_module: t.Type[t.Union[ModuleBase, t.Any]],
-        config: Config,
+        config: "Config",
         injector: EllarInjector,
     ) -> None:
         """
@@ -133,7 +133,7 @@ def _get_config_kwargs() -> t.Dict:
         config = Config(app_configured=True, **_get_config_kwargs())
         injector = EllarInjector(auto_bind=config.INJECTOR_AUTO_BIND)
         injector.container.register_instance(config, concrete_type=Config)
-        _CoreServiceRegistration(injector, config).register_all()
+        CoreServiceRegistration(injector, config).register_all()
 
         cls._build_modules(app_module=module, injector=injector, config=config)
 

ellar/core/main.py

@@ -4,9 +4,7 @@
 from starlette.routing import BaseRoute, Mount
 
 from ellar.constants import LOG_LEVELS
-from ellar.core.conf import Config
 from ellar.core.datastructures import State, URLPath
-from ellar.core.events import EventHandler, RouterEventManager
 from ellar.core.exceptions.interfaces import (
     IExceptionHandler,
     IExceptionMiddlewareService,
@@ -31,14 +29,17 @@
 from ellar.core.templating import AppTemplating, Environment
 from ellar.core.versioning import BaseAPIVersioning, VersioningSchemes
 from ellar.di.injector import EllarInjector
+from ellar.events import EventHandler, RouterEventManager
 from ellar.logger import logger
 from ellar.types import ASGIApp, T, TReceive, TScope, TSend
 
+from .conf import Config
+
 
 class App(AppTemplating):
     def __init__(
         self,
-        config: Config,
+        config: "Config",
         injector: EllarInjector,
         on_startup_event_handlers: t.Optional[t.Sequence[EventHandler]] = None,
         on_shutdown_event_handlers: t.Optional[t.Sequence[EventHandler]] = None,
@@ -186,7 +187,7 @@ def has_static_files(self) -> bool:  # type: ignore
         )
 
     @property
-    def config(self) -> Config:  # type: ignore
+    def config(self) -> "Config":  # type: ignore
         return self._config
 
     def build_middleware_stack(self) -> ASGIApp:

ellar/core/middleware/exceptions.py

@@ -7,8 +7,8 @@
 from ellar.types import ASGIApp, TMessage, TReceive, TScope, TSend
 
 if t.TYPE_CHECKING:  # pragma: no cover
-    from ellar.core.exceptions.service import ExceptionMiddlewareService
     from ellar.di import EllarInjector
+    from ellar.exceptions.service import ExceptionMiddlewareService
 
 
 class ExceptionMiddleware: