Merge stashed changes

Author: Leifur Halldor Asgeirsson

example/tests/test_serializers.py

@@ -0,0 +1,73 @@
+from django.test import TestCase
+from django.utils import timezone
+
+from rest_framework_json_api.utils import format_relation_name
+from rest_framework_json_api.serializers import ResourceIdentifierObjectSerializer
+
+from example.models import Blog, Entry, Author
+
+
+class TestResourceIdentifierObjectSerializer(TestCase):
+    def setUp(self):
+        self.blog = Blog.objects.create(name='Some Blog', tagline="It's a blog")
+        self.entry = Entry.objects.create(
+            blog=self.blog,
+            headline='headline',
+            body_text='body_text',
+            pub_date=timezone.now(),
+            mod_date=timezone.now(),
+            n_comments=0,
+            n_pingbacks=0,
+            rating=3
+        )
+        for i in range(1,6):
+            name = 'some_author{}'.format(i)
+            self.entry.authors.add(
+                Author.objects.create(name=name, email='{}@example.org'.format(name))
+            )
+
+    def test_data_in_correct_format_when_instantiated_with_blog_object(self):
+        serializer = ResourceIdentifierObjectSerializer(instance=self.blog)
+
+        expected_data = {'type': format_relation_name('Blog'), 'id': str(self.blog.id)}
+
+        assert serializer.data == expected_data
+
+    def test_data_in_correct_format_when_instantiated_with_entry_object(self):
+        serializer = ResourceIdentifierObjectSerializer(instance=self.entry)
+
+        expected_data = {'type': format_relation_name('Entry'), 'id': str(self.entry.id)}
+
+        assert serializer.data == expected_data
+
+    def test_deserialize_primitive_data_blog(self):
+        initial_data = {
+            'type': format_relation_name('Blog'),
+            'id': str(self.blog.id)
+        }
+        serializer = ResourceIdentifierObjectSerializer(data=initial_data, model_class=Blog)
+
+        self.assertTrue(serializer.is_valid(), msg=serializer.errors)
+        assert serializer.validated_data == self.blog
+
+    def test_data_in_correct_format_when_instantiated_with_queryset(self):
+        qs = Author.objects.all()
+        serializer = ResourceIdentifierObjectSerializer(instance=qs, many=True)
+
+        type_string = format_relation_name('Author')
+        author_pks = Author.objects.values_list('pk', flat=True)
+        expected_data = [{'type': type_string, 'id': str(pk)} for pk in author_pks]
+
+        assert serializer.data == expected_data
+
+    def test_deserialize_many(self):
+        type_string = format_relation_name('Author')
+        author_pks = Author.objects.values_list('pk', flat=True)
+        initial_data = [{'type': type_string, 'id': str(pk)} for pk in author_pks]
+
+        serializer = ResourceIdentifierObjectSerializer(data=initial_data, model_class=Author, many=True)
+
+        self.assertTrue(serializer.is_valid(), msg=serializer.errors)
+
+        print(serializer.data)
+

example/tests/test_views.py

@@ -0,0 +1,37 @@
+from django.utils import timezone
+from rest_framework.test import APITestCase
+
+from rest_framework_json_api.utils import format_relation_name
+
+from example.models import Blog, Entry
+from example.views import EntryRelationshipView, BlogRelationshipView
+
+
+class TestRelationshipView(APITestCase):
+
+    def setUp(self):
+        self.blog = Blog.objects.create(name='Some Blog', tagline="It's a blog")
+        self.entry = Entry.objects.create(
+            blog=self.blog,
+            headline='headline',
+            body_text='body_text',
+            pub_date=timezone.now(),
+            mod_date=timezone.now(),
+            n_comments=0,
+            n_pingbacks=0,
+            rating=3
+        )
+
+    def test_get_entry_relationship_blog(self):
+        response = self.client.get('/entries/{}/relationships/blog'.format(self.entry.id))
+        expected_data = {'type': format_relation_name('Blog'), 'id': str(self.entry.blog.id)}
+
+        assert response.data == expected_data
+
+    def test_get_entry_relationship_invalid_field(self):
+        response = self.client.get('/entries/{}/relationships/invalid_field'.format(self.entry.id))
+
+        assert response.status_code == 404
+
+    def test_get_blog_relationship_entry_set(self):
+        response = self.client.get('/blogs/{}/relationships/entry_set'.format(self.blog.id))

example/urls.py

@@ -1,7 +1,8 @@
 from django.conf.urls import include, url
 from rest_framework import routers
 
