3.2, 3.3 compat

1 files changed, 54 insertions, 54 deletions

diff --git a/rest_framework/tests/relations_slug.py b/rest_framework/tests/relations_slug.py
index 37ccc75e..b4c2cb5f 100644
--- a/rest_framework/tests/relations_slug.py
+++ b/rest_framework/tests/relations_slug.py
@@ -39,9 +39,9 @@ class PKForeignKeyTests(TestCase):
         queryset = ForeignKeySource.objects.all()
         serializer = ForeignKeySourceSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'source-1', 'target': 'target-1'},
-            {'id': 2, 'name': u'source-2', 'target': 'target-1'},
-            {'id': 3, 'name': u'source-3', 'target': 'target-1'}
+            {'id': 1, 'name': 'source-1', 'target': 'target-1'},
+            {'id': 2, 'name': 'source-2', 'target': 'target-1'},
+            {'id': 3, 'name': 'source-3', 'target': 'target-1'}
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -49,13 +49,13 @@ class PKForeignKeyTests(TestCase):
         queryset = ForeignKeyTarget.objects.all()
         serializer = ForeignKeyTargetSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
-            {'id': 2, 'name': u'target-2', 'sources': []},
+            {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
+            {'id': 2, 'name': 'target-2', 'sources': []},
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_foreign_key_update(self):
-        data = {'id': 1, 'name': u'source-1', 'target': 'target-2'}
+        data = {'id': 1, 'name': 'source-1', 'target': 'target-2'}
         instance = ForeignKeySource.objects.get(pk=1)
         serializer = ForeignKeySourceSerializer(instance, data=data)
         self.assertTrue(serializer.is_valid())
@@ -66,21 +66,21 @@ class PKForeignKeyTests(TestCase):
         queryset = ForeignKeySource.objects.all()
         serializer = ForeignKeySourceSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'source-1', 'target': 'target-2'},
-            {'id': 2, 'name': u'source-2', 'target': 'target-1'},
-            {'id': 3, 'name': u'source-3', 'target': 'target-1'}
+            {'id': 1, 'name': 'source-1', 'target': 'target-2'},
+            {'id': 2, 'name': 'source-2', 'target': 'target-1'},
+            {'id': 3, 'name': 'source-3', 'target': 'target-1'}
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_foreign_key_update_incorrect_type(self):
-        data = {'id': 1, 'name': u'source-1', 'target': 123}
+        data = {'id': 1, 'name': 'source-1', 'target': 123}
         instance = ForeignKeySource.objects.get(pk=1)
         serializer = ForeignKeySourceSerializer(instance, data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'target': [u'Object with name=123 does not exist.']})
+        self.assertEquals(serializer.errors, {'target': ['Object with name=123 does not exist.']})
 
     def test_reverse_foreign_key_update(self):
-        data = {'id': 2, 'name': u'target-2', 'sources': ['source-1', 'source-3']}
+        data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}
         instance = ForeignKeyTarget.objects.get(pk=2)
         serializer = ForeignKeyTargetSerializer(instance, data=data)
         self.assertTrue(serializer.is_valid())
@@ -89,8 +89,8 @@ class PKForeignKeyTests(TestCase):
         queryset = ForeignKeyTarget.objects.all()
         new_serializer = ForeignKeyTargetSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
-            {'id': 2, 'name': u'target-2', 'sources': []},
+            {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
+            {'id': 2, 'name': 'target-2', 'sources': []},
         ]
         self.assertEquals(new_serializer.data, expected)
 
@@ -101,55 +101,55 @@ class PKForeignKeyTests(TestCase):
         queryset = ForeignKeyTarget.objects.all()
         serializer = ForeignKeyTargetSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'target-1', 'sources': ['source-2']},
