Skip to content

D
django-rest-framework
Commit 093febb9 by Tom Christie
Options

Tests for relational fields

parent 3fa4a189
Showing with 1168 additions and 1155 deletions
rest_framework/fields.py
from django import forms from django import forms
from django.conf import settings from django.conf import settings
from django.core import validators from django.core import validators
from django.core.exceptions import ValidationError from django.core.exceptions import ObjectDoesNotExist, ValidationError
from django.utils import six, timezone from django.utils import six, timezone
from django.utils.datastructures import SortedDict from django.utils.datastructures import SortedDict
from django.utils.dateparse import parse_date, parse_datetime, parse_time from django.utils.dateparse import parse_date, parse_datetime, parse_time
...@@ -54,6 +54,8 @@ def get_attribute(instance, attrs): ...@@ -54,6 +54,8 @@ def get_attribute(instance, attrs):
for attr in attrs: for attr in attrs:
try: try:
instance = getattr(instance, attr) instance = getattr(instance, attr)
except ObjectDoesNotExist:
return None
except AttributeError as exc: except AttributeError as exc:
try: try:
return instance[attr] return instance[attr]
...@@ -108,6 +110,7 @@ class Field(object): ...@@ -108,6 +110,7 @@ class Field(object):
default_validators = [] default_validators = []
default_empty_html = empty default_empty_html = empty
initial = None initial = None
coerce_blank_to_null = True
def __init__(self, read_only=False, write_only=False, def __init__(self, read_only=False, write_only=False,
required=None, default=empty, initial=empty, source=None, required=None, default=empty, initial=empty, source=None,
...@@ -245,6 +248,9 @@ class Field(object): ...@@ -245,6 +248,9 @@ class Field(object):
self.fail('required') self.fail('required')
return self.get_default() return self.get_default()
if data == '' and self.coerce_blank_to_null:
data = None
if data is None: if data is None:
if not self.allow_null: if not self.allow_null:
self.fail('null') self.fail('null')
...@@ -413,6 +419,7 @@ class CharField(Field): ...@@ -413,6 +419,7 @@ class CharField(Field):
'blank': _('This field may not be blank.') 'blank': _('This field may not be blank.')
} }
initial = '' initial = ''
coerce_blank_to_null = False
def __init__(self, **kwargs): def __init__(self, **kwargs):
self.allow_blank = kwargs.pop('allow_blank', False) self.allow_blank = kwargs.pop('allow_blank', False)
......
tests/test_relations_hyperlink.py
# from __future__ import unicode_literals from __future__ import unicode_literals
# from django.conf.urls import patterns, url from django.conf.urls import patterns, url
# from django.test import TestCase from django.test import TestCase
# from rest_framework import serializers from rest_framework import serializers
# from rest_framework.test import APIRequestFactory from rest_framework.test import APIRequestFactory
# from tests.models import ( from tests.models import (
# BlogPost, ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource,
# ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource
# NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource )
# )
factory = APIRequestFactory()
# factory = APIRequestFactory() request = factory.get('/') # Just to ensure we have a request in the serializer context
# request = factory.get('/') # Just to ensure we have a request in the serializer context
dummy_view = lambda request, pk: None
# def dummy_view(request, pk):
# pass urlpatterns = patterns(
'',
# urlpatterns = patterns( url(r'^dummyurl/(?P<pk>[0-9]+)/$', dummy_view, name='dummy-url'),
# '', url(r'^manytomanysource/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanysource-detail'),
# url(r'^dummyurl/(?P<pk>[0-9]+)/$', dummy_view, name='dummy-url'), url(r'^manytomanytarget/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanytarget-detail'),
# url(r'^manytomanysource/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanysource-detail'), url(r'^foreignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeysource-detail'),
# url(r'^manytomanytarget/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanytarget-detail'), url(r'^foreignkeytarget/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeytarget-detail'),
# url(r'^foreignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeysource-detail'), url(r'^nullableforeignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableforeignkeysource-detail'),
# url(r'^foreignkeytarget/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeytarget-detail'), url(r'^onetoonetarget/(?P<pk>[0-9]+)/$', dummy_view, name='onetoonetarget-detail'),
# url(r'^nullableforeignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableforeignkeysource-detail'), url(r'^nullableonetoonesource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableonetoonesource-detail'),
# url(r'^onetoonetarget/(?P<pk>[0-9]+)/$', dummy_view, name='onetoonetarget-detail'), )
# url(r'^nullableonetoonesource/(?P<pk>[0-9]+)/$', dummy_view, name='nullableonetoonesource-detail'),
# )
# ManyToMany
class ManyToManyTargetSerializer(serializers.HyperlinkedModelSerializer):
# # ManyToMany class Meta:
# class ManyToManyTargetSerializer(serializers.HyperlinkedModelSerializer): model = ManyToManyTarget
# class Meta: fields = ('url', 'name', 'sources')
# model = ManyToManyTarget
# fields = ('url', 'name', 'sources')
class ManyToManySourceSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
# class ManyToManySourceSerializer(serializers.HyperlinkedModelSerializer): model = ManyToManySource
# class Meta: fields = ('url', 'name', 'targets')
# model = ManyToManySource
# fields = ('url', 'name', 'targets')
# ForeignKey
class ForeignKeyTargetSerializer(serializers.HyperlinkedModelSerializer):
# # ForeignKey class Meta:
# class ForeignKeyTargetSerializer(serializers.HyperlinkedModelSerializer): model = ForeignKeyTarget
# class Meta: fields = ('url', 'name', 'sources')
# model = ForeignKeyTarget
# fields = ('url', 'name', 'sources')
class ForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer):
class Meta:
# class ForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): model = ForeignKeySource
# class Meta: fields = ('url', 'name', 'target')
# model = ForeignKeySource
# fields = ('url', 'name', 'target')
# Nullable ForeignKey
class NullableForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer):
# # Nullable ForeignKey class Meta:
# class NullableForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): model = NullableForeignKeySource
# class Meta: fields = ('url', 'name', 'target')
# model = NullableForeignKeySource
# fields = ('url', 'name', 'target')
# Nullable OneToOne
class NullableOneToOneTargetSerializer(serializers.HyperlinkedModelSerializer):
# # Nullable OneToOne class Meta:
# class NullableOneToOneTargetSerializer(serializers.HyperlinkedModelSerializer): model = OneToOneTarget
# class Meta: fields = ('url', 'name', 'nullable_source')
# model = OneToOneTarget
# fields = ('url', 'name', 'nullable_source')
# TODO: Add test that .data cannot be accessed prior to .is_valid
# # TODO: Add test that .data cannot be accessed prior to .is_valid class HyperlinkedManyToManyTests(TestCase):
urls = 'tests.test_relations_hyperlink'
# class HyperlinkedManyToManyTests(TestCase):
# urls = 'tests.test_relations_hyperlink' def setUp(self):
for idx in range(1, 4):
# def setUp(self): target = ManyToManyTarget(name='target-%d' % idx)
# for idx in range(1, 4): target.save()
# target = ManyToManyTarget(name='target-%d' % idx) source = ManyToManySource(name='source-%d' % idx)
# target.save() source.save()
# source = ManyToManySource(name='source-%d' % idx) for target in ManyToManyTarget.objects.all():
# source.save() source.targets.add(target)
# for target in ManyToManyTarget.objects.all():
# source.targets.add(target) def test_many_to_many_retrieve(self):
queryset = ManyToManySource.objects.all()
# def test_many_to_many_retrieve(self): serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request})
# queryset = ManyToManySource.objects.all() expected = [
# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']},
# expected = [ {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']},
# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}
# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, ]
# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_reverse_many_to_many_retrieve(self):
queryset = ManyToManyTarget.objects.all()
# def test_reverse_many_to_many_retrieve(self): serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request})
# queryset = ManyToManyTarget.objects.all() expected = [
# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']},
# expected = [ {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']},
# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}
# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, ]
# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_many_to_many_update(self):
data = {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}
# def test_many_to_many_update(self): instance = ManyToManySource.objects.get(pk=1)
# data = {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} serializer = ManyToManySourceSerializer(instance, data=data, context={'request': request})
# instance = ManyToManySource.objects.get(pk=1) self.assertTrue(serializer.is_valid())
# serializer = ManyToManySourceSerializer(instance, data=data, context={'request': request}) serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# serializer.save()
# self.assertEqual(serializer.data, data) # Ensure source 1 is updated, and everything else is as expected
queryset = ManyToManySource.objects.all()
# # Ensure source 1 is updated, and everything else is as expected serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request})
# queryset = ManyToManySource.objects.all() expected = [
# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']},
# expected = [ {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']},
# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}
# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, ]
# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_reverse_many_to_many_update(self):
data = {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']}
# def test_reverse_many_to_many_update(self): instance = ManyToManyTarget.objects.get(pk=1)
# data = {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']} serializer = ManyToManyTargetSerializer(instance, data=data, context={'request': request})
# instance = ManyToManyTarget.objects.get(pk=1) self.assertTrue(serializer.is_valid())
# serializer = ManyToManyTargetSerializer(instance, data=data, context={'request': request}) serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# serializer.save()
# self.assertEqual(serializer.data, data) # Ensure target 1 is updated, and everything else is as expected
queryset = ManyToManyTarget.objects.all()
# # Ensure target 1 is updated, and everything else is as expected serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request})
# queryset = ManyToManyTarget.objects.all() expected = [
# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']},
# expected = [ {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']},
# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']}, {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}
# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']},
# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} ]
self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_many_to_many_create(self):
data = {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']}
# def test_many_to_many_create(self): serializer = ManyToManySourceSerializer(data=data, context={'request': request})
# data = {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} self.assertTrue(serializer.is_valid())
# serializer = ManyToManySourceSerializer(data=data, context={'request': request}) obj = serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# obj = serializer.save() self.assertEqual(obj.name, 'source-4')
# self.assertEqual(serializer.data, data)
# self.assertEqual(obj.name, 'source-4') # Ensure source 4 is added, and everything else is as expected
queryset = ManyToManySource.objects.all()
# # Ensure source 4 is added, and everything else is as expected serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request})
# queryset = ManyToManySource.objects.all() expected = [
# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']},
# expected = [ {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']},
# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']},
# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']}
# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, ]
# {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_reverse_many_to_many_create(self):
data = {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']}
# def test_reverse_many_to_many_create(self): serializer = ManyToManyTargetSerializer(data=data, context={'request': request})
# data = {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} self.assertTrue(serializer.is_valid())
# serializer = ManyToManyTargetSerializer(data=data, context={'request': request}) obj = serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# obj = serializer.save() self.assertEqual(obj.name, 'target-4')
# self.assertEqual(serializer.data, data)
# self.assertEqual(obj.name, 'target-4') # Ensure target 4 is added, and everything else is as expected
queryset = ManyToManyTarget.objects.all()
# # Ensure target 4 is added, and everything else is as expected serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request})
# queryset = ManyToManyTarget.objects.all() expected = [
# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']},
# expected = [ {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']},
# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']},
# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']}
# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}, ]
# {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected)
class HyperlinkedForeignKeyTests(TestCase):
urls = 'tests.test_relations_hyperlink'
# class HyperlinkedForeignKeyTests(TestCase):
# urls = 'tests.test_relations_hyperlink' def setUp(self):
target = ForeignKeyTarget(name='target-1')
# def setUp(self): target.save()
# target = ForeignKeyTarget(name='target-1') new_target = ForeignKeyTarget(name='target-2')
# target.save() new_target.save()
# new_target = ForeignKeyTarget(name='target-2') for idx in range(1, 4):
# new_target.save() source = ForeignKeySource(name='source-%d' % idx, target=target)
# for idx in range(1, 4): source.save()
# source = ForeignKeySource(name='source-%d' % idx, target=target)
# source.save() def test_foreign_key_retrieve(self):
queryset = ForeignKeySource.objects.all()
# def test_foreign_key_retrieve(self): serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request})
# queryset = ForeignKeySource.objects.all() expected = [
# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'},
# expected = [ {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}
# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, ]
# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_reverse_foreign_key_retrieve(self):
queryset = ForeignKeyTarget.objects.all()
# def test_reverse_foreign_key_retrieve(self): serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request})
# queryset = ForeignKeyTarget.objects.all() expected = [
# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']},
# expected = [ {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []},
# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, ]
# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_foreign_key_update(self):
data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'}
# def test_foreign_key_update(self): instance = ForeignKeySource.objects.get(pk=1)
# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'} serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request})
# instance = ForeignKeySource.objects.get(pk=1) self.assertTrue(serializer.is_valid())
# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# self.assertEqual(serializer.data, data)
# serializer.save() # Ensure source 1 is updated, and everything else is as expected
queryset = ForeignKeySource.objects.all()
# # Ensure source 1 is updated, and everything else is as expected serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request})
# queryset = ForeignKeySource.objects.all() expected = [
# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'},
# expected = [ {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'}, {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}
# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, ]
# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_foreign_key_update_incorrect_type(self):
data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 2}
# def test_foreign_key_update_incorrect_type(self): instance = ForeignKeySource.objects.get(pk=1)
# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 2} serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request})
# instance = ForeignKeySource.objects.get(pk=1) self.assertFalse(serializer.is_valid())
# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected URL string, received int.']})
# self.assertFalse(serializer.is_valid())
# self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected url string, received int.']}) def test_reverse_foreign_key_update(self):
data = {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}
# def test_reverse_foreign_key_update(self): instance = ForeignKeyTarget.objects.get(pk=2)
# data = {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} serializer = ForeignKeyTargetSerializer(instance, data=data, context={'request': request})
# instance = ForeignKeyTarget.objects.get(pk=2) self.assertTrue(serializer.is_valid())
# serializer = ForeignKeyTargetSerializer(instance, data=data, context={'request': request}) # We shouldn't have saved anything to the db yet since save
# self.assertTrue(serializer.is_valid()) # hasn't been called.
# # We shouldn't have saved anything to the db yet since save queryset = ForeignKeyTarget.objects.all()
# # hasn't been called. new_serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request})
# queryset = ForeignKeyTarget.objects.all() expected = [
# new_serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']},
# expected = [ {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []},
# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, ]
# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, self.assertEqual(new_serializer.data, expected)
# ]
# self.assertEqual(new_serializer.data, expected) serializer.save()
self.assertEqual(serializer.data, data)
# serializer.save()
# self.assertEqual(serializer.data, data) # Ensure target 2 is update, and everything else is as expected
queryset = ForeignKeyTarget.objects.all()
# # Ensure target 2 is update, and everything else is as expected serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request})
# queryset = ForeignKeyTarget.objects.all() expected = [
# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']},
# expected = [ {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']},
# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, ]
# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_foreign_key_create(self):
data = {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'}
# def test_foreign_key_create(self): serializer = ForeignKeySourceSerializer(data=data, context={'request': request})
# data = {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'} self.assertTrue(serializer.is_valid())
# serializer = ForeignKeySourceSerializer(data=data, context={'request': request}) obj = serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# obj = serializer.save() self.assertEqual(obj.name, 'source-4')
# self.assertEqual(serializer.data, data)
# self.assertEqual(obj.name, 'source-4') # Ensure source 1 is updated, and everything else is as expected
queryset = ForeignKeySource.objects.all()
# # Ensure source 1 is updated, and everything else is as expected serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request})
# queryset = ForeignKeySource.objects.all() expected = [
# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'},
# expected = [ {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'},
# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}, ]
# {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'}, self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_reverse_foreign_key_create(self):
data = {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}
# def test_reverse_foreign_key_create(self): serializer = ForeignKeyTargetSerializer(data=data, context={'request': request})
# data = {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} self.assertTrue(serializer.is_valid())
# serializer = ForeignKeyTargetSerializer(data=data, context={'request': request}) obj = serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# obj = serializer.save() self.assertEqual(obj.name, 'target-3')
# self.assertEqual(serializer.data, data)
# self.assertEqual(obj.name, 'target-3') # Ensure target 4 is added, and everything else is as expected
queryset = ForeignKeyTarget.objects.all()
# # Ensure target 4 is added, and everything else is as expected serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request})
# queryset = ForeignKeyTarget.objects.all() expected = [
# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']},
# expected = [ {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []},
# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']},
# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, ]
# {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_foreign_key_update_with_invalid_null(self):
data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': None}
# def test_foreign_key_update_with_invalid_null(self): instance = ForeignKeySource.objects.get(pk=1)
# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': None} serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request})
# instance = ForeignKeySource.objects.get(pk=1) self.assertFalse(serializer.is_valid())
# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) self.assertEqual(serializer.errors, {'target': ['This field may not be null.']})
# self.assertFalse(serializer.is_valid())
# self.assertEqual(serializer.errors, {'target': ['This field is required.']})
class HyperlinkedNullableForeignKeyTests(TestCase):
urls = 'tests.test_relations_hyperlink'
# class HyperlinkedNullableForeignKeyTests(TestCase):
# urls = 'tests.test_relations_hyperlink' def setUp(self):
target = ForeignKeyTarget(name='target-1')
# def setUp(self): target.save()
# target = ForeignKeyTarget(name='target-1') for idx in range(1, 4):
# target.save() if idx == 3:
# for idx in range(1, 4): target = None
# if idx == 3: source = NullableForeignKeySource(name='source-%d' % idx, target=target)
# target = None source.save()
# source = NullableForeignKeySource(name='source-%d' % idx, target=target)
# source.save() def test_foreign_key_retrieve_with_null(self):
queryset = NullableForeignKeySource.objects.all()
# def test_foreign_key_retrieve_with_null(self): serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request})
# queryset = NullableForeignKeySource.objects.all() expected = [
# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'},
# expected = [ {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, ]
# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_foreign_key_create_with_valid_null(self):
data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None}
# def test_foreign_key_create_with_valid_null(self): serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request})
# data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} self.assertTrue(serializer.is_valid())
# serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) obj = serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# obj = serializer.save() self.assertEqual(obj.name, 'source-4')
# self.assertEqual(serializer.data, data)
# self.assertEqual(obj.name, 'source-4') # Ensure source 4 is created, and everything else is as expected
queryset = NullableForeignKeySource.objects.all()
# # Ensure source 4 is created, and everything else is as expected serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request})
# queryset = NullableForeignKeySource.objects.all() expected = [
# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'},
# expected = [ {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None}
# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, ]
# {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_foreign_key_create_with_valid_emptystring(self):
"""
# def test_foreign_key_create_with_valid_emptystring(self): The emptystring should be interpreted as null in the context
# """ of relationships.
# The emptystring should be interpreted as null in the context """
# of relationships. data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': ''}
# """ expected_data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None}
# data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': ''} serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request})
# expected_data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} self.assertTrue(serializer.is_valid())
# serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) obj = serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, expected_data)
# obj = serializer.save() self.assertEqual(obj.name, 'source-4')
# self.assertEqual(serializer.data, expected_data)
# self.assertEqual(obj.name, 'source-4') # Ensure source 4 is created, and everything else is as expected
queryset = NullableForeignKeySource.objects.all()
# # Ensure source 4 is created, and everything else is as expected serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request})
# queryset = NullableForeignKeySource.objects.all() expected = [
# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'},
# expected = [ {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None}
# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, ]
# {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_foreign_key_update_with_valid_null(self):
data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}
# def test_foreign_key_update_with_valid_null(self): instance = NullableForeignKeySource.objects.get(pk=1)
# data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request})
# instance = NullableForeignKeySource.objects.get(pk=1) self.assertTrue(serializer.is_valid())
# serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, data)
# self.assertEqual(serializer.data, data)
# serializer.save() # Ensure source 1 is updated, and everything else is as expected
queryset = NullableForeignKeySource.objects.all()
# # Ensure source 1 is updated, and everything else is as expected serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request})
# queryset = NullableForeignKeySource.objects.all() expected = [
# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None},
# expected = [ {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, ]
# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_foreign_key_update_with_valid_emptystring(self):
"""
# def test_foreign_key_update_with_valid_emptystring(self): The emptystring should be interpreted as null in the context
# """ of relationships.
# The emptystring should be interpreted as null in the context """
# of relationships. data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': ''}
# """ expected_data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}
# data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': ''} instance = NullableForeignKeySource.objects.get(pk=1)
# expected_data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request})
# instance = NullableForeignKeySource.objects.get(pk=1) self.assertTrue(serializer.is_valid())
# serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) serializer.save()
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, expected_data)
# self.assertEqual(serializer.data, expected_data)
# serializer.save() # Ensure source 1 is updated, and everything else is as expected
queryset = NullableForeignKeySource.objects.all()
# # Ensure source 1 is updated, and everything else is as expected serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request})
# queryset = NullableForeignKeySource.objects.all() expected = [
# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None},
# expected = [ {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, ]
# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected)
# # reverse foreign keys MUST be read_only # # reverse foreign keys MUST be read_only
# # In the general case they do not provide .remove() or .clear() # # In the general case they do not provide .remove() or .clear()
# # and cannot be arbitrarily set. # # and cannot be arbitrarily set.
# # def test_reverse_foreign_key_update(self): # def test_reverse_foreign_key_update(self):
# # data = {'id': 1, 'name': 'target-1', 'sources': [1]} # data = {'id': 1, 'name': 'target-1', 'sources': [1]}
# # instance = ForeignKeyTarget.objects.get(pk=1) # instance = ForeignKeyTarget.objects.get(pk=1)
# # serializer = ForeignKeyTargetSerializer(instance, data=data) # serializer = ForeignKeyTargetSerializer(instance, data=data)
# # self.assertTrue(serializer.is_valid()) # print serializer.is_valid()
# # self.assertEqual(serializer.data, data) # print serializer.errors
# # serializer.save() # print serializer
# self.assertTrue(serializer.is_valid())
# # # Ensure target 1 is updated, and everything else is as expected # serializer.save()
# # queryset = ForeignKeyTarget.objects.all() # self.assertEqual(serializer.data, data)
# # serializer = ForeignKeyTargetSerializer(queryset, many=True)
# # expected = [ # # Ensure target 1 is updated, and everything else is as expected
# # {'id': 1, 'name': 'target-1', 'sources': [1]}, # queryset = ForeignKeyTarget.objects.all()
# # {'id': 2, 'name': 'target-2', 'sources': []}, # serializer = ForeignKeyTargetSerializer(queryset, many=True)
# # ] # expected = [
# # self.assertEqual(serializer.data, expected) # {'id': 1, 'name': 'target-1', 'sources': [1]},
# {'id': 2, 'name': 'target-2', 'sources': []},
# ]
# class HyperlinkedNullableOneToOneTests(TestCase): # self.assertEqual(serializer.data, expected)
# urls = 'tests.test_relations_hyperlink'
# def setUp(self): class HyperlinkedNullableOneToOneTests(TestCase):
# target = OneToOneTarget(name='target-1') urls = 'tests.test_relations_hyperlink'
# target.save()
# new_target = OneToOneTarget(name='target-2') def setUp(self):
# new_target.save() target = OneToOneTarget(name='target-1')
# source = NullableOneToOneSource(name='source-1', target=target) target.save()
# source.save() new_target = OneToOneTarget(name='target-2')
new_target.save()
# def test_reverse_foreign_key_retrieve_with_null(self): source = NullableOneToOneSource(name='source-1', target=target)
# queryset = OneToOneTarget.objects.all() source.save()
# serializer = NullableOneToOneTargetSerializer(queryset, many=True, context={'request': request})
# expected = [ def test_reverse_foreign_key_retrieve_with_null(self):
# {'url': 'http://testserver/onetoonetarget/1/', 'name': 'target-1', 'nullable_source': 'http://testserver/nullableonetoonesource/1/'}, queryset = OneToOneTarget.objects.all()
# {'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None}, serializer = NullableOneToOneTargetSerializer(queryset, many=True, context={'request': request})
# ] expected = [
# self.assertEqual(serializer.data, expected) {'url': 'http://testserver/onetoonetarget/1/', 'name': 'target-1', 'nullable_source': 'http://testserver/nullableonetoonesource/1/'},
{'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None},
]
self.assertEqual(serializer.data, expected)
# # Regression tests for #694 (`source` attribute on related fields) # # Regression tests for #694 (`source` attribute on related fields)
......
tests/test_relations_pk.py
# from __future__ import unicode_literals from __future__ import unicode_literals
# from django.db import models from django.test import TestCase
# from django.test import TestCase from django.utils import six
# from django.utils import six from rest_framework import serializers
# from rest_framework import serializers from tests.models import (
# from tests.models import ( ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource,
# BlogPost, ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource,
# NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource, )
# )
# ManyToMany
# # ManyToMany class ManyToManyTargetSerializer(serializers.ModelSerializer):
# class ManyToManyTargetSerializer(serializers.ModelSerializer): class Meta:
# class Meta: model = ManyToManyTarget
# model = ManyToManyTarget fields = ('id', 'name', 'sources')
# fields = ('id', 'name', 'sources')
class ManyToManySourceSerializer(serializers.ModelSerializer):
# class ManyToManySourceSerializer(serializers.ModelSerializer): class Meta:
# class Meta: model = ManyToManySource
# model = ManyToManySource fields = ('id', 'name', 'targets')
# fields = ('id', 'name', 'targets')
# ForeignKey
# # ForeignKey class ForeignKeyTargetSerializer(serializers.ModelSerializer):
# class ForeignKeyTargetSerializer(serializers.ModelSerializer): class Meta:
# class Meta: model = ForeignKeyTarget
# model = ForeignKeyTarget fields = ('id', 'name', 'sources')
# fields = ('id', 'name', 'sources')
class ForeignKeySourceSerializer(serializers.ModelSerializer):
# class ForeignKeySourceSerializer(serializers.ModelSerializer): class Meta:
# class Meta: model = ForeignKeySource
# model = ForeignKeySource fields = ('id', 'name', 'target')
# fields = ('id', 'name', 'target')
# Nullable ForeignKey
# # Nullable ForeignKey class NullableForeignKeySourceSerializer(serializers.ModelSerializer):
# class NullableForeignKeySourceSerializer(serializers.ModelSerializer): class Meta:
# class Meta: model = NullableForeignKeySource
# model = NullableForeignKeySource fields = ('id', 'name', 'target')
# fields = ('id', 'name', 'target')
# Nullable OneToOne
# # Nullable OneToOne class NullableOneToOneTargetSerializer(serializers.ModelSerializer):
# class NullableOneToOneTargetSerializer(serializers.ModelSerializer): class Meta:
# class Meta: model = OneToOneTarget
# model = OneToOneTarget fields = ('id', 'name', 'nullable_source')
# fields = ('id', 'name', 'nullable_source')
# TODO: Add test that .data cannot be accessed prior to .is_valid
# # TODO: Add test that .data cannot be accessed prior to .is_valid
class PKManyToManyTests(TestCase):
# class PKManyToManyTests(TestCase): def setUp(self):
# def setUp(self): for idx in range(1, 4):
# for idx in range(1, 4): target = ManyToManyTarget(name='target-%d' % idx)
# target = ManyToManyTarget(name='target-%d' % idx) target.save()
# target.save() source = ManyToManySource(name='source-%d' % idx)
# source = ManyToManySource(name='source-%d' % idx) source.save()
# source.save() for target in ManyToManyTarget.objects.all():
# for target in ManyToManyTarget.objects.all(): source.targets.add(target)
# source.targets.add(target)
def test_many_to_many_retrieve(self):
# def test_many_to_many_retrieve(self): queryset = ManyToManySource.objects.all()
# queryset = ManyToManySource.objects.all() serializer = ManyToManySourceSerializer(queryset, many=True)
# serializer = ManyToManySourceSerializer(queryset, many=True) expected = [
# expected = [ {'id': 1, 'name': 'source-1', 'targets': [1]},
# {'id': 1, 'name': 'source-1', 'targets': [1]}, {'id': 2, 'name': 'source-2', 'targets': [1, 2]},
# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}
# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} ]
# ] self.assertEqual(serializer.data, expected)
# self.assertEqual(serializer.data, expected)
def test_reverse_many_to_many_retrieve(self):
# def test_reverse_many_to_many_retrieve(self): queryset = ManyToManyTarget.objects.all()
# queryset = ManyToManyTarget.objects.all() serializer = ManyToManyTargetSerializer(queryset, many=True)
# serializer = ManyToManyTargetSerializer(queryset, many=True) expected = [
# expected = [ {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]},
# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, {'id': 2, 'name': 'target-2', 'sources': [2, 3]},
# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, {'id': 3, 'name': 'target-3', 'sources': [3]}
# {'id': 3, 'name': 'target-3', 'sources': [3]} ]
# ] self.assertEqual(serializer.data, expected)
# self.assertEqual(serializer.data, expected)
def test_many_to_many_update(self):
# def test_many_to_many_update(self): data = {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]}
# data = {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]} instance = ManyToManySource.objects.get(pk=1)
# instance = ManyToManySource.objects.get(pk=1) serializer = ManyToManySourceSerializer(instance, data=data)
# serializer = ManyToManySourceSerializer(instance, data=data) self.assertTrue(serializer.is_valid())
# self.assertTrue(serializer.is_valid()) serializer.save()
# serializer.save() self.assertEqual(serializer.data, data)
# self.assertEqual(serializer.data, data)
# Ensure source 1 is updated, and everything else is as expected
# # Ensure source 1 is updated, and everything else is as expected queryset = ManyToManySource.objects.all()
# queryset = ManyToManySource.objects.all() serializer = ManyToManySourceSerializer(queryset, many=True)
# serializer = ManyToManySourceSerializer(queryset, many=True) expected = [
# expected = [ {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]},
# {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]}, {'id': 2, 'name': 'source-2', 'targets': [1, 2]},
# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}
# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} ]
# ] self.assertEqual(serializer.data, expected)
# self.assertEqual(serializer.data, expected)
def test_reverse_many_to_many_update(self):
# def test_reverse_many_to_many_update(self): data = {'id': 1, 'name': 'target-1', 'sources': [1]}
# data = {'id': 1, 'name': 'target-1', 'sources': [1]} instance = ManyToManyTarget.objects.get(pk=1)
# instance = ManyToManyTarget.objects.get(pk=1) serializer = ManyToManyTargetSerializer(instance, data=data)
# serializer = ManyToManyTargetSerializer(instance, data=data) self.assertTrue(serializer.is_valid())
# self.assertTrue(serializer.is_valid()) serializer.save()
# serializer.save() self.assertEqual(serializer.data, data)
# self.assertEqual(serializer.data, data)
# Ensure target 1 is updated, and everything else is as expected
# # Ensure target 1 is updated, and everything else is as expected queryset = ManyToManyTarget.objects.all()
# queryset = ManyToManyTarget.objects.all() serializer = ManyToManyTargetSerializer(queryset, many=True)
# serializer = ManyToManyTargetSerializer(queryset, many=True) expected = [
# expected = [ {'id': 1, 'name': 'target-1', 'sources': [1]},
# {'id': 1, 'name': 'target-1', 'sources': [1]}, {'id': 2, 'name': 'target-2', 'sources': [2, 3]},
# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, {'id': 3, 'name': 'target-3', 'sources': [3]}
# {'id': 3, 'name': 'target-3', 'sources': [3]} ]
# ] self.assertEqual(serializer.data, expected)
# self.assertEqual(serializer.data, expected)
def test_many_to_many_create(self):
# def test_many_to_many_create(self): data = {'id': 4, 'name': 'source-4', 'targets': [1, 3]}
# data = {'id': 4, 'name': 'source-4', 'targets': [1, 3]} serializer = ManyToManySourceSerializer(data=data)
# serializer = ManyToManySourceSerializer(data=data) self.assertTrue(serializer.is_valid())
# self.assertTrue(serializer.is_valid()) obj = serializer.save()
# obj = serializer.save() self.assertEqual(serializer.data, data)
# self.assertEqual(serializer.data, data) self.assertEqual(obj.name, 'source-4')
# self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is added, and everything else is as expected
# # Ensure source 4 is added, and everything else is as expected queryset = ManyToManySource.objects.all()
# queryset = ManyToManySource.objects.all() serializer = ManyToManySourceSerializer(queryset, many=True)
# serializer = ManyToManySourceSerializer(queryset, many=True) expected = [
# self.assertFalse(serializer.fields['targets'].read_only) {'id': 1, 'name': 'source-1', 'targets': [1]},
# expected = [ {'id': 2, 'name': 'source-2', 'targets': [1, 2]},
# {'id': 1, 'name': 'source-1', 'targets': [1]}, {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]},
# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, {'id': 4, 'name': 'source-4', 'targets': [1, 3]},
# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}, ]
# {'id': 4, 'name': 'source-4', 'targets': [1, 3]}, self.assertEqual(serializer.data, expected)
# ]
# self.assertEqual(serializer.data, expected) def test_reverse_many_to_many_create(self):
data = {'id': 4, 'name': 'target-4', 'sources': [1, 3]}
# def test_reverse_many_to_many_create(self): serializer = ManyToManyTargetSerializer(data=data)
# data = {'id': 4, 'name': 'target-4', 'sources': [1, 3]} self.assertTrue(serializer.is_valid())
# serializer = ManyToManyTargetSerializer(data=data) obj = serializer.save()
# self.assertFalse(serializer.fields['sources'].read_only) self.assertEqual(serializer.data, data)
# self.assertTrue(serializer.is_valid()) self.assertEqual(obj.name, 'target-4')
# obj = serializer.save()
# self.assertEqual(serializer.data, data) # Ensure target 4 is added, and everything else is as expected
# self.assertEqual(obj.name, 'target-4') queryset = ManyToManyTarget.objects.all()
serializer = ManyToManyTargetSerializer(queryset, many=True)
# # Ensure target 4 is added, and everything else is as expected expected = [
# queryset = ManyToManyTarget.objects.all() {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]},
# serializer = ManyToManyTargetSerializer(queryset, many=True) {'id': 2, 'name': 'target-2', 'sources': [2, 3]},
# expected = [ {'id': 3, 'name': 'target-3', 'sources': [3]},
# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, {'id': 4, 'name': 'target-4', 'sources': [1, 3]}
# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, ]
# {'id': 3, 'name': 'target-3', 'sources': [3]}, self.assertEqual(serializer.data, expected)
# {'id': 4, 'name': 'target-4', 'sources': [1, 3]}
# ]
# self.assertEqual(serializer.data, expected) class PKForeignKeyTests(TestCase):
def setUp(self):
target = ForeignKeyTarget(name='target-1')
# class PKForeignKeyTests(TestCase): target.save()
# def setUp(self): new_target = ForeignKeyTarget(name='target-2')
# target = ForeignKeyTarget(name='target-1') new_target.save()
# target.save() for idx in range(1, 4):
# new_target = ForeignKeyTarget(name='target-2') source = ForeignKeySource(name='source-%d' % idx, target=target)
# new_target.save() source.save()
# for idx in range(1, 4):
# source = ForeignKeySource(name='source-%d' % idx, target=target) def test_foreign_key_retrieve(self):
# source.save() queryset = ForeignKeySource.objects.all()
serializer = ForeignKeySourceSerializer(queryset, many=True)
# def test_foreign_key_retrieve(self): expected = [
# queryset = ForeignKeySource.objects.all() {'id': 1, 'name': 'source-1', 'target': 1},
# serializer = ForeignKeySourceSerializer(queryset, many=True) {'id': 2, 'name': 'source-2', 'target': 1},
# expected = [ {'id': 3, 'name': 'source-3', 'target': 1}
# {'id': 1, 'name': 'source-1', 'target': 1}, ]
# {'id': 2, 'name': 'source-2', 'target': 1}, self.assertEqual(serializer.data, expected)
# {'id': 3, 'name': 'source-3', 'target': 1}
# ] def test_reverse_foreign_key_retrieve(self):
# self.assertEqual(serializer.data, expected) queryset = ForeignKeyTarget.objects.all()
serializer = ForeignKeyTargetSerializer(queryset, many=True)
# def test_reverse_foreign_key_retrieve(self): expected = [
# queryset = ForeignKeyTarget.objects.all() {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]},
# serializer = ForeignKeyTargetSerializer(queryset, many=True) {'id': 2, 'name': 'target-2', 'sources': []},
# expected = [ ]
# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, self.assertEqual(serializer.data, expected)
# {'id': 2, 'name': 'target-2', 'sources': []},
# ] def test_foreign_key_update(self):
# self.assertEqual(serializer.data, expected) data = {'id': 1, 'name': 'source-1', 'target': 2}
instance = ForeignKeySource.objects.get(pk=1)
# def test_foreign_key_update(self): serializer = ForeignKeySourceSerializer(instance, data=data)
# data = {'id': 1, 'name': 'source-1', 'target': 2} self.assertTrue(serializer.is_valid())
# instance = ForeignKeySource.objects.get(pk=1) serializer.save()
# serializer = ForeignKeySourceSerializer(instance, data=data) self.assertEqual(serializer.data, data)
# self.assertTrue(serializer.is_valid())
# self.assertEqual(serializer.data, data) # Ensure source 1 is updated, and everything else is as expected
# serializer.save() queryset = ForeignKeySource.objects.all()
serializer = ForeignKeySourceSerializer(queryset, many=True)
# # Ensure source 1 is updated, and everything else is as expected expected = [
# queryset = ForeignKeySource.objects.all() {'id': 1, 'name': 'source-1', 'target': 2},
# serializer = ForeignKeySourceSerializer(queryset, many=True) {'id': 2, 'name': 'source-2', 'target': 1},
# expected = [ {'id': 3, 'name': 'source-3', 'target': 1}
# {'id': 1, 'name': 'source-1', 'target': 2}, ]
# {'id': 2, 'name': 'source-2', 'target': 1}, self.assertEqual(serializer.data, expected)
# {'id': 3, 'name': 'source-3', 'target': 1}
# ] def test_foreign_key_update_incorrect_type(self):
# self.assertEqual(serializer.data, expected) data = {'id': 1, 'name': 'source-1', 'target': 'foo'}
instance = ForeignKeySource.objects.get(pk=1)
# def test_foreign_key_update_incorrect_type(self): serializer = ForeignKeySourceSerializer(instance, data=data)
# data = {'id': 1, 'name': 'source-1', 'target': 'foo'} self.assertFalse(serializer.is_valid())
# instance = ForeignKeySource.objects.get(pk=1) self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected pk value, received %s.' % six.text_type.__name__]})
# serializer = ForeignKeySourceSerializer(instance, data=data)
# self.assertFalse(serializer.is_valid()) def test_reverse_foreign_key_update(self):
# self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected pk value, received %s.' % six.text_type.__name__]}) data = {'id': 2, 'name': 'target-2', 'sources': [1, 3]}
instance = ForeignKeyTarget.objects.get(pk=2)
# def test_reverse_foreign_key_update(self): serializer = ForeignKeyTargetSerializer(instance, data=data)
# data = {'id': 2, 'name': 'target-2', 'sources': [1, 3]} self.assertTrue(serializer.is_valid())
# instance = ForeignKeyTarget.objects.get(pk=2) # We shouldn't have saved anything to the db yet since save
# serializer = ForeignKeyTargetSerializer(instance, data=data) # hasn't been called.
# self.assertTrue(serializer.is_valid()) queryset = ForeignKeyTarget.objects.all()
# # We shouldn't have saved anything to the db yet since save new_serializer = ForeignKeyTargetSerializer(queryset, many=True)
# # hasn't been called. expected = [
# queryset = ForeignKeyTarget.objects.all() {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]},
# new_serializer = ForeignKeyTargetSerializer(queryset, many=True) {'id': 2, 'name': 'target-2', 'sources': []},
# expected = [ ]
# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, self.assertEqual(new_serializer.data, expected)
# {'id': 2, 'name': 'target-2', 'sources': []},
# ] serializer.save()
# self.assertEqual(new_serializer.data, expected) self.assertEqual(serializer.data, data)
# serializer.save() # Ensure target 2 is update, and everything else is as expected
# self.assertEqual(serializer.data, data) queryset = ForeignKeyTarget.objects.all()
serializer = ForeignKeyTargetSerializer(queryset, many=True)
# # Ensure target 2 is update, and everything else is as expected expected = [
# queryset = ForeignKeyTarget.objects.all() {'id': 1, 'name': 'target-1', 'sources': [2]},
# serializer = ForeignKeyTargetSerializer(queryset, many=True) {'id': 2, 'name': 'target-2', 'sources': [1, 3]},
# expected = [ ]
# {'id': 1, 'name': 'target-1', 'sources': [2]}, self.assertEqual(serializer.data, expected)
# {'id': 2, 'name': 'target-2', 'sources': [1, 3]},
# ] def test_foreign_key_create(self):
# self.assertEqual(serializer.data, expected) data = {'id': 4, 'name': 'source-4', 'target': 2}
serializer = ForeignKeySourceSerializer(data=data)
# def test_foreign_key_create(self): self.assertTrue(serializer.is_valid())
# data = {'id': 4, 'name': 'source-4', 'target': 2} obj = serializer.save()
# serializer = ForeignKeySourceSerializer(data=data) self.assertEqual(serializer.data, data)
# self.assertTrue(serializer.is_valid()) self.assertEqual(obj.name, 'source-4')
# obj = serializer.save()
# self.assertEqual(serializer.data, data) # Ensure source 4 is added, and everything else is as expected
# self.assertEqual(obj.name, 'source-4') queryset = ForeignKeySource.objects.all()
serializer = ForeignKeySourceSerializer(queryset, many=True)
# # Ensure source 4 is added, and everything else is as expected expected = [
# queryset = ForeignKeySource.objects.all() {'id': 1, 'name': 'source-1', 'target': 1},
# serializer = ForeignKeySourceSerializer(queryset, many=True) {'id': 2, 'name': 'source-2', 'target': 1},
# expected = [ {'id': 3, 'name': 'source-3', 'target': 1},
# {'id': 1, 'name': 'source-1', 'target': 1}, {'id': 4, 'name': 'source-4', 'target': 2},
# {'id': 2, 'name': 'source-2', 'target': 1}, ]
# {'id': 3, 'name': 'source-3', 'target': 1}, self.assertEqual(serializer.data, expected)
# {'id': 4, 'name': 'source-4', 'target': 2},
# ] def test_reverse_foreign_key_create(self):
# self.assertEqual(serializer.data, expected) data = {'id': 3, 'name': 'target-3', 'sources': [1, 3]}
serializer = ForeignKeyTargetSerializer(data=data)
# def test_reverse_foreign_key_create(self): self.assertTrue(serializer.is_valid())
# data = {'id': 3, 'name': 'target-3', 'sources': [1, 3]} obj = serializer.save()
# serializer = ForeignKeyTargetSerializer(data=data) self.assertEqual(serializer.data, data)
# self.assertTrue(serializer.is_valid()) self.assertEqual(obj.name, 'target-3')
# obj = serializer.save()
# self.assertEqual(serializer.data, data) # Ensure target 3 is added, and everything else is as expected
# self.assertEqual(obj.name, 'target-3') queryset = ForeignKeyTarget.objects.all()
serializer = ForeignKeyTargetSerializer(queryset, many=True)
# # Ensure target 3 is added, and everything else is as expected expected = [
# queryset = ForeignKeyTarget.objects.all() {'id': 1, 'name': 'target-1', 'sources': [2]},
# serializer = ForeignKeyTargetSerializer(queryset, many=True) {'id': 2, 'name': 'target-2', 'sources': []},
# expected = [ {'id': 3, 'name': 'target-3', 'sources': [1, 3]},
# {'id': 1, 'name': 'target-1', 'sources': [2]}, ]
# {'id': 2, 'name': 'target-2', 'sources': []}, self.assertEqual(serializer.data, expected)
# {'id': 3, 'name': 'target-3', 'sources': [1, 3]},
# ] def test_foreign_key_update_with_invalid_null(self):
# self.assertEqual(serializer.data, expected) data = {'id': 1, 'name': 'source-1', 'target': None}
instance = ForeignKeySource.objects.get(pk=1)
# def test_foreign_key_update_with_invalid_null(self): serializer = ForeignKeySourceSerializer(instance, data=data)
# data = {'id': 1, 'name': 'source-1', 'target': None} self.assertFalse(serializer.is_valid())
# instance = ForeignKeySource.objects.get(pk=1) self.assertEqual(serializer.errors, {'target': ['This field may not be null.']})
# serializer = ForeignKeySourceSerializer(instance, data=data)
# self.assertFalse(serializer.is_valid()) def test_foreign_key_with_empty(self):
# self.assertEqual(serializer.errors, {'target': ['This field is required.']}) """
Regression test for #1072
# def test_foreign_key_with_empty(self):
# """ https://github.com/tomchristie/django-rest-framework/issues/1072
# Regression test for #1072 """
serializer = NullableForeignKeySourceSerializer()
# https://github.com/tomchristie/django-rest-framework/issues/1072 self.assertEqual(serializer.data['target'], None)
# """
# serializer = NullableForeignKeySourceSerializer()
# self.assertEqual(serializer.data['target'], None) class PKNullableForeignKeyTests(TestCase):
def setUp(self):
target = ForeignKeyTarget(name='target-1')
# class PKNullableForeignKeyTests(TestCase): target.save()
# def setUp(self): for idx in range(1, 4):
# target = ForeignKeyTarget(name='target-1') if idx == 3:
# target.save() target = None
# for idx in range(1, 4): source = NullableForeignKeySource(name='source-%d' % idx, target=target)
# if idx == 3: source.save()
# target = None
# source = NullableForeignKeySource(name='source-%d' % idx, target=target) def test_foreign_key_retrieve_with_null(self):
# source.save() queryset = NullableForeignKeySource.objects.all()
serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# def test_foreign_key_retrieve_with_null(self): expected = [
# queryset = NullableForeignKeySource.objects.all() {'id': 1, 'name': 'source-1', 'target': 1},
# serializer = NullableForeignKeySourceSerializer(queryset, many=True) {'id': 2, 'name': 'source-2', 'target': 1},
# expected = [ {'id': 3, 'name': 'source-3', 'target': None},
# {'id': 1, 'name': 'source-1', 'target': 1}, ]
# {'id': 2, 'name': 'source-2', 'target': 1}, self.assertEqual(serializer.data, expected)
# {'id': 3, 'name': 'source-3', 'target': None},
# ] def test_foreign_key_create_with_valid_null(self):
# self.assertEqual(serializer.data, expected) data = {'id': 4, 'name': 'source-4', 'target': None}
serializer = NullableForeignKeySourceSerializer(data=data)
# def test_foreign_key_create_with_valid_null(self): self.assertTrue(serializer.is_valid())
# data = {'id': 4, 'name': 'source-4', 'target': None} obj = serializer.save()
# serializer = NullableForeignKeySourceSerializer(data=data) self.assertEqual(serializer.data, data)
# self.assertTrue(serializer.is_valid()) self.assertEqual(obj.name, 'source-4')
# obj = serializer.save()
# self.assertEqual(serializer.data, data) # Ensure source 4 is created, and everything else is as expected
# self.assertEqual(obj.name, 'source-4') queryset = NullableForeignKeySource.objects.all()
serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# # Ensure source 4 is created, and everything else is as expected expected = [
# queryset = NullableForeignKeySource.objects.all() {'id': 1, 'name': 'source-1', 'target': 1},
# serializer = NullableForeignKeySourceSerializer(queryset, many=True) {'id': 2, 'name': 'source-2', 'target': 1},
# expected = [ {'id': 3, 'name': 'source-3', 'target': None},
# {'id': 1, 'name': 'source-1', 'target': 1}, {'id': 4, 'name': 'source-4', 'target': None}
# {'id': 2, 'name': 'source-2', 'target': 1}, ]
# {'id': 3, 'name': 'source-3', 'target': None}, self.assertEqual(serializer.data, expected)
# {'id': 4, 'name': 'source-4', 'target': None}
# ] def test_foreign_key_create_with_valid_emptystring(self):
# self.assertEqual(serializer.data, expected) """
The emptystring should be interpreted as null in the context
# def test_foreign_key_create_with_valid_emptystring(self): of relationships.
# """ """
# The emptystring should be interpreted as null in the context data = {'id': 4, 'name': 'source-4', 'target': ''}
# of relationships. expected_data = {'id': 4, 'name': 'source-4', 'target': None}
# """ serializer = NullableForeignKeySourceSerializer(data=data)
# data = {'id': 4, 'name': 'source-4', 'target': ''} self.assertTrue(serializer.is_valid())
# expected_data = {'id': 4, 'name': 'source-4', 'target': None} obj = serializer.save()
# serializer = NullableForeignKeySourceSerializer(data=data) self.assertEqual(serializer.data, expected_data)
# self.assertTrue(serializer.is_valid()) self.assertEqual(obj.name, 'source-4')
# obj = serializer.save()
# self.assertEqual(serializer.data, expected_data) # Ensure source 4 is created, and everything else is as expected
# self.assertEqual(obj.name, 'source-4') queryset = NullableForeignKeySource.objects.all()
serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# # Ensure source 4 is created, and everything else is as expected expected = [
# queryset = NullableForeignKeySource.objects.all() {'id': 1, 'name': 'source-1', 'target': 1},
# serializer = NullableForeignKeySourceSerializer(queryset, many=True) {'id': 2, 'name': 'source-2', 'target': 1},
# expected = [ {'id': 3, 'name': 'source-3', 'target': None},
# {'id': 1, 'name': 'source-1', 'target': 1}, {'id': 4, 'name': 'source-4', 'target': None}
# {'id': 2, 'name': 'source-2', 'target': 1}, ]
# {'id': 3, 'name': 'source-3', 'target': None}, self.assertEqual(serializer.data, expected)
# {'id': 4, 'name': 'source-4', 'target': None}
# ] def test_foreign_key_update_with_valid_null(self):
# self.assertEqual(serializer.data, expected) data = {'id': 1, 'name': 'source-1', 'target': None}
instance = NullableForeignKeySource.objects.get(pk=1)
# def test_foreign_key_update_with_valid_null(self): serializer = NullableForeignKeySourceSerializer(instance, data=data)
# data = {'id': 1, 'name': 'source-1', 'target': None} self.assertTrue(serializer.is_valid())
# instance = NullableForeignKeySource.objects.get(pk=1) serializer.save()
# serializer = NullableForeignKeySourceSerializer(instance, data=data) self.assertEqual(serializer.data, data)
# self.assertTrue(serializer.is_valid())
# self.assertEqual(serializer.data, data) # Ensure source 1 is updated, and everything else is as expected
# serializer.save() queryset = NullableForeignKeySource.objects.all()
serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# # Ensure source 1 is updated, and everything else is as expected expected = [
# queryset = NullableForeignKeySource.objects.all() {'id': 1, 'name': 'source-1', 'target': None},
# serializer = NullableForeignKeySourceSerializer(queryset, many=True) {'id': 2, 'name': 'source-2', 'target': 1},
# expected = [ {'id': 3, 'name': 'source-3', 'target': None}
# {'id': 1, 'name': 'source-1', 'target': None}, ]
# {'id': 2, 'name': 'source-2', 'target': 1}, self.assertEqual(serializer.data, expected)
# {'id': 3, 'name': 'source-3', 'target': None}
# ] def test_foreign_key_update_with_valid_emptystring(self):
# self.assertEqual(serializer.data, expected) """
The emptystring should be interpreted as null in the context
# def test_foreign_key_update_with_valid_emptystring(self): of relationships.
# """ """
# The emptystring should be interpreted as null in the context data = {'id': 1, 'name': 'source-1', 'target': ''}
# of relationships. expected_data = {'id': 1, 'name': 'source-1', 'target': None}
# """ instance = NullableForeignKeySource.objects.get(pk=1)
# data = {'id': 1, 'name': 'source-1', 'target': ''} serializer = NullableForeignKeySourceSerializer(instance, data=data)
# expected_data = {'id': 1, 'name': 'source-1', 'target': None} self.assertTrue(serializer.is_valid())
# instance = NullableForeignKeySource.objects.get(pk=1) serializer.save()
# serializer = NullableForeignKeySourceSerializer(instance, data=data) self.assertEqual(serializer.data, expected_data)
# self.assertTrue(serializer.is_valid())
# self.assertEqual(serializer.data, expected_data) # Ensure source 1 is updated, and everything else is as expected
# serializer.save() queryset = NullableForeignKeySource.objects.all()
serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# # Ensure source 1 is updated, and everything else is as expected expected = [
# queryset = NullableForeignKeySource.objects.all() {'id': 1, 'name': 'source-1', 'target': None},
# serializer = NullableForeignKeySourceSerializer(queryset, many=True) {'id': 2, 'name': 'source-2', 'target': 1},
# expected = [ {'id': 3, 'name': 'source-3', 'target': None}
# {'id': 1, 'name': 'source-1', 'target': None}, ]
# {'id': 2, 'name': 'source-2', 'target': 1}, self.assertEqual(serializer.data, expected)
# {'id': 3, 'name': 'source-3', 'target': None}
# ] # reverse foreign keys MUST be read_only
# self.assertEqual(serializer.data, expected) # In the general case they do not provide .remove() or .clear()
# and cannot be arbitrarily set.
# # reverse foreign keys MUST be read_only
# # In the general case they do not provide .remove() or .clear() # def test_reverse_foreign_key_update(self):
# # and cannot be arbitrarily set. # data = {'id': 1, 'name': 'target-1', 'sources': [1]}
# instance = ForeignKeyTarget.objects.get(pk=1)
# # def test_reverse_foreign_key_update(self): # serializer = ForeignKeyTargetSerializer(instance, data=data)
# # data = {'id': 1, 'name': 'target-1', 'sources': [1]} # self.assertTrue(serializer.is_valid())
# # instance = ForeignKeyTarget.objects.get(pk=1) # self.assertEqual(serializer.data, data)
# # serializer = ForeignKeyTargetSerializer(instance, data=data) # serializer.save()
# # self.assertTrue(serializer.is_valid())
# # self.assertEqual(serializer.data, data) # # Ensure target 1 is updated, and everything else is as expected
# # serializer.save() # queryset = ForeignKeyTarget.objects.all()
# serializer = ForeignKeyTargetSerializer(queryset, many=True)
# # # Ensure target 1 is updated, and everything else is as expected # expected = [
# # queryset = ForeignKeyTarget.objects.all() # {'id': 1, 'name': 'target-1', 'sources': [1]},
# # serializer = ForeignKeyTargetSerializer(queryset, many=True) # {'id': 2, 'name': 'target-2', 'sources': []},
# # expected = [ # ]
# # {'id': 1, 'name': 'target-1', 'sources': [1]}, # self.assertEqual(serializer.data, expected)
# # {'id': 2, 'name': 'target-2', 'sources': []},
# # ]
# # self.assertEqual(serializer.data, expected) class PKNullableOneToOneTests(TestCase):
def setUp(self):
target = OneToOneTarget(name='target-1')
# class PKNullableOneToOneTests(TestCase): target.save()
# def setUp(self): new_target = OneToOneTarget(name='target-2')
# target = OneToOneTarget(name='target-1') new_target.save()
# target.save() source = NullableOneToOneSource(name='source-1', target=new_target)
# new_target = OneToOneTarget(name='target-2') source.save()
# new_target.save()
# source = NullableOneToOneSource(name='source-1', target=new_target) def test_reverse_foreign_key_retrieve_with_null(self):
# source.save() queryset = OneToOneTarget.objects.all()
serializer = NullableOneToOneTargetSerializer(queryset, many=True)
# def test_reverse_foreign_key_retrieve_with_null(self): expected = [
# queryset = OneToOneTarget.objects.all() {'id': 1, 'name': 'target-1', 'nullable_source': None},
# serializer = NullableOneToOneTargetSerializer(queryset, many=True) {'id': 2, 'name': 'target-2', 'nullable_source': 1},
# expected = [ ]
# {'id': 1, 'name': 'target-1', 'nullable_source': None}, self.assertEqual(serializer.data, expected)
# {'id': 2, 'name': 'target-2', 'nullable_source': 1},
# ]
# self.assertEqual(serializer.data, expected) # The below models and tests ensure that serializer fields corresponding
# to a ManyToManyField field with a user-specified ``through`` model are
# set to read only
# # The below models and tests ensure that serializer fields corresponding
# # to a ManyToManyField field with a user-specified ``through`` model are
# # set to read only
# class ManyToManyThroughTarget(models.Model): # class ManyToManyThroughTarget(models.Model):
...@@ -481,7 +478,6 @@ ...@@ -481,7 +478,6 @@
# def test_many_to_many_create(self): # def test_many_to_many_create(self):
# data = {'id': 2, 'name': 'source-2', 'targets': [self.target.pk]} # data = {'id': 2, 'name': 'source-2', 'targets': [self.target.pk]}
# serializer = ManyToManyThroughSourceSerializer(data=data) # serializer = ManyToManyThroughSourceSerializer(data=data)
# self.assertTrue(serializer.fields['targets'].read_only)
# self.assertTrue(serializer.is_valid()) # self.assertTrue(serializer.is_valid())
# obj = serializer.save() # obj = serializer.save()
# self.assertEqual(obj.name, 'source-2') # self.assertEqual(obj.name, 'source-2')
...@@ -490,9 +486,7 @@ ...@@ -490,9 +486,7 @@
# def test_many_to_many_reverse_create(self): # def test_many_to_many_reverse_create(self):
# data = {'id': 2, 'name': 'target-2', 'sources': [self.source.pk]} # data = {'id': 2, 'name': 'target-2', 'sources': [self.source.pk]}
# serializer = ManyToManyThroughTargetSerializer(data=data) # serializer = ManyToManyThroughTargetSerializer(data=data)
# self.assertTrue(serializer.fields['sources'].read_only)
# self.assertTrue(serializer.is_valid()) # self.assertTrue(serializer.is_valid())
# serializer.save()
# obj = serializer.save() # obj = serializer.save()
# self.assertEqual(obj.name, 'target-2') # self.assertEqual(obj.name, 'target-2')
# self.assertEqual(obj.sources.count(), 0) # self.assertEqual(obj.sources.count(), 0)
......
tests/test_relations_slug.py
# from django.test import TestCase from django.test import TestCase
# from rest_framework import serializers from rest_framework import serializers
# from tests.models import NullableForeignKeySource, ForeignKeySource, ForeignKeyTarget from tests.models import NullableForeignKeySource, ForeignKeySource, ForeignKeyTarget
# class ForeignKeyTargetSerializer(serializers.ModelSerializer): class ForeignKeyTargetSerializer(serializers.ModelSerializer):
# sources = serializers.SlugRelatedField(many=True, slug_field='name') sources = serializers.SlugRelatedField(
slug_field='name',
# class Meta: queryset=ForeignKeySource.objects.all(),
# model = ForeignKeyTarget many=True
)
# class ForeignKeySourceSerializer(serializers.ModelSerializer): class Meta:
# target = serializers.SlugRelatedField(slug_field='name') model = ForeignKeyTarget
# class Meta:
# model = ForeignKeySource class ForeignKeySourceSerializer(serializers.ModelSerializer):
target = serializers.SlugRelatedField(
slug_field='name',
# class NullableForeignKeySourceSerializer(serializers.ModelSerializer): queryset=ForeignKeyTarget.objects.all()
# target = serializers.SlugRelatedField(slug_field='name', required=False) )
# class Meta: class Meta:
# model = NullableForeignKeySource model = ForeignKeySource
# # TODO: M2M Tests, FKTests (Non-nullable), One2One class NullableForeignKeySourceSerializer(serializers.ModelSerializer):
# class SlugForeignKeyTests(TestCase): target = serializers.SlugRelatedField(
# def setUp(self): slug_field='name',
# target = ForeignKeyTarget(name='target-1') queryset=ForeignKeyTarget.objects.all(),
# target.save() allow_null=True
# new_target = ForeignKeyTarget(name='target-2') )
# new_target.save()
# for idx in range(1, 4): class Meta:
# source = ForeignKeySource(name='source-%d' % idx, target=target) model = NullableForeignKeySource
# source.save()
# def test_foreign_key_retrieve(self): # TODO: M2M Tests, FKTests (Non-nullable), One2One
# queryset = ForeignKeySource.objects.all() class SlugForeignKeyTests(TestCase):
# serializer = ForeignKeySourceSerializer(queryset, many=True) def setUp(self):
# expected = [ target = ForeignKeyTarget(name='target-1')
# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, target.save()
# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, new_target = ForeignKeyTarget(name='target-2')
# {'id': 3, 'name': 'source-3', 'target': 'target-1'} new_target.save()
# ] for idx in range(1, 4):
# self.assertEqual(serializer.data, expected) source = ForeignKeySource(name='source-%d' % idx, target=target)
source.save()
# def test_reverse_foreign_key_retrieve(self):
# queryset = ForeignKeyTarget.objects.all() def test_foreign_key_retrieve(self):
# serializer = ForeignKeyTargetSerializer(queryset, many=True) queryset = ForeignKeySource.objects.all()
# expected = [ serializer = ForeignKeySourceSerializer(queryset, many=True)
# {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, expected = [
# {'id': 2, 'name': 'target-2', 'sources': []}, {'id': 1, 'name': 'source-1', 'target': 'target-1'},
# ] {'id': 2, 'name': 'source-2', 'target': 'target-1'},
# self.assertEqual(serializer.data, expected) {'id': 3, 'name': 'source-3', 'target': 'target-1'}
]
# def test_foreign_key_update(self): self.assertEqual(serializer.data, expected)
# data = {'id': 1, 'name': 'source-1', 'target': 'target-2'}
# instance = ForeignKeySource.objects.get(pk=1) def test_reverse_foreign_key_retrieve(self):
# serializer = ForeignKeySourceSerializer(instance, data=data) queryset = ForeignKeyTarget.objects.all()
# self.assertTrue(serializer.is_valid()) serializer = ForeignKeyTargetSerializer(queryset, many=True)
# self.assertEqual(serializer.data, data) expected = [
# serializer.save() {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
{'id': 2, 'name': 'target-2', 'sources': []},
# # Ensure source 1 is updated, and everything else is as expected ]
# queryset = ForeignKeySource.objects.all() self.assertEqual(serializer.data, expected)
# serializer = ForeignKeySourceSerializer(queryset, many=True)
# expected = [ def test_foreign_key_update(self):
# {'id': 1, 'name': 'source-1', 'target': 'target-2'}, data = {'id': 1, 'name': 'source-1', 'target': 'target-2'}
# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, instance = ForeignKeySource.objects.get(pk=1)
# {'id': 3, 'name': 'source-3', 'target': 'target-1'} serializer = ForeignKeySourceSerializer(instance, data=data)
# ] self.assertTrue(serializer.is_valid())
# self.assertEqual(serializer.data, expected) serializer.save()
self.assertEqual(serializer.data, data)
# def test_foreign_key_update_incorrect_type(self):
# data = {'id': 1, 'name': 'source-1', 'target': 123} # Ensure source 1 is updated, and everything else is as expected
# instance = ForeignKeySource.objects.get(pk=1) queryset = ForeignKeySource.objects.all()
# serializer = ForeignKeySourceSerializer(instance, data=data) serializer = ForeignKeySourceSerializer(queryset, many=True)
# self.assertFalse(serializer.is_valid()) expected = [
# self.assertEqual(serializer.errors, {'target': ['Object with name=123 does not exist.']}) {'id': 1, 'name': 'source-1', 'target': 'target-2'},
{'id': 2, 'name': 'source-2', 'target': 'target-1'},
# def test_reverse_foreign_key_update(self): {'id': 3, 'name': 'source-3', 'target': 'target-1'}
# data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']} ]
# instance = ForeignKeyTarget.objects.get(pk=2) self.assertEqual(serializer.data, expected)
# serializer = ForeignKeyTargetSerializer(instance, data=data)
# self.assertTrue(serializer.is_valid()) def test_foreign_key_update_incorrect_type(self):
# # We shouldn't have saved anything to the db yet since save data = {'id': 1, 'name': 'source-1', 'target': 123}
# # hasn't been called. instance = ForeignKeySource.objects.get(pk=1)
# queryset = ForeignKeyTarget.objects.all() serializer = ForeignKeySourceSerializer(instance, data=data)
# new_serializer = ForeignKeyTargetSerializer(queryset, many=True) self.assertFalse(serializer.is_valid())
# expected = [ self.assertEqual(serializer.errors, {'target': ['Object with name=123 does not exist.']})
# {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
# {'id': 2, 'name': 'target-2', 'sources': []}, def test_reverse_foreign_key_update(self):
# ] data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}
# self.assertEqual(new_serializer.data, expected) instance = ForeignKeyTarget.objects.get(pk=2)
serializer = ForeignKeyTargetSerializer(instance, data=data)
# serializer.save() self.assertTrue(serializer.is_valid())
# self.assertEqual(serializer.data, data) # We shouldn't have saved anything to the db yet since save
# hasn't been called.
# # Ensure target 2 is update, and everything else is as expected queryset = ForeignKeyTarget.objects.all()
# queryset = ForeignKeyTarget.objects.all() new_serializer = ForeignKeyTargetSerializer(queryset, many=True)
# serializer = ForeignKeyTargetSerializer(queryset, many=True) expected = [
# expected = [ {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
# {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, {'id': 2, 'name': 'target-2', 'sources': []},
# {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}, ]
# ] self.assertEqual(new_serializer.data, expected)
# self.assertEqual(serializer.data, expected)
serializer.save()
# def test_foreign_key_create(self): self.assertEqual(serializer.data, data)
# data = {'id': 4, 'name': 'source-4', 'target': 'target-2'}
# serializer = ForeignKeySourceSerializer(data=data) # Ensure target 2 is update, and everything else is as expected
# serializer.is_valid() queryset = ForeignKeyTarget.objects.all()
# self.assertTrue(serializer.is_valid()) serializer = ForeignKeyTargetSerializer(queryset, many=True)
# obj = serializer.save() expected = [
# self.assertEqual(serializer.data, data) {'id': 1, 'name': 'target-1', 'sources': ['source-2']},
# self.assertEqual(obj.name, 'source-4') {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']},
]
# # Ensure source 4 is added, and everything else is as expected self.assertEqual(serializer.data, expected)
# queryset = ForeignKeySource.objects.all()
# serializer = ForeignKeySourceSerializer(queryset, many=True) def test_foreign_key_create(self):
# expected = [ data = {'id': 4, 'name': 'source-4', 'target': 'target-2'}
# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, serializer = ForeignKeySourceSerializer(data=data)
# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, serializer.is_valid()
# {'id': 3, 'name': 'source-3', 'target': 'target-1'}, self.assertTrue(serializer.is_valid())
# {'id': 4, 'name': 'source-4', 'target': 'target-2'}, obj = serializer.save()
# ] self.assertEqual(serializer.data, data)
# self.assertEqual(serializer.data, expected) self.assertEqual(obj.name, 'source-4')
# def test_reverse_foreign_key_create(self): # Ensure source 4 is added, and everything else is as expected
# data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']} queryset = ForeignKeySource.objects.all()
# serializer = ForeignKeyTargetSerializer(data=data) serializer = ForeignKeySourceSerializer(queryset, many=True)
# self.assertTrue(serializer.is_valid()) expected = [
# obj = serializer.save() {'id': 1, 'name': 'source-1', 'target': 'target-1'},
# self.assertEqual(serializer.data, data) {'id': 2, 'name': 'source-2', 'target': 'target-1'},
# self.assertEqual(obj.name, 'target-3') {'id': 3, 'name': 'source-3', 'target': 'target-1'},
{'id': 4, 'name': 'source-4', 'target': 'target-2'},
# # Ensure target 3 is added, and everything else is as expected ]
# queryset = ForeignKeyTarget.objects.all() self.assertEqual(serializer.data, expected)
# serializer = ForeignKeyTargetSerializer(queryset, many=True)
# expected = [ def test_reverse_foreign_key_create(self):
# {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}
# {'id': 2, 'name': 'target-2', 'sources': []}, serializer = ForeignKeyTargetSerializer(data=data)
# {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}, self.assertTrue(serializer.is_valid())
# ] obj = serializer.save()
# self.assertEqual(serializer.data, expected) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'target-3')
# def test_foreign_key_update_with_invalid_null(self):
# data = {'id': 1, 'name': 'source-1', 'target': None} # Ensure target 3 is added, and everything else is as expected
# instance = ForeignKeySource.objects.get(pk=1) queryset = ForeignKeyTarget.objects.all()
# serializer = ForeignKeySourceSerializer(instance, data=data) serializer = ForeignKeyTargetSerializer(queryset, many=True)
# self.assertFalse(serializer.is_valid()) expected = [
# self.assertEqual(serializer.errors, {'target': ['This field is required.']}) {'id': 1, 'name': 'target-1', 'sources': ['source-2']},
{'id': 2, 'name': 'target-2', 'sources': []},
{'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']},
# class SlugNullableForeignKeyTests(TestCase): ]
# def setUp(self): self.assertEqual(serializer.data, expected)
# target = ForeignKeyTarget(name='target-1')
# target.save() def test_foreign_key_update_with_invalid_null(self):
# for idx in range(1, 4): data = {'id': 1, 'name': 'source-1', 'target': None}
# if idx == 3: instance = ForeignKeySource.objects.get(pk=1)
# target = None serializer = ForeignKeySourceSerializer(instance, data=data)
# source = NullableForeignKeySource(name='source-%d' % idx, target=target) self.assertFalse(serializer.is_valid())
# source.save() self.assertEqual(serializer.errors, {'target': ['This field may not be null.']})
# def test_foreign_key_retrieve_with_null(self):
# queryset = NullableForeignKeySource.objects.all() class SlugNullableForeignKeyTests(TestCase):
# serializer = NullableForeignKeySourceSerializer(queryset, many=True) def setUp(self):
# expected = [ target = ForeignKeyTarget(name='target-1')
# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, target.save()
# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, for idx in range(1, 4):
# {'id': 3, 'name': 'source-3', 'target': None}, if idx == 3:
# ] target = None
# self.assertEqual(serializer.data, expected) source = NullableForeignKeySource(name='source-%d' % idx, target=target)
source.save()
# def test_foreign_key_create_with_valid_null(self):
# data = {'id': 4, 'name': 'source-4', 'target': None} def test_foreign_key_retrieve_with_null(self):
# serializer = NullableForeignKeySourceSerializer(data=data) queryset = NullableForeignKeySource.objects.all()
# self.assertTrue(serializer.is_valid()) serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# obj = serializer.save() expected = [
# self.assertEqual(serializer.data, data) {'id': 1, 'name': 'source-1', 'target': 'target-1'},
# self.assertEqual(obj.name, 'source-4') {'id': 2, 'name': 'source-2', 'target': 'target-1'},
{'id': 3, 'name': 'source-3', 'target': None},
# # Ensure source 4 is created, and everything else is as expected ]
# queryset = NullableForeignKeySource.objects.all() self.assertEqual(serializer.data, expected)
# serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# expected = [ def test_foreign_key_create_with_valid_null(self):
# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, data = {'id': 4, 'name': 'source-4', 'target': None}
# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, serializer = NullableForeignKeySourceSerializer(data=data)
# {'id': 3, 'name': 'source-3', 'target': None}, self.assertTrue(serializer.is_valid())
# {'id': 4, 'name': 'source-4', 'target': None} obj = serializer.save()
# ] self.assertEqual(serializer.data, data)
# self.assertEqual(serializer.data, expected) self.assertEqual(obj.name, 'source-4')
# def test_foreign_key_create_with_valid_emptystring(self): # Ensure source 4 is created, and everything else is as expected
# """ queryset = NullableForeignKeySource.objects.all()
# The emptystring should be interpreted as null in the context serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# of relationships. expected = [
# """ {'id': 1, 'name': 'source-1', 'target': 'target-1'},
# data = {'id': 4, 'name': 'source-4', 'target': ''} {'id': 2, 'name': 'source-2', 'target': 'target-1'},
# expected_data = {'id': 4, 'name': 'source-4', 'target': None} {'id': 3, 'name': 'source-3', 'target': None},
# serializer = NullableForeignKeySourceSerializer(data=data) {'id': 4, 'name': 'source-4', 'target': None}
# self.assertTrue(serializer.is_valid()) ]
# obj = serializer.save() self.assertEqual(serializer.data, expected)
# self.assertEqual(serializer.data, expected_data)
# self.assertEqual(obj.name, 'source-4') def test_foreign_key_create_with_valid_emptystring(self):
"""
# # Ensure source 4 is created, and everything else is as expected The emptystring should be interpreted as null in the context
# queryset = NullableForeignKeySource.objects.all() of relationships.
# serializer = NullableForeignKeySourceSerializer(queryset, many=True) """
# expected = [ data = {'id': 4, 'name': 'source-4', 'target': ''}
# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, expected_data = {'id': 4, 'name': 'source-4', 'target': None}
# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, serializer = NullableForeignKeySourceSerializer(data=data)
# {'id': 3, 'name': 'source-3', 'target': None}, self.assertTrue(serializer.is_valid())
# {'id': 4, 'name': 'source-4', 'target': None} obj = serializer.save()
# ] self.assertEqual(serializer.data, expected_data)
# self.assertEqual(serializer.data, expected) self.assertEqual(obj.name, 'source-4')
# def test_foreign_key_update_with_valid_null(self): # Ensure source 4 is created, and everything else is as expected
# data = {'id': 1, 'name': 'source-1', 'target': None} queryset = NullableForeignKeySource.objects.all()
# instance = NullableForeignKeySource.objects.get(pk=1) serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# serializer = NullableForeignKeySourceSerializer(instance, data=data) expected = [
# self.assertTrue(serializer.is_valid()) {'id': 1, 'name': 'source-1', 'target': 'target-1'},
# self.assertEqual(serializer.data, data) {'id': 2, 'name': 'source-2', 'target': 'target-1'},
# serializer.save() {'id': 3, 'name': 'source-3', 'target': None},
{'id': 4, 'name': 'source-4', 'target': None}
# # Ensure source 1 is updated, and everything else is as expected ]
# queryset = NullableForeignKeySource.objects.all() self.assertEqual(serializer.data, expected)
# serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# expected = [ def test_foreign_key_update_with_valid_null(self):
# {'id': 1, 'name': 'source-1', 'target': None}, data = {'id': 1, 'name': 'source-1', 'target': None}
# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, instance = NullableForeignKeySource.objects.get(pk=1)
# {'id': 3, 'name': 'source-3', 'target': None} serializer = NullableForeignKeySourceSerializer(instance, data=data)
# ] self.assertTrue(serializer.is_valid())
# self.assertEqual(serializer.data, expected) serializer.save()
self.assertEqual(serializer.data, data)
# def test_foreign_key_update_with_valid_emptystring(self):
# """ # Ensure source 1 is updated, and everything else is as expected
# The emptystring should be interpreted as null in the context queryset = NullableForeignKeySource.objects.all()
# of relationships. serializer = NullableForeignKeySourceSerializer(queryset, many=True)
# """ expected = [
# data = {'id': 1, 'name': 'source-1', 'target': ''} {'id': 1, 'name': 'source-1', 'target': None},
# expected_data = {'id': 1, 'name': 'source-1', 'target': None} {'id': 2, 'name': 'source-2', 'target': 'target-1'},
# instance = NullableForeignKeySource.objects.get(pk=1) {'id': 3, 'name': 'source-3', 'target': None}
# serializer = NullableForeignKeySourceSerializer(instance, data=data) ]
# self.assertTrue(serializer.is_valid()) self.assertEqual(serializer.data, expected)
# self.assertEqual(serializer.data, expected_data)
# serializer.save() def test_foreign_key_update_with_valid_emptystring(self):
"""
# # Ensure source 1 is updated, and everything else is as expected The emptystring should be interpreted as null in the context
# queryset = NullableForeignKeySource.objects.all() of relationships.
# serializer = NullableForeignKeySourceSerializer(queryset, many=True) """
# expected = [ data = {'id': 1, 'name': 'source-1', 'target': ''}
# {'id': 1, 'name': 'source-1', 'target': None}, expected_data = {'id': 1, 'name': 'source-1', 'target': None}
# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, instance = NullableForeignKeySource.objects.get(pk=1)
# {'id': 3, 'name': 'source-3', 'target': None} serializer = NullableForeignKeySourceSerializer(instance, data=data)
# ] self.assertTrue(serializer.is_valid())
# self.assertEqual(serializer.data, expected) serializer.save()
self.assertEqual(serializer.data, expected_data)
# Ensure source 1 is updated, and everything else is as expected
queryset = NullableForeignKeySource.objects.all()
serializer = NullableForeignKeySourceSerializer(queryset, many=True)
expected = [
{'id': 1, 'name': 'source-1', 'target': None},
{'id': 2, 'name': 'source-2', 'target': 'target-1'},
{'id': 3, 'name': 'source-3', 'target': None}
]
self.assertEqual(serializer.data, expected)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment