From 6b4bb48dd410d0a878b0142d351c7c41cd51f819 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 12 Mar 2013 13:33:02 +0000
Subject: Initial support for writable nested serialization (Not
 ModelSerializer)

---
 rest_framework/serializers.py             | 70 +++++++++++++++++++++++--------
 rest_framework/tests/serializer_nested.py | 62 +++++++++++++++++++++++++++
 2 files changed, 115 insertions(+), 17 deletions(-)
 create mode 100644 rest_framework/tests/serializer_nested.py

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 2ae7c215..81619b3a 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -20,6 +20,11 @@ from rest_framework.relations import *
 from rest_framework.fields import *
 
 
+class NestedValidationError(ValidationError):
+    def __init__(self, message):
+        self.messages = message
+
+
 class DictWithMetadata(dict):
     """
     A dict-like object, that can have additional properties attached.
@@ -98,7 +103,7 @@ class SerializerOptions(object):
         self.exclude = getattr(meta, 'exclude', ())
 
 
-class BaseSerializer(Field):
+class BaseSerializer(WritableField):
     """
     This is the Serializer implementation.
     We need to implement it as `BaseSerializer` due to metaclass magicks.
@@ -303,33 +308,64 @@ class BaseSerializer(Field):
             return self.to_native(obj)
 
         try:
-            if self.source:
-                for component in self.source.split('.'):
-                    obj = getattr(obj, component)
-                    if is_simple_callable(obj):
-                        obj = obj()
-            else:
-                obj = getattr(obj, field_name)
-                if is_simple_callable(obj):
-                    obj = obj()
+            source = self.source or field_name
+            value = obj
+
+            for component in source.split('.'):
+                value = get_component(value, component)
+                if value is None:
+                    break
         except ObjectDoesNotExist:
             return None
 
-        # If the object has an "all" method, assume it's a relationship
-        if is_simple_callable(getattr(obj, 'all', None)):
-            return [self.to_native(item) for item in obj.all()]
+        if is_simple_callable(getattr(value, 'all', None)):
+            return [self.to_native(item) for item in value.all()]
 
-        if obj is None:
+        if value is None:
             return None
 
         if self.many is not None:
             many = self.many
         else:
-            many = hasattr(obj, '__iter__') and not isinstance(obj, (Page, dict, six.text_type))
+            many = hasattr(value, '__iter__') and not isinstance(value, (Page, dict, six.text_type))
 
         if many:
-            return [self.to_native(item) for item in obj]
-        return self.to_native(obj)
+            return [self.to_native(item) for item in value]
+        return self.to_native(value)
+
+    def field_from_native(self, data, files, field_name, into):
+        if self.read_only:
+            return
+
+        try:
+            value = data[field_name]
+        except KeyError:
+            if self.required:
+                raise ValidationError(self.error_messages['required'])
+            return
+
+        if self.parent.object:
+            # Set the serializer object if it exists
+            obj = getattr(self.parent.object, field_name)
+            self.object = obj
+
+        if value in (None, ''):
+            into[(self.source or field_name)] = None
+        else:
+            kwargs = {
+                'data': value,
+                'context': self.context,
+                'partial': self.partial,
+                'many': self.many
+            }
+            serializer = self.__class__(**kwargs)
+
+            if serializer.is_valid():
+                self.object = serializer.object
+                into[self.source or field_name] = serializer.object
+            else:
+                # Propagate errors up to our parent
+                raise NestedValidationError(serializer.errors)
 
     @property
     def errors(self):
diff --git a/rest_framework/tests/serializer_nested.py b/rest_framework/tests/serializer_nested.py
new file mode 100644
index 00000000..c8987bc5
--- /dev/null
+++ b/rest_framework/tests/serializer_nested.py
@@ -0,0 +1,62 @@
+from __future__ import unicode_literals
+from django.test import TestCase
+from rest_framework import serializers
+
+
+class TrackSerializer(serializers.Serializer):
+    order = serializers.IntegerField()
+    title = serializers.CharField(max_length=100)
+    duration = serializers.IntegerField()
+
+
+class AlbumSerializer(serializers.Serializer):
+    album_name = serializers.CharField(max_length=100)
+    artist = serializers.CharField(max_length=100)
+    tracks = TrackSerializer(many=True)
+
+
+class NestedSerializerTestCase(TestCase):
+    def test_nested_validation_success(self):
+        """
+        Correct nested serialization should return the input data.
+        """
+
+        data = {
+            'album_name': 'Discovery',
+            'artist': 'Daft Punk',
+            'tracks': [
+                {'order': 1, 'title': 'One More Time', 'duration': 235},
+                {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
+                {'order': 3, 'title': 'Digital Love', 'duration': 239}
+            ]
+        }
+
+        serializer = AlbumSerializer(data=data)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.data, data)
+
+    def test_nested_validation_error(self):
+        """
+        Incorrect nested serialization should return appropriate error data.
+        """
+
+        data = {
+            'album_name': 'Discovery',
+            'artist': 'Daft Punk',
+            'tracks': [
+                {'order': 1, 'title': 'One More Time', 'duration': 235},
+                {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
+                {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'}
+            ]
+        }
+        expected_errors = {
+            'tracks': [
+                {},
+                {},
+                {'duration': ['Enter a whole number.']}
+            ]
+        }
+
+        serializer = AlbumSerializer(data=data)
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, expected_errors)
-- 
cgit v1.2.3


From d8c5dca9aea5ad073936c1c5b3975ed53a6aeca8 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 12 Mar 2013 18:34:52 +0000
Subject: Extra tests for nested serializers

---
 rest_framework/tests/serializer_nested.py | 206 ++++++++++++++++++++++++++++--
 1 file changed, 194 insertions(+), 12 deletions(-)

(limited to 'rest_framework')

diff --git a/rest_framework/tests/serializer_nested.py b/rest_framework/tests/serializer_nested.py
index c8987bc5..fcf644c7 100644
--- a/rest_framework/tests/serializer_nested.py
+++ b/rest_framework/tests/serializer_nested.py
@@ -1,21 +1,30 @@
+"""
+Tests to cover nested serializers.
+"""
 from __future__ import unicode_literals
 from django.test import TestCase
 from rest_framework import serializers
 
 
-class TrackSerializer(serializers.Serializer):
-    order = serializers.IntegerField()
-    title = serializers.CharField(max_length=100)
-    duration = serializers.IntegerField()
+class WritableNestedSerializerBasicTests(TestCase):
+    """
+    Tests for deserializing nested entities.
+    Basic tests that use serializers that simply restore to dicts.
+    """
 
+    def setUp(self):
+        class TrackSerializer(serializers.Serializer):
+            order = serializers.IntegerField()
+            title = serializers.CharField(max_length=100)
+            duration = serializers.IntegerField()
 
-class AlbumSerializer(serializers.Serializer):
-    album_name = serializers.CharField(max_length=100)
-    artist = serializers.CharField(max_length=100)
-    tracks = TrackSerializer(many=True)
+        class AlbumSerializer(serializers.Serializer):
+            album_name = serializers.CharField(max_length=100)
+            artist = serializers.CharField(max_length=100)
+            tracks = TrackSerializer(many=True)
 
+        self.AlbumSerializer = AlbumSerializer
 
-class NestedSerializerTestCase(TestCase):
     def test_nested_validation_success(self):
         """
         Correct nested serialization should return the input data.
@@ -31,9 +40,9 @@ class NestedSerializerTestCase(TestCase):
             ]
         }
 
-        serializer = AlbumSerializer(data=data)
+        serializer = self.AlbumSerializer(data=data)
         self.assertEqual(serializer.is_valid(), True)
-        self.assertEqual(serializer.data, data)
+        self.assertEqual(serializer.object, data)
 
     def test_nested_validation_error(self):
         """
@@ -57,6 +66,179 @@ class NestedSerializerTestCase(TestCase):
             ]
         }
 
