Merge pull request #10 from eadwinCode/common_test

Common Package Testing

Author: eadwinCode

README.md

@@ -106,7 +106,6 @@ You will see the automatic interactive API documentation (provided by <a href="h
 ## Status
 Project is still in development
 - Remaining testing modules:
-    - common
     - configuration
     - guard
     - openapi

ellar/common/decorators/controller.py

@@ -6,10 +6,10 @@
 from ellar.constants import (
     CONTROLLER_CLASS_KEY,
     CONTROLLER_METADATA,
+    CONTROLLER_OPERATION_HANDLER_KEY,
     CONTROLLER_WATERMARK,
     NOT_SET,
     OPERATION_ENDPOINT_KEY,
-    OPERATION_HANDLER_KEY,
 )
 from ellar.core import ControllerBase
 from ellar.core.controller import ControllerType
@@ -33,10 +33,10 @@ def reflect_all_controller_type_routes(cls: t.Type[ControllerBase]) -> None:
     for base_cls in reversed(bases):
         if base_cls not in [ABC, ControllerBase, object]:
             for item in get_route_functions(base_cls):
-                operation = reflect.get_metadata(OPERATION_HANDLER_KEY, item)
+                operation = reflect.get_metadata(CONTROLLER_OPERATION_HANDLER_KEY, item)
                 reflect.define_metadata(CONTROLLER_CLASS_KEY, cls, item)
                 reflect.define_metadata(
-                    OPERATION_HANDLER_KEY,
+                    CONTROLLER_OPERATION_HANDLER_KEY,
                     operation,
                     cls,
                     default_value=[],

ellar/common/decorators/html.py

@@ -1,6 +1,5 @@
 import asyncio
 import inspect
-import re
 import typing as t
 import warnings
 
@@ -14,7 +13,7 @@
 from ellar.core.routing import RouteOperationBase
 from ellar.core.templating import TemplateFunctionData
 from ellar.exceptions import ImproperConfiguration
-from ellar.helper import get_name
+from ellar.helper import class_base_function_regex, get_name
 from ellar.types import TemplateFilterCallable, TemplateGlobalCallable
 
 from .base import set_meta
@@ -30,9 +29,6 @@ def render(template_name: t.Optional[str] = NOT_SET) -> t.Callable:
             template_name, str
         ), "Render Operation must invoked eg. @render()"
     template_name = None if template_name is NOT_SET else template_name
-    class_base_function_regex = re.compile(
-        "<\\w+ (\\w+)\\.(\\w+) at \\w+>", re.IGNORECASE
-    )
 
     def _decorator(func: t.Union[t.Callable, t.Any]) -> t.Union[t.Callable, t.Any]:
         if not callable(func) or isinstance(func, RouteOperationBase):

ellar/common/decorators/modules.py

@@ -22,28 +22,30 @@ def _wrapper(
     name: str,
     kwargs: AttributeDict,
 ) -> t.Type:
-    if not reflect.get_metadata(watermark_key, target):
-        if not isinstance(target, type):
-            raise ImproperConfiguration(f"{name} is a class decorator - {target}")
+    if reflect.get_metadata(watermark_key, target):
+        raise ImproperConfiguration(f"{target} is already identified as a Module")
 
-        if not kwargs.base_directory:
-            kwargs.update(base_directory=Path(inspect.getfile(target)).resolve().parent)
+    if not isinstance(target, type):
+        raise ImproperConfiguration(f"{name} is a class decorator - {target}")
 
-        if type(target) != ModuleBaseMeta:
-            attr: t.Dict = {
-                item: getattr(target, item) for item in dir(target) if "__" not in item
-            }
-            target = type(
-                target.__name__,
-                (target, ModuleBase),
-                attr,
-            )
+    if not kwargs.base_directory:
+        kwargs.update(base_directory=Path(inspect.getfile(target)).resolve().parent)
 
-        reflect.define_metadata(watermark_key, True, target)
-        for key in metadata_keys:
-            reflect.define_metadata(key, kwargs[key], target)
-        injectable(SingletonScope)(target)
-    return target
+    if type(target) != ModuleBaseMeta:
+        attr: t.Dict = {
+            item: getattr(target, item) for item in dir(target) if "__" not in item
+        }
+        target = type(
+            target.__name__,
+            (target, ModuleBase),
+            attr,
+        )
+
+    reflect.define_metadata(watermark_key, True, target)
+    for key in metadata_keys:
+        reflect.define_metadata(key, kwargs[key], target)
+    injectable(SingletonScope)(target)
+    return t.cast(t.Type, target)
 
 
 def Module(

ellar/constants.py

@@ -69,7 +69,7 @@ def __new__(mcls, name, bases, namespace):
 ROUTE_OPENAPI_PARAMETERS = "ROUTE_OPENAPI_PARAMETERS"
 
 OPERATION_ENDPOINT_KEY = "OPERATION_ENDPOINT"
-OPERATION_HANDLER_KEY = "OPERATION_HANDLER"
+CONTROLLER_OPERATION_HANDLER_KEY = "CONTROLLER_OPERATION_HANDLER"
 CONTROLLER_CLASS_KEY = "CONTROLLER_CLASS_KEY"
 REFLECT_TYPE = "__REFLECT_TYPE__"
 GROUP_METADATA = "GROUP_METADATA"
@@ -121,12 +121,15 @@ class CONTROLLER_METADATA(metaclass=_AnnotationToValue):
 REF_PREFIX = "#/components/schemas/"
 
 
-class _NOT_SET:
+class NOT_SET_TYPE:
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"{__name__}.{self.__class__.__name__}"
+
     def __copy__(self) -> Any:  # pragma: no cover
         return NOT_SET
 
     def __deepcopy__(self, memodict: Dict = {}) -> Any:  # pragma: no cover
         return NOT_SET
 
 
-NOT_SET: Any = _NOT_SET()
+NOT_SET: Any = NOT_SET_TYPE()

ellar/core/routing/operation_definitions.py

@@ -1,4 +1,3 @@
-import re
 import typing as t
 from functools import partial
 
@@ -14,6 +13,7 @@
     TRACE,
 )
 from ellar.core.schema import RouteParameters, WsRouteParameters
+from ellar.helper import class_base_function_regex
 from ellar.types import TCallable
 
 from .base import RouteOperationBase
@@ -30,28 +30,25 @@
 
 
 class OperationDefinitions:
-    __slots__ = ("_routes", "class_base_function_regex")
+    __slots__ = ("_routes",)
 
     def __init__(
         self,
         app_routes: t.List[RouteOperationBase] = None,
     ):
         self._routes = app_routes
-        self.class_base_function_regex = re.compile(
-            "<\\w+ (\\w+)\\.(\\w+) at \\w+>", re.IGNORECASE
-        )
 
     @property
     def routes(self) -> t.List[RouteOperationBase]:
         return self._routes or []
 
     def _get_http_operations_class(self, func: t.Callable) -> t.Type[TOperation]:
-        if self.class_base_function_regex.match(repr(func)):
+        if class_base_function_regex.match(repr(func)):
             return ControllerRouteOperation
         return RouteOperation
 
     def _get_ws_operations_class(self, func: t.Callable) -> t.Type[TWebsocketOperation]:
-        if self.class_base_function_regex.match(repr(func)):
+        if class_base_function_regex.match(repr(func)):
             return ControllerWebsocketRouteOperation
         return WebsocketRouteOperation
 

ellar/core/routing/route.py

@@ -8,9 +8,9 @@
 )
 
 from ellar.constants import (
+    CONTROLLER_OPERATION_HANDLER_KEY,
     EXTRA_ROUTE_ARGS_KEY,
     NOT_SET,
-    OPERATION_HANDLER_KEY,
     RESPONSE_OVERRIDE_KEY,
 )
 from ellar.core.context import ExecutionContext
