renamed ControllerRouterBuilder to RouterBuilder and fixed circular import issues

eadwinCode · eadwinCode · commit c85f0c9ac50d · 2023-04-20T16:02:13.000+01:00
diff --git a/ellar/core/controller/__init__.py b/ellar/core/controller/__init__.py
@@ -1,4 +1,3 @@
-from .factory import ControllerRouterFactory
 from .model import ControllerBase, ControllerType
 
-__all__ = ["ControllerBase", "ControllerType", "ControllerRouterFactory"]
+__all__ = ["ControllerBase", "ControllerType"]
diff --git a/ellar/core/modules/ref.py b/ellar/core/modules/ref.py
@@ -14,8 +14,8 @@
     TEMPLATE_FILTER_KEY,
     TEMPLATE_GLOBAL_KEY,
 )
-from ellar.core.controller.builder import get_controller_builder_factory
 from ellar.core.routing import ModuleMount
+from ellar.core.routing.builder import get_controller_builder_factory
 from ellar.core.templating import ModuleTemplating
 from ellar.di import Container, ProviderConfig, injectable, is_decorated_with_injectable
 from ellar.di.providers import ModuleProvider
diff --git a/ellar/core/routing/__init__.py b/ellar/core/routing/__init__.py
@@ -1,7 +1,10 @@
+from .app import ApplicationRouter
 from .base import RouteOperationBase
+from .factory import ControllerRouterFactory
+from .mount import ModuleMount, ModuleRouter
 from .operation_definitions import OperationDefinitions
 from .route import RouteOperation
-from .router import ApplicationRouter, ModuleMount, ModuleRouter, RouteCollection
+from .route_collections import RouteCollection
 from .websocket import WebsocketRouteOperation
 
 __all__ = [
@@ -13,4 +16,5 @@
     "RouteOperationBase",
     "OperationDefinitions",
     "WebsocketRouteOperation",
+    "ControllerRouterFactory",
 ]
diff --git a/ellar/core/routing/app.py b/ellar/core/routing/app.py
diff --git a/ellar/core/routing/builder.py b/ellar/core/routing/builder.py
@@ -5,22 +5,28 @@
 if t.TYPE_CHECKING:
     from ellar.core.routing import ModuleMount
 
-_controller_build_factory: t.Dict[t.Type, t.Type["ControllerRouterBuilder"]] = {}
+_router_builder_factory: t.Dict[t.Type, t.Type["RouterBuilder"]] = {}
 
 
 def _register_controller_builder(
-    controller_type: t.Type, factory: t.Type["ControllerRouterBuilder"]
+    controller_type: t.Type, factory: t.Type["RouterBuilder"]
 ) -> None:
-    _controller_build_factory[controller_type] = factory
+    _router_builder_factory[controller_type] = factory
 
 
 def get_controller_builder_factory(
     controller_type: t.Type,
-) -> t.Type["ControllerRouterBuilder"]:
-    return _controller_build_factory[controller_type]
+) -> t.Type["RouterBuilder"]:
+    res = _router_builder_factory.get(controller_type)
+    if not res:
+        raise Exception(
+            f"Router Factory Builder was not found.\nUse `ControllerRouterBuilderFactory` "
+            f"as an example create a FactoryBuilder for this type: {controller_type}"
+        )
+    return res
 
 
-class ControllerRouterBuilder:
+class RouterBuilder:
     @classmethod
     def build(
         cls, controller_type: t.Union[t.Type, t.Any]
diff --git a/ellar/core/routing/controller/route.py b/ellar/core/routing/controller/route.py
@@ -10,9 +10,7 @@
 from .base import ControllerRouteOperationBase
 
 
-class ControllerRouteOperation(  # type:ignore[misc]
-    ControllerRouteOperationBase, RouteOperation
-):
+class ControllerRouteOperation(ControllerRouteOperationBase, RouteOperation):
     methods: t.Set[str]
 
     async def _handle_request(self, context: IExecutionContext) -> t.Any:
diff --git a/ellar/core/routing/factory.py b/ellar/core/routing/factory.py
@@ -7,16 +7,15 @@
     CONTROLLER_OPERATION_HANDLER_KEY,
     CONTROLLER_WATERMARK,
 )
-from ellar.core.routing import ModuleMount, RouteCollection
+from ellar.core.controller.model import ControllerBase, ControllerType
 from ellar.reflect import reflect
 