-        serializer = AlbumSerializer(data=data)
+        serializer = self.AlbumSerializer(data=data)
         self.assertEqual(serializer.is_valid(), False)
         self.assertEqual(serializer.errors, expected_errors)
+
+    def test_many_nested_validation_error(self):
+        """
+        Incorrect nested serialization should return appropriate error data
+        when multiple entities are being deserialized.
+        """
+
+        data = [
+            {
+                'album_name': 'Russian Red',
+                'artist': 'I Love Your Glasses',
+                'tracks': [
+                    {'order': 1, 'title': 'Cigarettes', 'duration': 121},
+                    {'order': 2, 'title': 'No Past Land', 'duration': 198},
+                    {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191}
+                ]
+            },
+            {
+                'album_name': 'Discovery',
+                'artist': 'Daft Punk',
+                'tracks': [
+                    {'order': 1, 'title': 'One More Time', 'duration': 235},
+                    {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
+                    {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'}
+                ]
+            }
+        ]
+        expected_errors = [
+            {},
+            {
+                'tracks': [
+                    {},
+                    {},
+                    {'duration': ['Enter a whole number.']}
+                ]
+            }
+        ]
+
+        serializer = self.AlbumSerializer(data=data)
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, expected_errors)
+
+
+class WritableNestedSerializerObjectTests(TestCase):
+    """
+    Tests for deserializing nested entities.
+    These tests use serializers that restore to concrete objects.
+    """
+
+    def setUp(self):
+        # Couple of concrete objects that we're going to deserialize into
+        class Track(object):
+            def __init__(self, order, title, duration):
+                self.order, self.title, self.duration = order, title, duration
+
+            def __cmp__(self, other):
+                return (
+                    self.order == other.order and
+                    self.title == other.title and
+                    self.duration == other.duration
+                )
+
+        class Album(object):
+            def __init__(self, album_name, artist, tracks):
+                self.album_name, self.artist, self.tracks = album_name, artist, tracks
+
+            def __cmp__(self, other):
+                return (
+                    self.album_name == other.album_name and
+                    self.artist == other.artist and
+                    self.tracks == other.tracks
+                )
+
+        # And their corresponding serializers
+        class TrackSerializer(serializers.Serializer):
+            order = serializers.IntegerField()
+            title = serializers.CharField(max_length=100)
+            duration = serializers.IntegerField()
+
+            def restore_object(self, attrs, instance=None):
+                return Track(attrs['order'], attrs['title'], attrs['duration'])
+
+        class AlbumSerializer(serializers.Serializer):
+            album_name = serializers.CharField(max_length=100)
+            artist = serializers.CharField(max_length=100)
+            tracks = TrackSerializer(many=True)
+
+            def restore_object(self, attrs, instance=None):
+                return Album(attrs['album_name'], attrs['artist'], attrs['tracks'])
+
+        self.Album, self.Track = Album, Track
+        self.AlbumSerializer = AlbumSerializer
+
+    def test_nested_validation_success(self):
+        """
+        Correct nested serialization should return a restored object
+        that corresponds to the input data.
+        """
+
+        data = {
+            'album_name': 'Discovery',
+            'artist': 'Daft Punk',
+            'tracks': [
+                {'order': 1, 'title': 'One More Time', 'duration': 235},
+                {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
+                {'order': 3, 'title': 'Digital Love', 'duration': 239}
+            ]
+        }
+        expected_object = self.Album(
+            album_name='Discovery',
+            artist='Daft Punk',
+            tracks=[
+                self.Track(order=1, title='One More Time', duration=235),
+                self.Track(order=2, title='Aerodynamic', duration=184),
+                self.Track(order=3, title='Digital Love', duration=239),
+            ]
+        )
+
+        serializer = self.AlbumSerializer(data=data)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.object, expected_object)
+
+    def test_many_nested_validation_success(self):
+        """
+        Correct nested serialization should return multiple restored objects
+        that corresponds to the input data when multiple objects are
+        being deserialized.
+        """
+
+        data = [
+            {
+                'album_name': 'Russian Red',
+                'artist': 'I Love Your Glasses',
+                'tracks': [
+                    {'order': 1, 'title': 'Cigarettes', 'duration': 121},
+                    {'order': 2, 'title': 'No Past Land', 'duration': 198},
+                    {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191}
+                ]
+            },
+            {
+                'album_name': 'Discovery',
+                'artist': 'Daft Punk',
+                'tracks': [
+                    {'order': 1, 'title': 'One More Time', 'duration': 235},
+                    {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
+                    {'order': 3, 'title': 'Digital Love', 'duration': 239}
+                ]
+            }
+        ]
+        expected_object = [
+            self.Album(
+                album_name='Russian Red',
+                artist='I Love Your Glasses',
+                tracks=[
+                    self.Track(order=1, title='Cigarettes', duration=121),
+                    self.Track(order=2, title='No Past Land', duration=198),
+                    self.Track(order=3, title='They Don\'t Believe', duration=191),
+                ]
+            ),
+            self.Album(
+                album_name='Discovery',
+                artist='Daft Punk',
+                tracks=[
+                    self.Track(order=1, title='One More Time', duration=235),
+                    self.Track(order=2, title='Aerodynamic', duration=184),
+                    self.Track(order=3, title='Digital Love', duration=239),
+                ]
+            )
+        ]
+
+        serializer = self.AlbumSerializer(data=data)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.object, expected_object)
-- 
cgit v1.2.3


From 2f1951910f264852b530c94c3a9946afe10eedd2 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 12 Mar 2013 18:35:20 +0000
Subject: Descriptive text for NestedValidationError

---
 rest_framework/serializers.py | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 81619b3a..f83451d3 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -21,6 +21,16 @@ from rest_framework.fields import *
 
 
 class NestedValidationError(ValidationError):
+    """
+    The default ValidationError behavior is to stringify each item in the list
+    if the messages are a list of error messages.
+
+    In the case of nested serializers, where the parent has many children,
+    then the child's `serializer.errors` will be a list of dicts.
+
+    We need to override the default behavior to get properly nested error dicts.
+    """
+
     def __init__(self, message):
         self.messages = message
 
-- 
cgit v1.2.3


From 3006e3825f29e920f881b816fd71566bf0e8d341 Mon Sep 17 00:00:00 2001
From: Mark Aaron Shirley
Date: Tue, 12 Mar 2013 20:59:25 -0700
Subject: One-to-one writable, nested serializer support

---
 rest_framework/serializers.py             |  44 ++++++++---
 rest_framework/tests/nesting.py           | 125 ++++++++++++++++++++++++++++++
 rest_framework/tests/serializer_nested.py |   4 +-
 3 files changed, 160 insertions(+), 13 deletions(-)
 create mode 100644 rest_framework/tests/nesting.py

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index f83451d3..893db2ec 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -26,13 +26,17 @@ class NestedValidationError(ValidationError):
     if the messages are a list of error messages.
 
     In the case of nested serializers, where the parent has many children,
-    then the child's `serializer.errors` will be a list of dicts.
+    then the child's `serializer.errors` will be a list of dicts.  In the case
+    of a single child, the `serializer.errors` will be a dict.
 
     We need to override the default behavior to get properly nested error dicts.
     """
 
     def __init__(self, message):
-        self.messages = message
+        if isinstance(message, dict):
+            self.messages = [message]
+        else:
+            self.messages = message
 
 
 class DictWithMetadata(dict):
@@ -143,6 +147,7 @@ class BaseSerializer(WritableField):
         self._data = None
         self._files = None
         self._errors = None
+        self._delete = False
 
     #####
     # Methods to determine which fields to use when (de)serializing objects.
@@ -354,15 +359,19 @@ class BaseSerializer(WritableField):
                 raise ValidationError(self.error_messages['required'])
             return
 
-        if self.parent.object:
-            # Set the serializer object if it exists
-            obj = getattr(self.parent.object, field_name)
-            self.object = obj
+        # Set the serializer object if it exists
+        obj = getattr(self.parent.object, field_name) if self.parent.object else None
 
         if value in (None, ''):
-            into[(self.source or field_name)] = None
+            if isinstance(self, ModelSerializer):
+                self._delete = True
+                self.object = obj
+                into[(self.source or field_name)] = self
+            else:
+                into[(self.source or field_name)] = None
         else:
             kwargs = {
+                'instance': obj,
                 'data': value,
                 'context': self.context,
                 'partial': self.partial,
@@ -371,8 +380,10 @@ class BaseSerializer(WritableField):
             serializer = self.__class__(**kwargs)
 
             if serializer.is_valid():
-                self.object = serializer.object
-                into[self.source or field_name] = serializer.object
+                if isinstance(serializer, ModelSerializer):
+                    into[self.source or field_name] = serializer
+                else:
+                    into[self.source or field_name] = serializer.object
             else:
                 # Propagate errors up to our parent
                 raise NestedValidationError(serializer.errors)
@@ -664,10 +675,17 @@ class ModelSerializer(Serializer):
         if instance:
             return self.full_clean(instance)
 
-    def save_object(self, obj):
+    def save_object(self, obj, parent=None, fk_field=None):
         """
         Save the deserialized object and return it.
         """
+        if self._delete:
+            obj.delete()
+            return
+
+        if parent and fk_field:
+            setattr(self.object, fk_field, parent)
+
         obj.save()
 
         if getattr(self, 'm2m_data', None):
@@ -677,7 +695,11 @@ class ModelSerializer(Serializer):
 
         if getattr(self, 'related_data', None):
             for accessor_name, object_list in self.related_data.items():
-                setattr(self.object, accessor_name, object_list)
+                if isinstance(object_list, ModelSerializer):
+                    fk_field = self.object._meta.get_field_by_name(accessor_name)[0].field.name
+                    object_list.save_object(object_list.object, parent=self.object, fk_field=fk_field)
+                else:
+                    setattr(self.object, accessor_name, object_list)
             self.related_data = {}
 
 
diff --git a/rest_framework/tests/nesting.py b/rest_framework/tests/nesting.py
new file mode 100644
index 00000000..35b7a365
--- /dev/null
+++ b/rest_framework/tests/nesting.py
@@ -0,0 +1,125 @@
+from __future__ import unicode_literals
+from django.db import models
+from django.test import TestCase
+from rest_framework import serializers
+
+
+class OneToOneTarget(models.Model):
+    name = models.CharField(max_length=100)
+
+
+class OneToOneTargetSource(models.Model):
+    name = models.CharField(max_length=100)
+    target = models.OneToOneField(OneToOneTarget, null=True, blank=True,
+                                  related_name='target_source')
+
+
+class OneToOneSource(models.Model):
+    name = models.CharField(max_length=100)
+    target_source = models.OneToOneField(OneToOneTargetSource, related_name='source')
+
+
+class OneToOneSourceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = OneToOneSource
+        exclude = ('target_source', )
+
+
+class OneToOneTargetSourceSerializer(serializers.ModelSerializer):
+    source = OneToOneSourceSerializer()
+
+    class Meta:
+        model = OneToOneTargetSource
+        exclude = ('target', )
+
+class OneToOneTargetSerializer(serializers.ModelSerializer):
+    target_source = OneToOneTargetSourceSerializer()
+
+    class Meta:
+        model = OneToOneTarget
+
+
+class NestedOneToOneTests(TestCase):
+    def setUp(self):
+        for idx in range(1, 4):
+            target = OneToOneTarget(name='target-%d' % idx)
+            target.save()
+            target_source = OneToOneTargetSource(name='target-source-%d' % idx, target=target)
+            target_source.save()
+            source = OneToOneSource(name='source-%d' % idx, target_source=target_source)
+            source.save()
+
+    def test_one_to_one_retrieve(self):
+        queryset = OneToOneTarget.objects.all()
+        serializer = OneToOneTargetSerializer(queryset)
+        expected = [
+            {'id': 1, 'name': 'target-1', 'target_source': {'id': 1, 'name': 'target-source-1', 'source': {'id': 1, 'name': 'source-1'}}},
+            {'id': 2, 'name': 'target-2', 'target_source': {'id': 2, 'name': 'target-source-2', 'source': {'id': 2, 'name': 'source-2'}}},
+            {'id': 3, 'name': 'target-3', 'target_source': {'id': 3, 'name': 'target-source-3', 'source': {'id': 3, 'name': 'source-3'}}}            
+        ]
+        self.assertEqual(serializer.data, expected)
+        
+
+    def test_one_to_one_create(self):
+        data = {'id': 4, 'name': 'target-4', 'target_source': {'id': 4, 'name': 'target-source-4', 'source': {'id': 4, 'name': 'source-4'}}}
+        serializer = OneToOneTargetSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+        obj = serializer.save()
+        self.assertEqual(serializer.data, data)
+        self.assertEqual(obj.name, 'target-4')
+
+        # Ensure (target 4, target_source 4, source 4) are added, and
+        # everything else is as expected.
+        queryset = OneToOneTarget.objects.all()
+        serializer = OneToOneTargetSerializer(queryset)
+        expected = [
+            {'id': 1, 'name': 'target-1', 'target_source': {'id': 1, 'name': 'target-source-1', 'source': {'id': 1, 'name': 'source-1'}}},
+            {'id': 2, 'name': 'target-2', 'target_source': {'id': 2, 'name': 'target-source-2', 'source': {'id': 2, 'name': 'source-2'}}},
+            {'id': 3, 'name': 'target-3', 'target_source': {'id': 3, 'name': 'target-source-3', 'source': {'id': 3, 'name': 'source-3'}}},
+            {'id': 4, 'name': 'target-4', 'target_source': {'id': 4, 'name': 'target-source-4', 'source': {'id': 4, 'name': 'source-4'}}}
+        ]
+        self.assertEqual(serializer.data, expected)
+
+    def test_one_to_one_create_with_invalid_data(self):
+        data = {'id': 4, 'name': 'target-4', 'target_source': {'id': 4, 'name': 'target-source-4', 'source': {'id': 4}}}
+        serializer = OneToOneTargetSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEqual(serializer.errors, {'target_source': [{'source': [{'name': ['This field is required.']}]}]})
+
+    def test_one_to_one_update(self):
+        data = {'id': 3, 'name': 'target-3-updated', 'target_source': {'id': 3, 'name': 'target-source-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}}}
+        instance = OneToOneTarget.objects.get(pk=3)
+        serializer = OneToOneTargetSerializer(instance, data=data)
+        self.assertTrue(serializer.is_valid())
+        obj = serializer.save()
+        self.assertEqual(serializer.data, data)
+        self.assertEqual(obj.name, 'target-3-updated')
+
+        # Ensure (target 3, target_source 3, source 3) are updated,
+        # and everything else is as expected.
+        queryset = OneToOneTarget.objects.all()
+        serializer = OneToOneTargetSerializer(queryset)
+        expected = [
+            {'id': 1, 'name': 'target-1', 'target_source': {'id': 1, 'name': 'target-source-1', 'source': {'id': 1, 'name': 'source-1'}}},
+            {'id': 2, 'name': 'target-2', 'target_source': {'id': 2, 'name': 'target-source-2', 'source': {'id': 2, 'name': 'source-2'}}},
+            {'id': 3, 'name': 'target-3-updated', 'target_source': {'id': 3, 'name': 'target-source-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}}}
+        ]
+        self.assertEqual(serializer.data, expected)
+
+    def test_one_to_one_delete(self):
+        data = {'id': 3, 'name': 'target-3', 'target_source': None}
+        instance = OneToOneTarget.objects.get(pk=3)
+        serializer = OneToOneTargetSerializer(instance, data=data)
+        self.assertTrue(serializer.is_valid())
+        obj = serializer.save()
+
+        # Ensure (target_source 3, source 3) are deleted,
+        # and everything else is as expected.
+        queryset = OneToOneTarget.objects.all()
+        serializer = OneToOneTargetSerializer(queryset)
+        expected = [
+            {'id': 1, 'name': 'target-1', 'target_source': {'id': 1, 'name': 'target-source-1', 'source': {'id': 1, 'name': 'source-1'}}},
+            {'id': 2, 'name': 'target-2', 'target_source': {'id': 2, 'name': 'target-source-2', 'source': {'id': 2, 'name': 'source-2'}}},
+            {'id': 3, 'name': 'target-3', 'target_source': None}
+        ]
+        self.assertEqual(serializer.data, expected)
diff --git a/rest_framework/tests/serializer_nested.py b/rest_framework/tests/serializer_nested.py
index fcf644c7..299c3bc5 100644
--- a/rest_framework/tests/serializer_nested.py
+++ b/rest_framework/tests/serializer_nested.py
@@ -124,7 +124,7 @@ class WritableNestedSerializerObjectTests(TestCase):
             def __init__(self, order, title, duration):
                 self.order, self.title, self.duration = order, title, duration
 
-            def __cmp__(self, other):
+            def __eq__(self, other):
                 return (
                     self.order == other.order and
                     self.title == other.title and
@@ -135,7 +135,7 @@ class WritableNestedSerializerObjectTests(TestCase):
             def __init__(self, album_name, artist, tracks):
                 self.album_name, self.artist, self.tracks = album_name, artist, tracks
 
-            def __cmp__(self, other):
+            def __eq__(self, other):
                 return (
                     self.album_name == other.album_name and
                     self.artist == other.artist and
-- 
cgit v1.2.3


From 47492e3ef4e24ecd155091247e479851789ee8e9 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 15 Mar 2013 19:22:31 +0000
Subject: Clean out ModelSerializer special casing from
 Serializer.field_from_native

---
 rest_framework/serializers.py | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index f073e00a..5dadebb2 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -379,11 +379,7 @@ class BaseSerializer(WritableField):
             serializer = self.__class__(**kwargs)
 
             if serializer.is_valid():
-                if isinstance(serializer, ModelSerializer):
-                    into[self.source or field_name] = serializer
-                else:
-                    into[self.source or field_name] = serializer.object
-                # into[self.source or field_name] = serializer.object
+                into[self.source or field_name] = serializer.object
             else:
                 # Propagate errors up to our parent
                 raise NestedValidationError(serializer.errors)
@@ -681,12 +677,6 @@ class ModelSerializer(Serializer):
         if instance:
             return self.full_clean(instance)
 
-#     def save_object(self, obj, **kwargs):
-#         """
-#         Save the deserialized object and return it.
-#         """
-#         obj.save(**kwargs)
-# =======
     def save_object(self, obj, parent=None, fk_field=None, **kwargs):
         """
         Save the deserialized object and return it.
@@ -706,13 +696,10 @@ class ModelSerializer(Serializer):
                 if related is None:
                     previous = getattr(self.object, accessor_name, related)
                     previous.delete()
-                elif isinstance(related, ModelSerializer):
-                    # print related.object
-                    # print related.related_data, related.m2m_data
+                elif isinstance(related, models.Model):
                     fk_field = obj._meta.get_field_by_name(accessor_name)[0].field.name
-                    related.save_object(related.object, parent=self.object, fk_field=fk_field)
-                    # setattr(related, fk_field, obj)
-                    # related.save(**kwargs)
+                    setattr(related, fk_field, obj)
+                    self.save_object(related)
                 else:
                     setattr(self.object, accessor_name, related)
             obj._related_data = {}
-- 
cgit v1.2.3


From 32e0e5e18c84e7b720c74df8aeba26e0f335bbf6 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 15 Mar 2013 19:55:32 +0000
Subject: Remove erronous _delete attribute

---
 rest_framework/serializers.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 5dadebb2..691d2aab 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -147,7 +147,6 @@ class BaseSerializer(WritableField):
         self._data = None
         self._files = None
         self._errors = None
-        self._delete = False
 
     #####
     # Methods to determine which fields to use when (de)serializing objects.
-- 
cgit v1.2.3


From 56653111a6848f6ef5d4bb645b87cbcaf5bffba1 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 15 Mar 2013 19:57:57 +0000
Subject: Remove unneeded arguments to save_object

---
 rest_framework/serializers.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 691d2aab..ebc2eec9 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -676,13 +676,10 @@ class ModelSerializer(Serializer):
         if instance:
             return self.full_clean(instance)
 
-    def save_object(self, obj, parent=None, fk_field=None, **kwargs):
+    def save_object(self, obj, **kwargs):
         """
         Save the deserialized object and return it.
         """
-        if parent and fk_field:
-            setattr(self.object, fk_field, parent)
-
         obj.save(**kwargs)
 
         if getattr(obj, '_m2m_data', None):
-- 
cgit v1.2.3


From ccf551201feb96451ffdc5d824bb0681596bcdae Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Sat, 16 Mar 2013 07:32:50 +0000
Subject: Clean up and comment `restore_object`

---
 rest_framework/serializers.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index ebc2eec9..fb772262 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -638,31 +638,38 @@ class ModelSerializer(Serializer):
         """
         m2m_data = {}
         related_data = {}
+        meta = self.opts.model._meta
 
-        # Reverse fk relations
-        for (obj, model) in self.opts.model._meta.get_all_related_objects_with_model():
+        # Reverse fk or one-to-one relations
+        for (obj, model) in meta.get_all_related_objects_with_model():
             field_name = obj.field.related_query_name()
             if field_name in attrs:
                 related_data[field_name] = attrs.pop(field_name)
 
         # Reverse m2m relations
-        for (obj, model) in self.opts.model._meta.get_all_related_m2m_objects_with_model():
+        for (obj, model) in meta.get_all_related_m2m_objects_with_model():
             field_name = obj.field.related_query_name()
             if field_name in attrs:
                 m2m_data[field_name] = attrs.pop(field_name)
 
         # Forward m2m relations
-        for field in self.opts.model._meta.many_to_many:
+        for field in meta.many_to_many:
             if field.name in attrs:
                 m2m_data[field.name] = attrs.pop(field.name)
 
+        # Update an existing instance...
         if instance is not None:
             for key, val in attrs.items():
                 setattr(instance, key, val)
 
+        # ...or create a new instance
         else:
             instance = self.opts.model(**attrs)
 
+        # Any relations that cannot be set until we've
+        # saved the model get hidden away on these
+        # private attributes, so we can deal with them
+        # at the point of save.
         instance._related_data = related_data
         instance._m2m_data = m2m_data
 
-- 
cgit v1.2.3


From 3ff103ad043420b430cc2052241994d597b1fe8a Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Sat, 16 Mar 2013 07:35:27 +0000
Subject: Fixes to save_object

---
 rest_framework/serializers.py | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index fb772262..5826a173 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -691,21 +691,23 @@ class ModelSerializer(Serializer):
 
         if getattr(obj, '_m2m_data', None):
             for accessor_name, object_list in obj._m2m_data.items():
-                setattr(self.object, accessor_name, object_list)
-            obj._m2m_data = {}
+                setattr(obj, accessor_name, object_list)
+            del(obj._m2m_data)
 
         if getattr(obj, '_related_data', None):
             for accessor_name, related in obj._related_data.items():
                 if related is None:
-                    previous = getattr(self.object, accessor_name, related)
-                    previous.delete()
+                    previous = getattr(obj, accessor_name, related)
+                    if previous:
+                        previous.delete()
                 elif isinstance(related, models.Model):
                     fk_field = obj._meta.get_field_by_name(accessor_name)[0].field.name
                     setattr(related, fk_field, obj)
                     self.save_object(related)
                 else:
                     setattr(self.object, accessor_name, related)
-            obj._related_data = {}
+                    setattr(obj, accessor_name, related)
+            del(obj._related_data)
 
 
 class HyperlinkedModelSerializerOptions(ModelSerializerOptions):
-- 
cgit v1.2.3


From 66bdd608e1e4bbb02a815104572b80034d73aa6b Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Sat, 16 Mar 2013 07:35:44 +0000
Subject: Fixes to save_object

---
 rest_framework/serializers.py | 1 -
 1 file changed, 1 deletion(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 5826a173..21336dc2 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -705,7 +705,6 @@ class ModelSerializer(Serializer):
                     setattr(related, fk_field, obj)
                     self.save_object(related)
                 else:
-                    setattr(self.object, accessor_name, related)
                     setattr(obj, accessor_name, related)
             del(obj._related_data)
 
-- 
cgit v1.2.3


From c8416df0c4b7179eeaf86b61c32907f32494b85c Mon Sep 17 00:00:00 2001
From: Craig de Stigter
Date: Mon, 18 Mar 2013 14:27:15 +1300
Subject: accept all WritableField kwargs for writable serializers (eg
 required=True)

---
 rest_framework/serializers.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 21336dc2..c6599886 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -129,8 +129,8 @@ class BaseSerializer(WritableField):
     _dict_class = SortedDictWithMetadata
 
     def __init__(self, instance=None, data=None, files=None,
-                 context=None, partial=False, many=None, source=None):
-        super(BaseSerializer, self).__init__(source=source)
+                 context=None, partial=False, many=None, **kwargs):
+        super(BaseSerializer, self).__init__(**kwargs)
         self.opts = self._options_class(self.Meta)
         self.parent = None
         self.root = None
-- 
cgit v1.2.3


From d6d5b1d82a4ccc1a2fe29ff18e9ecf7c196a07a5 Mon Sep 17 00:00:00 2001
From: Craig de Stigter
Date: Mon, 18 Mar 2013 14:50:08 +1300
Subject: allow default values in writable serializer fields

---
 rest_framework/serializers.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index c6599886..cc6d60da 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -360,7 +360,9 @@ class BaseSerializer(WritableField):
         except KeyError:
             if self.required:
                 raise ValidationError(self.error_messages['required'])
-            return
+            if self.default is None:
+                return
+            value = copy.deepcopy(self.default)
 
         # Set the serializer object if it exists
         obj = getattr(self.parent.object, field_name) if self.parent.object else None
-- 
cgit v1.2.3


From 101fa26ebc092a43acbf3f28617eb58be7629b5f Mon Sep 17 00:00:00 2001
From: Craig de Stigter
Date: Mon, 18 Mar 2013 16:05:34 +1300
Subject: use writablefield style for serializer handling of self.default

---
 rest_framework/serializers.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index cc6d60da..a81cbc29 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -358,11 +358,13 @@ class BaseSerializer(WritableField):
         try:
             value = data[field_name]
         except KeyError:
-            if self.required:
-                raise ValidationError(self.error_messages['required'])
-            if self.default is None:
+            if self.default is not None and not self.partial:
+                # Note: partial updates shouldn't set defaults
+                value = copy.deepcopy(self.default)
+            else:
+                if self.required:
+                    raise ValidationError(self.error_messages['required'])
                 return
-            value = copy.deepcopy(self.default)
 
         # Set the serializer object if it exists
         obj = getattr(self.parent.object, field_name) if self.parent.object else None
-- 
cgit v1.2.3


From deb5e653e441bf31f3b183b575f72e6b4cf537ea Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Mon, 18 Mar 2013 21:35:06 +0000
Subject: Added bulk create tests

---
 rest_framework/tests/serializer_bulk_update.py | 73 ++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 rest_framework/tests/serializer_bulk_update.py

(limited to 'rest_framework')

diff --git a/rest_framework/tests/serializer_bulk_update.py b/rest_framework/tests/serializer_bulk_update.py
new file mode 100644
index 00000000..3ecb23ed
--- /dev/null
+++ b/rest_framework/tests/serializer_bulk_update.py
@@ -0,0 +1,73 @@
+"""
+Tests to cover bulk create and update using serializers.
+"""
+from __future__ import unicode_literals
+from django.test import TestCase
+from rest_framework import serializers
+
+
+class BulkCreateSerializerTests(TestCase):
+
+    def setUp(self):
+        class BookSerializer(serializers.Serializer):
+            id = serializers.IntegerField()
+            title = serializers.CharField(max_length=100)
+            author = serializers.CharField(max_length=100)
+
+        self.BookSerializer = BookSerializer
+
+    def test_bulk_create_success(self):
+        """
+        Correct bulk update serialization should return the input data.
+        """
+
+        data = [
+            {
+                'id': 0,
+                'title': 'The electric kool-aid acid test',
+                'author': 'Tom Wolfe'
+            }, {
+                'id': 1,
+                'title': 'If this is a man',
+                'author': 'Primo Levi'
+            }, {
+                'id': 2,
+                'title': 'The wind-up bird chronicle',
+                'author': 'Haruki Murakami'
+            }
+        ]
+
+        serializer = self.BookSerializer(data=data, many=True)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.object, data)
+
+    def test_bulk_create_errors(self):
+        """
+        Correct bulk update serialization should return the input data.
+        """
+
+        data = [
+            {
+                'id': 0,
+                'title': 'The electric kool-aid acid test',
+                'author': 'Tom Wolfe'
+            }, {
+                'id': 1,
+                'title': 'If this is a man',
+                'author': 'Primo Levi'
+            }, {
+                'id': 'foo',
+                'title': 'The wind-up bird chronicle',
+                'author': 'Haruki Murakami'
+            }
+        ]
+        expected_errors = [
+            {},
+            {},
+            {'id': ['Enter a whole number.']}
+        ]
+
+        serializer = self.BookSerializer(data=data, many=True)
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, expected_errors)
+
-- 
cgit v1.2.3


