added tests for userspace type cast

Author: CosmoV

fastapi_jsonapi/data_layers/filtering/sqlalchemy.py

@@ -1,4 +1,5 @@
 """Helper to create sqlalchemy filters according to filter querystring parameter"""
+import logging
 from typing import (
     Any,
     Callable,
@@ -24,6 +25,8 @@
 from fastapi_jsonapi.splitter import SPLIT_REL
 from fastapi_jsonapi.utils.sqla import get_related_model_cls
 
+log = logging.getLogger(__name__)
+
 Filter = BinaryExpression
 Join = List[Any]
 
@@ -61,7 +64,7 @@ def __init__(self, model: Type[TypeModel], filter_: dict, schema: Type[TypeSchem
         self.filter_ = filter_
         self.schema = schema
 
-    def create_filter(self, schema_field: ModelField, model_column, operator, value):
+    def create_filter(self, schema_field: ModelField, model_column, operator, value):  # noqa: PLR0912 temporary
         """
         Create sqlalchemy filter
         :param schema_field:
@@ -101,6 +104,11 @@ def create_filter(self, schema_field: ModelField, model_column, operator, value)
                 clear_value, errors = self._cast_value_with_pydantic(pydantic_types, value)
 
         if clear_value is None and userspace_types:
+            log.warning("Filtering by user type values is not properly tested yet. Use this on your own risk.")
+
+            cast_failed = object()
+            clear_value = cast_failed
+
             for i_type in types:
                 try:
                     if isinstance(value, list):  # noqa: SIM108
@@ -110,6 +118,9 @@ def create_filter(self, schema_field: ModelField, model_column, operator, value)
                 except (TypeError, ValueError) as ex:
                     errors.append(str(ex))
 
+            if clear_value is cast_failed:
+                raise InvalidType(detail=f"Can't cast filter value `{value}` to user type. {', '.join(errors)}")
+
         # Если None, при этом поле обязательное (среди типов в аннотации нет None, то кидаем ошибку)
         if clear_value is None and not any(not i_f.required for i_f in fields):
             raise InvalidType(detail=", ".join(errors))

tests/test_api/test_api_sqla_with_includes.py

@@ -4,16 +4,19 @@
 from collections import defaultdict
 from itertools import chain, zip_longest
 from json import dumps
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional
+from unittest.mock import Mock
 from uuid import UUID, uuid4
 
 from fastapi import FastAPI, status
 from httpx import AsyncClient
 from pydantic import BaseModel, Field
-from pytest import fixture, mark, param  # noqa PT013
+from pytest import fixture, mark, param, raises  # noqa PT013
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
+from fastapi_jsonapi.data_layers.filtering.sqlalchemy import Node
+from fastapi_jsonapi.exceptions.json_api import InvalidType
 from fastapi_jsonapi.views.view_base import ViewBase
 from tests.common import is_postgres_tests
 from tests.fixtures.app import build_app_custom
@@ -1235,7 +1238,7 @@ class ContainsTimestampAttrsSchema(BaseModel):
         )
 
         create_timestamp = datetime.now(tz=timezone.utc)
-        create_user_body = {
+        create_body = {
             "data": {
                 "attributes": {
                     "timestamp": create_timestamp.isoformat(),
@@ -1245,7 +1248,7 @@ class ContainsTimestampAttrsSchema(BaseModel):
 
         async with AsyncClient(app=app, base_url="http://test") as client:
             url = app.url_path_for(f"get_{resource_type}_list")
-            res = await client.post(url, json=create_user_body)
+            res = await client.post(url, json=create_body)
             assert res.status_code == status.HTTP_201_CREATED, res.text
             response_json = res.json()
 
@@ -2355,4 +2358,73 @@ async def test_sort(
         }
 
 
+# TODO: move to it's own test module
+class TestSQLAFilteringModule:
+    def test_user_type_cast_success(self):
+        class UserType:
+            def __init__(self, *args, **kwargs):
+                self.value = "success"
+
+        class ModelSchema(BaseModel):
+            user_type: UserType
+
+            class Config:
+                arbitrary_types_allowed = True
+
+        node = Node(
+            model=Mock(),
+            filter_={
+                "name": "user_type",
+                "op": "eq",
+                "val": Any,
+            },
+            schema=ModelSchema,
+        )
+
+        model_column_mock = Mock()
+        model_column_mock.eq = lambda clear_value: clear_value
+
+        clear_value = node.create_filter(
+            schema_field=ModelSchema.__fields__["user_type"],
+            model_column=model_column_mock,
+            operator=Mock(),
+            value=Any,
+        )
+        assert isinstance(clear_value, UserType)
+        assert clear_value.value == "success"
+
+    def test_user_type_cast_fail(self):
+        class UserType:
+            def __init__(self, *args, **kwargs):
+                msg = "Cast failed"
+                raise ValueError(msg)
+
+        class ModelSchema(BaseModel):
+            user_type: UserType
+
+            class Config:
+                arbitrary_types_allowed = True
+
+        node = Node(
+            model=Mock(),
+            filter_=Mock(),
+            schema=ModelSchema,
+        )
+
+        with raises(InvalidType) as exc_info:
+            node.create_filter(
+                schema_field=ModelSchema.__fields__["user_type"],
+                model_column=Mock(),
+                operator=Mock(),
+                value=Any,
+            )
+
+        assert exc_info.value.as_dict == {
+            "detail": "Can't cast filter value `typing.Any` to user type. Cast failed",
+            "source": {"pointer": ""},
+            "status_code": status.HTTP_409_CONFLICT,
+            "title": "Invalid type.",
+        }
+
+
 # todo: test errors