From 6b4bb48dd410d0a878b0142d351c7c41cd51f819 Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Tue, 12 Mar 2013 13:33:02 +0000
Subject: [PATCH 01/16] 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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 2ae7c215f..81619b3af 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 000000000..c8987bc56
--- /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)

From d8c5dca9aea5ad073936c1c5b3975ed53a6aeca8 Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Tue, 12 Mar 2013 18:34:52 +0000
Subject: [PATCH 02/16] Extra tests for nested serializers

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

diff --git a/rest_framework/tests/serializer_nested.py b/rest_framework/tests/serializer_nested.py
index c8987bc56..fcf644c75 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)

From 2f1951910f264852b530c94c3a9946afe10eedd2 Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Tue, 12 Mar 2013 18:35:20 +0000
Subject: [PATCH 03/16] Descriptive text for NestedValidationError

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 81619b3af..f83451d37 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
 

From 3006e3825f29e920f881b816fd71566bf0e8d341 Mon Sep 17 00:00:00 2001
From: Mark Aaron Shirley <maspwr@gmail.com>
Date: Tue, 12 Mar 2013 20:59:25 -0700
Subject: [PATCH 04/16] 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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index f83451d37..893db2ece 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 000000000..35b7a365d
--- /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 fcf644c75..299c3bc5a 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

From 47492e3ef4e24ecd155091247e479851789ee8e9 Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Fri, 15 Mar 2013 19:22:31 +0000
Subject: [PATCH 05/16] Clean out ModelSerializer special casing from
 Serializer.field_from_native

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index f073e00aa..5dadebb28 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 = {}

From 32e0e5e18c84e7b720c74df8aeba26e0f335bbf6 Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Fri, 15 Mar 2013 19:55:32 +0000
Subject: [PATCH 06/16] Remove erronous _delete attribute

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 5dadebb28..691d2aab9 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.

From 56653111a6848f6ef5d4bb645b87cbcaf5bffba1 Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Fri, 15 Mar 2013 19:57:57 +0000
Subject: [PATCH 07/16] Remove unneeded arguments to save_object

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 691d2aab9..ebc2eec95 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):

From ccf551201feb96451ffdc5d824bb0681596bcdae Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Sat, 16 Mar 2013 07:32:50 +0000
Subject: [PATCH 08/16] Clean up and comment `restore_object`

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index ebc2eec95..fb7722626 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
 

From 3ff103ad043420b430cc2052241994d597b1fe8a Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Sat, 16 Mar 2013 07:35:27 +0000
Subject: [PATCH 09/16] Fixes to save_object

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index fb7722626..5826a1730 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):

From 66bdd608e1e4bbb02a815104572b80034d73aa6b Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Sat, 16 Mar 2013 07:35:44 +0000
Subject: [PATCH 10/16] Fixes to save_object

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 5826a1730..21336dc29 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)
 

From c8416df0c4b7179eeaf86b61c32907f32494b85c Mon Sep 17 00:00:00 2001
From: Craig de Stigter <craig.destigter@koordinates.com>
Date: Mon, 18 Mar 2013 14:27:15 +1300
Subject: [PATCH 11/16] accept all WritableField kwargs for writable
 serializers (eg required=True)

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 21336dc29..c6599886c 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

From d6d5b1d82a4ccc1a2fe29ff18e9ecf7c196a07a5 Mon Sep 17 00:00:00 2001
From: Craig de Stigter <craig.destigter@koordinates.com>
Date: Mon, 18 Mar 2013 14:50:08 +1300
Subject: [PATCH 12/16] allow default values in writable serializer fields

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index c6599886c..cc6d60da1 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

From 101fa26ebc092a43acbf3f28617eb58be7629b5f Mon Sep 17 00:00:00 2001
From: Craig de Stigter <craig.destigter@koordinates.com>
Date: Mon, 18 Mar 2013 16:05:34 +1300
Subject: [PATCH 13/16] use writablefield style for serializer handling of
 self.default

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

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index cc6d60da1..a81cbc291 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

From deb5e653e441bf31f3b183b575f72e6b4cf537ea Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Mon, 18 Mar 2013 21:35:06 +0000
Subject: [PATCH 14/16] Added bulk create tests