From addf7e9b36a274506cc940744487977ee8a7b574 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 22 Mar 2013 22:27:03 +0000
Subject: Defer the writable nested modelserializers work

---
 rest_framework/serializers.py            |  11 +--
 rest_framework/tests/relations_nested.py | 154 +++++++++++++++----------------
 2 files changed, 73 insertions(+), 92 deletions(-)

(limited to 'rest_framework')

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 26c34044..6aca2f57 100644
--- a/rest_framework/serializers.py
+++ b/rest_framework/serializers.py
@@ -753,16 +753,7 @@ class ModelSerializer(Serializer):
 
         if getattr(obj, '_related_data', None):
             for accessor_name, related in obj._related_data.items():
-                if related is None:
-                    previous = getattr(obj, accessor_name, related)
-                    if previous:
-                        previous.delete()
-                elif isinstance(related, models.Model):
-                    fk_field = obj._meta.get_field_by_name(accessor_name)[0].field.name
-                    setattr(related, fk_field, obj)
-                    self.save_object(related)
-                else:
-                    setattr(obj, accessor_name, related)
+                setattr(obj, accessor_name, related)
             del(obj._related_data)
 
 
diff --git a/rest_framework/tests/relations_nested.py b/rest_framework/tests/relations_nested.py
index 4592e559..a125ba65 100644
--- a/rest_framework/tests/relations_nested.py
+++ b/rest_framework/tests/relations_nested.py
@@ -1,125 +1,115 @@
 from __future__ import unicode_literals
