From b3698acb6c0b9eaa04189599e27014c788a75adc Mon Sep 17 00:00:00 2001
From: Xavier Ordoquy
Date: Thu, 22 Nov 2012 00:20:49 +0100
Subject: First passing test under p3k \o/

---
 rest_framework/tests/serializer.py | 28 +++++++++++++++-------------
 1 file changed, 15 insertions(+), 13 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 520029ec..804f578d 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -1,3 +1,5 @@
+from __future__ import unicode_literals
+
 import datetime
 from django.test import TestCase
 from rest_framework import serializers
@@ -48,7 +50,7 @@ class BookSerializer(serializers.ModelSerializer):
 
 
 class ActionItemSerializer(serializers.ModelSerializer):
-    
+
     class Meta:
         model = ActionItem
 
@@ -163,12 +165,12 @@ class ValidationTests(TestCase):
     def test_create(self):
         serializer = CommentSerializer(data=self.data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
+        self.assertEquals(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']})
 
     def test_update(self):
         serializer = CommentSerializer(self.comment, data=self.data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
+        self.assertEquals(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']})
 
     def test_update_missing_field(self):
         data = {
@@ -177,7 +179,7 @@ class ValidationTests(TestCase):
         }
         serializer = CommentSerializer(self.comment, data=data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'email': [u'This field is required.']})
+        self.assertEquals(serializer.errors, {'email': ['This field is required.']})
 
     def test_missing_bool_with_default(self):
         """Make sure that a boolean value with a 'False' value is not
@@ -213,7 +215,7 @@ class ValidationTests(TestCase):
 
         serializer = CommentSerializerWithFieldValidator(data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'content': [u'Test not in value']})
+        self.assertEquals(serializer.errors, {'content': ['Test not in value']})
 
     def test_cross_field_validation(self):
 
@@ -237,7 +239,7 @@ class ValidationTests(TestCase):
 
         serializer = CommentSerializerWithCrossFieldValidator(data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'non_field_errors': [u'Email address not in content']})
+        self.assertEquals(serializer.errors, {'non_field_errors': ['Email address not in content']})
 
     def test_null_is_true_fields(self):
         """
@@ -253,7 +255,7 @@ class ValidationTests(TestCase):
         }
         serializer = ActionItemSerializer(data=data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'title': [u'Ensure this value has at most 200 characters (it has 201).']})
+        self.assertEquals(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']})
 
     def test_default_modelfield_max_length_exceeded(self):
         data = {
@@ -262,22 +264,22 @@ class ValidationTests(TestCase):
         }
         serializer = ActionItemSerializer(data=data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'info': [u'Ensure this value has at most 12 characters (it has 13).']})
+        self.assertEquals(serializer.errors, {'info': ['Ensure this value has at most 12 characters (it has 13).']})
 
 
 class RegexValidationTest(TestCase):
     def test_create_failed(self):
         serializer = BookSerializer(data={'isbn': '1234567890'})
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'isbn': [u'isbn has to be exact 13 numbers']})
+        self.assertEquals(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
 
         serializer = BookSerializer(data={'isbn': '12345678901234'})
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'isbn': [u'isbn has to be exact 13 numbers']})
+        self.assertEquals(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
 
         serializer = BookSerializer(data={'isbn': 'abcdefghijklm'})
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'isbn': [u'isbn has to be exact 13 numbers']})
+        self.assertEquals(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
 
     def test_create_success(self):
         serializer = BookSerializer(data={'isbn': '1234567890123'})
@@ -574,8 +576,8 @@ class SerializerMethodFieldTests(TestCase):
         serializer = self.serializer_class(source_data)
 
         expected = {
-            'beep': u'hello!',
-            'boop': [u'a', u'b', u'c'],
+            'beep': 'hello!',
+            'boop': ['a', 'b', 'c'],
             'boop_count': 3,
         }
 
-- 
cgit v1.2.3


From 9c7524fc33b52e4b119ba65ef9d84a58118dff43 Mon Sep 17 00:00:00 2001
From: Xavier Ordoquy
Date: Wed, 2 Jan 2013 19:06:02 +0100
Subject: Fixed unicode errors.

---
 rest_framework/tests/serializer.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 4654882e..6ce7de31 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -308,7 +308,7 @@ class ModelValidationTests(TestCase):
         serializer.save()
         second_serializer = AlbumsSerializer(data={'title': 'a'})
         self.assertFalse(second_serializer.is_valid())
-        self.assertEqual(second_serializer.errors,  {'title': [u'Album with this Title already exists.']})
+        self.assertEqual(second_serializer.errors,  {'title': ['Album with this Title already exists.']})
 
     def test_foreign_key_with_partial(self):
         """
@@ -654,11 +654,11 @@ class RelatedTraversalTest(TestCase):
         serializer = BlogPostSerializer(instance=post)
 
         expected = {
-            'title': u'Test blog post',
+            'title': 'Test blog post',
             'comments': [{
-                'text': u'I love this blog post',
+                'text': 'I love this blog post',
                 'post_owner': {
-                    "name": u"django",
+                    "name": "django",
                     "age": None
                 }
             }]
@@ -793,8 +793,8 @@ class DepthTest(TestCase):
                 depth = 1
 
         serializer = BlogPostSerializer(instance=post)
-        expected = {'id': 1, 'title': u'Test blog post',
-                    'writer': {'id': 1, 'name': u'django', 'age': 1}}
+        expected = {'id': 1, 'title': 'Test blog post',
+                    'writer': {'id': 1, 'name': 'django', 'age': 1}}
 
         self.assertEqual(serializer.data, expected)
 
@@ -813,8 +813,8 @@ class DepthTest(TestCase):
                 model = BlogPost
 
         serializer = BlogPostSerializer(instance=post)
-        expected = {'id': 1, 'title': u'Test blog post',
-                    'writer': {'id': 1, 'name': u'django', 'age': 1}}
+        expected = {'id': 1, 'title': 'Test blog post',
+                    'writer': {'id': 1, 'name': 'django', 'age': 1}}
 
         self.assertEqual(serializer.data, expected)
 
-- 
cgit v1.2.3


From 4eb5861f3676781493af29f8e9fd87ec22e591aa Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 18 Jan 2013 23:36:35 +0000
Subject: Starting migration from ManyField to Field(many=True)

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

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index bd96ba23..b2d62ade 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -1,5 +1,6 @@
 import datetime
 import pickle
+from django.utils.datastructures import MultiValueDict
 from django.test import TestCase
 from rest_framework import serializers
 from rest_framework.tests.models import (HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel,
@@ -479,7 +480,8 @@ class ManyToManyTests(TestCase):
         containing no items, using a representation that does not support
         lists (eg form data).
         """
-        data = {'rel': ''}
+        data = MultiValueDict()
+        data.setlist('rel', [''])
         serializer = self.serializer_class(data=data)
         self.assertEquals(serializer.is_valid(), True)
         instance = serializer.save()
-- 
cgit v1.2.3


From dc1c57d595c3917e3fed9076894d5fa88ec083c9 Mon Sep 17 00:00:00 2001
From: Stephan Groß
Date: Mon, 21 Jan 2013 12:45:30 +0100
Subject: Add failed testcase for fieldvalidation

---
 rest_framework/tests/serializer.py | 8 ++++++++
 1 file changed, 8 insertions(+)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index bd96ba23..0ba4e765 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -241,6 +241,14 @@ class ValidationTests(TestCase):
         self.assertFalse(serializer.is_valid())
         self.assertEquals(serializer.errors, {'content': [u'Test not in value']})
 
+        incomplete_data = {
+            'email': 'tom@example.com',
+            'created': datetime.datetime(2012, 1, 1)
+        }
+        serializer = CommentSerializerWithFieldValidator(data=incomplete_data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEquals(serializer.errors, {'content': [u'This field is required.']})
+
     def test_bad_type_data_is_false(self):
         """
         Data of the wrong type is not valid.
-- 
cgit v1.2.3


From f0071dbccd592ba3157738ced66809869f68b1cb Mon Sep 17 00:00:00 2001
From: Stephan Groß
Date: Wed, 23 Jan 2013 07:52:56 +0100
Subject: Add separate test for failed custom validation

---
 rest_framework/tests/serializer.py | 96 +++++++++++++++++++++++---------------
 1 file changed, 59 insertions(+), 37 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 0ba4e765..b4428ca3 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -162,7 +162,6 @@ class BasicTests(TestCase):
         """
         Attempting to update fields set as read_only should have no effect.
         """
-
         serializer = PersonSerializer(self.person, data={'name': 'dwight', 'age': 99})
         self.assertEquals(serializer.is_valid(), True)
         instance = serializer.save()
@@ -183,8 +182,7 @@ class ValidationTests(TestCase):
             'content': 'x' * 1001,
             'created': datetime.datetime(2012, 1, 1)
         }
-        self.actionitem = ActionItem(title='Some to do item',
-        )
+        self.actionitem = ActionItem(title='Some to do item',)
 
     def test_create(self):
         serializer = CommentSerializer(data=self.data)
@@ -216,39 +214,6 @@ class ValidationTests(TestCase):
         self.assertEquals(serializer.is_valid(), True)
         self.assertEquals(serializer.errors, {})
 
-    def test_field_validation(self):
-
-        class CommentSerializerWithFieldValidator(CommentSerializer):
-
-            def validate_content(self, attrs, source):
-                value = attrs[source]
-                if "test" not in value:
-                    raise serializers.ValidationError("Test not in value")
-                return attrs
-
-        data = {
-            'email': 'tom@example.com',
-            'content': 'A test comment',
-            'created': datetime.datetime(2012, 1, 1)
-        }
-
-        serializer = CommentSerializerWithFieldValidator(data=data)
-        self.assertTrue(serializer.is_valid())
-
-        data['content'] = 'This should not validate'
-
-        serializer = CommentSerializerWithFieldValidator(data=data)
-        self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'content': [u'Test not in value']})
-
-        incomplete_data = {
-            'email': 'tom@example.com',
-            'created': datetime.datetime(2012, 1, 1)
-        }
-        serializer = CommentSerializerWithFieldValidator(data=incomplete_data)
-        self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'content': [u'This field is required.']})
-
     def test_bad_type_data_is_false(self):
         """
         Data of the wrong type is not valid.
@@ -318,12 +283,69 @@ class ValidationTests(TestCase):
         self.assertEquals(serializer.errors, {'info': [u'Ensure this value has at most 12 characters (it has 13).']})
 
 
+class CustomValidationTests(TestCase):
+    class CommentSerializerWithFieldValidator(CommentSerializer):
+
+        def validate_email(self, attrs, source):
+            value = attrs[source]
+
+            return attrs
+
+        def validate_content(self, attrs, source):
+            value = attrs[source]
+            if "test" not in value:
+                raise serializers.ValidationError("Test not in value")
+            return attrs
+
+    def test_field_validation(self):
+        data = {
+            'email': 'tom@example.com',
+            'content': 'A test comment',
+            'created': datetime.datetime(2012, 1, 1)
+        }
+
+        serializer = self.CommentSerializerWithFieldValidator(data=data)
+        self.assertTrue(serializer.is_valid())
+
+        data['content'] = 'This should not validate'
+
+        serializer = self.CommentSerializerWithFieldValidator(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEquals(serializer.errors, {'content': [u'Test not in value']})
+
+    def test_missing_data(self):
+        """
+        Make sure that validate_content isn't called if the field is missing
+        """
+        incomplete_data = {
+            'email': 'tom@example.com',
+            'created': datetime.datetime(2012, 1, 1)
+        }
+        serializer = self.CommentSerializerWithFieldValidator(data=incomplete_data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEquals(serializer.errors, {'content': [u'This field is required.']})
+
+    def test_wrong_data(self):
+        """
+        Make sure that validate_content isn't called if the field input is wrong
+        """
+        wrong_data = {
+            'email': 'not an email',
+            'content': 'A test comment',
+            'created': datetime.datetime(2012, 1, 1)
+        }
+        serializer = self.CommentSerializerWithFieldValidator(data=wrong_data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEquals(serializer.errors, {'email': [u'Enter a valid e-mail address.']})
+
+
 class PositiveIntegerAsChoiceTests(TestCase):
     def test_positive_integer_in_json_is_correctly_parsed(self):
-        data = {'some_integer':1}
+        data = {'some_integer': 1}
         serializer = PositiveIntegerAsChoiceSerializer(data=data)
         self.assertEquals(serializer.is_valid(), True)
 
+
 class ModelValidationTests(TestCase):
     def test_validate_unique(self):
         """
-- 
cgit v1.2.3


From a3a06d11cc39da55d34f99e272bf092a2dcd4c5c Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Mon, 28 Jan 2013 12:56:42 +0000
Subject: Ensure model field validation is performed for ModelSerializers with
 a custom restore_object method.  Fixes #623.

---
 rest_framework/tests/serializer.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index b4428ca3..48b4f1ab 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -54,6 +54,19 @@ class ActionItemSerializer(serializers.ModelSerializer):
         model = ActionItem
 
 
+class ActionItemSerializerCustomRestore(serializers.ModelSerializer):
+
+    class Meta:
+        model = ActionItem
+
+    def restore_object(self, data, instance=None):
+        if instance is None:
+            return ActionItem(**data)
+        for key, val in data.items():
+            setattr(instance, key, val)
+        return instance
+
+
 class PersonSerializer(serializers.ModelSerializer):
     info = serializers.Field(source='info')
 
@@ -273,6 +286,20 @@ class ValidationTests(TestCase):
         self.assertEquals(serializer.is_valid(), False)
         self.assertEquals(serializer.errors, {'title': [u'Ensure this value has at most 200 characters (it has 201).']})
 
+    def test_modelserializer_max_length_exceeded_with_custom_restore(self):
+        """
+        When overriding ModelSerializer.restore_object, validation tests should still apply.
+        Regression test for #623.
+
+        https://github.com/tomchristie/django-rest-framework/pull/623
+        """
+        data = {
+            'title': 'x' * 201,
+        }
+        serializer = ActionItemSerializerCustomRestore(data=data)
+        self.assertEquals(serializer.is_valid(), False)
+        self.assertEquals(serializer.errors, {'title': [u'Ensure this value has at most 200 characters (it has 201).']})
+
     def test_default_modelfield_max_length_exceeded(self):
         data = {
             'title': 'Testing "info" field...',
-- 
cgit v1.2.3


From f4f237e3ee02fef4fd5f389bf4fb3bbdd00173bd Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 1 Feb 2013 14:03:28 +0000
Subject: 3.2, 3.3 compat

---
 rest_framework/tests/serializer.py | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index a00626b5..9697889d 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -236,17 +236,17 @@ class ValidationTests(TestCase):
         data = ['i am', 'a', 'list']
         serializer = CommentSerializer(self.comment, data=data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'non_field_errors': [u'Invalid data']})
+        self.assertEquals(serializer.errors, {'non_field_errors': ['Invalid data']})
 
         data = 'and i am a string'
         serializer = CommentSerializer(self.comment, data=data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'non_field_errors': [u'Invalid data']})
+        self.assertEquals(serializer.errors, {'non_field_errors': ['Invalid data']})
 
         data = 42
         serializer = CommentSerializer(self.comment, data=data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'non_field_errors': [u'Invalid data']})
+        self.assertEquals(serializer.errors, {'non_field_errors': ['Invalid data']})
 
     def test_cross_field_validation(self):
 
@@ -300,7 +300,7 @@ class ValidationTests(TestCase):
         }
         serializer = ActionItemSerializerCustomRestore(data=data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'title': [u'Ensure this value has at most 200 characters (it has 201).']})
+        self.assertEquals(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']})
 
     def test_default_modelfield_max_length_exceeded(self):
         data = {
@@ -340,7 +340,7 @@ class CustomValidationTests(TestCase):
 
         serializer = self.CommentSerializerWithFieldValidator(data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'content': [u'Test not in value']})
+        self.assertEquals(serializer.errors, {'content': ['Test not in value']})
 
     def test_missing_data(self):
         """
@@ -352,7 +352,7 @@ class CustomValidationTests(TestCase):
         }
         serializer = self.CommentSerializerWithFieldValidator(data=incomplete_data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'content': [u'This field is required.']})
+        self.assertEquals(serializer.errors, {'content': ['This field is required.']})
 
     def test_wrong_data(self):
         """
@@ -365,7 +365,7 @@ class CustomValidationTests(TestCase):
         }
         serializer = self.CommentSerializerWithFieldValidator(data=wrong_data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'email': [u'Enter a valid e-mail address.']})
+        self.assertEquals(serializer.errors, {'email': ['Enter a valid e-mail address.']})
 
 
 class PositiveIntegerAsChoiceTests(TestCase):
-- 
cgit v1.2.3


From b052c92ac38f90e5b56cfd128cd4a488713c048e Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Mon, 4 Feb 2013 20:55:35 +0000
Subject: Cleanup imports

Mostly adding `from __future__ import unicode_literals` everywhere.
---
 rest_framework/tests/serializer.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 1f46cfc7..dda388aa 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -1,13 +1,12 @@
 from __future__ import unicode_literals
-
-import datetime
-import pickle
 from django.utils.datastructures import MultiValueDict
 from django.test import TestCase
 from rest_framework import serializers
 from rest_framework.tests.models import (HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel,
     BlankFieldModel, BlogPost, Book, CallableDefaultValueModel, DefaultValueModel,
     ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo)
+import datetime
+import pickle
 
 
 class SubComment(object):
-- 
cgit v1.2.3


From 221e77d3575c182eb49d50546f844f392a5f7ba6 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Mon, 4 Feb 2013 21:18:54 +0000
Subject: Fix incorrect test name.  Fixes #635

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 48b4f1ab..88ad6e85 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -842,7 +842,7 @@ class BlankFieldTests(TestCase):
         serializer = self.not_blank_model_serializer_class(data=self.data)
         self.assertEquals(serializer.is_valid(), False)
 
-    def test_create_model_null_field(self):
+    def test_create_model_empty_field(self):
         serializer = self.model_serializer_class(data={})
         self.assertEquals(serializer.is_valid(), True)
 
-- 
cgit v1.2.3


From 5813a0951221f68591ade2039964531e754ca262 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 7 Feb 2013 09:14:58 +0000
Subject: Use new many=True relations style.

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index a0e1474f..57429e2e 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -551,7 +551,7 @@ class ManyToManyTests(TestCase):
 class ReadOnlyManyToManyTests(TestCase):
     def setUp(self):
         class ReadOnlyManyToManySerializer(serializers.ModelSerializer):
-            rel = serializers.ManyRelatedField(read_only=True)
+            rel = serializers.RelatedField(many=True, read_only=True)
 
             class Meta:
                 model = ReadOnlyManyToManyModel
-- 
cgit v1.2.3


From 8113d661260834a91d91481f31860398cde9212d Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 7 Feb 2013 09:24:34 +0000
Subject: Use new style of `required=<bool>` not `blank` or `null`

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 57429e2e..62de16ab 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -802,7 +802,7 @@ class BlankFieldTests(TestCase):
                 model = BlankFieldModel
 
         class BlankFieldSerializer(serializers.Serializer):
-            title = serializers.CharField(blank=True)
+            title = serializers.CharField(required=False)
 
         class NotBlankFieldModelSerializer(serializers.ModelSerializer):
             class Meta:
-- 
cgit v1.2.3


From 670ac25b25a3c7fb54fca6aa9344b8250ab49edb Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 7 Feb 2013 12:57:40 +0000
Subject: Allow serializers to handle dicts as well as objects.  Fixes #447.

---
 rest_framework/tests/serializer.py | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 62de16ab..2d17e99d 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -185,6 +185,33 @@ class BasicTests(TestCase):
         self.assertEquals(instance.age, self.person_data['age'])
 
 
+class DictStyleSerializer(serializers.Serializer):
+    """
+    Note that we don't have any `restore_object` method, so the default
+    case of simply returning a dict will apply.
+    """
+    email = serializers.EmailField()
+
+
+class DictStyleSerializerTests(TestCase):
+    def test_dict_style_deserialize(self):
+        """
+        Ensure serializers can deserialize into a dict.
+        """
+        data = {'email': 'foo@example.com'}
+        serializer = DictStyleSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+        self.assertEquals(serializer.data, data)
+
+    def test_dict_style_serialize(self):
+        """
+        Ensure serializers can serialize dict objects.
+        """
+        data = {'email': 'foo@example.com'}
+        serializer = DictStyleSerializer(data)
+        self.assertEquals(serializer.data, data)
+
+
 class ValidationTests(TestCase):
     def setUp(self):
         self.comment = Comment(
-- 
cgit v1.2.3


From ea004b5e7a51ccf176545642692462dc2086056d Mon Sep 17 00:00:00 2001
From: Fernando Rocha
Date: Mon, 11 Feb 2013 19:18:22 -0300
Subject: Make use o issubclass instead of isinstance (fix issue #645)

Because __mro__ is a list of classes and not instances.
DictWithMetadata.__getstate__ was never called

Signed-off-by: Fernando Rocha <fernandogrd@gmail.com>
---
 rest_framework/tests/serializer.py | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 48b4f1ab..4f4508f5 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -870,6 +870,13 @@ class SerializerPickleTests(TestCase):
                 fields = ('name', 'age')
         pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data)
 
+    def test_getstate_method_should_not_return_none(self):
+        '''Regression test for 
+        https://github.com/tomchristie/django-rest-framework/issues/645
+        '''
+        d = serializers.DictWithMetadata({1:1})
+        self.assertEqual(d.__getstate__(), serializers.SortedDict({1:1}))
+
 
 class DepthTest(TestCase):
     def test_implicit_nesting(self):
-- 
cgit v1.2.3


From 7f797abc19dff6972ebf41a2211daeb30cadff46 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 12 Feb 2013 20:07:35 +0000
Subject: Remove deprecated APIs from tests

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 19379552..f269d1a7 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -261,7 +261,7 @@ class ValidationTests(TestCase):
         Data of the wrong type is not valid.
         """
         data = ['i am', 'a', 'list']
-        serializer = CommentSerializer(self.comment, data=data)
+        serializer = CommentSerializer(self.comment, data=data, many=True)
         self.assertEquals(serializer.is_valid(), False)
         self.assertEquals(serializer.errors, {'non_field_errors': ['Invalid data']})
 
-- 
cgit v1.2.3


From 724906c516b71f3ec5bc2005c66a6145c77c3739 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 12 Feb 2013 22:58:38 +0000
Subject: Test for #637.

---
 rest_framework/tests/serializer.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index f269d1a7..5350a8f2 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -785,6 +785,23 @@ class RelatedTraversalTest(TestCase):
 
         self.assertEqual(serializer.data, expected)
 
+    def test_queryset_nested_traversal(self):
+        """
+        Relational fields should be able to use methods as their source.
+        """
+        BlogPost.objects.create(title='blah')
+
+        class QuerysetMethodSerializer(serializers.Serializer):
+            blogposts = serializers.RelatedField(many=True, source='get_all_blogposts')
+
+        class ClassWithQuerysetMethod(object):
+            def get_all_blogposts(self):
+                return BlogPost.objects
+
+        obj = ClassWithQuerysetMethod()
+        serializer = QuerysetMethodSerializer(obj)
+        self.assertEquals(serializer.data, {'blogposts': [u'BlogPost object']})
+
 
 class SerializerMethodFieldTests(TestCase):
     def setUp(self):
-- 
cgit v1.2.3


From 15fa42b647e1bac0a9a9309bd4ad2d810e55c9cd Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 12 Feb 2013 23:00:43 +0000
Subject: Unicode literal fix

---
 rest_framework/tests/serializer.py | 1 +
 1 file changed, 1 insertion(+)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 5350a8f2..799ca108 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -801,6 +801,7 @@ class RelatedTraversalTest(TestCase):
         obj = ClassWithQuerysetMethod()
         serializer = QuerysetMethodSerializer(obj)
         self.assertEquals(serializer.data, {'blogposts': [u'BlogPost object']})
+        self.assertEquals(serializer.data, {'blogposts': ['BlogPost object']})
 
 
 class SerializerMethodFieldTests(TestCase):
-- 
cgit v1.2.3


From f341ead49944050b7902254ed4c89b3c9c11a018 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 12 Feb 2013 23:01:20 +0000
Subject: Test for None in 'dotted.source' component.

Closes #643.
---
 rest_framework/tests/serializer.py | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 799ca108..da110138 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -747,6 +747,9 @@ class ManyRelatedTests(TestCase):
 
 class RelatedTraversalTest(TestCase):
     def test_nested_traversal(self):
+        """
+        Source argument should support dotted.source notation.
+        """
         user = Person.objects.create(name="django")
         post = BlogPost.objects.create(title="Test blog post", writer=user)
         post.blogpostcomment_set.create(text="I love this blog post")
@@ -785,6 +788,24 @@ class RelatedTraversalTest(TestCase):
 
         self.assertEqual(serializer.data, expected)
 
+    def test_nested_traversal_with_none(self):
+        """
+        If a component of the dotted.source is None, return None for the field.
+        """
+        from rest_framework.tests.models import NullableForeignKeySource
+        instance = NullableForeignKeySource.objects.create(name='Source with null FK')
+
+        class NullableSourceSerializer(serializers.Serializer):
+            target_name = serializers.Field(source='target.name')
+
+        serializer = NullableSourceSerializer(instance=instance)
+
+        expected = {
+            'target_name': None,
+        }
+
+        self.assertEqual(serializer.data, expected)
+
     def test_queryset_nested_traversal(self):
         """
         Relational fields should be able to use methods as their source.
@@ -800,7 +821,6 @@ class RelatedTraversalTest(TestCase):
 
         obj = ClassWithQuerysetMethod()
         serializer = QuerysetMethodSerializer(obj)
-        self.assertEquals(serializer.data, {'blogposts': [u'BlogPost object']})
         self.assertEquals(serializer.data, {'blogposts': ['BlogPost object']})
 
 
-- 
cgit v1.2.3


From 1b4c078db2e0d23dbb970fbf5790db843377dc11 Mon Sep 17 00:00:00 2001
From: Yuri Prezument
Date: Thu, 21 Feb 2013 12:15:31 +0200
Subject: Failing test case for #669

---
 rest_framework/tests/serializer.py | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index da110138..24a2d644 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -338,6 +338,21 @@ class ValidationTests(TestCase):
         self.assertEquals(serializer.is_valid(), False)
         self.assertEquals(serializer.errors, {'info': ['Ensure this value has at most 12 characters (it has 13).']})
 
+    def test_datetime_validation_failure(self):
+        """
+        Test DateTimeField validation errors on non-str values.
+        Regression test for #669.
+
+        https://github.com/tomchristie/django-rest-framework/issues/669
+        """
+        data = self.data
+        data['created'] = 0
+
+        serializer = CommentSerializer(data=data)
+        self.assertEquals(serializer.is_valid(), False)
+
+        # TODO: check validation error value
+
 
 class CustomValidationTests(TestCase):
     class CommentSerializerWithFieldValidator(CommentSerializer):
-- 
cgit v1.2.3


From 8fa82822a07854a7036bfae84dfa9db3b4a0a61c Mon Sep 17 00:00:00 2001
From: Yuri Prezument
Date: Thu, 21 Feb 2013 12:35:24 +0200
Subject: Add assertion in test

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 24a2d644..e85323e0 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -351,7 +351,7 @@ class ValidationTests(TestCase):
         serializer = CommentSerializer(data=data)
         self.assertEquals(serializer.is_valid(), False)
 
-        # TODO: check validation error value
+        self.assertIn('created', serializer.errors)
 
 
 class CustomValidationTests(TestCase):
-- 
cgit v1.2.3


From 9f98455362393e193f3a81588476d9352f871283 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 22 Feb 2013 22:22:29 +0000
Subject: Formatting

---
 rest_framework/tests/serializer.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index e85323e0..ee415eea 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -954,11 +954,12 @@ class SerializerPickleTests(TestCase):
         pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data)
 
     def test_getstate_method_should_not_return_none(self):
-        '''Regression test for 
+        """
+        Regression test for
         https://github.com/tomchristie/django-rest-framework/issues/645
-        '''
-        d = serializers.DictWithMetadata({1:1})
-        self.assertEqual(d.__getstate__(), serializers.SortedDict({1:1}))
+        """
+        d = serializers.DictWithMetadata({1: 1})
+        self.assertEqual(d.__getstate__(), serializers.SortedDict({1: 1}))
 
 
 class DepthTest(TestCase):
-- 
cgit v1.2.3


From e1f0001f92b812c7406b009edff786dfbccc32cb Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 22 Feb 2013 22:59:55 +0000
Subject: Fix and test for #645

Yuck, pickle is weird.  Closes #645.
---
 rest_framework/tests/serializer.py | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index ee415eea..671494b5 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -951,15 +951,21 @@ class SerializerPickleTests(TestCase):
             class Meta:
                 model = Person
                 fields = ('name', 'age')
-        pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data)
+        pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data, 0)
 
     def test_getstate_method_should_not_return_none(self):
         """
-        Regression test for
-        https://github.com/tomchristie/django-rest-framework/issues/645
+        Regression test for #645.
         """
-        d = serializers.DictWithMetadata({1: 1})
-        self.assertEqual(d.__getstate__(), serializers.SortedDict({1: 1}))
+        data = serializers.DictWithMetadata({1: 1})
+        self.assertEqual(data.__getstate__(), serializers.SortedDict({1: 1}))
+
+    def test_serializer_data_is_pickleable(self):
+        """
+        Another regression test for #645.
+        """
+        data = serializers.SortedDictWithMetadata({1: 1})
+        repr(pickle.loads(pickle.dumps(data, 0)))
 
 
 class DepthTest(TestCase):
-- 
cgit v1.2.3


From 3e6f99e273b3ca4278c417f32f0db1b7bdfe408b Mon Sep 17 00:00:00 2001
From: Danilo Bargen
Date: Mon, 25 Feb 2013 22:34:05 +0100
Subject: Improved exception message for missing serializer model meta option

---
 rest_framework/tests/serializer.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 671494b5..af84c46b 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -91,6 +91,11 @@ class PositiveIntegerAsChoiceSerializer(serializers.ModelSerializer):
         fields = ['some_integer']
 
 
+class BrokenModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        fields = ['some_field']
+
+
 class BasicTests(TestCase):
     def setUp(self):
         self.comment = Comment(
@@ -353,6 +358,18 @@ class ValidationTests(TestCase):
 
         self.assertIn('created', serializer.errors)
 
+    def test_missing_model_field_exception_msg(self):
+        """
+        Assert that a meaningful exception message is outputted when the model
+        field is missing (e.g. when mistyping ``model``).
+        """
+        try:
+            serializer = BrokenModelSerializer()
+        except AttributeError as e:
+            self.assertEquals(e.args[0], "Serializer class is missing 'model' Meta option")
+        except:
+            self.fail('Wrong exception type thrown.')
+
 
 class CustomValidationTests(TestCase):
     class CommentSerializerWithFieldValidator(CommentSerializer):
-- 
cgit v1.2.3


From ec4d79bcaf08d577e8c44cad873515d018e21986 Mon Sep 17 00:00:00 2001
From: Danilo Bargen
Date: Mon, 25 Feb 2013 23:02:42 +0100
Subject: Show class name in exception message

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index af84c46b..d4e9cc13 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -366,7 +366,7 @@ class ValidationTests(TestCase):
         try:
             serializer = BrokenModelSerializer()
         except AttributeError as e:
-            self.assertEquals(e.args[0], "Serializer class is missing 'model' Meta option")
+            self.assertEquals(e.args[0], "Serializer class 'BrokenModelSerializer' is missing 'model' Meta option")
         except:
             self.fail('Wrong exception type thrown.')
 
-- 
cgit v1.2.3


From e476dcb8c70f3792f01214f8d4a13c9316e11341 Mon Sep 17 00:00:00 2001
From: Danilo Bargen
Date: Tue, 26 Feb 2013 09:38:57 +0100
Subject: Changed AttributeError to AssertionError

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index d4e9cc13..36703fd9 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -365,7 +365,7 @@ class ValidationTests(TestCase):
         """
         try:
             serializer = BrokenModelSerializer()
-        except AttributeError as e:
+        except AssertionError as e:
             self.assertEquals(e.args[0], "Serializer class 'BrokenModelSerializer' is missing 'model' Meta option")
         except:
             self.fail('Wrong exception type thrown.')
-- 
cgit v1.2.3


From a1dbd93f5467a8a25e18516f57f34c15b3b31b36 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 27 Feb 2013 21:15:00 +0000
Subject: `assertEquals` -> `assertEqual`

---
 rest_framework/tests/serializer.py | 212 ++++++++++++++++++-------------------
 1 file changed, 106 insertions(+), 106 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 36703fd9..d0300f9e 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -127,39 +127,39 @@ class BasicTests(TestCase):
             'created': None,
             'sub_comment': ''
         }
-        self.assertEquals(serializer.data, expected)
+        self.assertEqual(serializer.data, expected)
 
     def test_retrieve(self):
         serializer = CommentSerializer(self.comment)
-        self.assertEquals(serializer.data, self.expected)
+        self.assertEqual(serializer.data, self.expected)
 
     def test_create(self):
         serializer = CommentSerializer(data=self.data)
         expected = self.comment
-        self.assertEquals(serializer.is_valid(), True)
-        self.assertEquals(serializer.object, expected)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.object, expected)
         self.assertFalse(serializer.object is expected)
-        self.assertEquals(serializer.data['sub_comment'], 'And Merry Christmas!')
+        self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!')
 
     def test_update(self):
         serializer = CommentSerializer(self.comment, data=self.data)
         expected = self.comment
-        self.assertEquals(serializer.is_valid(), True)
-        self.assertEquals(serializer.object, expected)
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.object, expected)
         self.assertTrue(serializer.object is expected)
-        self.assertEquals(serializer.data['sub_comment'], 'And Merry Christmas!')
+        self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!')
 
     def test_partial_update(self):
         msg = 'Merry New Year!'
         partial_data = {'content': msg}
         serializer = CommentSerializer(self.comment, data=partial_data)
-        self.assertEquals(serializer.is_valid(), False)
+        self.assertEqual(serializer.is_valid(), False)
         serializer = CommentSerializer(self.comment, data=partial_data, partial=True)
         expected = self.comment
         self.assertEqual(serializer.is_valid(), True)
-        self.assertEquals(serializer.object, expected)
+        self.assertEqual(serializer.object, expected)
         self.assertTrue(serializer.object is expected)
-        self.assertEquals(serializer.data['content'], msg)
+        self.assertEqual(serializer.data['content'], msg)
 
     def test_model_fields_as_expected(self):
         """
@@ -167,7 +167,7 @@ class BasicTests(TestCase):
         in the Meta data
         """
         serializer = PersonSerializer(self.person)
-        self.assertEquals(set(serializer.data.keys()),
+        self.assertEqual(set(serializer.data.keys()),
                           set(['name', 'age', 'info']))
 
     def test_field_with_dictionary(self):
@@ -176,18 +176,18 @@ class BasicTests(TestCase):
         """
         serializer = PersonSerializer(self.person)
         expected = self.person_data
-        self.assertEquals(serializer.data['info'], expected)
+        self.assertEqual(serializer.data['info'], expected)
 
     def test_read_only_fields(self):
         """
         Attempting to update fields set as read_only should have no effect.
         """
         serializer = PersonSerializer(self.person, data={'name': 'dwight', 'age': 99})
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(serializer.errors, {})
+        self.assertEqual(serializer.errors, {})
         # Assert age is unchanged (35)
-        self.assertEquals(instance.age, self.person_data['age'])
+        self.assertEqual(instance.age, self.person_data['age'])
 
 
 class DictStyleSerializer(serializers.Serializer):
@@ -206,7 +206,7 @@ class DictStyleSerializerTests(TestCase):
         data = {'email': 'foo@example.com'}
         serializer = DictStyleSerializer(data=data)
         self.assertTrue(serializer.is_valid())
-        self.assertEquals(serializer.data, data)
+        self.assertEqual(serializer.data, data)
 
     def test_dict_style_serialize(self):
         """
@@ -214,7 +214,7 @@ class DictStyleSerializerTests(TestCase):
         """
         data = {'email': 'foo@example.com'}
         serializer = DictStyleSerializer(data)
-        self.assertEquals(serializer.data, data)
+        self.assertEqual(serializer.data, data)
 
 
 class ValidationTests(TestCase):
@@ -233,13 +233,13 @@ class ValidationTests(TestCase):
 
     def test_create(self):
         serializer = CommentSerializer(data=self.data)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']})
 
     def test_update(self):
         serializer = CommentSerializer(self.comment, data=self.data)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']})
 
     def test_update_missing_field(self):
         data = {
@@ -247,8 +247,8 @@ class ValidationTests(TestCase):
             'created': datetime.datetime(2012, 1, 1)
         }
         serializer = CommentSerializer(self.comment, data=data)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'email': ['This field is required.']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'email': ['This field is required.']})
 
     def test_missing_bool_with_default(self):
         """Make sure that a boolean value with a 'False' value is not
@@ -258,8 +258,8 @@ class ValidationTests(TestCase):
             #No 'done' value.
         }
         serializer = ActionItemSerializer(self.actionitem, data=data)
-        self.assertEquals(serializer.is_valid(), True)
-        self.assertEquals(serializer.errors, {})
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.errors, {})
 
     def test_bad_type_data_is_false(self):
         """
@@ -267,18 +267,18 @@ class ValidationTests(TestCase):
         """
         data = ['i am', 'a', 'list']
         serializer = CommentSerializer(self.comment, data=data, many=True)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'non_field_errors': ['Invalid data']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'non_field_errors': ['Invalid data']})
 
         data = 'and i am a string'
         serializer = CommentSerializer(self.comment, data=data)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'non_field_errors': ['Invalid data']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'non_field_errors': ['Invalid data']})
 
         data = 42
         serializer = CommentSerializer(self.comment, data=data)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'non_field_errors': ['Invalid data']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'non_field_errors': ['Invalid data']})
 
     def test_cross_field_validation(self):
 
@@ -302,23 +302,23 @@ class ValidationTests(TestCase):
 
         serializer = CommentSerializerWithCrossFieldValidator(data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'non_field_errors': ['Email address not in content']})
+        self.assertEqual(serializer.errors, {'non_field_errors': ['Email address not in content']})
 
     def test_null_is_true_fields(self):
         """
         Omitting a value for null-field should validate.
         """
         serializer = PersonSerializer(data={'name': 'marko'})
-        self.assertEquals(serializer.is_valid(), True)
-        self.assertEquals(serializer.errors, {})
+        self.assertEqual(serializer.is_valid(), True)
+        self.assertEqual(serializer.errors, {})
 
     def test_modelserializer_max_length_exceeded(self):
         data = {
             'title': 'x' * 201,
         }
         serializer = ActionItemSerializer(data=data)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']})
 
     def test_modelserializer_max_length_exceeded_with_custom_restore(self):
         """
@@ -331,8 +331,8 @@ class ValidationTests(TestCase):
             'title': 'x' * 201,
         }
         serializer = ActionItemSerializerCustomRestore(data=data)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']})
 
     def test_default_modelfield_max_length_exceeded(self):
         data = {
@@ -340,8 +340,8 @@ class ValidationTests(TestCase):
             'info': 'x' * 13,
         }
         serializer = ActionItemSerializer(data=data)
-        self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'info': ['Ensure this value has at most 12 characters (it has 13).']})
+        self.assertEqual(serializer.is_valid(), False)
+        self.assertEqual(serializer.errors, {'info': ['Ensure this value has at most 12 characters (it has 13).']})
 
     def test_datetime_validation_failure(self):
         """
@@ -354,7 +354,7 @@ class ValidationTests(TestCase):
         data['created'] = 0
 
         serializer = CommentSerializer(data=data)
-        self.assertEquals(serializer.is_valid(), False)
+        self.assertEqual(serializer.is_valid(), False)
 
         self.assertIn('created', serializer.errors)
 
@@ -366,7 +366,7 @@ class ValidationTests(TestCase):
         try:
             serializer = BrokenModelSerializer()
         except AssertionError as e:
-            self.assertEquals(e.args[0], "Serializer class 'BrokenModelSerializer' is missing 'model' Meta option")
+            self.assertEqual(e.args[0], "Serializer class 'BrokenModelSerializer' is missing 'model' Meta option")
         except:
             self.fail('Wrong exception type thrown.')
 
@@ -399,7 +399,7 @@ class CustomValidationTests(TestCase):
 
         serializer = self.CommentSerializerWithFieldValidator(data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'content': ['Test not in value']})
+        self.assertEqual(serializer.errors, {'content': ['Test not in value']})
 
     def test_missing_data(self):
         """
@@ -411,7 +411,7 @@ class CustomValidationTests(TestCase):
         }
         serializer = self.CommentSerializerWithFieldValidator(data=incomplete_data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'content': ['This field is required.']})
+        self.assertEqual(serializer.errors, {'content': ['This field is required.']})
 
     def test_wrong_data(self):
         """
@@ -424,14 +424,14 @@ class CustomValidationTests(TestCase):
         }
         serializer = self.CommentSerializerWithFieldValidator(data=wrong_data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'email': ['Enter a valid e-mail address.']})
+        self.assertEqual(serializer.errors, {'email': ['Enter a valid e-mail address.']})
 
 
 class PositiveIntegerAsChoiceTests(TestCase):
     def test_positive_integer_in_json_is_correctly_parsed(self):
         data = {'some_integer': 1}
         serializer = PositiveIntegerAsChoiceSerializer(data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
 
 
 class ModelValidationTests(TestCase):
@@ -482,15 +482,15 @@ class RegexValidationTest(TestCase):
     def test_create_failed(self):
         serializer = BookSerializer(data={'isbn': '1234567890'})
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
+        self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
 
         serializer = BookSerializer(data={'isbn': '12345678901234'})
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
+        self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
 
         serializer = BookSerializer(data={'isbn': 'abcdefghijklm'})
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
+        self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
 
     def test_create_success(self):
         serializer = BookSerializer(data={'isbn': '1234567890123'})
@@ -535,7 +535,7 @@ class ManyToManyTests(TestCase):
         """
         serializer = self.serializer_class(instance=self.instance)
         expected = self.data
-        self.assertEquals(serializer.data, expected)
+        self.assertEqual(serializer.data, expected)
 
     def test_create(self):
         """
@@ -543,11 +543,11 @@ class ManyToManyTests(TestCase):
         """
         data = {'rel': [self.anchor.id]}
         serializer = self.serializer_class(data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(ManyToManyModel.objects.all()), 2)
-        self.assertEquals(instance.pk, 2)
-        self.assertEquals(list(instance.rel.all()), [self.anchor])
+        self.assertEqual(len(ManyToManyModel.objects.all()), 2)
+        self.assertEqual(instance.pk, 2)
+        self.assertEqual(list(instance.rel.all()), [self.anchor])
 
     def test_update(self):
         """
@@ -557,11 +557,11 @@ class ManyToManyTests(TestCase):
         new_anchor.save()
         data = {'rel': [self.anchor.id, new_anchor.id]}
         serializer = self.serializer_class(self.instance, data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(ManyToManyModel.objects.all()), 1)
-        self.assertEquals(instance.pk, 1)
-        self.assertEquals(list(instance.rel.all()), [self.anchor, new_anchor])
+        self.assertEqual(len(ManyToManyModel.objects.all()), 1)
+        self.assertEqual(instance.pk, 1)
+        self.assertEqual(list(instance.rel.all()), [self.anchor, new_anchor])
 
     def test_create_empty_relationship(self):
         """
@@ -570,11 +570,11 @@ class ManyToManyTests(TestCase):
         """
         data = {'rel': []}
         serializer = self.serializer_class(data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(ManyToManyModel.objects.all()), 2)
-        self.assertEquals(instance.pk, 2)
-        self.assertEquals(list(instance.rel.all()), [])
+        self.assertEqual(len(ManyToManyModel.objects.all()), 2)
+        self.assertEqual(instance.pk, 2)
+        self.assertEqual(list(instance.rel.all()), [])
 
     def test_update_empty_relationship(self):
         """
@@ -585,11 +585,11 @@ class ManyToManyTests(TestCase):
         new_anchor.save()
         data = {'rel': []}
         serializer = self.serializer_class(self.instance, data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(ManyToManyModel.objects.all()), 1)
-        self.assertEquals(instance.pk, 1)
-        self.assertEquals(list(instance.rel.all()), [])
+        self.assertEqual(len(ManyToManyModel.objects.all()), 1)
+        self.assertEqual(instance.pk, 1)
+        self.assertEqual(list(instance.rel.all()), [])
 
     def test_create_empty_relationship_flat_data(self):
         """
@@ -600,11 +600,11 @@ class ManyToManyTests(TestCase):
         data = MultiValueDict()
         data.setlist('rel', [''])
         serializer = self.serializer_class(data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(ManyToManyModel.objects.all()), 2)
-        self.assertEquals(instance.pk, 2)
-        self.assertEquals(list(instance.rel.all()), [])
+        self.assertEqual(len(ManyToManyModel.objects.all()), 2)
+        self.assertEqual(instance.pk, 2)
+        self.assertEqual(list(instance.rel.all()), [])
 
 
 class ReadOnlyManyToManyTests(TestCase):
@@ -638,12 +638,12 @@ class ReadOnlyManyToManyTests(TestCase):
         new_anchor.save()
         data = {'rel': [self.anchor.id, new_anchor.id]}
         serializer = self.serializer_class(self.instance, data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(ReadOnlyManyToManyModel.objects.all()), 1)
-        self.assertEquals(instance.pk, 1)
+        self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1)
+        self.assertEqual(instance.pk, 1)
         # rel is still as original (1 entry)
-        self.assertEquals(list(instance.rel.all()), [self.anchor])
+        self.assertEqual(list(instance.rel.all()), [self.anchor])
 
     def test_update_without_relationship(self):
         """
@@ -654,12 +654,12 @@ class ReadOnlyManyToManyTests(TestCase):
         new_anchor.save()
         data = {}
         serializer = self.serializer_class(self.instance, data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(ReadOnlyManyToManyModel.objects.all()), 1)
-        self.assertEquals(instance.pk, 1)
+        self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1)
+        self.assertEqual(instance.pk, 1)
         # rel is still as original (1 entry)
-        self.assertEquals(list(instance.rel.all()), [self.anchor])
+        self.assertEqual(list(instance.rel.all()), [self.anchor])
 
 
 class DefaultValueTests(TestCase):
@@ -674,35 +674,35 @@ class DefaultValueTests(TestCase):
     def test_create_using_default(self):
         data = {}
         serializer = self.serializer_class(data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(self.objects.all()), 1)
-        self.assertEquals(instance.pk, 1)
-        self.assertEquals(instance.text, 'foobar')
+        self.assertEqual(len(self.objects.all()), 1)
+        self.assertEqual(instance.pk, 1)
+        self.assertEqual(instance.text, 'foobar')
 
     def test_create_overriding_default(self):
         data = {'text': 'overridden'}
         serializer = self.serializer_class(data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(self.objects.all()), 1)
-        self.assertEquals(instance.pk, 1)
-        self.assertEquals(instance.text, 'overridden')
+        self.assertEqual(len(self.objects.all()), 1)
+        self.assertEqual(instance.pk, 1)
+        self.assertEqual(instance.text, 'overridden')
 
     def test_partial_update_default(self):
         """ Regression test for issue #532 """
         data = {'text': 'overridden'}
         serializer = self.serializer_class(data=data, partial=True)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
 
         data = {'extra': 'extra_value'}
         serializer = self.serializer_class(instance=instance, data=data, partial=True)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
 
-        self.assertEquals(instance.extra, 'extra_value')
-        self.assertEquals(instance.text, 'overridden')
+        self.assertEqual(instance.extra, 'extra_value')
+        self.assertEqual(instance.text, 'overridden')
 
 
 class CallableDefaultValueTests(TestCase):
@@ -717,20 +717,20 @@ class CallableDefaultValueTests(TestCase):
     def test_create_using_default(self):
         data = {}
         serializer = self.serializer_class(data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(self.objects.all()), 1)
-        self.assertEquals(instance.pk, 1)
-        self.assertEquals(instance.text, 'foobar')
+        self.assertEqual(len(self.objects.all()), 1)
+        self.assertEqual(instance.pk, 1)
+        self.assertEqual(instance.text, 'foobar')
 
     def test_create_overriding_default(self):
         data = {'text': 'overridden'}
         serializer = self.serializer_class(data=data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
         instance = serializer.save()
-        self.assertEquals(len(self.objects.all()), 1)
-        self.assertEquals(instance.pk, 1)
-        self.assertEquals(instance.text, 'overridden')
+        self.assertEqual(len(self.objects.all()), 1)
+        self.assertEqual(instance.pk, 1)
+        self.assertEqual(instance.text, 'overridden')
 
 
 class ManyRelatedTests(TestCase):
@@ -853,7 +853,7 @@ class RelatedTraversalTest(TestCase):
 
         obj = ClassWithQuerysetMethod()
         serializer = QuerysetMethodSerializer(obj)
-        self.assertEquals(serializer.data, {'blogposts': ['BlogPost object']})
+        self.assertEqual(serializer.data, {'blogposts': ['BlogPost object']})
 
 
 class SerializerMethodFieldTests(TestCase):
@@ -916,15 +916,15 @@ class BlankFieldTests(TestCase):
 
     def test_create_blank_field(self):
         serializer = self.serializer_class(data=self.data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
 
     def test_create_model_blank_field(self):
         serializer = self.model_serializer_class(data=self.data)
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
 
     def test_create_model_null_field(self):
         serializer = self.model_serializer_class(data={'title': None})
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
 
     def test_create_not_blank_field(self):
         """
@@ -932,7 +932,7 @@ class BlankFieldTests(TestCase):
         is considered invalid in a non-model serializer
         """
         serializer = self.not_blank_serializer_class(data=self.data)
-        self.assertEquals(serializer.is_valid(), False)
+        self.assertEqual(serializer.is_valid(), False)
 
     def test_create_model_not_blank_field(self):
         """
@@ -940,11 +940,11 @@ class BlankFieldTests(TestCase):
         is considered invalid in a model serializer
         """
         serializer = self.not_blank_model_serializer_class(data=self.data)
-        self.assertEquals(serializer.is_valid(), False)
+        self.assertEqual(serializer.is_valid(), False)
 
     def test_create_model_empty_field(self):
         serializer = self.model_serializer_class(data={})
-        self.assertEquals(serializer.is_valid(), True)
+        self.assertEqual(serializer.is_valid(), True)
 
 
 #test for issue #460
-- 
cgit v1.2.3


From f208d8d2bbe2f418caa51199070f703fba544d49 Mon Sep 17 00:00:00 2001
From: Stephan Groß
Date: Fri, 1 Mar 2013 13:16:00 +0100
Subject: Add drf settings + output format + testcases

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index d0300f9e..51065017 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -112,7 +112,7 @@ class BasicTests(TestCase):
         self.expected = {
             'email': 'tom@example.com',
             'content': 'Happy new year!',
-            'created': datetime.datetime(2012, 1, 1),
+            'created': '2012-01-01T00:00:00',
             'sub_comment': 'And Merry Christmas!'
         }
         self.person_data = {'name': 'dwight', 'age': 35}
-- 
cgit v1.2.3


From 66605acaf02d46eb899f495137afb4f9ff127ff0 Mon Sep 17 00:00:00 2001
From: Ian Dash
Date: Thu, 7 Mar 2013 17:29:25 +0000
Subject: Errors during deserializing lists now return a list of tuples with
 index of bad item in data plus usual errors dict

---
 rest_framework/tests/serializer.py | 45 +++++++++++++++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 51065017..33910936 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -268,7 +268,16 @@ class ValidationTests(TestCase):
         data = ['i am', 'a', 'list']
         serializer = CommentSerializer(self.comment, data=data, many=True)
         self.assertEqual(serializer.is_valid(), False)
-        self.assertEqual(serializer.errors, {'non_field_errors': ['Invalid data']})
+        self.assertTrue(isinstance(serializer.errors, list))
+
+        self.assertEqual(
+            serializer.errors,
+            [
+                (0, {'non_field_errors': ['Invalid data']}),
+                (1, {'non_field_errors': ['Invalid data']}),
+                (2, {'non_field_errors': ['Invalid data']})
+            ]
+        )
 
         data = 'and i am a string'
         serializer = CommentSerializer(self.comment, data=data)
@@ -1072,3 +1081,37 @@ class NestedSerializerContextTests(TestCase):
 
         # This will raise RuntimeError if context doesn't get passed correctly to the nested Serializers
         AlbumCollectionSerializer(album_collection, context={'context_item': 'album context'}).data
+
+
+class DeserializeListTestCase(TestCase):
+
+    def setUp(self):
+        self.data = {
+            'email': 'nobody@nowhere.com',
+            'content': 'This is some test content',
+            'created': datetime.datetime(2013, 3, 7),
+        }
+
+    def test_no_errors(self):
+        data = [self.data.copy() for x in range(0, 3)]
+        serializer = CommentSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+        self.assertTrue(isinstance(serializer.object, list))
+        self.assertTrue(
+            all((isinstance(item, Comment) for item in serializer.object))
+        )
+
+    def test_errors_return_as_list(self):
+        invalid_item = self.data.copy()
+        invalid_item['email'] = ''
+        data = [self.data.copy(), invalid_item, self.data.copy()]
+
+        serializer = CommentSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertTrue(isinstance(serializer.errors, list))
+        self.assertEqual(1, len(serializer.errors))
+        expected = (1, {'email': ['This field is required.']})
+        self.assertEqual(
+            serializer.errors[0],
+            expected
+        )
-- 
cgit v1.2.3


From 68683b2ea2907f367fdff60de91656504a242a14 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 8 Mar 2013 22:19:09 +0000
Subject: Tweak implementation, and use FormSet style errors

---
 rest_framework/tests/serializer.py | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 33910936..394af827 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -273,9 +273,9 @@ class ValidationTests(TestCase):
         self.assertEqual(
             serializer.errors,
             [
-                (0, {'non_field_errors': ['Invalid data']}),
-                (1, {'non_field_errors': ['Invalid data']}),
-                (2, {'non_field_errors': ['Invalid data']})
+                {'non_field_errors': ['Invalid data']},
+                {'non_field_errors': ['Invalid data']},
+                {'non_field_errors': ['Invalid data']}
             ]
         )
 
@@ -1108,10 +1108,5 @@ class DeserializeListTestCase(TestCase):
 
         serializer = CommentSerializer(data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertTrue(isinstance(serializer.errors, list))
-        self.assertEqual(1, len(serializer.errors))
-        expected = (1, {'email': ['This field is required.']})
-        self.assertEqual(
-            serializer.errors[0],
-            expected
-        )
+        expected = [{}, {'email': [u'This field is required.']}, {}]
+        self.assertEqual(serializer.errors, expected)
-- 
cgit v1.2.3


From 28ae26466e1b1493feeba19480c6eb148d603330 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 8 Mar 2013 22:43:46 +0000
Subject: Py3k fixes.

---
 rest_framework/tests/serializer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests/serializer.py')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 394af827..beb372c2 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -1108,5 +1108,5 @@ class DeserializeListTestCase(TestCase):
 
         serializer = CommentSerializer(data=data)
         self.assertFalse(serializer.is_valid())
-        expected = [{}, {'email': [u'This field is required.']}, {}]
+        expected = [{}, {'email': ['This field is required.']}, {}]
         self.assertEqual(serializer.errors, expected)
-- 
cgit v1.2.3