-from example.views import BlogViewSet, EntryViewSet, AuthorViewSet
+from example.views import BlogViewSet, EntryViewSet, AuthorViewSet, EntryRelationshipView, BlogRelationshipView
+
 
 router = routers.DefaultRouter(trailing_slash=False)
 
@@ -11,4 +12,8 @@
 
 urlpatterns = [
     url(r'^', include(router.urls)),
+
+    url(r'^entries/(?P<pk>[^/.]+)/relationships/(?P<related_field>\w+)', EntryRelationshipView.as_view()),
+    url(r'^blogs/(?P<pk>[^/.]+)/relationships/(?P<related_field>\w+)', BlogRelationshipView.as_view())
+
 ]

example/views.py

@@ -1,4 +1,5 @@
 from rest_framework import viewsets
+from rest_framework_json_api.views import RelationshipView
 from example.models import Blog, Entry, Author
 from example.serializers import BlogSerializer, EntrySerializer, AuthorSerializer
 
@@ -19,3 +20,10 @@ class AuthorViewSet(viewsets.ModelViewSet):
     queryset = Author.objects.all()
     serializer_class = AuthorSerializer
 
+
+
+class EntryRelationshipView(RelationshipView):
+    queryset = Entry.objects
+
+class BlogRelationshipView(RelationshipView):
+    queryset = Blog.objects

rest_framework_json_api/serializers.py

@@ -1,4 +1,6 @@
+from django.utils.translation import ugettext_lazy as _
 from rest_framework.serializers import *
+from rest_framework_json_api.utils import format_relation_name, get_resource_type_from_instance
 
 from rest_framework_json_api.relations import HyperlinkedRelatedField
 
@@ -13,3 +15,34 @@ class HyperlinkedModelSerializer(HyperlinkedModelSerializer):
     * Uses django-rest-framework-json-api HyperlinkedRelatedField instead of the default HyperlinkedRelatedField
     """
     serializer_related_field = HyperlinkedRelatedField
+
+
+class ResourceIdentifierObjectSerializer(BaseSerializer):
+    default_error_messages = {
+        'incorrect_model_type': _('Incorrect model type. Expected {model_type}, received {received_type}.'),
+        'does_not_exist': _('Invalid pk "{pk_value}" - object does not exist.'),
+        'incorrect_type': _('Incorrect type. Expected pk value, received {data_type}.'),
+    }
+
+    def __init__(self, *args, **kwargs):
+        self.model_class = kwargs.pop('model_class', None)
+        if 'instance' not in kwargs and not self.model_class:
+            raise RuntimeError('ResourceIdentifierObjectsSerializer must be initialized with a model class.')
+        super(ResourceIdentifierObjectSerializer, self).__init__(*args, **kwargs)
+
+    def to_representation(self, instance):
+        return {
+            'type': format_relation_name(get_resource_type_from_instance(instance)),
+            'id': str(instance.pk)
+        }
+
+    def to_internal_value(self, data):
+        if data['type'] != format_relation_name(self.model_class.__name__):
+            self.fail('incorrect_model_type', model_type=self.model_class, received_type=data['type'])
+        pk = data['id']
+        try:
+            return self.model_class.objects.get(pk=pk)
+        except ObjectDoesNotExist:
+            self.fail('does_not_exist', pk_value=pk)
+        except (TypeError, ValueError):
+            self.fail('incorrect_type', data_type=type(data['pk']).__name__)

rest_framework_json_api/views.py

@@ -1,10 +1,17 @@
 from rest_framework import generics
 from rest_framework.response import Response
+from rest_framework_json_api.serializers import ResourceIdentifierObjectSerializer
+from rest_framework.exceptions import NotFound
 
 
 class RelationshipView(generics.GenericAPIView):
+    serializer_class = ResourceIdentifierObjectSerializer
+
     def get(self, request, *args, **kwargs):
-        return Response()
+        related_instance = self.get_related_instance(kwargs)
+        serializer_class = self.get_serializer_class()
+        serializer = serializer_class(instance=related_instance)
+        return Response(serializer.data)
 
     def put(self, request, *args, **kwargs):
         return Response()
@@ -17,3 +24,9 @@ def post(self, request, *args, **kwargs):
 
     def delete(self, request, *args, **kwargs):
         return Response()
+
+    def get_related_instance(self, kwargs):
+        try:
+            return getattr(self.get_object(), kwargs['related_field'])
+        except AttributeError:
+            raise NotFound