Fixed test and increase cov to 100%

Author: eadwinCode

ninja_extra/ordering.py

@@ -178,7 +178,7 @@ def __init__(
         self.as_view = wraps(view_func)(orderator_view)
 
     @property
-    def view_func_has_kwargs(self) -> bool:
+    def view_func_has_kwargs(self) -> bool:  # pragma: no cover
         return self.orderator.pass_parameter is not None
 
     def get_view_function(self) -> Callable:

ninja_extra/pagination.py

@@ -207,7 +207,7 @@ def __init__(
         self.as_view = wraps(view_func)(paginator_view)
 
     @property
-    def view_func_has_kwargs(self) -> bool:
+    def view_func_has_kwargs(self) -> bool:  # pragma: no cover
         return self.paginator.pass_parameter is not None
 
     def get_view_function(self) -> Callable:

ninja_extra/searching.py

@@ -190,7 +190,7 @@ def __init__(
         self.as_view = wraps(view_func)(searcherator_view)
 
     @property
-    def view_func_has_kwargs(self) -> bool:
+    def view_func_has_kwargs(self) -> bool:  # pragma: no cover
         return self.searcherator.pass_parameter is not None
 
     def get_view_function(self) -> Callable:

tests/test_controller.py

@@ -14,8 +14,13 @@
     testing,
 )
 from ninja_extra.controllers import ControllerBase, RouteContext, RouteFunction
-from ninja_extra.controllers.base import APIController, get_route_functions
+from ninja_extra.controllers.base import (
+    APIController,
+    MissingAPIControllerDecoratorException,
+    get_route_functions,
+)
 from ninja_extra.controllers.response import Detail, Id, Ok
+from ninja_extra.helper import get_route_function
 from ninja_extra.permissions.common import AllowAny
 
 from .schemas import UserSchema
@@ -76,23 +81,32 @@ class DisableAutoImportController:
 
 class TestAPIController:
     def test_api_controller_as_decorator(self):
-        api_controller_instance = api_controller(
-            "prefix", tags="new_tag", auth=FakeAuth()
+        controller_type = api_controller("prefix", tags="new_tag", auth=FakeAuth())(
+            type("Any", (), {})
         )
+        api_controller_instance = controller_type.get_api_controller()
 
         assert not api_controller_instance.has_auth_async
         assert not api_controller_instance._prefix_has_route_param
         assert api_controller_instance.prefix == "prefix"
         assert api_controller_instance.tags == ["new_tag"]
         assert api_controller_instance.permission_classes == [AllowAny]
 
-        api_controller_instance = api_controller()
+        controller_type = api_controller()(controller_type)
+        api_controller_instance = controller_type.get_api_controller()
         assert api_controller_instance.prefix == ""
-        assert api_controller_instance.tags is None
+        assert api_controller_instance.tags == ["any"]
         assert "abc" in SomeController.__module__
         assert "tests.test_controller" in Some2Controller.__module__
         assert Some2Controller.get_api_controller()
 
+    def test_controller_get_api_controller_raise_exception(self):
+        class BController(ControllerBase):
+            pass
+
+        with pytest.raises(MissingAPIControllerDecoratorException):
+            BController.get_api_controller()
+
     def test_api_controller_prefix_with_parameter(self):
         @api_controller("/{int:organisation_id}")
         class UsersController:
@@ -130,7 +144,9 @@ def test_controller_should_have_path_operation_list(self):
         _api_controller = SomeControllerWithRoute.get_api_controller()
         assert len(_api_controller._path_operations) == 7
 
-        route_function: RouteFunction = SomeControllerWithRoute.example
+        route_function: RouteFunction = get_route_function(
+            SomeControllerWithRoute().example
+        )
         path_view = _api_controller._path_operations.get(str(route_function))
         assert path_view, "route doesn't exist in controller"
         assert len(path_view.operations) == 1
@@ -144,18 +160,16 @@ def test_get_route_function_should_return_instance_route_definitions(self):
             assert isinstance(route_definition, RouteFunction)
 
     def test_compute_api_route_function_works(self):
-        _api_controller = api_controller()
-
+        @api_controller()
         class AnyClassTypeWithRoute:
             @http_get("/example")
             def example(self):
                 pass
 
-        _api_controller(AnyClassTypeWithRoute)
-        assert len(_api_controller.path_operations) == 1
-        path_view = _api_controller.path_operations.get(
-            str(AnyClassTypeWithRoute.example)
-        )
+        api_controller_instance = AnyClassTypeWithRoute.get_api_controller()
+        assert len(api_controller_instance.path_operations) == 1
+        route_function = get_route_function(AnyClassTypeWithRoute().example)
+        path_view = api_controller_instance.path_operations.get(str(route_function))
         assert path_view
 
     @pytest.mark.django_db
@@ -207,29 +221,32 @@ def test_controller_base_get_object_or_none_works(self):
 
 @pytest.mark.skipif(django.VERSION < (3, 1), reason="requires django 3.1 or higher")
 def test_async_controller():
-    api_controller_instance = api_controller(
+    api_controller_decorator = api_controller(
         "prefix", tags="any_Tag", auth=AsyncFakeAuth()
     )
-    assert api_controller_instance.has_auth_async
 
     with pytest.raises(Exception) as ex:
 
-        @api_controller_instance
+        @api_controller_decorator
         class NonAsyncRouteInControllerWithAsyncAuth:
             @http_get("/example")
             def example(self):
                 pass
 
     assert "NonAsyncRouteInControllerWithAsyncAuth" in str(ex) and "example" in str(ex)
 
-    @api_controller_instance
+    @api_controller_decorator
     class AsyncRouteInControllerWithAsyncAuth:
         @http_get("/example")
         async def example(self):
             pass
 
+    example_route_function = get_route_function(
+        AsyncRouteInControllerWithAsyncAuth().example
+    )
+    assert AsyncRouteInControllerWithAsyncAuth.get_api_controller().has_auth_async
     assert isinstance(
-        AsyncRouteInControllerWithAsyncAuth.example.operation.auth_callbacks[0],
+        example_route_function.operation.auth_callbacks[0],
         AsyncFakeAuth,
     )
 
@@ -291,9 +308,10 @@ def test_generic_controller_response_in_route_functions_works(self):
         )
 
         ok_response = Ok[UserSchema](dict(name="John", age=56))
-        result = SomeControllerWithRoute.example_with_ok_schema_response(
-            request=Mock(), user=UserSchema(name="John", age=56)
+        route_function = get_route_function(
+            SomeControllerWithRoute().example_with_ok_schema_response
         )
+        result = route_function(request=Mock(), user=UserSchema(name="John", age=56))
         assert isinstance(result, tuple)
         assert result[1] == ok_response.convert_to_schema()
         assert result[0] == ok_response.status_code
@@ -307,17 +325,19 @@ def test_controller_response_in_route_functions_works(self):
         assert detail.convert_to_schema().dict() == response.json()
 
         ok_response = Ok("5242")
-        result = SomeControllerWithRoute.example_with_ok_response(
-            request=Mock(), ex_id="5242"
+        route_function = get_route_function(
+            SomeControllerWithRoute().example_with_ok_response
         )
+        result = route_function(request=Mock(), ex_id="5242")
         assert isinstance(result, tuple)
         assert result[1] == ok_response.convert_to_schema()
         assert result[0] == ok_response.status_code
 
         id_response = Id("5242")
-        result = SomeControllerWithRoute.example_with_id_response(
-            request=Mock(), ex_id="5242"
+        route_function = get_route_function(
+            SomeControllerWithRoute().example_with_id_response
         )
+        result = route_function(request=Mock(), ex_id="5242")
         assert isinstance(result, tuple)
         assert result[1] == id_response.convert_to_schema()
         assert result[0] == id_response.status_code

tests/test_operation.py

@@ -3,6 +3,7 @@
 
 from ninja_extra import api_controller, route
 from ninja_extra.controllers import AsyncRouteFunction, RouteFunction
+from ninja_extra.helper import get_route_function
 from ninja_extra.operation import AsyncOperation, Operation
 from ninja_extra.testing import TestAsyncClient, TestClient
 
@@ -25,7 +26,7 @@ def example_exception(self):
     @mock_log_call("info")
     def test_route_operation_execution_works(self):
         client = TestClient(self.SomeTestController)
-        response = client.get(str(self.SomeTestController.example))
+        response = client.get("/example")
         assert response.json() == {"message": "example"}
 
     @mock_signal_call("route_context_started")
@@ -34,12 +35,16 @@ def test_route_operation_execution_works(self):
     def test_route_operation_execution_should_log_execution(self):
         client = TestClient(self.SomeTestController)
         with pytest.raises(Exception):
-            client.get(str(self.SomeTestController.example_exception))
+            client.get("/example_exception")
 
 
 @pytest.mark.skipif(django.VERSION < (3, 1), reason="requires django 3.1 or higher")
 def test_operation_auth_configs():
-    api_controller_instance = api_controller("prefix", tags="any_Tag")
+    @api_controller("prefix", tags="any_Tag")
+    class AController:
+        pass
+
+    api_controller_instance = AController.get_api_controller()
 
     async def async_endpoint(self, request):
         pass
@@ -50,23 +55,26 @@ def sync_endpoint(self, request):
     sync_auth_http_get = route.get("/example", auth=[FakeAuth()])
     async_auth_http_get = route.get("/example/async", auth=[AsyncFakeAuth()])
 
-    route_function = sync_auth_http_get(async_endpoint)
-    assert isinstance(route_function, AsyncRouteFunction)
-    async_route_function = async_auth_http_get(async_endpoint)
+    sync_auth_http_get(async_endpoint)
+    async_route_function = get_route_function(async_endpoint)
+    assert isinstance(async_route_function, AsyncRouteFunction)
 
-    api_controller_instance._add_operation_from_route_function(route_function)
-    assert isinstance(route_function.operation, AsyncOperation)
+    api_controller_instance._add_operation_from_route_function(async_route_function)
+    assert isinstance(async_route_function.operation, AsyncOperation)
     api_controller_instance._add_operation_from_route_function(async_route_function)
     assert isinstance(async_route_function.operation, AsyncOperation)
 
-    sync_route_function = sync_auth_http_get(sync_endpoint)
+    sync_auth_http_get(sync_endpoint)
+    sync_route_function = get_route_function(sync_endpoint)
     api_controller_instance._add_operation_from_route_function(sync_route_function)
     assert isinstance(sync_route_function.operation, Operation)
     assert isinstance(sync_route_function, RouteFunction)
 
     with pytest.raises(Exception) as ex:
+        new_sync_endpoint = async_auth_http_get(sync_endpoint)
+        new_sync_route_function = get_route_function(new_sync_endpoint)
         api_controller_instance._add_operation_from_route_function(
-            async_auth_http_get(sync_endpoint)
+            new_sync_route_function
         )
     assert "sync_endpoint" in str(ex) and "AsyncFakeAuth" in str(ex)
 
@@ -91,7 +99,7 @@ async def example_exception(self):
         @mock_log_call("info")
         async def test_async_route_operation_execution_works(self):
             client = TestAsyncClient(self.SomeTestController)
-            response = await client.get(str(self.SomeTestController.example))
+            response = await client.get("/example")
             assert response.json() == {"message": "example"}
 
         @mock_signal_call("route_context_started")
@@ -100,4 +108,4 @@ async def test_async_route_operation_execution_works(self):
         async def test_async_route_operation_execution_should_log_execution(self):
             client = TestAsyncClient(self.SomeTestController)
             with pytest.raises(Exception):
-                await client.get(str(self.SomeTestController.example_exception))
+                await client.get("/example_exception")

tests/test_permissions.py

@@ -69,6 +69,10 @@ def test_or_true(self):
     def test_not_false(self):
         composed_perm = ~permissions.IsAuthenticated
         assert composed_perm().has_permission(anonymous_request, None) is True
+        assert (
+            composed_perm().has_object_permission(anonymous_request, None, None)
+            is False
+        )
 
     @pytest.mark.django_db
     def test_not_true(self):