-            {'id': 2, 'name': u'target-2', 'sources': ['source-1', 'source-3']},
+            {'id': 1, 'name': 'target-1', 'sources': ['source-2']},
+            {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']},
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_foreign_key_create(self):
-        data = {'id': 4, 'name': u'source-4', 'target': 'target-2'}
+        data = {'id': 4, 'name': 'source-4', 'target': 'target-2'}
         serializer = ForeignKeySourceSerializer(data=data)
         serializer.is_valid()
         self.assertTrue(serializer.is_valid())
         obj = serializer.save()
         self.assertEquals(serializer.data, data)
-        self.assertEqual(obj.name, u'source-4')
+        self.assertEqual(obj.name, 'source-4')
 
         # Ensure source 4 is added, and everything else is as expected
         queryset = ForeignKeySource.objects.all()
         serializer = ForeignKeySourceSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'source-1', 'target': 'target-1'},
-            {'id': 2, 'name': u'source-2', 'target': 'target-1'},
-            {'id': 3, 'name': u'source-3', 'target': 'target-1'},
-            {'id': 4, 'name': u'source-4', 'target': 'target-2'},
+            {'id': 1, 'name': 'source-1', 'target': 'target-1'},
+            {'id': 2, 'name': 'source-2', 'target': 'target-1'},
+            {'id': 3, 'name': 'source-3', 'target': 'target-1'},
+            {'id': 4, 'name': 'source-4', 'target': 'target-2'},
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_reverse_foreign_key_create(self):
-        data = {'id': 3, 'name': u'target-3', 'sources': ['source-1', 'source-3']}
+        data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}
         serializer = ForeignKeyTargetSerializer(data=data)
         self.assertTrue(serializer.is_valid())
         obj = serializer.save()
         self.assertEquals(serializer.data, data)
-        self.assertEqual(obj.name, u'target-3')
+        self.assertEqual(obj.name, 'target-3')
 
         # Ensure target 3 is added, and everything else is as expected
         queryset = ForeignKeyTarget.objects.all()
         serializer = ForeignKeyTargetSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'target-1', 'sources': ['source-2']},
-            {'id': 2, 'name': u'target-2', 'sources': []},
-            {'id': 3, 'name': u'target-3', 'sources': ['source-1', 'source-3']},
+            {'id': 1, 'name': 'target-1', 'sources': ['source-2']},
+            {'id': 2, 'name': 'target-2', 'sources': []},
+            {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']},
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_foreign_key_update_with_invalid_null(self):
-        data = {'id': 1, 'name': u'source-1', 'target': None}
+        data = {'id': 1, 'name': 'source-1', 'target': None}
         instance = ForeignKeySource.objects.get(pk=1)
         serializer = ForeignKeySourceSerializer(instance, data=data)
         self.assertFalse(serializer.is_valid())
-        self.assertEquals(serializer.errors, {'target': [u'Value may not be null']})
+        self.assertEquals(serializer.errors, {'target': ['Value may not be null']})
 
 
 class SlugNullableForeignKeyTests(TestCase):
@@ -166,28 +166,28 @@ class SlugNullableForeignKeyTests(TestCase):
         queryset = NullableForeignKeySource.objects.all()
         serializer = NullableForeignKeySourceSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'source-1', 'target': 'target-1'},
-            {'id': 2, 'name': u'source-2', 'target': 'target-1'},
-            {'id': 3, 'name': u'source-3', 'target': None},
+            {'id': 1, 'name': 'source-1', 'target': 'target-1'},
+            {'id': 2, 'name': 'source-2', 'target': 'target-1'},
+            {'id': 3, 'name': 'source-3', 'target': None},
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_foreign_key_create_with_valid_null(self):
-        data = {'id': 4, 'name': u'source-4', 'target': None}
+        data = {'id': 4, 'name': 'source-4', 'target': None}
         serializer = NullableForeignKeySourceSerializer(data=data)
         self.assertTrue(serializer.is_valid())
         obj = serializer.save()
         self.assertEquals(serializer.data, data)
-        self.assertEqual(obj.name, u'source-4')
+        self.assertEqual(obj.name, 'source-4')
 
         # Ensure source 4 is created, and everything else is as expected
         queryset = NullableForeignKeySource.objects.all()
         serializer = NullableForeignKeySourceSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'source-1', 'target': 'target-1'},