-from django.db import models
 from django.test import TestCase
 from rest_framework import serializers
+from rest_framework.tests.models import ForeignKeyTarget, ForeignKeySource, NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource
 
 
-class OneToOneTarget(models.Model):
-    name = models.CharField(max_length=100)
-
+class ForeignKeySourceSerializer(serializers.ModelSerializer):
+    class Meta:
+        depth = 1
+        model = ForeignKeySource
 
-class OneToOneTargetSource(models.Model):
-    name = models.CharField(max_length=100)
-    target = models.OneToOneField(OneToOneTarget, null=True, blank=True,
-                                  related_name='target_source')
 
+class FlatForeignKeySourceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ForeignKeySource
 
-class OneToOneSource(models.Model):
-    name = models.CharField(max_length=100)
-    target_source = models.OneToOneField(OneToOneTargetSource, related_name='source')
 
+class ForeignKeyTargetSerializer(serializers.ModelSerializer):
+    sources = FlatForeignKeySourceSerializer(many=True)
 
-class OneToOneSourceSerializer(serializers.ModelSerializer):
     class Meta:
-        model = OneToOneSource
-        exclude = ('target_source', )
+        model = ForeignKeyTarget
+
 
+class NullableForeignKeySourceSerializer(serializers.ModelSerializer):
+    class Meta:
+        depth = 1
+        model = NullableForeignKeySource
 
