coverage for atomic operations method config resolution

mahenzon · mahenzon · commit 5886f4e7ef5d · 2023-09-26T20:13:14.000+03:00
diff --git a/tests/fixtures/app.py b/tests/fixtures/app.py
@@ -1,11 +1,14 @@
 from pathlib import Path
+from typing import Type
 
 import uvicorn
 from fastapi import APIRouter, FastAPI
 from pytest import fixture  # noqa PT013
 
 from fastapi_jsonapi import RoutersJSONAPI, init
 from fastapi_jsonapi.atomic import AtomicOperations
+from fastapi_jsonapi.views.detail_view import DetailViewBase
+from fastapi_jsonapi.views.list_view import ListViewBase
 from tests.fixtures.views import (
     DetailViewBaseGeneric,
     ListViewBaseGeneric,
@@ -191,3 +194,36 @@ def app(app_plain: FastAPI):
         reload=True,
         app_dir=str(CURRENT_DIR),
     )
+
+
+def build_app_custom(
+    model,
+    schema,
+    schema_in_patch=None,
+    schema_in_post=None,
+    path: str = "/misc",
+    resource_type: str = "misc",
+    class_list: Type[ListViewBase] = ListViewBaseGeneric,
+    class_detail: Type[DetailViewBase] = DetailViewBaseGeneric,
+) -> FastAPI:
+    router: APIRouter = APIRouter()
+
+    RoutersJSONAPI(
+        router=router,
+        path=path,
+        tags=["Misc"],
+        class_list=class_list,
+        class_detail=class_detail,
+        schema=schema,
+        resource_type=resource_type,
+        schema_in_patch=schema_in_patch,
+        schema_in_post=schema_in_post,
+        model=model,
+    )
+
+    app = build_app_plain()
+    app.include_router(router, prefix="")
+
+    atomic = AtomicOperations()
+    app.include_router(atomic.router, prefix="")
+    return app
diff --git a/tests/fixtures/views.py b/tests/fixtures/views.py
@@ -16,13 +16,15 @@
 from tests.fixtures.db_connection import async_session_dependency
 
 
-class SessionDependency(BaseModel):
-    session: AsyncSession = Depends(async_session_dependency)
-
+class ArbitraryModelBase(BaseModel):
     class Config:
         arbitrary_types_allowed = True
 
 
+class SessionDependency(ArbitraryModelBase):
+    session: AsyncSession = Depends(async_session_dependency)
+
+
 def common_handler(view: ViewBase, dto: SessionDependency) -> Dict:
     return {"session": dto.session}
 
diff --git a/tests/test_api/test_api_sqla_with_includes.py b/tests/test_api/test_api_sqla_with_includes.py
@@ -5,7 +5,7 @@
 from typing import Dict, List
 from uuid import UUID, uuid4
 
-from fastapi import APIRouter, FastAPI, status
+from fastapi import FastAPI, status
 from httpx import AsyncClient
 from pydantic import BaseModel, Field, root_validator, validator
 from pytest import fixture, mark, param  # noqa PT013
@@ -15,9 +15,8 @@
 from fastapi_jsonapi.exceptions import BadRequest
 from fastapi_jsonapi.schema_builder import SchemaBuilder
 from fastapi_jsonapi.views.view_base import ViewBase
-from tests.fixtures.app import build_app_plain
+from tests.fixtures.app import build_app_custom
 from tests.fixtures.entities import build_workplace, create_user
