combine fields from sub-serializers in a polymorphic serializer, and if the same field exists in more than one sub-serializer, combine their error codes so all error codes are visible in the resulting schema

Author: ghazi-git

docs/changelog.md

@@ -6,8 +6,8 @@ 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 using `@extend_schema(request=OpenApiTypes.STR)`
-when determining error codes for validation errors.
+- 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_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

@@ -5,7 +5,7 @@
 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 extend_schema
+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
@@ -141,6 +141,81 @@ def test_no_error_raised_when_request_serializer_is_set_as_openapi_type():
         )
 
 
+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()