test_relations.py

from __future__ importabsolute_import

fromdjango.utilsimporttimezone
fromrest_frameworkimportserializers

from . importTestBase
fromrest_framework_json_api.exceptionsimportConflict
fromrest_framework_json_api.utilsimportformat_resource_type
fromexample.modelsimportBlog, Entry, Comment, Author
fromexample.serializersimportCommentSerializer
fromrest_framework_json_api.relationsimportResourceRelatedField


classTestResourceRelatedField(TestBase):

defsetUp(self):
super(TestResourceRelatedField, 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
 )
foriinrange(1,6):
name='some_author{}'.format(i)
self.entry.authors.add(
Author.objects.create(name=name, email='{}@example.org'.format(name))
 )

self.comment=Comment.objects.create(
entry=self.entry,
body='testing one two three',
author=Author.objects.first()
 )

deftest_data_in_correct_format_when_instantiated_with_blog_object(self):
serializer=BlogFKSerializer(instance={'blog': self.blog})

expected_data= {
'type': format_resource_type('Blog'),
'id': str(self.blog.id)
 }

actual_data=serializer.data['blog']

self.assertEqual(actual_data, expected_data)

deftest_data_in_correct_format_when_instantiated_with_entry_object(self):
serializer=EntryFKSerializer(instance={'entry': self.entry})

expected_data= {
'type': format_resource_type('Entry'),
'id': str(self.entry.id)
 }

actual_data=serializer.data['entry']

self.assertEqual(actual_data, expected_data)

deftest_deserialize_primitive_data_blog(self):
serializer=BlogFKSerializer(data={
'blog': {
'type': format_resource_type('Blog'),
'id': str(self.blog.id)
 }
 }
 )

self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data['blog'], self.blog)

deftest_validation_fails_for_wrong_type(self):
withself.assertRaises(Conflict) ascm:
serializer=BlogFKSerializer(data={
'blog': {
'type': 'Entries',
'id': str(self.blog.id)
 }
 }
 )
serializer.is_valid()
the_exception=cm.exception
self.assertEqual(the_exception.status_code, 409)

deftest_serialize_many_to_many_relation(self):
serializer=EntryModelSerializer(instance=self.entry)

type_string=format_resource_type('Author')
author_pks=Author.objects.values_list('pk', flat=True)
expected_data= [{'type': type_string, 'id': str(pk)} forpkinauthor_pks]

self.assertEqual(
serializer.data['authors'],
expected_data
 )

deftest_deserialize_many_to_many_relation(self):
type_string=format_resource_type('Author')
author_pks=Author.objects.values_list('pk', flat=True)
authors= [{'type': type_string, 'id': pk} forpkinauthor_pks]

serializer=EntryModelSerializer(data={'authors': authors, 'comment_set': []})

self.assertTrue(serializer.is_valid())
self.assertEqual(len(serializer.validated_data['authors']), Author.objects.count())
forauthorinserializer.validated_data['authors']:
self.assertIsInstance(author, Author)

deftest_read_only(self):
serializer=EntryModelSerializer(data={'authors': [], 'comment_set': [{'type': 'Comments', 'id': 2}]})
serializer.is_valid(raise_exception=True)
self.assertNotIn('comment_set', serializer.validated_data)

deftest_invalid_resource_id_object(self):
comment= {'body': 'testing 123', 'entry': {'type': 'entry'}, 'author': {'id': '5'}}
serializer=CommentSerializer(data=comment)
assertnotserializer.is_valid()
assertserializer.errors== {
'author': ["Invalid resource identifier object: missing 'type' attribute"],
'entry': ["Invalid resource identifier object: missing 'id' attribute"]
 }


classBlogFKSerializer(serializers.Serializer):
blog=ResourceRelatedField(queryset=Blog.objects)


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


classEntryModelSerializer(serializers.ModelSerializer):
authors=ResourceRelatedField(many=True, queryset=Author.objects)
comment_set=ResourceRelatedField(many=True, read_only=True)

classMeta:
model=Entry
fields= ('authors', 'comment_set')