test_relations.py

from __future__ import absolute_import

from django.test.client import RequestFactory
from django.utils import timezone
from rest_framework import serializers
from rest_framework.fields import SkipField
from rest_framework.reverse import reverse

from rest_framework_json_api.relations import (
    HyperlinkedRelatedField,
    ResourceRelatedField,
    SerializerMethodHyperlinkedRelatedField,
)

from . import TestBase
from example.models import Author, Blog, Comment, Entry
from example.views import EntryViewSet


class TestHyperlinkedFieldBase(TestBase):
    def setUp(self):
        super(TestHyperlinkedFieldBase, self).setUp()
        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,
        )
        self.comment = Comment.objects.create(
            entry=self.entry,
            body="testing one two three",
        )

        self.request = RequestFactory().get(
            reverse("entry-detail", kwargs={"pk": self.entry.pk})
        )
        self.view = EntryViewSet(
            request=self.request, kwargs={"entry_pk": self.entry.id}
        )


class TestHyperlinkedRelatedField(TestHyperlinkedFieldBase):
    def test_single_hyperlinked_related_field(self):
        field = HyperlinkedRelatedField(
            related_link_view_name="entry-blog",
            related_link_url_kwarg="entry_pk",
            self_link_view_name="entry-relationships",
            read_only=True,
        )
        field._context = {"request": self.request, "view": self.view}
        field.field_name = "blog"

        self.assertRaises(NotImplementedError, field.to_representation, self.entry)
        self.assertRaises(SkipField, field.get_attribute, self.entry)

        links_expected = {
            "self": "http://testserver/entries/{}/relationships/blog".format(
                self.entry.pk
            ),
            "related": "http://testserver/entries/{}/blog".format(self.entry.pk),
        }
        got = field.get_links(self.entry)
        self.assertEqual(got, links_expected)

    def test_many_hyperlinked_related_field(self):
        field = HyperlinkedRelatedField(
            related_link_view_name="entry-comments",
            related_link_url_kwarg="entry_pk",
            self_link_view_name="entry-relationships",
            read_only=True,
            many=True,
        )
        field._context = {"request": self.request, "view": self.view}
        field.field_name = "comments"

        self.assertRaises(
            NotImplementedError, field.to_representation, self.entry.comments.all()
        )
        self.assertRaises(SkipField, field.get_attribute, self.entry)

        links_expected = {
            "self": "http://testserver/entries/{}/relationships/comments".format(
                self.entry.pk
            ),
            "related": "http://testserver/entries/{}/comments".format(self.entry.pk),
        }
        got = field.child_relation.get_links(self.entry)
        self.assertEqual(got, links_expected)


class TestSerializerMethodHyperlinkedRelatedField(TestHyperlinkedFieldBase):
    def test_single_serializer_method_hyperlinked_related_field(self):
        serializer = EntryModelSerializerWithHyperLinks(
            instance=self.entry, context={"request": self.request, "view": self.view}
        )
        field = serializer.fields["blog"]

        self.assertRaises(NotImplementedError, field.to_representation, self.entry)
        self.assertRaises(SkipField, field.get_attribute, self.entry)

        expected = {
            "self": "http://testserver/entries/{}/relationships/blog".format(
                self.entry.pk
            ),
            "related": "http://testserver/entries/{}/blog".format(self.entry.pk),
        }
        got = field.get_links(self.entry)
        self.assertEqual(got, expected)

    def test_many_serializer_method_hyperlinked_related_field(self):
        serializer = EntryModelSerializerWithHyperLinks(
            instance=self.entry, context={"request": self.request, "view": self.view}
        )
        field = serializer.fields["comments"]

        self.assertRaises(NotImplementedError, field.to_representation, self.entry)
        self.assertRaises(SkipField, field.get_attribute, self.entry)

        expected = {
            "self": "http://testserver/entries/{}/relationships/comments".format(
                self.entry.pk
            ),
            "related": "http://testserver/entries/{}/comments".format(self.entry.pk),
        }
        got = field.get_links(self.entry)
        self.assertEqual(got, expected)

    def test_get_blog(self):
        serializer = EntryModelSerializerWithHyperLinks(instance=self.entry)
        got = serializer.get_blog(self.entry)
        expected = self.entry.blog

        self.assertEqual(got, expected)

    def test_get_comments(self):
        serializer = EntryModelSerializerWithHyperLinks(instance=self.entry)
        got = serializer.get_comments(self.entry)
        expected = self.entry.comments.all()

        self.assertListEqual(list(got), list(expected))


class BlogResourceRelatedField(ResourceRelatedField):
    def get_queryset(self):
        return Blog.objects


class BlogFKSerializer(serializers.Serializer):
    blog = BlogResourceRelatedField()


class EntryFKSerializer(serializers.Serializer):
    entry = ResourceRelatedField(queryset=Entry.objects)


class EntryModelSerializer(serializers.ModelSerializer):
    authors = ResourceRelatedField(many=True, queryset=Author.objects)
    comments = ResourceRelatedField(many=True, read_only=True)

    class Meta:
        model = Entry
        fields = ("authors", "comments")


class EntryModelSerializerWithHyperLinks(serializers.ModelSerializer):
    blog = SerializerMethodHyperlinkedRelatedField(
        related_link_view_name="entry-blog",
        related_link_url_kwarg="entry_pk",
        self_link_view_name="entry-relationships",
        many=True,
    )
    comments = SerializerMethodHyperlinkedRelatedField(
        related_link_view_name="entry-comments",
        related_link_url_kwarg="entry_pk",
        self_link_view_name="entry-relationships",
        many=True,
    )

    class Meta:
        model = Entry
        fields = (
            "blog",
            "comments",
        )

    def get_blog(self, obj):
        return obj.blog

    def get_comments(self, obj):
        return obj.comments.all()