---
 docs/topics/contributing.md                   | 137 +++++++++++++++++-
 .../tests/serializer_bulk_update.py           |  73 ++++++++++
 2 files changed, 205 insertions(+), 5 deletions(-)
 create mode 100644 rest_framework/tests/serializer_bulk_update.py

diff --git a/docs/topics/contributing.md b/docs/topics/contributing.md
index 7fd61c10e..bc9c2e931 100644
--- a/docs/topics/contributing.md
+++ b/docs/topics/contributing.md
@@ -4,12 +4,139 @@
 >
 > &mdash; [Tim Berners-Lee][cite]
 
-## Running the tests
+There are many ways you can contribute to Django REST framework.  We'd like it to be a community-led project, so please get involved and help shape the future of the project.
 
-## Building the docs
+# Community
 
-## Managing compatibility issues
+If you use and enjoy REST framework please consider [staring the project on GitHub][github], and [upvoting it on Django packages][django-packages].  Doing so helps potential new users see that the project is well used, and help us continue to attract new users.
 
-**Describe compat module**
+You might also consider writing a blog post on your experience with using REST framework, writing a tutorial about using the project with a particular javascript framework, or simply sharing the love on Twitter.
+
+Other really great ways you can help move the community forward include helping answer questions on the [discussion group][google-group], or setting up an [email alert on StackOverflow][so-filter] so that you get notified of any new questions with the `django-rest-framework` tag.
+
+When answering questions make sure to help future contributors find their way around by hyperlinking wherever possible to related threads and tickets, and include backlinks from those items if relevant. 
+
+# Issues
+
+Usage questions should be directed to the [discussion group][google-group].  Feature requests, bug reports and other issues should be raised on the GitHub [issue tracker][issues].
+
+Some tips on good issue reporting:
+
+* When decribing issues try to phrase your ticket in terms of the *behavior* you think needs changing rather than the *code* you think need changing.
+* Search the issue list first for related items, and make sure you're running the latest version of REST framework before reporting an issue.
+* If reporting a bug, then try to include a pull request with a failing test case.  This'll help us quickly identify if there is a valid issue, and make sure that it gets fixed more quickly if there is one. 
+
+
+
+* TODO: Triage
+
+# Development
+
+* git clone & PYTHONPATH
+* Pep8
+* Recommend editor that runs pep8
+
+### Pull requests
+
+* Make pull requests early
+* Describe branching
+
+### Managing compatibility issues
+
+* Describe compat module
+
+# Testing
+
+* Running the tests
+* tox
+
+# Documentation
+
+The documentation for REST framework is built from the [Markdown][markdown] source files in [the docs directory][docs].
+
+There are many great markdown editors that make working with the documentation really easy.  The [Mou editor for Mac][mou] is one such editor that comes highly recommended.
+
+## Building the documentation
+
+To build the documentation, simply run the `mkdocs.py` script.
+
+    ./mkdocs.py
+
+This will build the html output into the `html` directory.
+
+You can build the documentation and open a preview in a browser window by using the `-p` flag.
+
+    ./mkdocs.py -p
+
+## Language style
+
+Documentation should be in American English.  The tone of the documentation is very important - try to stick to a simple, plain, objective and well-balanced style where possible.
+
+Some other tips:
+
+* Keep paragraphs reasonably short.
+* Use double spacing after the end of sentences.
+* Don't use the abbreviations such as 'e.g..' but instead use long form, such as 'For example'.
+
+## Markdown style
+
+There are a couple of conventions you should follow when working on the documentation.
+
+##### 1. Headers
+
+Headers should use the hash style.  For example:
+
+    ### Some important topic
+    
+The underline style should not be used.  **Don't do this:** 
+
+    Some important topic
+    ====================
+
+##### 2. Links
+
+Links should always use the reference style, with the referenced hyperlinks kept at the end of the document.
+
+    Here is a link to [some other thing][other-thing].
+    
+    More text...
+    
+    [other-thing]: http://example.com/other/thing
+
+This style helps keep the documentation source consistent and readable.
+
+If you are hyperlinking to another REST framework document, you should use a relative link, and link to the `.md` suffix.  For example:
+
+    [authentication]: ../api-guide/authentication.md
+
+Linking in this style means you'll be able to click the hyperlink in your markdown editor to open the referenced document.  When the documentation is built, these links will be converted into regular links to HTML pages.
+
+##### 3. Notes
+
+If you want to draw attention to a note or warning, use a pair of enclosing lines, like so:
+
+    ---
+    
+    **Note:** Make sure you do this thing.
+    
+    ---
+
+# Third party packages
+
+* Django reusable app
+
+# Core committers
+
+* Still use pull reqs
+* Credits
+
+[cite]: http://www.w3.org/People/Berners-Lee/FAQ.html
+[github]: https://github.com/tomchristie/django-rest-framework
+[django-packages]: https://www.djangopackages.com/grids/g/api/
+[google-group]: https://groups.google.com/forum/?fromgroups#!forum/django-rest-framework
+[so-filter]: http://stackexchange.com/filters/66475/rest-framework
+[issues]: https://github.com/tomchristie/django-rest-framework/issues?state=open
+[markdown]: http://daringfireball.net/projects/markdown/basics
+[docs]: https://github.com/tomchristie/django-rest-framework/tree/master/docs
+[mou]: http://mouapp.com/
 