-class OneToOneTargetSourceSerializer(serializers.ModelSerializer):
-    source = OneToOneSourceSerializer()
 
+class NullableOneToOneSourceSerializer(serializers.ModelSerializer):
     class Meta:
-        model = OneToOneTargetSource
-        exclude = ('target', )
+        model = NullableOneToOneSource
 
 
-class OneToOneTargetSerializer(serializers.ModelSerializer):
-    target_source = OneToOneTargetSourceSerializer()
+class NullableOneToOneTargetSerializer(serializers.ModelSerializer):
+    nullable_source = NullableOneToOneSourceSerializer()
 
     class Meta:
         model = OneToOneTarget
 
 
-class NestedOneToOneTests(TestCase):
+class ReverseForeignKeyTests(TestCase):
     def setUp(self):
+        target = ForeignKeyTarget(name='target-1')
+        target.save()
+        new_target = ForeignKeyTarget(name='target-2')
+        new_target.save()
         for idx in range(1, 4):
-            target = OneToOneTarget(name='target-%d' % idx)
-            target.save()
-            target_source = OneToOneTargetSource(name='target-source-%d' % idx, target=target)
-            target_source.save()
-            source = OneToOneSource(name='source-%d' % idx, target_source=target_source)
+            source = ForeignKeySource(name='source-%d' % idx, target=target)
             source.save()
 