@@ -67,7 +67,7 @@ def __init__(
         self.endpoint_parameter_model: RequestEndpointArgsModel = NOT_SET
         self.response_model: RouteResponseModel = NOT_SET
 
-        reflect.define_metadata(OPERATION_HANDLER_KEY, self, self.endpoint)
+        reflect.define_metadata(CONTROLLER_OPERATION_HANDLER_KEY, self, self.endpoint)
         self._load_model()
 
     def build_route_operation(  # type:ignore

ellar/core/routing/router/app.py

@@ -4,7 +4,10 @@
 
 from starlette.routing import BaseRoute, Router as StarletteRouter
 
-from ellar.constants import OPERATION_HANDLER_KEY, SCOPE_API_VERSIONING_RESOLVER
+from ellar.constants import (
+    CONTROLLER_OPERATION_HANDLER_KEY,
+    SCOPE_API_VERSIONING_RESOLVER,
+)
 from ellar.reflect import reflect
 from ellar.types import ASGIApp, TReceive, TScope, TSend
 
@@ -56,7 +59,7 @@ def __init__(
     def append(self, item: t.Union[BaseRoute, t.Callable]) -> None:
         _item: t.Any = item
         if callable(_item) and type(_item) == FunctionType:
-            _item = reflect.get_metadata(OPERATION_HANDLER_KEY, _item)
+            _item = reflect.get_metadata(CONTROLLER_OPERATION_HANDLER_KEY, _item)
         self.routes.append(_item)
 
     def extend(self, routes: t.Sequence[t.Union[BaseRoute, t.Callable]]) -> None:

ellar/core/routing/router/module.py

@@ -6,10 +6,10 @@
 from ellar.compatible import AttributeDict
 from ellar.constants import (
     CONTROLLER_METADATA,
+    CONTROLLER_OPERATION_HANDLER_KEY,
     GUARDS_KEY,
     NOT_SET,
     OPENAPI_KEY,
-    OPERATION_HANDLER_KEY,
     VERSIONING_KEY,
 )
 from ellar.core.controller import ControllerBase
@@ -31,7 +31,7 @@ def controller_router_factory(
     controller: t.Union[t.Type[ControllerBase], t.Any]
 ) -> "ModuleMount":
     openapi = reflect.get_metadata(CONTROLLER_METADATA.OPENAPI, controller) or dict()
-    routes = reflect.get_metadata(OPERATION_HANDLER_KEY, controller) or []
+    routes = reflect.get_metadata(CONTROLLER_OPERATION_HANDLER_KEY, controller) or []
     app = Router()
     app.routes = ModuleRouteCollection(routes)  # type:ignore
     router = ModuleMount(

ellar/core/routing/websocket/route.py

@@ -3,7 +3,11 @@
 from starlette.routing import WebSocketRoute as StarletteWebSocketRoute, compile_path
 from starlette.status import WS_1008_POLICY_VIOLATION
 
-from ellar.constants import EXTRA_ROUTE_ARGS_KEY, NOT_SET, OPERATION_HANDLER_KEY
+from ellar.constants import (
+    CONTROLLER_OPERATION_HANDLER_KEY,
+    EXTRA_ROUTE_ARGS_KEY,
+    NOT_SET,
+)
 from ellar.core.connection import WebSocket
 from ellar.core.context import ExecutionContext
 from ellar.core.params import WebsocketEndpointArgsModel
@@ -76,7 +80,7 @@ def __init__(
         super().__init__(path=path, endpoint=endpoint, name=name)
         self.endpoint_parameter_model: WebsocketEndpointArgsModel = NOT_SET
 
-        reflect.define_metadata(OPERATION_HANDLER_KEY, self, self.endpoint)
+        reflect.define_metadata(CONTROLLER_OPERATION_HANDLER_KEY, self, self.endpoint)
 
         if self._use_extra_handler:
             self._handlers_kwargs.update(on_receive=self.endpoint)