unittest: add unit tests for auto generated apis and follow the idea of ninja-extra's new testing client

Author: freemindcore

Makefile

@@ -28,7 +28,7 @@ fmt format: ## Run code formatters
 	black easy tests
 
 test: ## Run tests
-	pytest
+	pytest -s
 
 test-cov: ## Run tests with coverage
 	pytest --cov=easy --cov-report term

easy/testing/client.py

@@ -1,30 +1,62 @@
-from typing import Any, Callable, Dict, Sequence, Type, Union
+from json import dumps as json_dumps
+from typing import Any, Callable, Dict, List, Sequence, Type, Union, cast
 from unittest.mock import Mock
+from urllib.parse import urlencode
 
+from ninja import NinjaAPI, Router
 from ninja.constants import NOT_SET, NOT_SET_TYPE
-from ninja.testing.client import NinjaResponse
+from ninja.testing.client import NinjaClientBase, NinjaResponse
 from ninja_extra import ControllerBase
-from ninja_extra.testing.client import NinjaExtraClientBase
 
 from easy.main import EasyAPI
 
 
-class EasyAPIClientBase(NinjaExtraClientBase):
+class EasyAPIClientBase(NinjaClientBase):
     def __init__(
         self,
-        controller_class: Union[Type[ControllerBase], Type],
+        router_or_app: Union[EasyAPI, Router, Type[ControllerBase]],
         auth: Union[
             Sequence[Callable[..., Any]], Callable[..., Any], NOT_SET_TYPE, None
         ] = NOT_SET,
         api_cls: Union[Type[EasyAPI], Type] = EasyAPI,
     ) -> None:
-        api = api_cls(auth=auth)
-        assert hasattr(controller_class, "get_api_controller"), "Not a valid object"
-        controller_ninja_api_controller = controller_class.get_api_controller()
-        assert controller_ninja_api_controller
-        controller_ninja_api_controller.set_api_instance(api)
-        self._urls_cache = list(controller_ninja_api_controller.urls_paths(""))
-        super(NinjaExtraClientBase, self).__init__(api)
+        if hasattr(router_or_app, "get_api_controller"):
+            api = api_cls(auth=auth)
+            controller_ninja_api_controller = router_or_app.get_api_controller()  # type: ignore
+            assert controller_ninja_api_controller
+            controller_ninja_api_controller.set_api_instance(api)
+            self._urls_cache = list(controller_ninja_api_controller.urls_paths(""))
+            router_or_app = api
+        super().__init__(cast(Union[NinjaAPI, Router], router_or_app))
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        data: Dict = {},
+        json: Any = None,
+        **request_params: Any,
+    ) -> "NinjaResponse":
+        if json is not None:
+            request_params["body"] = json_dumps(json)
+        if "query" in request_params and isinstance(request_params["query"], dict):
+            query = request_params.pop("query")
+            url_encode = urlencode(query)
+            path = f"{path}?{url_encode}"
+        func, request, kwargs = self._resolve(method, path, data, request_params)
+        return self._call(func, request, kwargs)  # type: ignore
+
+    @property
+    def urls(self) -> List:
+        if not hasattr(self, "_urls_cache"):
+            self._urls_cache: List
+            if isinstance(self.router_or_app, EasyAPI):
+                self._urls_cache = self.router_or_app.urls[0]  # pragma: no cover
+            else:
+                api = EasyAPI()
+                self.router_or_app.set_api_instance(api)  # type: ignore
+                self._urls_cache = list(self.router_or_app.urls_paths(""))  # type: ignore
+        return self._urls_cache
 
 
 class EasyTestClient(EasyAPIClientBase):

tests/demo_app/test_auto_api_creation.py

@@ -5,31 +5,49 @@
 api_admin_v1 = EasyAPI()
 api_admin_v1.auto_create_admin_controllers()
 
+path_names = []
+controllers = []
+controller_names = []
+
+for path, rtr in api_admin_v1._routers:
+    path_names.append(path)
+    controllers.append(rtr)
+    controller_names.append(str(rtr))
+    for path_ops in rtr.path_operations.values():
+        for op in path_ops.operations:
+            assert isinstance(op, AsyncOperation)
+            assert op.api is api_admin_v1
+
 
 def test_auto_generate_admin_api():
     assert len(api_admin_v1._routers) == 5  # default + 3 models
-    path_names = []
-    controllers = []
-    for path, rtr in api_admin_v1._routers:
-        path_names.append(path)
-        controllers.append(str(rtr))
-        for path_ops in rtr.path_operations.values():
-            for op in path_ops.operations:
-                assert isinstance(op, AsyncOperation)
-                assert op.api is api_admin_v1
-
     assert "/demo_app/category" in path_names
     assert "/demo_app/client" in path_names
     assert "/demo_app/event" in path_names
     assert "/demo_app/type" in path_names
 
-    assert "CategoryAdminAPIController" in controllers
-    assert "EventAdminAPIController" in controllers
-    assert "ClientAdminAPIController" in controllers
-    assert "TypeAdminAPIController" in controllers
+    assert "CategoryAdminAPIController" in controller_names
+    assert "EventAdminAPIController" in controller_names
+    assert "ClientAdminAPIController" in controller_names
+    assert "TypeAdminAPIController" in controller_names
+
+
+async def test_auto_apis(transactional_db, easy_api_client):
+    for controller_class in controllers:
+        if not str(controller_class).endswith("AdminAPIController"):
+            continue
+        client = easy_api_client(controller_class)
+        response = await client.get(
+            "/get_all",
+            query=dict(
+                maximum=100,
+            ),
+        )
+        assert response.status_code == 200
+        assert response.json()["data"] == []
 
 
-def test_auto_generation_settings(settings):
+async def test_auto_generation_settings(settings):
     settings.AUTO_ADMIN_EXCLUDE_APPS = ["tests.demo_app"]
     api_admin_v2 = EasyAPI()
     api_admin_v2.auto_create_admin_controllers()