-[cite]: http://www.w3.org/People/Berners-Lee/FAQ.html
\ No newline at end of file
diff --git a/rest_framework/tests/serializer_bulk_update.py b/rest_framework/tests/serializer_bulk_update.py
new file mode 100644
index 000000000..3ecb23edd
--- /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)
+

From 9cdf8411698296fdbedf978d7b83c9d46b30e0d7 Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Fri, 22 Mar 2013 22:11:30 +0000
Subject: [PATCH 15/16] Tweaking

---
 docs/topics/contributing.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/docs/topics/contributing.md b/docs/topics/contributing.md
index f8e2baabf..a13f4461e 100644
--- a/docs/topics/contributing.md
+++ b/docs/topics/contributing.md
@@ -26,6 +26,8 @@ Some tips on good issue reporting:
 * Search the issue list first for related items, and make sure you're running the latest version of REST framework before reporting an issue.
 * If reporting a bug, then try to include a pull request with a failing test case.  This'll help us quickly identify if there is a valid issue, and make sure that it gets fixed more quickly if there is one. 
 
+
+
 * TODO: Triage
 
 # Development
@@ -119,7 +121,7 @@ If you want to draw attention to a note or warning, use a pair of enclosing line
     
     ---
 
-# Third party packages
+# Third party packages
 
 * Django reusable app
 

From addf7e9b36a274506cc940744487977ee8a7b574 Mon Sep 17 00:00:00 2001
From: Tom Christie <tom@tomchristie.com>
Date: Fri, 22 Mar 2013 22:27:03 +0000
Subject: [PATCH 16/16] Defer the writable nested modelserializers work

---
 rest_framework/serializers.py            |  11 +-
 rest_framework/tests/relations_nested.py | 160 +++++++++++------------
 2 files changed, 76 insertions(+), 95 deletions(-)

diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py
index 26c34044c..6aca2f574 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 4592e5593..a125ba656 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 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 ForeignKeySourceSerializer(serializers.ModelSerializer):
     class Meta:
-        model = OneToOneSource
-        exclude = ('target_source', )
+        depth = 1
+        model = ForeignKeySource
 
 
-class OneToOneTargetSourceSerializer(serializers.ModelSerializer):
-    source = OneToOneSourceSerializer()
+class FlatForeignKeySourceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ForeignKeySource
+
+
+class ForeignKeyTargetSerializer(serializers.ModelSerializer):
+    sources = FlatForeignKeySourceSerializer(many=True)
 
     class Meta:
-        model = OneToOneTargetSource
-        exclude = ('target', )
+        model = ForeignKeyTarget
 
 
-class OneToOneTargetSerializer(serializers.ModelSerializer):
-    target_source = OneToOneTargetSourceSerializer()
+class NullableForeignKeySourceSerializer(serializers.ModelSerializer):
+    class Meta:
+        depth = 1
+        model = NullableForeignKeySource
+
+
+class NullableOneToOneSourceSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = NullableOneToOneSource
+
+
+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')
+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()
 
-        # Ensure (target 3, target_source 3, source 3) are updated,
-        # and everything else is as expected.
-        queryset = OneToOneTarget.objects.all()
-        serializer = OneToOneTargetSerializer(queryset)
+    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)