-            {'id': 2, 'name': u'source-2', 'target': 'target-1'},
-            {'id': 3, 'name': u'source-3', 'target': None},
-            {'id': 4, 'name': u'source-4', 'target': None}
+            {'id': 1, 'name': 'source-1', 'target': 'target-1'},
+            {'id': 2, 'name': 'source-2', 'target': 'target-1'},
+            {'id': 3, 'name': 'source-3', 'target': None},
+            {'id': 4, 'name': 'source-4', 'target': None}
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -196,27 +196,27 @@ class SlugNullableForeignKeyTests(TestCase):
         The emptystring should be interpreted as null in the context
         of relationships.
         """
-        data = {'id': 4, 'name': u'source-4', 'target': ''}
-        expected_data = {'id': 4, 'name': u'source-4', 'target': None}
+        data = {'id': 4, 'name': 'source-4', 'target': ''}
+        expected_data = {'id': 4, 'name': 'source-4', 'target': None}
         serializer = NullableForeignKeySourceSerializer(data=data)
         self.assertTrue(serializer.is_valid())
         obj = serializer.save()
         self.assertEquals(serializer.data, expected_data)
-        self.assertEqual(obj.name, u'source-4')
+        self.assertEqual(obj.name, 'source-4')
 
         # Ensure source 4 is created, and everything else is as expected
         queryset = NullableForeignKeySource.objects.all()
         serializer = NullableForeignKeySourceSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'source-1', 'target': 'target-1'},
-            {'id': 2, 'name': u'source-2', 'target': 'target-1'},
-            {'id': 3, 'name': u'source-3', 'target': None},
-            {'id': 4, 'name': u'source-4', 'target': None}
+            {'id': 1, 'name': 'source-1', 'target': 'target-1'},
+            {'id': 2, 'name': 'source-2', 'target': 'target-1'},
+            {'id': 3, 'name': 'source-3', 'target': None},
+            {'id': 4, 'name': 'source-4', 'target': None}
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_foreign_key_update_with_valid_null(self):
-        data = {'id': 1, 'name': u'source-1', 'target': None}
+        data = {'id': 1, 'name': 'source-1', 'target': None}
         instance = NullableForeignKeySource.objects.get(pk=1)
         serializer = NullableForeignKeySourceSerializer(instance, data=data)
         self.assertTrue(serializer.is_valid())
@@ -227,9 +227,9 @@ class SlugNullableForeignKeyTests(TestCase):
         queryset = NullableForeignKeySource.objects.all()
         serializer = NullableForeignKeySourceSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'source-1', 'target': None},
-            {'id': 2, 'name': u'source-2', 'target': 'target-1'},
-            {'id': 3, 'name': u'source-3', 'target': None}
+            {'id': 1, 'name': 'source-1', 'target': None},
+            {'id': 2, 'name': 'source-2', 'target': 'target-1'},
+            {'id': 3, 'name': 'source-3', 'target': None}
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -238,8 +238,8 @@ class SlugNullableForeignKeyTests(TestCase):
         The emptystring should be interpreted as null in the context
         of relationships.
         """
-        data = {'id': 1, 'name': u'source-1', 'target': ''}
-        expected_data = {'id': 1, 'name': u'source-1', 'target': None}
+        data = {'id': 1, 'name': 'source-1', 'target': ''}
+        expected_data = {'id': 1, 'name': 'source-1', 'target': None}
         instance = NullableForeignKeySource.objects.get(pk=1)
         serializer = NullableForeignKeySourceSerializer(instance, data=data)
         self.assertTrue(serializer.is_valid())
@@ -250,8 +250,8 @@ class SlugNullableForeignKeyTests(TestCase):
         queryset = NullableForeignKeySource.objects.all()
         serializer = NullableForeignKeySourceSerializer(queryset)
         expected = [
-            {'id': 1, 'name': u'source-1', 'target': None},
-            {'id': 2, 'name': u'source-2', 'target': 'target-1'},
-            {'id': 3, 'name': u'source-3', 'target': None}
+            {'id': 1, 'name': 'source-1', 'target': None},
+            {'id': 2, 'name': 'source-2', 'target': 'target-1'},
+            {'id': 3, 'name': 'source-3', 'target': None}
         ]
         self.assertEquals(serializer.data, expected)