Merge pull request #21 from ghazi-git/openapitypes_and_polymorphic_serializer_as_request_serializer

openapitypes_and_polymorphic_serializer_as_request_serializer

Author: ghazi-git

README.md

@@ -100,8 +100,8 @@ DRF_STANDARDIZED_ERRORS = {"ENABLE_IN_DEBUG_FOR_UNHANDLED_EXCEPTIONS": True}
 
 ## Integration with DRF spectacular
 If you plan to use [drf-spectacular](https://github.com/tfranzel/drf-spectacular) to generate an OpenAPI 3 schema,
-install with `pip install drf-standardized-errors[openapi]`. After that, check the doc page for configuring the
-integration.
+install with `pip install drf-standardized-errors[openapi]`. After that, check the [doc page](https://drf-standardized-errors.readthedocs.io/en/latest/openapi.html)
+for configuring the integration.
 
 ## Links
 

docs/changelog.md

@@ -5,6 +5,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [UNRELEASED]
+### Fixed
+- account for specifying the request serializer as a basic type (like `OpenApiTypes.STR`) or as a
+`PolymorphicProxySerializer` using `@extend_schema(request=...)` when determining error codes for validation errors.
 
 ## [0.12.3] - 2022-11-13
 ### Added

drf_standardized_errors/openapi.py

@@ -1,3 +1,4 @@
+import inspect
 from typing import List, Optional, Type
 
 from drf_spectacular.drainage import warn
@@ -125,14 +126,14 @@ def _should_add_validation_error_response(self) -> bool:
         """
         add a validation error response when unsafe methods have a request body
         or when a list view implements filtering with django-filters.
-        todo add a way to disable adding the 400 validation response on an
-         operation-basis. This is because "serializer.is_valid" has the option
-         of not raising an exception. At the very least, add docs to demo what
-         to override to accomplish that (maybe sth like
-         isinstance(self.view, SomeViewSet) and checking self.method)
         """
-        has_request_body = self.method in ("PUT", "PATCH", "POST") and bool(
-            self.get_request_serializer()
+        request_serializer = self.get_request_serializer()
+        has_request_body = self.method in ("PUT", "PATCH", "POST") and (
+            isinstance(request_serializer, serializers.Field)
+            or (
+                inspect.isclass(request_serializer)
+                and issubclass(request_serializer, serializers.Field)
+            )
         )
 
         filter_backends = get_django_filter_backends(self.get_filter_backends())

drf_standardized_errors/openapi_utils.py

@@ -1,3 +1,4 @@
+from collections import defaultdict
 from dataclasses import dataclass
 from dataclasses import field as dataclass_field
 from typing import List, Optional, Set, Type, Union
@@ -54,6 +55,11 @@ def get_flat_serializer_fields(
         f = InputDataField(non_field_errors_name, field)
         prefix = get_prefix(prefix, package_settings.LIST_INDEX_IN_API_SCHEMA)
         return [f] + get_flat_serializer_fields(field.child, prefix)
+    elif isinstance(field, PolymorphicProxySerializer):
+        if isinstance(field.serializers, dict):
+            return get_flat_serializer_fields(list(field.serializers.values()), prefix)
+        else:
+            return get_flat_serializer_fields(field.serializers, prefix)
     elif is_serializer(field):
         prefix = get_prefix(prefix, field.field_name)
         non_field_errors_name = get_prefix(prefix, drf_settings.NON_FIELD_ERRORS_KEY)
@@ -384,9 +390,16 @@ def get_validation_error_serializer(
 ):
     validation_error_component_name = f"{camelize(operation_id)}ValidationError"
     errors_component_name = f"{camelize(operation_id)}Error"
+
+    # When there are multiple fields with the same name in the list of data_fields,
+    # their error codes are combined. This can happen when using a PolymorphicProxySerializer
+    error_codes_by_field = defaultdict(set)
+    for field in data_fields:
+        error_codes_by_field[field.name].update(field.error_codes)
+
     sub_serializers = {
-        sfield.name: get_error_serializer(operation_id, sfield.name, sfield.error_codes)
-        for sfield in data_fields
+        field_name: get_error_serializer(operation_id, field_name, error_codes)
+        for field_name, error_codes in error_codes_by_field.items()
     }
 
     class ValidationErrorSerializer(serializers.Serializer):

tests/test_openapi.py

@@ -4,6 +4,8 @@
 from django_filters import CharFilter
 from django_filters.rest_framework import DjangoFilterBackend, FilterSet
 from drf_spectacular.generators import SchemaGenerator
+from drf_spectacular.types import OpenApiTypes
+from drf_spectacular.utils import PolymorphicProxySerializer, extend_schema
 from rest_framework import serializers
 from rest_framework.authentication import BasicAuthentication
 from rest_framework.generics import GenericAPIView, ListAPIView
@@ -118,6 +120,102 @@ def test_no_validation_error_for_unsafe_method():
     assert "400" not in responses
 
 
+class OpenAPITypesView(GenericAPIView):
+    # ensure that 400 is not added due to the parser classes by using a parser
+    # that does not raise a ParseError which results in adding a 400 error response
+    parser_classes = [CustomParser]
+
+    @extend_schema(request=OpenApiTypes.OBJECT, responses={204: None})
+    def post(self, request, *args, **kwargs):
+        return Response(status=204)
+
+
+def test_no_error_raised_when_request_serializer_is_set_as_openapi_type():
+    route = "validate/"
+    view = OpenAPITypesView.as_view()
+    try:
+        generate_view_schema(route, view)
+    except Exception:
+        pytest.fail(
+            "Schema generation failed when using `@extend_schema(request.OpenApiTypes.OBJECT)`"
+        )
+
+
+class Object1Serializer(serializers.Serializer):
+    type = serializers.CharField()
+    field1 = serializers.IntegerField()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.error_messages.update(object1_code="first error")
+
+
+class Object2Serializer(serializers.Serializer):
+    type = serializers.CharField()
+    field2 = serializers.DateField()
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.error_messages.update(object2_code="second error")
+
+
+class PolymorphicView(GenericAPIView):
+    # ensure that 400 is not added due to the parser classes by using a parser
+    # that does not raise a ParseError which results in adding a 400 error response
+    parser_classes = [CustomParser]
+
+    @extend_schema(
+        request=PolymorphicProxySerializer(
+            component_name="Object",
+            serializers={"object1": Object1Serializer, "object2": Object2Serializer},
+            resource_type_field_name="type",
+        ),
+        responses={204: None},
+    )
+    def post(self, request, *args, **kwargs):
+        return Response(status=204)
+
+    @extend_schema(
+        request=PolymorphicProxySerializer(
+            component_name="AnotherObject",
+            serializers=[Object1Serializer, Object2Serializer],
+            resource_type_field_name="type",
+        ),
+        responses={204: None},
+    )
+    def patch(self, request, *args, **kwargs):
+        return Response(status=204)
+
+
+def test_error_codes_for_polymorphic_serializer():
+    """
+    For polymorphic serializers, the fields from the actual serializers are combined.
+    Also, when the same field exists in multiple serializers in a polymorphic serializer,
+    their error codes should be combined.
+
+    This test checks that fields from both serializers are present. It also checks that
+    the error codes of non_field_errors from both serializers are combined.
+    """
+    route = "validate/"
+    view = PolymorphicView.as_view()
+    schema = generate_view_schema(route, view)
+
+    mapping = schema["components"]["schemas"]["ValidateCreateError"]["discriminator"][
+        "mapping"
+    ]
+    assert set(mapping) == {"non_field_errors", "type", "field1", "field2"}
+
+    create_error_codes = schema["components"]["schemas"][
+        "ValidateCreateNonFieldErrorsErrorComponent"
+    ]["properties"]["code"]["enum"]
+    assert set(create_error_codes) == {"invalid", "object1_code", "object2_code"}
+
+    patch_error_codes = schema["components"]["schemas"][
+        "ValidatePartialUpdateNonFieldErrorsErrorComponent"
+    ]["properties"]["code"]["enum"]
+    assert set(patch_error_codes) == {"invalid", "object1_code", "object2_code"}
+
+
 class CustomFilterSet(FilterSet):
     first_name = CharFilter()