Merge pull request #15 from eadwinCode/application_test_client_test

App Test

Author: eadwinCode

README.md

@@ -105,8 +105,6 @@ You will see the automatic interactive API documentation (provided by <a href="h
 
 ## Status
 Project is still in development
-- Remaining testing modules:
-    - configuration
 - Project CLI scaffolding
 - Documentation
 - Database Plugin with [Encode/ORM](https://github.com/encode/orm)

ellar/core/conf/app_settings_models.py

@@ -69,11 +69,12 @@ class Config:
     DEBUG: bool = False
     DEFAULT_JSON_CLASS: t.Type[JSONResponse] = JSONResponse
 
-    TEMPLATES_AUTO_RELOAD: t.Optional[bool] = None
+    JINJA_TEMPLATES_OPTIONS: t.Dict[str, t.Any] = {}
     VERSIONING_SCHEME: TVersioning = Field(DefaultAPIVersioning())
 
     REDIRECT_SLASHES: bool = False
     STATIC_FOLDER_PACKAGES: t.Optional[t.List[t.Union[str, t.Tuple[str]]]] = []
+    STATIC_DIRECTORIES: t.Optional[t.List[t.Union[str, t.Any]]] = []
 
     MIDDLEWARE: t.List[TMiddleware] = []
     APP_EXCEPTION_HANDLERS: t.Dict[t.Union[int, t.Type[Exception]], t.Callable] = {}

ellar/core/conf/default_settings.py

@@ -28,12 +28,13 @@
 # For more info, read: https://injector.readthedocs.io/en/latest/index.html
 INJECTOR_AUTO_BIND = False
 
-TEMPLATES_AUTO_RELOAD: t.Optional[bool] = None
+JINJA_TEMPLATES_OPTIONS: t.Dict[str, t.Any] = {}
 
 VERSIONING_SCHEME: BaseAPIVersioning = DefaultAPIVersioning()
 REDIRECT_SLASHES: bool = False
 
 STATIC_FOLDER_PACKAGES: t.Optional[t.List[t.Union[str, t.Tuple[str]]]] = []
+STATIC_DIRECTORIES: t.Optional[t.List[t.Union[str, t.Any]]] = []
 STATIC_MOUNT_PATH: str = "/static"
 
 MIDDLEWARE: t.Sequence[Middleware] = []

ellar/core/factory.py

@@ -18,6 +18,7 @@
 from ellar.reflect import reflect
 
 if t.TYPE_CHECKING:  # pragma: no cover
+    from ellar.core import GuardCanActivate
     from ellar.core.routing import ModuleMount, ModuleRouter
 
 
@@ -65,7 +66,14 @@ def _run_module_application_ready(
             module_ref.run_application_ready(app)
 
     @classmethod
-    def _create_app(cls, module: t.Type[ModuleBase], config_module: str = None) -> App:
+    def _create_app(
+        cls,
+        module: t.Type[ModuleBase],
+        global_guards: t.List[
+            t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
+        ] = None,
+        config_module: str = None,
+    ) -> App:
         assert reflect.get_metadata(MODULE_WATERMARK, module), "Only Module is allowed"
 
         config = Config(app_configured=True, config_module=config_module)
@@ -84,6 +92,7 @@ def _create_app(cls, module: t.Type[ModuleBase], config_module: str = None) -> A
                 t.Optional[t.Callable[[App], t.AsyncContextManager[t.Any]]],
                 config.DEFAULT_LIFESPAN_HANDLER,
             ),
+            global_guards=global_guards,
         )
 
         cls._run_module_application_ready(
@@ -103,6 +112,9 @@ def create_app(
         template_folder: t.Optional[str] = None,
         base_directory: t.Optional[str] = None,
         static_folder: str = "static",
+        global_guards: t.List[
+            t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
+        ] = None,
         config_module: str = None,
     ) -> App:
         from ellar.common import Module
@@ -119,11 +131,20 @@ 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), config_module
+            t.cast(t.Type[ModuleBase], app_factory_module),
+            config_module=config_module,
+            global_guards=global_guards,
         )
 
     @classmethod
     def create_from_app_module(
-        cls, module: t.Type[ModuleBase], config_module: str = None
+        cls,
+        module: t.Type[t.Union[ModuleBase, t.Any]],
+        global_guards: t.List[
+            t.Union[t.Type["GuardCanActivate"], "GuardCanActivate"]
+        ] = None,
+        config_module: str = None,
     ) -> App:
-        return cls._create_app(module, config_module)
+        return cls._create_app(
+            module, config_module=config_module, global_guards=global_guards
+        )

ellar/core/main.py

