Improve polymorphic relations and tests.

Author: leo-naeka

docs/usage.md

@@ -471,6 +471,14 @@ class CompanySerializer(serializers.ModelSerializer):
 They must be explicitely declared with the `polymorphic_serializer` (first positional argument) correctly defined.
 It must be a subclass of `serializers.PolymorphicModelSerializer`.
 
+<div class="warning">
+    <strong>Note:</strong>
+    Polymorphic resources are not compatible with
+    <code class="docutils literal">
+        <span class="pre">resource_name</span>
+    </code>
+    defined on the view.
+</div>
 
 ### Meta
 

example/serializers.py

@@ -115,8 +115,10 @@ class Meta:
 
 
 class CompanySerializer(serializers.ModelSerializer):
-    current_project = relations.PolymorphicResourceRelatedField(ProjectSerializer, queryset=models.Project.objects.all())
-    future_projects = relations.PolymorphicResourceRelatedField(ProjectSerializer, queryset=models.Project.objects.all(), many=True)
+    current_project = relations.PolymorphicResourceRelatedField(
+        ProjectSerializer, queryset=models.Project.objects.all())
+    future_projects = relations.PolymorphicResourceRelatedField(
+        ProjectSerializer, queryset=models.Project.objects.all(), many=True)
 
     included_serializers = {
         'current_project': ProjectSerializer,

example/tests/integration/test_polymorphism.py

@@ -73,6 +73,29 @@ def test_polymorphism_on_polymorphic_model_list_post(client):
     assert content['data']['attributes']['artist'] == test_artist
 
 
+def test_invalid_type_on_polymorphic_model(client):
+    test_topic = 'New test topic {}'.format(random.randint(0, 999999))
+    test_artist = 'test-{}'.format(random.randint(0, 999999))
+    url = reverse('project-list')
+    data = {
+        'data': {
+            'type': 'invalidProjects',
+            'attributes': {
+                'topic': test_topic,
+                'artist': test_artist
+            }
+        }
+    }
+    response = client.post(url, data=json.dumps(data), content_type='application/vnd.api+json')
+    assert response.status_code == 409
+    content = load_json(response.content)
+    assert len(content["errors"]) is 1
+    assert content["errors"][0]["status"] == "409"
+    assert content["errors"][0]["detail"] == \
+        "The resource object's type (invalidProjects) is not the type that constitute the " \
+        "collection represented by the endpoint (one of [researchProjects, artProjects])."
+
+
 def test_polymorphism_relations_update(single_company, research_project_factory, client):
     response = client.get(reverse("company-detail", kwargs={'pk': single_company.pk}))
     content = load_json(response.content)
@@ -85,7 +108,29 @@ def test_polymorphism_relations_update(single_company, research_project_factory,
     }
     response = client.put(reverse("company-detail", kwargs={'pk': single_company.pk}),
                           data=json.dumps(content), content_type='application/vnd.api+json')
-    assert response.status_code is 200
+    assert response.status_code == 200
     content = load_json(response.content)
     assert content["data"]["relationships"]["currentProject"]["data"]["type"] == "researchProjects"
-    assert int(content["data"]["relationships"]["currentProject"]["data"]["id"]) is research_project.pk
+    assert int(content["data"]["relationships"]["currentProject"]["data"]["id"]) == \
+        research_project.pk
+
+
+def test_invalid_type_on_polymorphic_relation(single_company, research_project_factory, client):
+    response = client.get(reverse("company-detail", kwargs={'pk': single_company.pk}))
+    content = load_json(response.content)
+    assert content["data"]["relationships"]["currentProject"]["data"]["type"] == "artProjects"
+
+    research_project = research_project_factory()
+    content["data"]["relationships"]["currentProject"]["data"] = {
+        "type": "invalidProjects",
+        "id": research_project.pk
+    }
+    response = client.put(reverse("company-detail", kwargs={'pk': single_company.pk}),
+                          data=json.dumps(content), content_type='application/vnd.api+json')
+    assert response.status_code == 409
+    content = load_json(response.content)
+    assert len(content["errors"]) is 1
+    assert content["errors"][0]["status"] == "409"
+    assert content["errors"][0]["detail"] == \
+        "Incorrect relation type. Expected one of [researchProjects, artProjects], " \
+        "received invalidProjects."

rest_framework_json_api/parsers.py

@@ -30,7 +30,8 @@ class JSONParser(parsers.JSONParser):
 
     @staticmethod
     def parse_attributes(data):
-        return utils.format_keys(data.get('attributes'), 'underscore') if data.get('attributes') else dict()
+        return utils.format_keys(
+            data.get('attributes'), 'underscore') if data.get('attributes') else dict()
 
     @staticmethod
     def parse_relationships(data):
@@ -59,40 +60,49 @@ def parse(self, stream, media_type=None, parser_context=None):
         """
         Parses the incoming bytestream as JSON and returns the resulting data
         """
-        result = super(JSONParser, self).parse(stream, media_type=media_type, parser_context=parser_context)
+        result = super(JSONParser, self).parse(
+            stream, media_type=media_type, parser_context=parser_context)
         data = result.get('data')
 
         if data:
             from rest_framework_json_api.views import RelationshipView
             if isinstance(parser_context['view'], RelationshipView):
-                # We skip parsing the object as JSONAPI Resource Identifier Object and not a regular Resource Object
+                # We skip parsing the object as JSONAPI Resource Identifier Object is not a
+                # regular Resource Object
                 if isinstance(data, list):
                     for resource_identifier_object in data:
-                        if not (resource_identifier_object.get('id') and resource_identifier_object.get('type')):
-                            raise ParseError(
-                                'Received data contains one or more malformed JSONAPI Resource Identifier Object(s)'
-                            )
+                        if not (resource_identifier_object.get('id') and
+                                resource_identifier_object.get('type')):
+                            raise ParseError('Received data contains one or more malformed '
+                                             'JSONAPI Resource Identifier Object(s)')
                 elif not (data.get('id') and data.get('type')):
-                    raise ParseError('Received data is not a valid JSONAPI Resource Identifier Object')
+                    raise ParseError('Received data is not a valid '
+                                     'JSONAPI Resource Identifier Object')
 
                 return data
 
             request = parser_context.get('request')
 
             # Check for inconsistencies
-            resource_name = utils.get_resource_name(parser_context)
-            if isinstance(resource_name, six.string_types):
-                doesnt_match = data.get('type') != resource_name
-            else:
-                doesnt_match = data.get('type') not in resource_name
-            if doesnt_match and request.method in ('PUT', 'POST', 'PATCH'):
-                raise exceptions.Conflict(
-                    "The resource object's type ({data_type}) is not the type "
-                    "that constitute the collection represented by the endpoint ({resource_type}).".format(
-                        data_type=data.get('type'),
-                        resource_type=resource_name
-                    )
-                )
+            if request.method in ('PUT', 'POST', 'PATCH'):
+                resource_name = utils.get_resource_name(
+                    parser_context, expand_polymorphic_types=True)
+                if isinstance(resource_name, six.string_types):
+                    if data.get('type') != resource_name:
+                        raise exceptions.Conflict(
+                            "The resource object's type ({data_type}) is not the type that "
+                            "constitute the collection represented by the endpoint "
+                            "({resource_type}).".format(
+                                data_type=data.get('type'),
+                                resource_type=resource_name))
+                else:
+                    if data.get('type') not in resource_name:
+                        raise exceptions.Conflict(
+                            "The resource object's type ({data_type}) is not the type that "
+                            "constitute the collection represented by the endpoint "
+                            "(one of [{resource_types}]).".format(
+                                data_type=data.get('type'),
+                                resource_types=", ".join(resource_name)))
             if not data.get('id') and request.method in ('PATCH', 'PUT'):
                 raise ParseError("The resource identifier object must contain an 'id' member")
 

rest_framework_json_api/relations.py

@@ -22,7 +22,6 @@ class ResourceRelatedField(PrimaryKeyRelatedField):
         'does_not_exist': _('Invalid pk "{pk_value}" - object does not exist.'),
         'incorrect_type': _('Incorrect type. Expected resource identifier object, received {data_type}.'),
         'incorrect_relation_type': _('Incorrect relation type. Expected {relation_type}, received {received_type}.'),
-        # 'incorrect_poly_relation_type': _('Incorrect relation type. Expected one of {relation_type}, received {received_type}.'),
         'missing_type': _('Invalid resource identifier object: missing \'type\' attribute'),
         'missing_id': _('Invalid resource identifier object: missing \'id\' attribute'),
         'no_match': _('Invalid hyperlink - No URL match.'),
@@ -185,7 +184,7 @@ class PolymorphicResourceRelatedField(ResourceRelatedField):
 
     _skip_polymorphic_optimization = False
     default_error_messages = dict(ResourceRelatedField.default_error_messages, **{
-        'incorrect_relation_type': _('Incorrect relation type. Expected one of {relation_type}, '
+        'incorrect_relation_type': _('Incorrect relation type. Expected one of [{relation_type}], '
                                      'received {received_type}.'),
     })
 
@@ -209,7 +208,7 @@ def to_internal_value(self, data):
         if 'id' not in data:
             self.fail('missing_id')
 
-        expected_relation_types = get_resource_type_from_serializer(self.polymorphic_serializer)
+        expected_relation_types = self.polymorphic_serializer.get_polymorphic_types()
 
         if data['type'] not in expected_relation_types:
             self.conflict('incorrect_relation_type', relation_type=", ".join(

rest_framework_json_api/serializers.py

@@ -187,11 +187,12 @@ def __new__(cls, name, bases, attrs):
             serializer: serializer.Meta.model for serializer in polymorphic_serializers}
         model_to_serializer = {
             serializer.Meta.model: serializer for serializer in polymorphic_serializers}
-        type_to_model = {
-            get_resource_type_from_model(model): model for model in model_to_serializer.keys()}
+        type_to_serializer = {
+            get_resource_type_from_serializer(serializer): serializer for
+            serializer in polymorphic_serializers}
         setattr(new_class, '_poly_serializer_model_map', serializer_to_model)
         setattr(new_class, '_poly_model_serializer_map', model_to_serializer)
-        setattr(new_class, '_poly_type_model_map', type_to_model)
+        setattr(new_class, '_poly_type_serializer_map', type_to_serializer)
         return new_class
 
 
@@ -213,51 +214,62 @@ def get_fields(self):
                 raise Exception("Cannot get fields from a polymorphic serializer given a queryset")
         return super(PolymorphicModelSerializer, self).get_fields()
 
-    def get_polymorphic_serializer_for_instance(self, instance):
+    @classmethod
+    def get_polymorphic_serializer_for_instance(cls, instance):
         """
         Return the polymorphic serializer associated with the given instance/model.
         Raise `NotImplementedError` if no serializer is found for the given model. This usually
         means that a serializer is missing in the class's `polymorphic_serializers` attribute.
         """
         try:
-            return self._poly_model_serializer_map[instance._meta.model]
+            return cls._poly_model_serializer_map[instance._meta.model]
         except KeyError:
             raise NotImplementedError(
                 "No polymorphic serializer has been found for model {}".format(
                     instance._meta.model.__name__))
 
-    def get_polymorphic_model_for_serializer(self, serializer):
+    @classmethod
+    def get_polymorphic_model_for_serializer(cls, serializer):
         """
         Return the polymorphic model associated with the given serializer.
         Raise `NotImplementedError` if no model is found for the given serializer. This usually
         means that a serializer is missing in the class's `polymorphic_serializers` attribute.
         """
         try:
-            return self._poly_serializer_model_map[serializer]
+            return cls._poly_serializer_model_map[serializer]
         except KeyError:
             raise NotImplementedError(
                 "No polymorphic model has been found for serializer {}".format(serializer.__name__))
 
-    def get_polymorphic_model_for_type(self, obj_type):
+    @classmethod
+    def get_polymorphic_serializer_for_type(cls, obj_type):
         """
-        Return the polymorphic model associated with the given type.
-        Raise `NotImplementedError` if no model is found for the given type. This usually
+        Return the polymorphic serializer associated with the given type.
+        Raise `NotImplementedError` if no serializer is found for the given type. This usually
         means that a serializer is missing in the class's `polymorphic_serializers` attribute.
         """
         try:
-            return self._poly_type_model_map[obj_type]
+            return cls._poly_type_serializer_map[obj_type]
         except KeyError:
             raise NotImplementedError(
-                "No polymorphic model has been found for type {}".format(obj_type))
+                "No polymorphic serializer has been found for type {}".format(obj_type))
 
-    def get_polymorphic_serializer_for_type(self, obj_type):
+    @classmethod
+    def get_polymorphic_model_for_type(cls, obj_type):
         """
-        Return the polymorphic serializer associated with the given type.
-        Raise `NotImplementedError` if no serializer is found for the given type. This usually
+        Return the polymorphic model associated with the given type.
+        Raise `NotImplementedError` if no model is found for the given type. This usually
         means that a serializer is missing in the class's `polymorphic_serializers` attribute.
         """
-        return self.get_polymorphic_serializer_for_instance(
-            self.get_polymorphic_model_for_type(obj_type))
+        return cls.get_polymorphic_model_for_serializer(
+            cls.get_polymorphic_serializer_for_type(obj_type))
+
+    @classmethod
+    def get_polymorphic_types(cls):
+        """
+        Return the list of accepted types.
+        """
+        return cls._poly_type_serializer_map.keys()
 
     def to_representation(self, instance):
         """
@@ -272,10 +284,10 @@ def to_internal_value(self, data):
         appropriate polymorphic serializer and use this to handle internal value.
         """
         received_type = data.get('type')
-        expected_types = self._poly_type_model_map.keys()
+        expected_types = self.get_polymorphic_types()
         if received_type not in expected_types:
             raise Conflict(
-                'Incorrect relation type. Expected on of {expected_types}, '
+                'Incorrect relation type. Expected on of [{expected_types}], '
                 'received {received_type}.'.format(
                     expected_types=', '.join(expected_types), received_type=received_type))
         serializer_class = self.get_polymorphic_serializer_for_type(received_type)

rest_framework_json_api/utils.py

@@ -32,10 +32,11 @@
     POLYMORPHIC_ANCESTORS += (ancestor_class,)
 
 
-def get_resource_name(context):
+def get_resource_name(context, expand_polymorphic_types=False):
     """
     Return the name of a resource.
     """
+    from . import serializers
     view = context.get('view')
 
     # Sanity check to make sure we have a view.
@@ -57,7 +58,11 @@ def get_resource_name(context):
     except AttributeError:
         try:
             serializer = view.get_serializer_class()
-            return get_resource_type_from_serializer(serializer)
+            if issubclass(serializer, serializers.PolymorphicModelSerializer) and \
+                    expand_polymorphic_types:
+                return serializer.get_polymorphic_types()
+            else:
+                return get_resource_type_from_serializer(serializer)
         except AttributeError:
             try:
                 resource_name = get_resource_type_from_model(view.model)
@@ -246,9 +251,7 @@ def get_resource_type_from_manager(manager):
 def get_resource_type_from_serializer(serializer):
     json_api_meta = getattr(serializer, 'JSONAPIMeta', None)
     meta = getattr(serializer, 'Meta', None)
-    if hasattr(serializer, 'polymorphic_serializers'):
-        return [get_resource_type_from_serializer(s) for s in serializer.polymorphic_serializers]
-    elif hasattr(json_api_meta, 'resource_name'):
+    if hasattr(json_api_meta, 'resource_name'):
         return json_api_meta.resource_name
     elif hasattr(meta, 'resource_name'):
         return meta.resource_name