Merge pull request #16 from eadwinCode/app_factory_test

AppFactory and TestClientFactory Test

Author: eadwinCode

ellar/core/factory.py

@@ -13,7 +13,7 @@
 from ellar.core import Config
 from ellar.core.main import App
 from ellar.core.modules import ModuleBase
-from ellar.core.modules.ref import ModuleTemplateRef, create_module_ref_factor
+from ellar.core.modules.ref import create_module_ref_factor
 from ellar.di import EllarInjector, ProviderConfig
 from ellar.reflect import reflect
 
@@ -25,7 +25,7 @@
 class AppFactory:
     @classmethod
     def _read_all_module(
-        cls, module: t.Type[ModuleBase]
+        cls, module: t.Type[t.Union[ModuleBase, t.Any]]
     ) -> t.Dict[t.Type, t.Type[ModuleBase]]:
         modules = reflect.get_metadata(MODULE_METADATA.MODULES, module) or []
         module_dependency = OrderedDict()
@@ -36,11 +36,14 @@ def _read_all_module(
 
     @classmethod
     def _build_modules(
-        cls, app_module: t.Type[ModuleBase], config: Config, injector: EllarInjector
+        cls,
+        app_module: t.Type[t.Union[ModuleBase, t.Any]],
+        config: Config,
+        injector: EllarInjector,
     ) -> None:
         assert reflect.get_metadata(
             MODULE_WATERMARK, app_module
-        ), "Only ApplicationModule is allowed"
+        ), "Only Module is allowed"
 
         module_dependency = [app_module] + list(
             cls._read_all_module(app_module).values()
@@ -56,19 +59,10 @@ def _build_modules(
             )
             injector.add_module(module_ref)
 
-    @classmethod
-    def _run_module_application_ready(
-        cls,
-        modules: t.Dict[t.Type[ModuleBase], ModuleTemplateRef],
-        app: App,
-    ) -> None:
-        for _, module_ref in modules.items():
-            module_ref.run_application_ready(app)
-
     @classmethod
     def _create_app(
         cls,
-        module: t.Type[ModuleBase],
+        module: t.Type[t.Union[ModuleBase, t.Any]],
         global_guards: t.List[
             t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
         ] = None,
@@ -95,9 +89,6 @@ def _create_app(
             global_guards=global_guards,
         )
 
-        cls._run_module_application_ready(
-            modules=injector.get_templating_modules(), app=app
-        )
         return app
 
     @classmethod
@@ -108,7 +99,7 @@ def create_app(
             t.Union["ModuleRouter", "ModuleMount", Mount, Host]
         ] = tuple(),
         providers: t.Sequence[t.Union[t.Type, "ProviderConfig"]] = tuple(),
-        modules: t.Sequence[t.Type] = (),
+        modules: t.Sequence[t.Type[t.Union[ModuleBase, t.Any]]] = (),
         template_folder: t.Optional[str] = None,
         base_directory: t.Optional[str] = None,
         static_folder: str = "static",
@@ -131,7 +122,7 @@ def create_app(
         app_factory_module = type(f"Module{uuid4().hex[:6]}", (ModuleBase,), {})
         module(app_factory_module)
         return cls._create_app(
-            t.cast(t.Type[ModuleBase], app_factory_module),
+            module=app_factory_module,
             config_module=config_module,
             global_guards=global_guards,
         )

ellar/core/main.py

@@ -219,6 +219,12 @@ def enable_versioning(
             **init_kwargs,
         )
 
+    def _run_module_application_ready(
+        self,
+    ) -> None:
+        for _, module_ref in self.injector.get_templating_modules().items():
+            module_ref.run_application_ready(self)
+
     def _finalize_app_initialization(self) -> None:
         self.injector.container.register_instance(self)
         self.injector.container.register_instance(Reflector())
@@ -228,6 +234,7 @@ def _finalize_app_initialization(self) -> None:
             IExecutionContext,
             ModuleProvider(ExecutionContext, scope={}, receive=None, send=None),
         )
+        self._run_module_application_ready()
 
     def add_exception_handler(
         self,

ellar/core/testclient.py

@@ -2,13 +2,11 @@
 
 from starlette.testclient import TestClient as TestClient
 
-from ellar.constants import MODULE_METADATA, MODULE_WATERMARK
 from ellar.core import ModuleBase
 from ellar.core.factory import AppFactory
 from ellar.core.main import App
 from ellar.core.routing import ModuleRouter
 from ellar.di import ProviderConfig
-from ellar.reflect import reflect
 
 
 class _TestingModule:
@@ -39,7 +37,7 @@ def create_test_module(
         cls,
         controllers: t.Sequence[t.Union[t.Any]] = tuple(),
         routers: t.Sequence[ModuleRouter] = tuple(),
-        services: t.Sequence[ProviderConfig] = tuple(),
+        providers: t.Sequence[ProviderConfig] = tuple(),
         template_folder: t.Optional[str] = None,
         base_directory: t.Optional[str] = None,
         static_folder: str = "static",
@@ -48,7 +46,7 @@ def create_test_module(
         app = AppFactory.create_app(
             controllers=controllers,
             routers=routers,
-            providers=services,
+            providers=providers,
             template_folder=template_folder,
             base_directory=base_directory,
             static_folder=static_folder,
@@ -60,22 +58,10 @@ def create_test_module(
     def create_test_module_from_module(
         cls,
         module: t.Union[t.Type, t.Type[ModuleBase]],
-        mock_services: t.Sequence[ProviderConfig] = tuple(),
+        mock_providers: t.Sequence[ProviderConfig] = tuple(),
         config_module: str = None,
     ) -> _TestingModule:
-        app_module_watermark = reflect.get_metadata(MODULE_WATERMARK, module)
-        if mock_services:
-            reflect.define_metadata(
-                MODULE_METADATA.PROVIDERS, list(mock_services), module, default_value=[]
-            )
-
-        if app_module_watermark:
-            return _TestingModule(
-                app=AppFactory.create_from_app_module(
-                    module, config_module=config_module
-                )
-            )
         app = AppFactory.create_app(
-            modules=(module,), providers=mock_services, config_module=config_module
+            modules=(module,), providers=mock_providers, config_module=config_module
         )
         return _TestingModule(app=app)

tests/notstarted/test_application.py

@@ -0,0 +1,109 @@
+import os
+
+from starlette.exceptions import HTTPException
+from starlette.responses import JSONResponse, PlainTextResponse
+from starlette.routing import Host, Mount, Route, Router
+
+from ellar.common import Controller, Module, ModuleRouter, exception_handler, get
+from ellar.core.guard import APIKeyQuery
+
+
+def create_tmp_template_and_static_dir(tmpdir):
+    template_folder = os.path.join(tmpdir, "templates")
+    os.mkdir(template_folder)
+    static_folder = os.path.join(tmpdir, "statics")
+    os.mkdir(static_folder)
+
+    path = os.path.join(static_folder, "example.txt")
+    with open(path, "w") as file:
+        file.write("<file content>")
+
+    path = os.path.join(template_folder, "example.html")
+    with open(path, "w") as file:
+        file.write("<html>Hello World<html/>")
+    return template_folder, static_folder
+
+
+class AppAPIKey(APIKeyQuery):
+    async def authenticate(self, connection, key):
+        return key
+
+
+def custom_sub_domain(request):
+    return PlainTextResponse("Subdomain: " + request.path_params["subdomain"])
+
+
+def all_users_page(request):
+    return PlainTextResponse("Hello, everyone!")
+
+
+def user_page(request):
+    username = request.path_params["username"]
+    return PlainTextResponse(f"Hello, {username}!")
+
+
+sub_domain = Router(
+    routes=[
+        Route("/", custom_sub_domain),
+    ]
+)
+
+users = Router(
+    routes=[
+        Route("/", endpoint=all_users_page),
+        Route("/{username}", endpoint=user_page),
+    ]
+)
+
+router = ModuleRouter()
+
+
+@router.get("/func")
+@router.head("/func")
+def func_homepage(request):
+    return PlainTextResponse("Hello, world!")
+
+
+@router.get("/async")
+async def async_homepage(request):
+    return PlainTextResponse("Hello, world!")
+
+
+@router.ws_route("/ws")
+async def websocket_endpoint(session):
+    await session.accept()
+    await session.send_text("Hello, world!")
+    await session.close()
+
+
+@Controller
+class ClassBaseController:
+    @get("/class")
+    def class_function(self):
+        return PlainTextResponse("Hello, world!")
+
+    @get("/500")
+    def runtime_error(self, request):
+        raise RuntimeError()
+
+
+@Module(
+    routers=[
+        Host("{subdomain}.example.org", app=sub_domain),
+        Mount("/users", app=users),
+        router,
+    ],
+    controllers=[ClassBaseController],
+)
+class ApplicationModule:
+    @exception_handler(405)
+    async def method_not_allow_exception(self, request, exec):
+        return JSONResponse({"detail": "Custom message"}, status_code=405)
+
+    @exception_handler(500)
+    async def error_500(self, request, exec):
+        return JSONResponse({"detail": "Server Error"}, status_code=500)
+
+    @exception_handler(HTTPException)
+    async def http_exception(self, request, exc):
+        return JSONResponse({"detail": exc.detail}, status_code=exc.status_code)

tests/notstarted/test_application_factory.py

@@ -0,0 +1,103 @@
+from starlette.routing import Host, Mount
+
+from ellar.common import Module
+from ellar.core import AppFactory, Config, ModuleBase, TestClient
+from ellar.di import EllarInjector
+
+from .sample import (
+    AppAPIKey,
+    ApplicationModule,
+    ClassBaseController,
+    create_tmp_template_and_static_dir,
+    router,
+    sub_domain,
+    users,
+)
+
+
+@Module(modules=[ApplicationModule])
+class AModule:
+    pass
+
+
+@Module(modules=(AModule,))
+class BModule:
+    pass
+
+
+def test_factory__read_all_module():
+    modules_dict = AppFactory._read_all_module(module=BModule)
+    assert len(modules_dict) == 2
+    assert list(modules_dict.values())[0] is AModule
+    assert list(modules_dict.values())[1] is ApplicationModule
+
+    modules_dict = AppFactory._read_all_module(module=AModule)
+    assert len(modules_dict) == 1
+    assert list(modules_dict.values())[0] is ApplicationModule
+
+    modules_dict = AppFactory._read_all_module(module=ApplicationModule)
+    assert len(modules_dict) == 0
+
+
+def test_factory__build_modules():
+    config = Config()
+    injector = EllarInjector()
+    assert len(injector.get_modules()) == 0
+
+    AppFactory._build_modules(app_module=BModule, config=config, injector=injector)
+    module_refs = injector.get_modules()
+    assert len(module_refs) == 3
+
+    modules = [AModule, ApplicationModule, BModule]
+    for k, v in module_refs.items():
+        assert k in modules
+
+
+def test_factory_create_from_app_module():
+    app = AppFactory.create_from_app_module(
+        module=BModule,
+        global_guards=[AppAPIKey],
+        config_module="tests.test_application.settings",
+    )
+    assert app.get_guards() == [AppAPIKey]
+    assert app.config.config_module == "tests.test_application.settings"
+
+
+def test_factory_create_app_dynamically_creates_module():
+    app = AppFactory.create_app()
+    first_module_ref = next(app.get_module_loaders())
+    module_instance = first_module_ref.get_module_instance()
+    assert isinstance(module_instance, ModuleBase)
+    assert "ellar.core.factory.Module" in str(module_instance.__class__)
+
+
+def test_factory_create_app_works(tmpdir):
+    create_tmp_template_and_static_dir(tmpdir)
+
+    @Module()
+    class CModule:
+        pass
+
+    app = AppFactory.create_app(
+        modules=(CModule,),
+        global_guards=[AppAPIKey],
+        config_module="tests.test_application.settings",
+        controllers=(ClassBaseController,),
+        routers=[
+            Host("{subdomain}.example.org", app=sub_domain),
+            Mount("/users", app=users),
+            router,
+        ],
+        template_folder="templates",
+        static_folder="statics",
+        base_directory=tmpdir,
+    )
+
+    client = TestClient(app)
+    res = client.get("/static/example.txt")
+    assert res.status_code == 200
+    assert res.text == "<file content>"
+
+    template = app.jinja_environment.get_template("example.html")
+    result = template.render()
+    assert result == "<html>Hello World<html/>"