@@ -19,6 +19,7 @@
 from ellar.core.templating import AppTemplating, Environment
 from ellar.core.versioning import VERSIONING, BaseAPIVersioning
 from ellar.di.injector import EllarInjector
+from ellar.di.providers import ModuleProvider
 from ellar.logger import logger
 from ellar.services.reflector import Reflector
 from ellar.types import ASGIApp, T, TReceive, TScope, TSend
@@ -64,6 +65,8 @@ def __init__(
             else list(on_shutdown_event_handlers)
         )
 
+        self._static_app: t.Optional[ASGIApp] = None
+
         self.state = State()
         self.config.DEFAULT_LIFESPAN_HANDLER = (
             lifespan or self.config.DEFAULT_LIFESPAN_HANDLER
@@ -77,14 +80,11 @@ def __init__(
             lifespan=self.config.DEFAULT_LIFESPAN_HANDLER,  # type: ignore
         )
         self.middleware_stack = self.build_middleware_stack()
-
-        self._static_app: t.Optional[ASGIApp] = None
-
         self._finalize_app_initialization()
 
         logger.info(f"APP SETTINGS: {self._config.config_module}")
 
-    def statics_wrapper(self) -> t.Callable:
+    def _statics_wrapper(self) -> t.Callable:
         async def _statics_func_wrapper(
             scope: TScope, receive: TReceive, send: TSend
         ) -> t.Any:
@@ -100,7 +100,7 @@ def _get_module_routes(self) -> t.List[BaseRoute]:
             _routes.append(
                 Mount(
                     str(self.config.STATIC_MOUNT_PATH),
-                    app=self.statics_wrapper(),
+                    app=self._statics_wrapper(),
                     name="static",
                 )
             )
@@ -137,7 +137,9 @@ def install_module(
     def get_guards(self) -> t.List[t.Union[t.Type[GuardCanActivate], GuardCanActivate]]:
         return self._global_guards
 
-    def use_global_guards(self, *guards: "GuardCanActivate") -> None:
+    def use_global_guards(
+        self, *guards: t.Union["GuardCanActivate", t.Type["GuardCanActivate"]]
+    ) -> None:
         self._global_guards.extend(guards)
 
     @property
@@ -204,12 +206,6 @@ def routes(self) -> t.List[BaseRoute]:
     def url_path_for(self, name: str, **path_params: t.Any) -> URLPath:
         return self.router.url_path_for(name, **path_params)
 
-    def mount(self, path: str, app: ASGIApp, name: str = None) -> None:
-        self.router.mount(path, app=app, name=name)
-
-    def host(self, host: str, app: ASGIApp, name: str = None) -> None:
-        self.router.host(host, app=app, name=name)
-
     def enable_versioning(
         self,
         schema: VERSIONING,
@@ -228,7 +224,10 @@ def _finalize_app_initialization(self) -> None:
         self.injector.container.register_instance(Reflector())
         self.injector.container.register_instance(self.config, Config)
         self.injector.container.register_instance(self.jinja_environment, Environment)
-        self.injector.container.register_scoped(IExecutionContext, ExecutionContext)
+        self.injector.container.register_scoped(
+            IExecutionContext,
+            ModuleProvider(ExecutionContext, scope={}, receive=None, send=None),
+        )
 
     def add_exception_handler(
         self,

ellar/core/routing/router/route_collections.py

@@ -33,6 +33,7 @@ def _add_operation(
             if hasattr(operation, "get_allowed_version")
             else {}
         )
+        path = operation.host if isinstance(operation, Host) else operation.path  # type: ignore
 
         if isinstance(operation, (Mount, Host)):
             _methods = {
@@ -41,7 +42,7 @@ def _add_operation(
             }
 
         _hash = generate_controller_operation_unique_id(
-            path=operation.path,  # type: ignore
+            path=path,
             methods=list(_methods),
             versioning=_versioning or ["no_versioning"],
         )

ellar/core/templating/interface.py

@@ -135,6 +135,7 @@ class AppTemplating(JinjaTemplating):
     _static_app: t.Optional[ASGIApp]
     _injector: "EllarInjector"
     has_static_files: bool
+    build_middleware_stack: t.Callable
 
     def get_module_loaders(self) -> t.Generator[ModuleTemplating, None, None]:
         for loader in self._injector.get_templating_modules().values():
@@ -148,6 +149,7 @@ def debug(self) -> bool:
     def debug(self, value: bool) -> None:
         del self.__dict__["jinja_environment"]
         self.config.DEBUG = value
+        self.build_middleware_stack()
 
     @cached_property
     def jinja_environment(self) -> BaseEnvironment:
@@ -161,17 +163,15 @@ def select_jinja_auto_escape(filename: str) -> bool:
                 return True
             return filename.endswith((".html", ".htm", ".xml", ".xhtml"))
 
-        # TODO: get extensions from configuration
-        options: t.Dict = dict(extensions=[])
-
-        _auto_reload = self.config.TEMPLATES_AUTO_RELOAD
-        _auto_reload = _auto_reload if _auto_reload is not None else self.debug
-
-        if "autoescape" not in options:
-            options["autoescape"] = select_jinja_auto_escape
+        options_defaults: t.Dict = dict(
+            extensions=[], auto_reload=self.debug, autoescape=select_jinja_auto_escape
+        )
+        jinja_options: t.Dict = t.cast(
+            t.Dict, self.config.JINJA_TEMPLATES_OPTIONS or {}
+        )
 
-        if "auto_reload" not in options:
-            options["auto_reload"] = _auto_reload
+        for k, v in options_defaults.items():
+            jinja_options.setdefault(k, v)
 
         @pass_context
         def url_for(context: dict, name: str, **path_params: t.Any) -> str:
@@ -180,7 +180,7 @@ def url_for(context: dict, name: str, **path_params: t.Any) -> str:
 
         app: App = t.cast("App", self)
 
-        jinja_env = Environment(app, **options)
+        jinja_env = Environment(app, **jinja_options)
         jinja_env.globals.update(
             url_for=url_for,
             config=self.config,
@@ -208,7 +208,7 @@ def _update_jinja_env_filters(self, jinja_environment: Environment) -> None:
 
     @cached_property
     def static_files(self) -> t.List[str]:
-        static_directories = []
+        static_directories = t.cast(t.List, self.config.STATIC_DIRECTORIES or [])
         for module in self.get_module_loaders():
             if module.static_directory:
                 static_directories.append(module.static_directory)

ellar/core/testclient.py

@@ -43,6 +43,7 @@ def create_test_module(
         template_folder: t.Optional[str] = None,
         base_directory: t.Optional[str] = None,
         static_folder: str = "static",
+        config_module: str = None,
     ) -> _TestingModule:
         app = AppFactory.create_app(
             controllers=controllers,
@@ -51,6 +52,7 @@ def create_test_module(
             template_folder=template_folder,
             base_directory=base_directory,
             static_folder=static_folder,
+            config_module=config_module,
         )
         return _TestingModule(app=app)
 
@@ -59,6 +61,7 @@ def create_test_module_from_module(
         cls,
         module: t.Union[t.Type, t.Type[ModuleBase]],
         mock_services: t.Sequence[ProviderConfig] = tuple(),
+        config_module: str = None,
     ) -> _TestingModule:
         app_module_watermark = reflect.get_metadata(MODULE_WATERMARK, module)
         if mock_services:
@@ -67,6 +70,12 @@ def create_test_module_from_module(
             )
 
         if app_module_watermark:
-            return _TestingModule(app=AppFactory.create_from_app_module(module))
-        app = AppFactory.create_app(modules=(module,), providers=mock_services)
+            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
+        )
         return _TestingModule(app=app)

ellar/di/injector.py

@@ -120,29 +120,35 @@ def register(
             _scope = scope.scope
         self.register_binding(base_type, Binding(base_type, provider, _scope))
 
-    def register_instance(self, instance: T, concrete_type: t.Type[T] = None) -> None:
+    def register_instance(
+        self, instance: T, concrete_type: t.Union[t.Type[T], Provider] = None
+    ) -> None:
         assert not isinstance(instance, type)
         _concrete_type = instance.__class__ if not concrete_type else concrete_type
         self.register(_concrete_type, instance, scope=SingletonScope)
 
     def register_singleton(
         self,
         base_type: t.Type[T],
-        concrete_type: t.Optional[t.Union[t.Type[T], T]] = None,
+        concrete_type: t.Union[t.Type[T], T, Provider] = None,
     ) -> None:
         if not concrete_type:
             self.register_exact_singleton(base_type)
         self.register(base_type, concrete_type, scope=SingletonScope)
 
     def register_transient(
-        self, base_type: t.Type, concrete_type: t.Optional[t.Type] = None
+        self,
+        base_type: t.Type,
+        concrete_type: t.Union[t.Type, Provider] = None,
     ) -> None:
         if not concrete_type:
             self.register_exact_transient(base_type)
         self.register(base_type, concrete_type, scope=TransientScope)
 
     def register_scoped(
-        self, base_type: t.Type, concrete_type: t.Optional[t.Type] = None
+        self,
+        base_type: t.Type,
+        concrete_type: t.Union[t.Type, Provider] = None,
     ) -> None:
         if not concrete_type:
             self.register_exact_scoped(base_type)