-    def test_one_to_one_retrieve(self):
-        queryset = OneToOneTarget.objects.all()
-        serializer = OneToOneTargetSerializer(queryset)
+    def test_foreign_key_retrieve(self):
+        queryset = ForeignKeySource.objects.all()
+        serializer = ForeignKeySourceSerializer(queryset, many=True)
         expected = [
-            {'id': 1, 'name': 'target-1', 'target_source': {'id': 1, 'name': 'target-source-1', 'source': {'id': 1, 'name': 'source-1'}}},
-            {'id': 2, 'name': 'target-2', 'target_source': {'id': 2, 'name': 'target-source-2', 'source': {'id': 2, 'name': 'source-2'}}},
-            {'id': 3, 'name': 'target-3', 'target_source': {'id': 3, 'name': 'target-source-3', 'source': {'id': 3, 'name': 'source-3'}}}
+            {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}},
+            {'id': 2, 'name': 'source-2', 'target': {'id': 1, 'name': 'target-1'}},
+            {'id': 3, 'name': 'source-3', 'target': {'id': 1, 'name': 'target-1'}},
         ]
         self.assertEqual(serializer.data, expected)
 
-    def test_one_to_one_create(self):
-        data = {'id': 4, 'name': 'target-4', 'target_source': {'id': 4, 'name': 'target-source-4', 'source': {'id': 4, 'name': 'source-4'}}}
-        serializer = OneToOneTargetSerializer(data=data)
-        self.assertTrue(serializer.is_valid())
-        obj = serializer.save()
-        self.assertEqual(serializer.data, data)
-        self.assertEqual(obj.name, 'target-4')
-
-        # Ensure (target 4, target_source 4, source 4) are added, and
-        # everything else is as expected.
-        queryset = OneToOneTarget.objects.all()
-        serializer = OneToOneTargetSerializer(queryset)
+    def test_reverse_foreign_key_retrieve(self):
+        queryset = ForeignKeyTarget.objects.all()
+        serializer = ForeignKeyTargetSerializer(queryset, many=True)
         expected = [
-            {'id': 1, 'name': 'target-1', 'target_source': {'id': 1, 'name': 'target-source-1', 'source': {'id': 1, 'name': 'source-1'}}},
-            {'id': 2, 'name': 'target-2', 'target_source': {'id': 2, 'name': 'target-source-2', 'source': {'id': 2, 'name': 'source-2'}}},
-            {'id': 3, 'name': 'target-3', 'target_source': {'id': 3, 'name': 'target-source-3', 'source': {'id': 3, 'name': 'source-3'}}},
-            {'id': 4, 'name': 'target-4', 'target_source': {'id': 4, 'name': 'target-source-4', 'source': {'id': 4, 'name': 'source-4'}}}
+            {'id': 1, 'name': 'target-1', 'sources': [
+                {'id': 1, 'name': 'source-1', 'target': 1},
+                {'id': 2, 'name': 'source-2', 'target': 1},
+                {'id': 3, 'name': 'source-3', 'target': 1},
+            ]},
+            {'id': 2, 'name': 'target-2', 'sources': [
+            ]}
         ]
         self.assertEqual(serializer.data, expected)
 