-from .builder import ControllerRouterBuilder
-from .model import ControllerBase, ControllerType
+from .builder import RouterBuilder
+from .mount import ModuleMount
+from .route_collections import RouteCollection
 
 
-class ControllerRouterFactory(
-    ControllerRouterBuilder, controller_type=type(ControllerBase)
-):
+class ControllerRouterFactory(RouterBuilder, controller_type=type(ControllerBase)):
     @classmethod
     def build(
         cls, controller_type: t.Union[t.Type[ControllerBase], t.Any]
diff --git a/ellar/core/routing/mount.py b/ellar/core/routing/mount.py
@@ -17,13 +17,9 @@
 from ellar.helper import get_unique_control_type
 from ellar.reflect import reflect
 
-from ..operation_definitions import (
-    OperationDefinitions,
-    TOperation,
-    TWebsocketOperation,
-)
-from ..schema import RouteParameters, WsRouteParameters
+from .operation_definitions import OperationDefinitions, TOperation, TWebsocketOperation
 from .route_collections import RouteCollection
+from .schema import RouteParameters, WsRouteParameters
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.guard import GuardCanActivate
diff --git a/ellar/core/routing/route_collections.py b/ellar/core/routing/route_collections.py
@@ -5,15 +5,17 @@
 from starlette.routing import BaseRoute, Host, Mount
 
 from ellar.constants import CONTROLLER_CLASS_KEY
-from ellar.core.routing import RouteOperation, RouteOperationBase
-from ellar.core.routing.websocket.route import WebsocketRouteOperation
 from ellar.helper import (
     generate_controller_operation_unique_id,
     get_unique_control_type,
 )
 from ellar.logger import logger
 from ellar.reflect import reflect
 
+from .base import RouteOperationBase
+from .route import RouteOperation
+from .websocket.route import WebsocketRouteOperation
+
 
 class RouteCollection(t.Sequence[BaseRoute]):
     __slots__ = ("_routes", "_served_routes")
diff --git a/ellar/core/routing/router/__init__.py b/ellar/core/routing/router/__init__.py
diff --git a/ellar/socket_io/factory.py b/ellar/socket_io/factory.py
@@ -3,7 +3,7 @@
 import socketio
 from starlette.routing import Mount
 
-from ellar.core.controller.builder import ControllerRouterBuilder
+from ellar.core.routing.builder import RouterBuilder
 from ellar.reflect import reflect
 from ellar.socket_io.adapter import SocketIOASGIApp
 from ellar.socket_io.constants import (
@@ -19,7 +19,7 @@
 from ellar.socket_io.model import GatewayBase, GatewayType
 
 
-class GatewayRouterFactory(ControllerRouterBuilder, controller_type=type(GatewayBase)):
+class GatewayRouterFactory(RouterBuilder, controller_type=type(GatewayBase)):
     @classmethod
     def build(cls, controller_type: t.Union[t.Type[GatewayBase], t.Any]) -> "Mount":
         name = reflect.get_metadata_or_raise_exception(
diff --git a/ellar/socket_io/responses.py b/ellar/socket_io/responses.py
@@ -1,10 +1,20 @@
 import typing as t
 
-from ellar.core.serializer import Serializer
 
+class WsResponse:
+    __slots__ = ("_event", "_data", "_to", "_room")
 
-class WsResponse(Serializer):
-    event: str
-    data: t.Any
-    to: t.Optional[str] = None
-    room: t.Optional[str] = None
+    def __init__(
+        self,
+        event: str,
+        data: t.Any,
+        to: t.Optional[str] = None,
+        room: t.Optional[str] = None,
+    ):
+        self._event = event
+        self._data = data
+        self._to = to
+        self._room = room
+
+    def dict(self) -> t.Dict:
+        return dict(event=self._event, data=self._data, to=self._to, room=self._room)
diff --git a/tests/test_controller/test_controller_decorator.py b/tests/test_controller/test_controller_decorator.py
@@ -3,7 +3,7 @@
 from ellar.common import Controller, get, http_route, ws_route
 from ellar.constants import CONTROLLER_CLASS_KEY, CONTROLLER_OPERATION_HANDLER_KEY
 from ellar.core import ControllerBase
-from ellar.core.routing.router.module import controller_router_factory
+from ellar.core.routing import ControllerRouterFactory
 from ellar.di import has_binding, is_decorated_with_injectable
 from ellar.reflect import reflect
 
@@ -58,7 +58,7 @@ def test_controller_computed_properties():
     assert isinstance(SampleController, type) and issubclass(
         SampleController, ControllerBase
     )
-    router = controller_router_factory(SampleController)
+    router = ControllerRouterFactory.build(SampleController)
 
     assert is_decorated_with_injectable(SampleController)
     assert not has_binding(SampleController)
@@ -81,7 +81,7 @@ class SomeControllerB(ControllerBase):
         def __init__(self, a: str):
             self.a = a
 
-    router = controller_router_factory(SomeControllerB)
+    router = ControllerRouterFactory.build(SomeControllerB)
     assert router.get_meta() == {
         "tag": "Item",
         "description": "Some Controller",
@@ -96,22 +96,22 @@ def test_tag_configuration_controller_decorator():
     new_controller = Controller(
         prefix="/items/{orgID:int}", name="override_name", tag="new_tag"
     )(type("SomeControllerX", (ControllerBase,), {}))
-    router = controller_router_factory(new_controller)
+    router = ControllerRouterFactory.build(new_controller)
     assert router.get_meta()["tag"] == "new_tag"
     assert router.name == "override_name"
 
     # defaults to controller name
     new_controller = Controller(
         prefix="/items/{orgID:int}",
     )(type("SomeControllerY", (ControllerBase,), {}))
-    router = controller_router_factory(new_controller)
+    router = ControllerRouterFactory.build(new_controller)
     assert router.get_meta()["tag"] == "somey"
     assert router.name == "somey"
 
     new_controller = Controller(prefix="/items/{orgID:int}", tag="new_tag")(
         type("SomeControllerZ", (ControllerBase,), {})
     )
-    router = controller_router_factory(new_controller)
+    router = ControllerRouterFactory.build(new_controller)
     assert router.get_meta()["tag"] == "new_tag"
     assert router.name == "somez"
 
@@ -129,7 +129,7 @@ def test_tag_configuration_controller_decorator():
     ],
 )
 def test_controller_url_reverse(controller_type, tag, prefix, name):
-    router = controller_router_factory(controller_type)
+    router = ControllerRouterFactory.build(controller_type)
     for route in router.routes:
         reversed_path = router.url_path_for(f"{name}:{route.name}")
         assert reversed_path == router.path_format.replace("/{path}", route.path)
diff --git a/tests/test_controller/test_controller_inheritance.py b/tests/test_controller/test_controller_inheritance.py
@@ -3,7 +3,7 @@
 from ellar.common import Controller, get, ws_route
 from ellar.constants import CONTROLLER_CLASS_KEY
 from ellar.core import AppFactory
-from ellar.core.routing.router.module import controller_router_factory
+from ellar.core.routing import ControllerRouterFactory
 from ellar.reflect import reflect
 
 
@@ -49,7 +49,7 @@ def endpoint_once(self):
     )
 
     with pytest.raises(Exception, match=r"Operation must have a single control type."):
-        controller_router_factory(AnotherSampleController)
+        ControllerRouterFactory.build(AnotherSampleController)
 
 
 def test_controller_raise_exception_for_controller_operation_without_controller_class(
diff --git a/tests/test_controller/test_route_collection.py b/tests/test_controller/test_route_collection.py
@@ -6,8 +6,7 @@
 
 from ellar.common import Version as version_decorator, get, http_route, ws_route
 from ellar.constants import CONTROLLER_CLASS_KEY, CONTROLLER_OPERATION_HANDLER_KEY
-from ellar.core.routing import RouteOperation, WebsocketRouteOperation
-from ellar.core.routing.router import RouteCollection
+from ellar.core.routing import RouteCollection, RouteOperation, WebsocketRouteOperation
 from ellar.core.versioning import UrlPathAPIVersioning
 from ellar.helper import generate_controller_operation_unique_id
 from ellar.reflect import reflect
diff --git a/tests/test_modules/test_module_ref.py b/tests/test_modules/test_module_ref.py
@@ -205,10 +205,14 @@ def test_module_template_ref_get_all_routers_fails_for_invalid_controller():
         config = Config()
         container = EllarInjector(auto_bind=False).container
 
-        with pytest.raises(AssertionError, match="Invalid Controller Type."):
+        with pytest.raises(Exception) as ex:
             create_module_ref_factor(
                 ModuleBaseExample, config=config, container=container
             )
+        assert (
+            str(ex.value)
+            == "Router Factory Builder was not found.\nUse `ControllerRouterBuilderFactory` as an example create a FactoryBuilder for this type: <class 'type'>"
+        )
 
 
 def test_invalid_module_template_ref():
