updated field validators extraction logic

Author: CosmoV

fastapi_jsonapi/schema_builder.py

@@ -20,7 +20,6 @@
 from pydantic import BaseModel as PydanticBaseModel
 from pydantic.class_validators import (
     ROOT_VALIDATOR_CONFIG_KEY,
-    VALIDATOR_CONFIG_KEY,
     extract_validators,
     inherit_validators,
 )
@@ -297,7 +296,10 @@ def _get_info_from_schema_for_building(
                 # works both for to-one and to-many
                 included_schemas.append((name, field.type_, relationship.resource_type))
             elif name == "id":
-                id_validators = self._extract_field_validators(schema, target_field_name="id")
+                id_validators = self._extract_field_validators(
+                    schema,
+                    include_for_field_names={"id"},
+                )
                 resource_id_field = (*(resource_id_field[:-1]), id_validators)
 
                 if not field.field_info.extra.get("client_can_set_id"):
@@ -398,7 +400,13 @@ def deduplicate_field_validators(self, validators: dict) -> dict:
 
         return result_validators
 
-    def prepare_validators(self, model: Type[BaseModel]):
+    def _extract_field_validators(
+        self,
+        model: Type[BaseModel],
+        *,
+        include_for_field_names: Set[str] = None,
+        exclude_for_field_names: Set[str] = None,
+    ):
         validators = inherit_validators(
             extract_validators(model.__dict__),
             deepcopy(model.__validators__),
@@ -411,8 +419,21 @@ def prepare_validators(self, model: Type[BaseModel]):
             "check_fields",
         )
 
+        exclude_for_field_names = exclude_for_field_names or set()
+
+        if include_for_field_names and exclude_for_field_names:
+            exclude_for_field_names = include_for_field_names.difference(
+                exclude_for_field_names,
+            )
+
         result_validators = {}
         for field_name, field_validators in validators.items():
+            if field_name in exclude_for_field_names:
+                continue
+
+            if include_for_field_names and field_name not in include_for_field_names:
+                continue
+
             field_validator: Validator
             for field_validator in field_validators:
                 validator_name = f"{field_name}_{field_validator.func.__name__}_validator"
@@ -452,7 +473,7 @@ def _unpack_validators(self, model: Type[BaseModel], validator_config_key: str)
         :param validator_config_key: Choice field, available options are pydantic consts
                                      VALIDATOR_CONFIG_KEY, ROOT_VALIDATOR_CONFIG_KEY
         """
-        root_validator_class_methods = {
+        validator_class_methods = {
             # validators only
             attr_name: value
             for attr_name, value in model.__dict__.items()
@@ -461,7 +482,7 @@ def _unpack_validators(self, model: Type[BaseModel], validator_config_key: str)
 
         return {
             validator_name: getattr(validator_method, validator_config_key)
-            for validator_name, validator_method in root_validator_class_methods.items()
+            for validator_name, validator_method in validator_class_methods.items()
         }
 
     def _extract_root_validators(self, model: Type[BaseModel]) -> Dict[str, Callable]:
@@ -477,50 +498,6 @@ def _extract_root_validators(self, model: Type[BaseModel]) -> Dict[str, Callable
 
         return validators
 
-    def _extract_field_validators(
-        self,
-        model: Type[BaseModel],
-        target_field_name: str = None,
-        exclude_for_field_names: Set[str] = None,
-    ) -> Dict[str, Callable]:
-        """
-        :param model: Type[BaseModel]
-        :param target_field_name: Name of field for which validators will be returned.
-                                  If not set the function will return validators for all fields.
-        """
-        validators = {}
-        validator_origin_param_keys = ("pre", "each_item", "always", "check_fields")
-
-        unpacked_validators = self._unpack_validators(model, VALIDATOR_CONFIG_KEY)
-        for validator_name, (field_names, validator_instance) in unpacked_validators.items():
-            if target_field_name and target_field_name not in field_names:
-                continue
-            elif target_field_name:
-                field_names = [target_field_name]  # noqa: PLW2901
-
-            if exclude_for_field_names:
-                field_names = [  # noqa: PLW2901
-                    # filter names
-                    field_name
-                    for field_name in field_names
-                    if field_name not in exclude_for_field_names
-                ]
-
-            if not field_names:
-                continue
-
-            validators[validator_name] = validator(
-                *field_names,
-                allow_reuse=True,
-                **{
-                    # copy origin params
-                    param_name: getattr(validator_instance, param_name)
-                    for param_name in validator_origin_param_keys
-                },
-            )(validator_instance.func)
-
-        return validators
-
     def _extract_validators(
         self,
         model: Type[BaseModel],

tests/test_api/test_api_sqla_with_includes.py

@@ -2,7 +2,7 @@
 from copy import deepcopy
 from itertools import chain, zip_longest
 from json import dumps
-from typing import Dict, List
+from typing import Dict, List, Type
 from uuid import UUID, uuid4
 
 from fastapi import FastAPI, status
@@ -2050,6 +2050,11 @@ def _refresh_caches(self) -> None:
 
         RoutersJSONAPI.all_jsonapi_routers = all_jsonapi_routers
 
+    def _clear_cache(self):
+        SchemaBuilder.object_schemas_cache = {}
+        SchemaBuilder.relationship_schema_cache = {}
+        SchemaBuilder.base_jsonapi_object_schemas_cache = {}
+
     def build_app(self, schema) -> FastAPI:
         return build_app_custom(
             model=User,
@@ -2059,6 +2064,12 @@ def build_app(self, schema) -> FastAPI:
             resource_type=self.resource_type,
         )
 
+    def inherit(self, schema: Type[BaseModel]) -> Type[BaseModel]:
+        class InheritedSchema(schema):
+            pass
+
+        return InheritedSchema
+
     async def execute_request_and_check_response(
         self,
         app: FastAPI,
@@ -2082,6 +2093,28 @@ async def execute_request_and_check_response(
                 },
             }
 
+    async def execute_request_twice_and_check_response(
+        self,
+        schema: Type[BaseModel],
+        body: Dict,
+        expected_detail: str,
+    ):
+        """
+        Makes two requests for check schema inheritance
+        """
+        apps = [
+            self.build_app(schema),
+            self.build_app(self.inherit(schema)),
+        ]
+
+        for app in apps:
+            await self.execute_request_and_check_response(
+                app=app,
+                body=body,
+                expected_detail=expected_detail,
+            )
+            self._clear_cache()
+
     async def test_field_validator_call(self):
         """
         Basic check to ensure that field validator called
@@ -2103,8 +2136,8 @@ class Config:
         attrs = {"name": fake.name()}
         create_user_body = {"data": {"attributes": attrs}}
 
-        await self.execute_request_and_check_response(
-            app=self.build_app(UserSchemaWithValidator),
+        await self.execute_request_twice_and_check_response(
+            schema=UserSchemaWithValidator,
             body=create_user_body,
             expected_detail="Check validator",
         )
@@ -2124,8 +2157,8 @@ class Config:
         attrs = {"names": ["good_name", "bad_name"]}
         create_user_body = {"data": {"attributes": attrs}}
 
-        await self.execute_request_and_check_response(
-            app=self.build_app(UserSchemaWithValidator),
+        await self.execute_request_twice_and_check_response(
+            schema=UserSchemaWithValidator,
             body=create_user_body,
             expected_detail="Bad name not allowed",
         )
@@ -2148,8 +2181,8 @@ class Config:
         attrs = {"name": fake.name()}
         create_user_body = {"data": {"attributes": attrs}}
 
-        await self.execute_request_and_check_response(
-            app=self.build_app(UserSchemaWithValidator),
+        await self.execute_request_twice_and_check_response(
+            schema=UserSchemaWithValidator,
             body=create_user_body,
             expected_detail="Pre validator called",
         )
@@ -2167,8 +2200,8 @@ class Config:
 
         create_user_body = {"data": {"attributes": {}}}
 
-        await self.execute_request_and_check_response(
-            app=self.build_app(UserSchemaWithValidator),
+        await self.execute_request_twice_and_check_response(
+            schema=UserSchemaWithValidator,
             body=create_user_body,
             expected_detail="Called always validator",
         )
@@ -2274,8 +2307,8 @@ class Config:
             },
         }
 
-        await self.execute_request_and_check_response(
-            app=self.build_app(UserSchemaWithValidator),
+        await self.execute_request_twice_and_check_response(
+            schema=UserSchemaWithValidator,
             body=create_user_body,
             expected_detail="Check validator",
         )

tests/test_api/test_validators.py

@@ -18,10 +18,7 @@ async def task_with_none_ids(
     async_session.add(task)
     await async_session.commit()
 
-    yield task
-
-    await async_session.delete(task)
-    await async_session.commit()
+    return task
 
 
 @pytest.fixture()