-    def test_one_to_one_create_with_invalid_data(self):
-        data = {'id': 4, 'name': 'target-4', 'target_source': {'id': 4, 'name': 'target-source-4', 'source': {'id': 4}}}
-        serializer = OneToOneTargetSerializer(data=data)
-        self.assertFalse(serializer.is_valid())
-        self.assertEqual(serializer.errors, {'target_source': [{'source': [{'name': ['This field is required.']}]}]})
-
-    def test_one_to_one_update(self):
-        data = {'id': 3, 'name': 'target-3-updated', 'target_source': {'id': 3, 'name': 'target-source-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}}}
-        instance = OneToOneTarget.objects.get(pk=3)
-        serializer = OneToOneTargetSerializer(instance, data=data)
-        self.assertTrue(serializer.is_valid())
-        obj = serializer.save()
-        self.assertEqual(serializer.data, data)
-        self.assertEqual(obj.name, 'target-3-updated')
-
-        # Ensure (target 3, target_source 3, source 3) are updated,
-        # and everything else is as expected.
-        queryset = OneToOneTarget.objects.all()
-        serializer = OneToOneTargetSerializer(queryset)
+
+class NestedNullableForeignKeyTests(TestCase):
+    def setUp(self):
+        target = ForeignKeyTarget(name='target-1')
+        target.save()
+        for idx in range(1, 4):
+            if idx == 3:
+                target = None
+            source = NullableForeignKeySource(name='source-%d' % idx, target=target)
+            source.save()
+
+    def test_foreign_key_retrieve_with_null(self):
+        queryset = NullableForeignKeySource.objects.all()
+        serializer = NullableForeignKeySourceSerializer(queryset, many=True)
         expected = [
-            {'id': 1, 'name': 'target-1', 'target_source': {'id': 1, 'name': 'target-source-1', 'source': {'id': 1, 'name': 'source-1'}}},
-            {'id': 2, 'name': 'target-2', 'target_source': {'id': 2, 'name': 'target-source-2', 'source': {'id': 2, 'name': 'source-2'}}},
-            {'id': 3, 'name': 'target-3-updated', 'target_source': {'id': 3, 'name': 'target-source-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}}}
+            {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}},
+            {'id': 2, 'name': 'source-2', 'target': {'id': 1, 'name': 'target-1'}},
+            {'id': 3, 'name': 'source-3', 'target': None},
         ]
         self.assertEqual(serializer.data, expected)
 
-    def test_one_to_one_delete(self):
-        data = {'id': 3, 'name': 'target-3', 'target_source': None}
-        instance = OneToOneTarget.objects.get(pk=3)
-        serializer = OneToOneTargetSerializer(instance, data=data)
-        self.assertTrue(serializer.is_valid())
-        serializer.save()
 
-        # Ensure (target_source 3, source 3) are deleted,
-        # and everything else is as expected.
+class NestedNullableOneToOneTests(TestCase):
+    def setUp(self):
+        target = OneToOneTarget(name='target-1')
+        target.save()
+        new_target = OneToOneTarget(name='target-2')
+        new_target.save()
+        source = NullableOneToOneSource(name='source-1', target=target)
+        source.save()
+
+    def test_reverse_foreign_key_retrieve_with_null(self):
         queryset = OneToOneTarget.objects.all()
-        serializer = OneToOneTargetSerializer(queryset)
+        serializer = NullableOneToOneTargetSerializer(queryset, many=True)
         expected = [
-            {'id': 1, 'name': 'target-1', 'target_source': {'id': 1, 'name': 'target-source-1', 'source': {'id': 1, 'name': 'source-1'}}},
-            {'id': 2, 'name': 'target-2', 'target_source': {'id': 2, 'name': 'target-source-2', 'source': {'id': 2, 'name': 'source-2'}}},
-            {'id': 3, 'name': 'target-3', 'target_source': None}
+            {'id': 1, 'name': 'target-1', 'nullable_source': {'id': 1, 'name': 'source-1', 'target': 1}},
+            {'id': 2, 'name': 'target-2', 'nullable_source': None},
         ]
         self.assertEqual(serializer.data, expected)
-- 
cgit v1.2.3