-from tests.fixtures.views import DetailViewBaseGeneric, ListViewBaseGeneric
 from tests.misc.utils import fake
 from tests.models import (
     Computer,
@@ -51,34 +50,6 @@ def association_key(data: dict):
     return data["type"], data["id"]
 
 
-def build_app_custom(
-    model,
-    schema,
-    schema_in_patch=None,
-    schema_in_post=None,
-    resource_type: str = "misc",
-) -> FastAPI:
-    router: APIRouter = APIRouter()
-
-    RoutersJSONAPI(
-        router=router,
-        path="/misc",
-        tags=["Misc"],
-        class_detail=DetailViewBaseGeneric,
-        class_list=ListViewBaseGeneric,
-        schema=schema,
-        resource_type=resource_type,
-        schema_in_patch=schema_in_patch,
-        schema_in_post=schema_in_post,
-        model=model,
-    )
-
-    app = build_app_plain()
-    app.include_router(router, prefix="")
-
-    return app
-
-
 async def test_root(client: AsyncClient):
     response = await client.get("/docs")
     assert response.status_code == status.HTTP_200_OK
diff --git a/tests/test_atomic/test_dependencies.py b/tests/test_atomic/test_dependencies.py
@@ -0,0 +1,230 @@
+from typing import Dict
+
+import pytest
+from fastapi import Depends, Query, status
+from httpx import AsyncClient
+from pytest_asyncio import fixture
+
+from fastapi_jsonapi.misc.sqla.generics.base import DetailViewBaseGeneric, ListViewBaseGeneric
+from fastapi_jsonapi.views.utils import (
+    HTTPMethod,
+    HTTPMethodConfig,
+)
+from tests.fixtures.app import build_app_custom
+from tests.fixtures.views import ArbitraryModelBase, SessionDependency, common_handler
+from tests.misc.utils import fake
+from tests.models import User
+from tests.schemas import (
+    UserAttributesBaseSchema,
+    UserInSchema,
+    UserPatchSchema,
+    UserSchema,
+)
+
+pytestmark = pytest.mark.asyncio
+
+
+class CustomDependencyForCreate:
+    KEY = "spam_create"
+
+    def __init__(self, query_spam: str = Query(..., alias=KEY)):
+        self.query_spam = query_spam
+
+
+class CustomDependencyForUpdate:
+    KEY = "spam_update"
+
+    def __init__(self, query_spam: str = Query(..., alias=KEY)):
+        self.query_spam = query_spam
+
+
+class CustomDependencyForDelete:
+    KEY = "spam_delete"
+
+    def __init__(self, query_spam: str = Query(..., alias=KEY)):
+        self.query_spam = query_spam
+
+
+class UserCreateCustomDependency(ArbitraryModelBase):
+    dep: CustomDependencyForCreate = Depends()
+
+
+class UserUpdateCustomDependency(ArbitraryModelBase):
+    dep: CustomDependencyForUpdate = Depends()
+
+
+class UserDeleteCustomDependency(ArbitraryModelBase):
+    dep: CustomDependencyForDelete = Depends()
+
+
+class UserCustomListView(ListViewBaseGeneric):
+    method_dependencies: Dict[HTTPMethod, HTTPMethodConfig] = {
+        HTTPMethod.ALL: HTTPMethodConfig(
+            dependencies=SessionDependency,
+            prepare_data_layer_kwargs=common_handler,
+        ),
+        HTTPMethod.POST: HTTPMethodConfig(
+            dependencies=UserCreateCustomDependency,
+        ),
+    }
+
+
+class UserCustomDetailView(DetailViewBaseGeneric):
+    method_dependencies: Dict[HTTPMethod, HTTPMethodConfig] = {
+        HTTPMethod.ALL: HTTPMethodConfig(
+            dependencies=SessionDependency,
+            prepare_data_layer_kwargs=common_handler,
+        ),
+        HTTPMethod.PATCH: HTTPMethodConfig(
+            dependencies=UserUpdateCustomDependency,
+        ),
+        HTTPMethod.DELETE: HTTPMethodConfig(
+            dependencies=UserDeleteCustomDependency,
+        ),
+    }
+
+
+class TestDependenciesResolver:
+    @pytest.fixture(scope="class")
+    def resource_type(self):
+        return "user_custom_deps"
+
+    @pytest.fixture(scope="class")
+    def app_w_deps(self, resource_type):
+        app = build_app_custom(
+            model=User,
+            schema=UserSchema,
+            schema_in_post=UserInSchema,
+            schema_in_patch=UserPatchSchema,
+            resource_type=resource_type,
+            class_list=UserCustomListView,
+            class_detail=UserCustomDetailView,
+        )
+        return app
+
+    @fixture(scope="class")
+    async def client(self, app_w_deps):
+        app = app_w_deps
+        async with AsyncClient(app=app, base_url="http://test") as client:
+            yield client
+
+    async def send_and_validate_atomic(
+        self,
+        client: AsyncClient,
+        data_atomic: dict,
+        expected_body: dict,
+        expected_status=status.HTTP_422_UNPROCESSABLE_ENTITY,
+    ):
+        response = await client.post("/operations", json=data_atomic)
+        assert response.status_code == expected_status, response.text
+        response_data = response.json()
+        # TODO: JSON:API exception
+        assert response_data == expected_body
+
+    async def test_on_create_atomic(
+        self,
+        client: AsyncClient,
+        resource_type: str,
+    ):
+        user = UserAttributesBaseSchema(
+            name=fake.name(),
+            age=fake.pyint(min_value=13, max_value=99),
+            email=fake.email(),
+        )
+        data_atomic_request = {
+            "atomic:operations": [
+                {
+                    "op": "add",
+                    "data": {
+                        "type": resource_type,
+                        "attributes": user.dict(),
+                    },
+                },
+            ],
+        }
+        # TODO: JSON:API exception
+        expected_response_data = {
+            "detail": [
+                {
+                    "loc": ["query", CustomDependencyForCreate.KEY],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ],
+        }
+        await self.send_and_validate_atomic(
+            client=client,
+            data_atomic=data_atomic_request,
+            expected_body=expected_response_data,
+        )
+
+    async def test_on_update_atomic(
+        self,
+        client: AsyncClient,
+        resource_type: str,
+        user_1: User,
+    ):
+        user = UserAttributesBaseSchema(
+            name=fake.name(),
+            age=fake.pyint(min_value=13, max_value=99),
+            email=fake.email(),
+        )
+        data_atomic_request = {
+            "atomic:operations": [
+                {
+                    "op": "update",
+                    "id": user_1.id,
+                    "data": {
+                        "type": resource_type,
+                        "attributes": user.dict(),
+                    },
+                },
+            ],
+        }  # TODO: JSON:API exception
+        expected_response_data = {
+            "detail": [
+                {
+                    "loc": ["query", CustomDependencyForUpdate.KEY],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ],
+        }
+        await self.send_and_validate_atomic(
+            client=client,
+            data_atomic=data_atomic_request,
+            expected_body=expected_response_data,
+        )
+
+    async def test_on_delete_atomic(
+        self,
+        client: AsyncClient,
+        resource_type: str,
+        user_1: User,
+    ):
+        data_atomic_request = {
+            "atomic:operations": [
+                {
+                    "op": "remove",
+                    "ref": {
+                        "id": user_1.id,
+                        "type": resource_type,
+                    },
+                },
+            ],
+        }
+        # TODO: JSON:API exception
+        expected_response_data = {
+            "detail": [
+                {
+                    "loc": ["query", CustomDependencyForDelete.KEY],
+                    "msg": "field required",
+                    "type": "value_error.missing",
+                },
+            ],
+        }
+        await self.send_and_validate_atomic(
+            client=client,
+            data_atomic=data_atomic_request,
+            expected_body=expected_response_data,
+        )
