encode/django-rest-framework
1
1
Fork 0
mirror of https://github.com/encode/django-rest-framework.git synced 2025-02-09 08:00:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #692 from tomchristie/django1.5

Browse Source 
Django 1.5
This commit is contained in:
Tom Christie 2013-02-27 13:15:47 -08:00
commit a2dafd9643
26 changed files with 449 additions and 449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.travis.yml
View File

@ -7,7 +7,7 @@ python:
- "3.3" - "3.3"
env: env:
- DJANGO=https://www.djangoproject.com/download/1.5c1/tarball/ - DJANGO="django==1.5 --use-mirrors"
- DJANGO="django==1.4.3 --use-mirrors" - DJANGO="django==1.4.3 --use-mirrors"
- DJANGO="django==1.3.5 --use-mirrors" - DJANGO="django==1.3.5 --use-mirrors"

6
rest_framework/tests/decorators.py
View File

@ -139,7 +139,7 @@ class DecoratorTestCase(TestCase):
request = self.factory.get('/') request = self.factory.get('/')
response = view(request) response = view(request)
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_throttle_classes(self): def test_throttle_classes(self):
class OncePerDayUserThrottle(UserRateThrottle): class OncePerDayUserThrottle(UserRateThrottle):
@ -152,7 +152,7 @@ class DecoratorTestCase(TestCase):
request = self.factory.get('/') request = self.factory.get('/')
response = view(request) response = view(request)
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
response = view(request) response = view(request)
self.assertEquals(response.status_code, status.HTTP_429_TOO_MANY_REQUESTS) self.assertEqual(response.status_code, status.HTTP_429_TOO_MANY_REQUESTS)

14
rest_framework/tests/description.py
View File

@ -53,7 +53,7 @@ class TestViewNamesAndDescriptions(TestCase):
"""Ensure Resource names are based on the classname by default.""" """Ensure Resource names are based on the classname by default."""
class MockView(APIView): class MockView(APIView):
pass pass
self.assertEquals(MockView().get_name(), 'Mock') self.assertEqual(MockView().get_name(), 'Mock')
def test_resource_name_can_be_set_explicitly(self): def test_resource_name_can_be_set_explicitly(self):
"""Ensure Resource names can be set using the 'get_name' method.""" """Ensure Resource names can be set using the 'get_name' method."""
@ -61,7 +61,7 @@ class TestViewNamesAndDescriptions(TestCase):
class MockView(APIView): class MockView(APIView):
def get_name(self): def get_name(self):
return example return example
self.assertEquals(MockView().get_name(), example) self.assertEqual(MockView().get_name(), example)
def test_resource_description_uses_docstring_by_default(self): def test_resource_description_uses_docstring_by_default(self):
"""Ensure Resource names are based on the docstring by default.""" """Ensure Resource names are based on the docstring by default."""
@ -81,7 +81,7 @@ class TestViewNamesAndDescriptions(TestCase):
# hash style header #""" # hash style header #"""
self.assertEquals(MockView().get_description(), DESCRIPTION) self.assertEqual(MockView().get_description(), DESCRIPTION)
def test_resource_description_can_be_set_explicitly(self): def test_resource_description_can_be_set_explicitly(self):
"""Ensure Resource descriptions can be set using the 'get_description' method.""" """Ensure Resource descriptions can be set using the 'get_description' method."""
@ -91,7 +91,7 @@ class TestViewNamesAndDescriptions(TestCase):
"""docstring""" """docstring"""
def get_description(self): def get_description(self):
return example return example
self.assertEquals(MockView().get_description(), example) self.assertEqual(MockView().get_description(), example)
def test_resource_description_supports_unicode(self): def test_resource_description_supports_unicode(self):
@ -99,7 +99,7 @@ class TestViewNamesAndDescriptions(TestCase):
"""Проверка""" """Проверка"""
pass pass
self.assertEquals(MockView().get_description(), "Проверка") self.assertEqual(MockView().get_description(), "Проверка")
def test_resource_description_does_not_require_docstring(self): def test_resource_description_does_not_require_docstring(self):
@ -109,13 +109,13 @@ class TestViewNamesAndDescriptions(TestCase):
class MockView(APIView): class MockView(APIView):
def get_description(self): def get_description(self):
return example return example
self.assertEquals(MockView().get_description(), example) self.assertEqual(MockView().get_description(), example)
def test_resource_description_can_be_empty(self): def test_resource_description_can_be_empty(self):
"""Ensure that if a resource has no doctring or 'description' class attribute, then it's description is the empty string.""" """Ensure that if a resource has no doctring or 'description' class attribute, then it's description is the empty string."""
class MockView(APIView): class MockView(APIView):
pass pass
self.assertEquals(MockView().get_description(), '') self.assertEqual(MockView().get_description(), '')
def test_markdown(self): def test_markdown(self):
"""Ensure markdown to HTML works as expected""" """Ensure markdown to HTML works as expected"""

6
rest_framework/tests/fields.py
View File

@ -43,21 +43,21 @@ class BasicFieldTests(TestCase):
auto_now and auto_now_add fields should be read_only by default. auto_now and auto_now_add fields should be read_only by default.
""" """
serializer = TimestampedModelSerializer() serializer = TimestampedModelSerializer()
self.assertEquals(serializer.fields['added'].read_only, True) self.assertEqual(serializer.fields['added'].read_only, True)
def test_auto_pk_fields_read_only(self): def test_auto_pk_fields_read_only(self):
""" """
AutoField fields should be read_only by default. AutoField fields should be read_only by default.
""" """
serializer = TimestampedModelSerializer() serializer = TimestampedModelSerializer()
self.assertEquals(serializer.fields['id'].read_only, True) self.assertEqual(serializer.fields['id'].read_only, True)
def test_non_auto_pk_fields_not_read_only(self): def test_non_auto_pk_fields_not_read_only(self):
""" """
PK fields other than AutoField fields should not be read_only by default. PK fields other than AutoField fields should not be read_only by default.
""" """
serializer = CharPrimaryKeyModelSerializer() serializer = CharPrimaryKeyModelSerializer()
self.assertEquals(serializer.fields['id'].read_only, False) self.assertEqual(serializer.fields['id'].read_only, False)
def test_TimeField_from_native(self): def test_TimeField_from_native(self):
f = serializers.TimeField() f = serializers.TimeField()

4
rest_framework/tests/files.py
View File

@ -33,8 +33,8 @@ class FileSerializerTests(TestCase):
serializer = UploadedFileSerializer(data={'created': now}, files={'file': file}) serializer = UploadedFileSerializer(data={'created': now}, files={'file': file})
uploaded_file = UploadedFile(file=file, created=now) uploaded_file = UploadedFile(file=file, created=now)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.object.created, uploaded_file.created) self.assertEqual(serializer.object.created, uploaded_file.created)
self.assertEquals(serializer.object.file, uploaded_file.file) self.assertEqual(serializer.object.file, uploaded_file.file)
self.assertFalse(serializer.object is uploaded_file) self.assertFalse(serializer.object is uploaded_file)
def test_creation_failure(self): def test_creation_failure(self):

34
rest_framework/tests/filterset.py
View File

@ -79,24 +79,24 @@ class IntegrationTestFiltering(TestCase):
# Basic test with no filter. # Basic test with no filter.
request = factory.get('/') request = factory.get('/')
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data) self.assertEqual(response.data, self.data)
# Tests that the decimal filter works. # Tests that the decimal filter works.
search_decimal = Decimal('2.25') search_decimal = Decimal('2.25')
request = factory.get('/?decimal=%s' % search_decimal) request = factory.get('/?decimal=%s' % search_decimal)
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
expected_data = [f for f in self.data if f['decimal'] == search_decimal] expected_data = [f for f in self.data if f['decimal'] == search_decimal]
self.assertEquals(response.data, expected_data) self.assertEqual(response.data, expected_data)
# Tests that the date filter works. # Tests that the date filter works.
search_date = datetime.date(2012, 9, 22) search_date = datetime.date(2012, 9, 22)
request = factory.get('/?date=%s' % search_date) # search_date str: '2012-09-22' request = factory.get('/?date=%s' % search_date) # search_date str: '2012-09-22'
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
expected_data = [f for f in self.data if f['date'] == search_date] expected_data = [f for f in self.data if f['date'] == search_date]
self.assertEquals(response.data, expected_data) self.assertEqual(response.data, expected_data)
@unittest.skipUnless(django_filters, 'django-filters not installed') @unittest.skipUnless(django_filters, 'django-filters not installed')
def test_get_filtered_class_root_view(self): def test_get_filtered_class_root_view(self):
@ -109,42 +109,42 @@ class IntegrationTestFiltering(TestCase):
# Basic test with no filter. # Basic test with no filter.
request = factory.get('/') request = factory.get('/')
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data) self.assertEqual(response.data, self.data)
# Tests that the decimal filter set with 'lt' in the filter class works. # Tests that the decimal filter set with 'lt' in the filter class works.
search_decimal = Decimal('4.25') search_decimal = Decimal('4.25')
request = factory.get('/?decimal=%s' % search_decimal) request = factory.get('/?decimal=%s' % search_decimal)
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
expected_data = [f for f in self.data if f['decimal'] < search_decimal] expected_data = [f for f in self.data if f['decimal'] < search_decimal]
self.assertEquals(response.data, expected_data) self.assertEqual(response.data, expected_data)
# Tests that the date filter set with 'gt' in the filter class works. # Tests that the date filter set with 'gt' in the filter class works.
search_date = datetime.date(2012, 10, 2) search_date = datetime.date(2012, 10, 2)
request = factory.get('/?date=%s' % search_date) # search_date str: '2012-10-02' request = factory.get('/?date=%s' % search_date) # search_date str: '2012-10-02'
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
expected_data = [f for f in self.data if f['date'] > search_date] expected_data = [f for f in self.data if f['date'] > search_date]
self.assertEquals(response.data, expected_data) self.assertEqual(response.data, expected_data)
# Tests that the text filter set with 'icontains' in the filter class works. # Tests that the text filter set with 'icontains' in the filter class works.
search_text = 'ff' search_text = 'ff'
request = factory.get('/?text=%s' % search_text) request = factory.get('/?text=%s' % search_text)
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
expected_data = [f for f in self.data if search_text in f['text'].lower()] expected_data = [f for f in self.data if search_text in f['text'].lower()]
self.assertEquals(response.data, expected_data) self.assertEqual(response.data, expected_data)
# Tests that multiple filters works. # Tests that multiple filters works.
search_decimal = Decimal('5.25') search_decimal = Decimal('5.25')
search_date = datetime.date(2012, 10, 2) search_date = datetime.date(2012, 10, 2)
request = factory.get('/?decimal=%s&date=%s' % (search_decimal, search_date)) request = factory.get('/?decimal=%s&date=%s' % (search_decimal, search_date))
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
expected_data = [f for f in self.data if f['date'] > search_date and expected_data = [f for f in self.data if f['date'] > search_date and
f['decimal'] < search_decimal] f['decimal'] < search_decimal]
self.assertEquals(response.data, expected_data) self.assertEqual(response.data, expected_data)
@unittest.skipUnless(django_filters, 'django-filters not installed') @unittest.skipUnless(django_filters, 'django-filters not installed')
def test_incorrectly_configured_filter(self): def test_incorrectly_configured_filter(self):
@ -166,4 +166,4 @@ class IntegrationTestFiltering(TestCase):
search_integer = 10 search_integer = 10
request = factory.get('/?integer=%s' % search_integer) request = factory.get('/?integer=%s' % search_integer)
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)

4
rest_framework/tests/genericrelations.py
View File

@ -67,7 +67,7 @@ class TestGenericRelations(TestCase):
'tags': ['django', 'python'], 'tags': ['django', 'python'],
'url': 'https://www.djangoproject.com/' 'url': 'https://www.djangoproject.com/'
} }
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_generic_fk(self): def test_generic_fk(self):
""" """
@ -97,4 +97,4 @@ class TestGenericRelations(TestCase):
'tagged_item': 'Note: Remember the milk' 'tagged_item': 'Note: Remember the milk'
} }
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)

86
rest_framework/tests/generics.py
View File

@ -61,8 +61,8 @@ class TestRootView(TestCase):
""" """
request = factory.get('/') request = factory.get('/')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data) self.assertEqual(response.data, self.data)
def test_post_root_view(self): def test_post_root_view(self):
""" """
@ -72,10 +72,10 @@ class TestRootView(TestCase):
request = factory.post('/', json.dumps(content), request = factory.post('/', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEquals(response.data, {'id': 4, 'text': 'foobar'}) self.assertEqual(response.data, {'id': 4, 'text': 'foobar'})
created = self.objects.get(id=4) created = self.objects.get(id=4)
self.assertEquals(created.text, 'foobar') self.assertEqual(created.text, 'foobar')
def test_put_root_view(self): def test_put_root_view(self):
""" """
@ -85,8 +85,8 @@ class TestRootView(TestCase):
request = factory.put('/', json.dumps(content), request = factory.put('/', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED) self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
self.assertEquals(response.data, {"detail": "Method 'PUT' not allowed."}) self.assertEqual(response.data, {"detail": "Method 'PUT' not allowed."})
def test_delete_root_view(self): def test_delete_root_view(self):
""" """
@ -94,8 +94,8 @@ class TestRootView(TestCase):
""" """
request = factory.delete('/') request = factory.delete('/')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED) self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
self.assertEquals(response.data, {"detail": "Method 'DELETE' not allowed."}) self.assertEqual(response.data, {"detail": "Method 'DELETE' not allowed."})
def test_options_root_view(self): def test_options_root_view(self):
""" """
@ -116,8 +116,8 @@ class TestRootView(TestCase):
'name': 'Root', 'name': 'Root',
'description': 'Example description for OPTIONS.' 'description': 'Example description for OPTIONS.'
} }
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, expected) self.assertEqual(response.data, expected)
def test_post_cannot_set_id(self): def test_post_cannot_set_id(self):
""" """
@ -127,10 +127,10 @@ class TestRootView(TestCase):
request = factory.post('/', json.dumps(content), request = factory.post('/', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEquals(response.data, {'id': 4, 'text': 'foobar'}) self.assertEqual(response.data, {'id': 4, 'text': 'foobar'})
created = self.objects.get(id=4) created = self.objects.get(id=4)
self.assertEquals(created.text, 'foobar') self.assertEqual(created.text, 'foobar')
class TestInstanceView(TestCase): class TestInstanceView(TestCase):
@ -155,8 +155,8 @@ class TestInstanceView(TestCase):
""" """
request = factory.get('/1') request = factory.get('/1')
response = self.view(request, pk=1).render() response = self.view(request, pk=1).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data[0]) self.assertEqual(response.data, self.data[0])
def test_post_instance_view(self): def test_post_instance_view(self):
""" """
@ -166,8 +166,8 @@ class TestInstanceView(TestCase):
request = factory.post('/', json.dumps(content), request = factory.post('/', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED) self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
self.assertEquals(response.data, {"detail": "Method 'POST' not allowed."}) self.assertEqual(response.data, {"detail": "Method 'POST' not allowed."})
def test_put_instance_view(self): def test_put_instance_view(self):
""" """
@ -177,10 +177,10 @@ class TestInstanceView(TestCase):
request = factory.put('/1', json.dumps(content), request = factory.put('/1', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request, pk='1').render() response = self.view(request, pk='1').render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, {'id': 1, 'text': 'foobar'}) self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
updated = self.objects.get(id=1) updated = self.objects.get(id=1)
self.assertEquals(updated.text, 'foobar') self.assertEqual(updated.text, 'foobar')
def test_patch_instance_view(self): def test_patch_instance_view(self):
""" """
@ -191,10 +191,10 @@ class TestInstanceView(TestCase):
content_type='application/json') content_type='application/json')
response = self.view(request, pk=1).render() response = self.view(request, pk=1).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, {'id': 1, 'text': 'foobar'}) self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
updated = self.objects.get(id=1) updated = self.objects.get(id=1)
self.assertEquals(updated.text, 'foobar') self.assertEqual(updated.text, 'foobar')
def test_delete_instance_view(self): def test_delete_instance_view(self):
""" """
@ -202,10 +202,10 @@ class TestInstanceView(TestCase):
""" """
request = factory.delete('/1') request = factory.delete('/1')
response = self.view(request, pk=1).render() response = self.view(request, pk=1).render()
self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEquals(response.content, six.b('')) self.assertEqual(response.content, six.b(''))
ids = [obj.id for obj in self.objects.all()] ids = [obj.id for obj in self.objects.all()]
self.assertEquals(ids, [2, 3]) self.assertEqual(ids, [2, 3])
def test_options_instance_view(self): def test_options_instance_view(self):
""" """
@ -226,8 +226,8 @@ class TestInstanceView(TestCase):
'name': 'Instance', 'name': 'Instance',
'description': 'Example description for OPTIONS.' 'description': 'Example description for OPTIONS.'
} }
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, expected) self.assertEqual(response.data, expected)
def test_put_cannot_set_id(self): def test_put_cannot_set_id(self):
""" """
@ -237,10 +237,10 @@ class TestInstanceView(TestCase):
request = factory.put('/1', json.dumps(content), request = factory.put('/1', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request, pk=1).render() response = self.view(request, pk=1).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, {'id': 1, 'text': 'foobar'}) self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
updated = self.objects.get(id=1) updated = self.objects.get(id=1)
self.assertEquals(updated.text, 'foobar') self.assertEqual(updated.text, 'foobar')
def test_put_to_deleted_instance(self): def test_put_to_deleted_instance(self):
""" """
@ -252,10 +252,10 @@ class TestInstanceView(TestCase):
request = factory.put('/1', json.dumps(content), request = factory.put('/1', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request, pk=1).render() response = self.view(request, pk=1).render()
self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEquals(response.data, {'id': 1, 'text': 'foobar'}) self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
updated = self.objects.get(id=1) updated = self.objects.get(id=1)
self.assertEquals(updated.text, 'foobar') self.assertEqual(updated.text, 'foobar')
def test_put_as_create_on_id_based_url(self): def test_put_as_create_on_id_based_url(self):
""" """
@ -267,9 +267,9 @@ class TestInstanceView(TestCase):
request = factory.put('/5', json.dumps(content), request = factory.put('/5', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request, pk=5).render() response = self.view(request, pk=5).render()
self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.status_code, status.HTTP_201_CREATED)
new_obj = self.objects.get(pk=5) new_obj = self.objects.get(pk=5)
self.assertEquals(new_obj.text, 'foobar') self.assertEqual(new_obj.text, 'foobar')
def test_put_as_create_on_slug_based_url(self): def test_put_as_create_on_slug_based_url(self):
""" """
@ -280,10 +280,10 @@ class TestInstanceView(TestCase):
request = factory.put('/test_slug', json.dumps(content), request = factory.put('/test_slug', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.slug_based_view(request, slug='test_slug').render() response = self.slug_based_view(request, slug='test_slug').render()
self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEquals(response.data, {'slug': 'test_slug', 'text': 'foobar'}) self.assertEqual(response.data, {'slug': 'test_slug', 'text': 'foobar'})
new_obj = SlugBasedModel.objects.get(slug='test_slug') new_obj = SlugBasedModel.objects.get(slug='test_slug')
self.assertEquals(new_obj.text, 'foobar') self.assertEqual(new_obj.text, 'foobar')
# Regression test for #285 # Regression test for #285
@ -314,9 +314,9 @@ class TestCreateModelWithAutoNowAddField(TestCase):
request = factory.post('/', json.dumps(content), request = factory.post('/', json.dumps(content),
content_type='application/json') content_type='application/json')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.status_code, status.HTTP_201_CREATED)
created = self.objects.get(id=1) created = self.objects.get(id=1)
self.assertEquals(created.content, 'foobar') self.assertEqual(created.content, 'foobar')
# Test for particularly ugly regression with m2m in browseable API # Test for particularly ugly regression with m2m in browseable API
@ -349,4 +349,4 @@ class TestM2MBrowseableAPI(TestCase):
request = factory.get('/', HTTP_ACCEPT='text/html') request = factory.get('/', HTTP_ACCEPT='text/html')
view = ExampleView().as_view() view = ExampleView().as_view()
response = view(request).render() response = view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)

26
rest_framework/tests/htmlrenderer.py
View File

@ -66,19 +66,19 @@ class TemplateHTMLRendererTests(TestCase):
def test_simple_html_view(self): def test_simple_html_view(self):
response = self.client.get('/') response = self.client.get('/')
self.assertContains(response, "example: foobar") self.assertContains(response, "example: foobar")
self.assertEquals(response['Content-Type'], 'text/html') self.assertEqual(response['Content-Type'], 'text/html')
def test_not_found_html_view(self): def test_not_found_html_view(self):
response = self.client.get('/not_found') response = self.client.get('/not_found')
self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEquals(response.content, six.b("404 Not Found")) self.assertEqual(response.content, six.b("404 Not Found"))
self.assertEquals(response['Content-Type'], 'text/html') self.assertEqual(response['Content-Type'], 'text/html')
def test_permission_denied_html_view(self): def test_permission_denied_html_view(self):
response = self.client.get('/permission_denied') response = self.client.get('/permission_denied')
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEquals(response.content, six.b("403 Forbidden")) self.assertEqual(response.content, six.b("403 Forbidden"))
self.assertEquals(response['Content-Type'], 'text/html') self.assertEqual(response['Content-Type'], 'text/html')
class TemplateHTMLRendererExceptionTests(TestCase): class TemplateHTMLRendererExceptionTests(TestCase):
@ -107,12 +107,12 @@ class TemplateHTMLRendererExceptionTests(TestCase):
def test_not_found_html_view_with_template(self): def test_not_found_html_view_with_template(self):
response = self.client.get('/not_found') response = self.client.get('/not_found')
self.assertEquals(response.status_code, status.HTTP_404_NOT_FOUND) self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEquals(response.content, six.b("404: Not found")) self.assertEqual(response.content, six.b("404: Not found"))
self.assertEquals(response['Content-Type'], 'text/html') self.assertEqual(response['Content-Type'], 'text/html')
def test_permission_denied_html_view_with_template(self): def test_permission_denied_html_view_with_template(self):
response = self.client.get('/permission_denied') response = self.client.get('/permission_denied')
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEquals(response.content, six.b("403: Permission denied")) self.assertEqual(response.content, six.b("403: Permission denied"))
self.assertEquals(response['Content-Type'], 'text/html') self.assertEqual(response['Content-Type'], 'text/html')

20
rest_framework/tests/hyperlinkedserializers.py
View File

@ -119,8 +119,8 @@ class TestBasicHyperlinkedView(TestCase):
""" """
request = factory.get('/basic/') request = factory.get('/basic/')
response = self.list_view(request).render() response = self.list_view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data) self.assertEqual(response.data, self.data)
def test_get_detail_view(self): def test_get_detail_view(self):
""" """
@ -128,8 +128,8 @@ class TestBasicHyperlinkedView(TestCase):
""" """
request = factory.get('/basic/1') request = factory.get('/basic/1')
response = self.detail_view(request, pk=1).render() response = self.detail_view(request, pk=1).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data[0]) self.assertEqual(response.data, self.data[0])
class TestManyToManyHyperlinkedView(TestCase): class TestManyToManyHyperlinkedView(TestCase):
@ -167,8 +167,8 @@ class TestManyToManyHyperlinkedView(TestCase):
""" """
request = factory.get('/manytomany/') request = factory.get('/manytomany/')
response = self.list_view(request) response = self.list_view(request)
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data) self.assertEqual(response.data, self.data)
def test_get_detail_view(self): def test_get_detail_view(self):
""" """
@ -176,8 +176,8 @@ class TestManyToManyHyperlinkedView(TestCase):
""" """
request = factory.get('/manytomany/1/') request = factory.get('/manytomany/1/')
response = self.detail_view(request, pk=1) response = self.detail_view(request, pk=1)
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data[0]) self.assertEqual(response.data, self.data[0])
class TestCreateWithForeignKeys(TestCase): class TestCreateWithForeignKeys(TestCase):
@ -249,8 +249,8 @@ class TestOptionalRelationHyperlinkedView(TestCase):
""" """
request = factory.get('/optionalrelationmodel-detail/1') request = factory.get('/optionalrelationmodel-detail/1')
response = self.detail_view(request, pk=1) response = self.detail_view(request, pk=1)
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data, self.data) self.assertEqual(response.data, self.data)
def test_put_detail_view(self): def test_put_detail_view(self):
""" """

6
rest_framework/tests/negotiation.py
View File

@ -27,14 +27,14 @@ class TestAcceptedMediaType(TestCase):
def test_client_without_accept_use_renderer(self): def test_client_without_accept_use_renderer(self):
request = Request(factory.get('/')) request = Request(factory.get('/'))
accepted_renderer, accepted_media_type = self.select_renderer(request) accepted_renderer, accepted_media_type = self.select_renderer(request)
self.assertEquals(accepted_media_type, 'application/json') self.assertEqual(accepted_media_type, 'application/json')
def test_client_underspecifies_accept_use_renderer(self): def test_client_underspecifies_accept_use_renderer(self):
request = Request(factory.get('/', HTTP_ACCEPT='*/*')) request = Request(factory.get('/', HTTP_ACCEPT='*/*'))
accepted_renderer, accepted_media_type = self.select_renderer(request) accepted_renderer, accepted_media_type = self.select_renderer(request)
self.assertEquals(accepted_media_type, 'application/json') self.assertEqual(accepted_media_type, 'application/json')
def test_client_overspecifies_accept_use_client(self): def test_client_overspecifies_accept_use_client(self):
request = Request(factory.get('/', HTTP_ACCEPT='application/json; indent=8')) request = Request(factory.get('/', HTTP_ACCEPT='application/json; indent=8'))
accepted_renderer, accepted_media_type = self.select_renderer(request) accepted_renderer, accepted_media_type = self.select_renderer(request)
self.assertEquals(accepted_media_type, 'application/json; indent=8') self.assertEqual(accepted_media_type, 'application/json; indent=8')

90
rest_framework/tests/pagination.py
View File

@ -74,27 +74,27 @@ class IntegrationTestPagination(TestCase):
""" """
request = factory.get('/') request = factory.get('/')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data['count'], 26) self.assertEqual(response.data['count'], 26)
self.assertEquals(response.data['results'], self.data[:10]) self.assertEqual(response.data['results'], self.data[:10])
self.assertNotEquals(response.data['next'], None) self.assertNotEqual(response.data['next'], None)
self.assertEquals(response.data['previous'], None) self.assertEqual(response.data['previous'], None)
request = factory.get(response.data['next']) request = factory.get(response.data['next'])
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data['count'], 26) self.assertEqual(response.data['count'], 26)
self.assertEquals(response.data['results'], self.data[10:20]) self.assertEqual(response.data['results'], self.data[10:20])
self.assertNotEquals(response.data['next'], None) self.assertNotEqual(response.data['next'], None)
self.assertNotEquals(response.data['previous'], None) self.assertNotEqual(response.data['previous'], None)
request = factory.get(response.data['next']) request = factory.get(response.data['next'])
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data['count'], 26) self.assertEqual(response.data['count'], 26)
self.assertEquals(response.data['results'], self.data[20:]) self.assertEqual(response.data['results'], self.data[20:])
self.assertEquals(response.data['next'], None) self.assertEqual(response.data['next'], None)
self.assertNotEquals(response.data['previous'], None) self.assertNotEqual(response.data['previous'], None)
class IntegrationTestPaginationAndFiltering(TestCase): class IntegrationTestPaginationAndFiltering(TestCase):
@ -126,27 +126,27 @@ class IntegrationTestPaginationAndFiltering(TestCase):
""" """
request = factory.get('/?decimal=15.20') request = factory.get('/?decimal=15.20')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data['count'], 15) self.assertEqual(response.data['count'], 15)
self.assertEquals(response.data['results'], self.data[:10]) self.assertEqual(response.data['results'], self.data[:10])
self.assertNotEquals(response.data['next'], None) self.assertNotEqual(response.data['next'], None)
self.assertEquals(response.data['previous'], None) self.assertEqual(response.data['previous'], None)
request = factory.get(response.data['next']) request = factory.get(response.data['next'])
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data['count'], 15) self.assertEqual(response.data['count'], 15)
self.assertEquals(response.data['results'], self.data[10:15]) self.assertEqual(response.data['results'], self.data[10:15])
self.assertEquals(response.data['next'], None) self.assertEqual(response.data['next'], None)
self.assertNotEquals(response.data['previous'], None) self.assertNotEqual(response.data['previous'], None)
request = factory.get(response.data['previous']) request = factory.get(response.data['previous'])
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEquals(response.data['count'], 15) self.assertEqual(response.data['count'], 15)
self.assertEquals(response.data['results'], self.data[:10]) self.assertEqual(response.data['results'], self.data[:10])
self.assertNotEquals(response.data['next'], None) self.assertNotEqual(response.data['next'], None)
self.assertEquals(response.data['previous'], None) self.assertEqual(response.data['previous'], None)
class PassOnContextPaginationSerializer(pagination.PaginationSerializer): class PassOnContextPaginationSerializer(pagination.PaginationSerializer):
@ -167,16 +167,16 @@ class UnitTestPagination(TestCase):
def test_native_pagination(self): def test_native_pagination(self):
serializer = pagination.PaginationSerializer(self.first_page) serializer = pagination.PaginationSerializer(self.first_page)
self.assertEquals(serializer.data['count'], 26) self.assertEqual(serializer.data['count'], 26)
self.assertEquals(serializer.data['next'], '?page=2') self.assertEqual(serializer.data['next'], '?page=2')
self.assertEquals(serializer.data['previous'], None) self.assertEqual(serializer.data['previous'], None)
self.assertEquals(serializer.data['results'], self.objects[:10]) self.assertEqual(serializer.data['results'], self.objects[:10])
serializer = pagination.PaginationSerializer(self.last_page) serializer = pagination.PaginationSerializer(self.last_page)
self.assertEquals(serializer.data['count'], 26) self.assertEqual(serializer.data['count'], 26)
self.assertEquals(serializer.data['next'], None) self.assertEqual(serializer.data['next'], None)
self.assertEquals(serializer.data['previous'], '?page=2') self.assertEqual(serializer.data['previous'], '?page=2')
self.assertEquals(serializer.data['results'], self.objects[20:]) self.assertEqual(serializer.data['results'], self.objects[20:])
def test_context_available_in_result(self): def test_context_available_in_result(self):
""" """
@ -185,7 +185,7 @@ class UnitTestPagination(TestCase):
serializer = PassOnContextPaginationSerializer(self.first_page, context={'foo': 'bar'}) serializer = PassOnContextPaginationSerializer(self.first_page, context={'foo': 'bar'})
serializer.data serializer.data
results = serializer.fields[serializer.results_field] results = serializer.fields[serializer.results_field]
self.assertEquals(serializer.context, results.context) self.assertEqual(serializer.context, results.context)
class TestUnpaginated(TestCase): class TestUnpaginated(TestCase):
@ -213,7 +213,7 @@ class TestUnpaginated(TestCase):
""" """
request = factory.get('/') request = factory.get('/')
response = self.view(request) response = self.view(request)
self.assertEquals(response.data, self.data) self.assertEqual(response.data, self.data)
class TestCustomPaginateByParam(TestCase): class TestCustomPaginateByParam(TestCase):
@ -241,7 +241,7 @@ class TestCustomPaginateByParam(TestCase):
""" """
request = factory.get('/') request = factory.get('/')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.data, self.data) self.assertEqual(response.data, self.data)
def test_paginate_by_param(self): def test_paginate_by_param(self):
""" """
@ -249,8 +249,8 @@ class TestCustomPaginateByParam(TestCase):
""" """
request = factory.get('/?page_size=5') request = factory.get('/?page_size=5')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.data['count'], 13) self.assertEqual(response.data['count'], 13)
self.assertEquals(response.data['results'], self.data[:5]) self.assertEqual(response.data['results'], self.data[:5])
### Tests for context in pagination serializers ### Tests for context in pagination serializers
@ -285,7 +285,7 @@ class TestContextPassedToCustomField(TestCase):
request = factory.get('/') request = factory.get('/')
response = self.view(request).render() response = self.view(request).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
### Tests for custom pagination serializers ### Tests for custom pagination serializers
@ -322,4 +322,4 @@ class TestCustomPaginationSerializer(TestCase):
'total_results': 4, 'total_results': 4,
'objects': ['john', 'paul'] 'objects': ['john', 'paul']
} }
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)

20
rest_framework/tests/permissions.py
View File

@ -60,38 +60,38 @@ class ModelPermissionsIntegrationTests(TestCase):
content_type='application/json', content_type='application/json',
HTTP_AUTHORIZATION=self.permitted_credentials) HTTP_AUTHORIZATION=self.permitted_credentials)
response = root_view(request, pk=1) response = root_view(request, pk=1)
self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEqual(response.status_code, status.HTTP_201_CREATED)
def test_has_put_permissions(self): def test_has_put_permissions(self):
request = factory.put('/1', json.dumps({'text': 'foobar'}), request = factory.put('/1', json.dumps({'text': 'foobar'}),
content_type='application/json', content_type='application/json',
HTTP_AUTHORIZATION=self.permitted_credentials) HTTP_AUTHORIZATION=self.permitted_credentials)
response = instance_view(request, pk='1') response = instance_view(request, pk='1')
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
def test_has_delete_permissions(self): def test_has_delete_permissions(self):
request = factory.delete('/1', HTTP_AUTHORIZATION=self.permitted_credentials) request = factory.delete('/1', HTTP_AUTHORIZATION=self.permitted_credentials)
response = instance_view(request, pk=1) response = instance_view(request, pk=1)
self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_does_not_have_create_permissions(self): def test_does_not_have_create_permissions(self):
request = factory.post('/', json.dumps({'text': 'foobar'}), request = factory.post('/', json.dumps({'text': 'foobar'}),
content_type='application/json', content_type='application/json',
HTTP_AUTHORIZATION=self.disallowed_credentials) HTTP_AUTHORIZATION=self.disallowed_credentials)
response = root_view(request, pk=1) response = root_view(request, pk=1)
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_does_not_have_put_permissions(self): def test_does_not_have_put_permissions(self):
request = factory.put('/1', json.dumps({'text': 'foobar'}), request = factory.put('/1', json.dumps({'text': 'foobar'}),
content_type='application/json', content_type='application/json',
HTTP_AUTHORIZATION=self.disallowed_credentials) HTTP_AUTHORIZATION=self.disallowed_credentials)
response = instance_view(request, pk='1') response = instance_view(request, pk='1')
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_does_not_have_delete_permissions(self): def test_does_not_have_delete_permissions(self):
request = factory.delete('/1', HTTP_AUTHORIZATION=self.disallowed_credentials) request = factory.delete('/1', HTTP_AUTHORIZATION=self.disallowed_credentials)
response = instance_view(request, pk=1) response = instance_view(request, pk=1)
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_has_put_as_create_permissions(self): def test_has_put_as_create_permissions(self):
# User only has update permissions - should be able to update an entity. # User only has update permissions - should be able to update an entity.
@ -99,14 +99,14 @@ class ModelPermissionsIntegrationTests(TestCase):
content_type='application/json', content_type='application/json',
HTTP_AUTHORIZATION=self.updateonly_credentials) HTTP_AUTHORIZATION=self.updateonly_credentials)
response = instance_view(request, pk='1') response = instance_view(request, pk='1')
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
# But if PUTing to a new entity, permission should be denied. # But if PUTing to a new entity, permission should be denied.
request = factory.put('/2', json.dumps({'text': 'foobar'}), request = factory.put('/2', json.dumps({'text': 'foobar'}),
content_type='application/json', content_type='application/json',
HTTP_AUTHORIZATION=self.updateonly_credentials) HTTP_AUTHORIZATION=self.updateonly_credentials)
response = instance_view(request, pk='2') response = instance_view(request, pk='2')
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
class OwnerModel(models.Model): class OwnerModel(models.Model):
@ -145,9 +145,9 @@ class ObjectPermissionsIntegrationTests(TestCase):
def test_owner_has_delete_permissions(self): def test_owner_has_delete_permissions(self):
request = factory.delete('/1', HTTP_AUTHORIZATION=self.owner_credentials) request = factory.delete('/1', HTTP_AUTHORIZATION=self.owner_credentials)
response = owner_instance_view(request, pk='1') response = owner_instance_view(request, pk='1')
self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT) self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
def test_non_owner_does_not_have_delete_permissions(self): def test_non_owner_does_not_have_delete_permissions(self):
request = factory.delete('/1', HTTP_AUTHORIZATION=self.not_owner_credentials) request = factory.delete('/1', HTTP_AUTHORIZATION=self.not_owner_credentials)
response = owner_instance_view(request, pk='1') response = owner_instance_view(request, pk='1')
self.assertEquals(response.status_code, status.HTTP_403_FORBIDDEN) self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)

70
rest_framework/tests/relations_hyperlink.py
View File

@ -86,7 +86,7 @@ class HyperlinkedManyToManyTests(TestCase):
{'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']},
{'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_many_to_many_retrieve(self): def test_reverse_many_to_many_retrieve(self):
queryset = ManyToManyTarget.objects.all() queryset = ManyToManyTarget.objects.all()
@ -96,7 +96,7 @@ class HyperlinkedManyToManyTests(TestCase):
{'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']},
{'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_many_to_many_update(self): def test_many_to_many_update(self):
data = {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} data = {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}
@ -104,7 +104,7 @@ class HyperlinkedManyToManyTests(TestCase):
serializer = ManyToManySourceSerializer(instance, data=data, context={'request': request}) serializer = ManyToManySourceSerializer(instance, data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
serializer.save() serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
queryset = ManyToManySource.objects.all() queryset = ManyToManySource.objects.all()
@ -114,7 +114,7 @@ class HyperlinkedManyToManyTests(TestCase):
{'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']},
{'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_many_to_many_update(self): def test_reverse_many_to_many_update(self):
data = {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']} data = {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']}
@ -122,7 +122,7 @@ class HyperlinkedManyToManyTests(TestCase):
serializer = ManyToManyTargetSerializer(instance, data=data, context={'request': request}) serializer = ManyToManyTargetSerializer(instance, data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
serializer.save() serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
# Ensure target 1 is updated, and everything else is as expected # Ensure target 1 is updated, and everything else is as expected
queryset = ManyToManyTarget.objects.all() queryset = ManyToManyTarget.objects.all()
@ -133,14 +133,14 @@ class HyperlinkedManyToManyTests(TestCase):
{'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_many_to_many_create(self): def test_many_to_many_create(self):
data = {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} data = {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']}
serializer = ManyToManySourceSerializer(data=data, context={'request': request}) serializer = ManyToManySourceSerializer(data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is added, and everything else is as expected # Ensure source 4 is added, and everything else is as expected
@ -152,14 +152,14 @@ class HyperlinkedManyToManyTests(TestCase):
{'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']},
{'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_many_to_many_create(self): def test_reverse_many_to_many_create(self):
data = {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} data = {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']}
serializer = ManyToManyTargetSerializer(data=data, context={'request': request}) serializer = ManyToManyTargetSerializer(data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'target-4') self.assertEqual(obj.name, 'target-4')
# Ensure target 4 is added, and everything else is as expected # Ensure target 4 is added, and everything else is as expected
@ -171,7 +171,7 @@ class HyperlinkedManyToManyTests(TestCase):
{'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}, {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']},
{'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
class HyperlinkedForeignKeyTests(TestCase): class HyperlinkedForeignKeyTests(TestCase):
@ -194,7 +194,7 @@ class HyperlinkedForeignKeyTests(TestCase):
{'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
{'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_foreign_key_retrieve(self): def test_reverse_foreign_key_retrieve(self):
queryset = ForeignKeyTarget.objects.all() queryset = ForeignKeyTarget.objects.all()
@ -203,14 +203,14 @@ class HyperlinkedForeignKeyTests(TestCase):
{'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']},
{'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update(self): def test_foreign_key_update(self):
data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'} data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -221,14 +221,14 @@ class HyperlinkedForeignKeyTests(TestCase):
{'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
{'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_incorrect_type(self): def test_foreign_key_update_incorrect_type(self):
data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 2} data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 2}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request})
self.assertFalse(serializer.is_valid()) self.assertFalse(serializer.is_valid())
self.assertEquals(serializer.errors, {'target': ['Incorrect type. Expected url string, received int.']}) self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected url string, received int.']})
def test_reverse_foreign_key_update(self): def test_reverse_foreign_key_update(self):
data = {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} data = {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}
@ -243,10 +243,10 @@ class HyperlinkedForeignKeyTests(TestCase):
{'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']},
{'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []},
] ]
self.assertEquals(new_serializer.data, expected) self.assertEqual(new_serializer.data, expected)
serializer.save() serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
# Ensure target 2 is update, and everything else is as expected # Ensure target 2 is update, and everything else is as expected
queryset = ForeignKeyTarget.objects.all() queryset = ForeignKeyTarget.objects.all()
@ -255,14 +255,14 @@ class HyperlinkedForeignKeyTests(TestCase):
{'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']},
{'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create(self): def test_foreign_key_create(self):
data = {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'} data = {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'}
serializer = ForeignKeySourceSerializer(data=data, context={'request': request}) serializer = ForeignKeySourceSerializer(data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -274,14 +274,14 @@ class HyperlinkedForeignKeyTests(TestCase):
{'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'},
{'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'}, {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_foreign_key_create(self): def test_reverse_foreign_key_create(self):
data = {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} data = {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}
serializer = ForeignKeyTargetSerializer(data=data, context={'request': request}) serializer = ForeignKeyTargetSerializer(data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'target-3') self.assertEqual(obj.name, 'target-3')
# Ensure target 4 is added, and everything else is as expected # Ensure target 4 is added, and everything else is as expected
@ -292,14 +292,14 @@ class HyperlinkedForeignKeyTests(TestCase):
{'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []},
{'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_invalid_null(self): def test_foreign_key_update_with_invalid_null(self):
data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': None} data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': None}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request})
self.assertFalse(serializer.is_valid()) self.assertFalse(serializer.is_valid())
self.assertEquals(serializer.errors, {'target': ['This field is required.']}) self.assertEqual(serializer.errors, {'target': ['This field is required.']})
class HyperlinkedNullableForeignKeyTests(TestCase): class HyperlinkedNullableForeignKeyTests(TestCase):
@ -322,14 +322,14 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
{'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
{'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create_with_valid_null(self): def test_foreign_key_create_with_valid_null(self):
data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None}
serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is created, and everything else is as expected # Ensure source 4 is created, and everything else is as expected
@ -341,7 +341,7 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
{'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
{'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create_with_valid_emptystring(self): def test_foreign_key_create_with_valid_emptystring(self):
""" """
@ -353,7 +353,7 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, expected_data) self.assertEqual(serializer.data, expected_data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is created, and everything else is as expected # Ensure source 4 is created, and everything else is as expected
@ -365,14 +365,14 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
{'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
{'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_valid_null(self): def test_foreign_key_update_with_valid_null(self):
data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}
instance = NullableForeignKeySource.objects.get(pk=1) instance = NullableForeignKeySource.objects.get(pk=1)
serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -383,7 +383,7 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
{'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
{'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_valid_emptystring(self): def test_foreign_key_update_with_valid_emptystring(self):
""" """
@ -395,7 +395,7 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
instance = NullableForeignKeySource.objects.get(pk=1) instance = NullableForeignKeySource.objects.get(pk=1)
serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request})
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, expected_data) self.assertEqual(serializer.data, expected_data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -406,7 +406,7 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
{'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'},
{'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
# reverse foreign keys MUST be read_only # reverse foreign keys MUST be read_only
# In the general case they do not provide .remove() or .clear() # In the general case they do not provide .remove() or .clear()
@ -417,7 +417,7 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
# instance = ForeignKeyTarget.objects.get(pk=1) # instance = ForeignKeyTarget.objects.get(pk=1)
# serializer = ForeignKeyTargetSerializer(instance, data=data) # serializer = ForeignKeyTargetSerializer(instance, data=data)
# self.assertTrue(serializer.is_valid()) # self.assertTrue(serializer.is_valid())
# self.assertEquals(serializer.data, data) # self.assertEqual(serializer.data, data)
# serializer.save() # serializer.save()
# # Ensure target 1 is updated, and everything else is as expected # # Ensure target 1 is updated, and everything else is as expected
@ -427,7 +427,7 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
# {'id': 1, 'name': 'target-1', 'sources': [1]}, # {'id': 1, 'name': 'target-1', 'sources': [1]},
# {'id': 2, 'name': 'target-2', 'sources': []}, # {'id': 2, 'name': 'target-2', 'sources': []},
# ] # ]
# self.assertEquals(serializer.data, expected) # self.assertEqual(serializer.data, expected)
class HyperlinkedNullableOneToOneTests(TestCase): class HyperlinkedNullableOneToOneTests(TestCase):
@ -448,4 +448,4 @@ class HyperlinkedNullableOneToOneTests(TestCase):
{'url': 'http://testserver/onetoonetarget/1/', 'name': 'target-1', 'nullable_source': 'http://testserver/nullableonetoonesource/1/'}, {'url': 'http://testserver/onetoonetarget/1/', 'name': 'target-1', 'nullable_source': 'http://testserver/nullableonetoonesource/1/'},
{'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None}, {'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)

8
rest_framework/tests/relations_nested.py
View File

@ -58,7 +58,7 @@ class ReverseForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', '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'}}, {'id': 3, 'name': 'source-3', 'target': {'id': 1, 'name': 'target-1'}},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_foreign_key_retrieve(self): def test_reverse_foreign_key_retrieve(self):
queryset = ForeignKeyTarget.objects.all() queryset = ForeignKeyTarget.objects.all()
@ -72,7 +72,7 @@ class ReverseForeignKeyTests(TestCase):
{'id': 2, 'name': 'target-2', 'sources': [ {'id': 2, 'name': 'target-2', 'sources': [
]} ]}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
class NestedNullableForeignKeyTests(TestCase): class NestedNullableForeignKeyTests(TestCase):
@ -93,7 +93,7 @@ class NestedNullableForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': {'id': 1, 'name': 'target-1'}}, {'id': 2, 'name': 'source-2', 'target': {'id': 1, 'name': 'target-1'}},
{'id': 3, 'name': 'source-3', 'target': None}, {'id': 3, 'name': 'source-3', 'target': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
class NestedNullableOneToOneTests(TestCase): class NestedNullableOneToOneTests(TestCase):
@ -112,4 +112,4 @@ class NestedNullableOneToOneTests(TestCase):
{'id': 1, 'name': 'target-1', 'nullable_source': {'id': 1, 'name': 'source-1', 'target': 1}}, {'id': 1, 'name': 'target-1', 'nullable_source': {'id': 1, 'name': 'source-1', 'target': 1}},
{'id': 2, 'name': 'target-2', 'nullable_source': None}, {'id': 2, 'name': 'target-2', 'nullable_source': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)

70
rest_framework/tests/relations_pk.py
View File

@ -62,7 +62,7 @@ class PKManyToManyTests(TestCase):
{'id': 2, 'name': 'source-2', 'targets': [1, 2]}, {'id': 2, 'name': 'source-2', 'targets': [1, 2]},
{'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_many_to_many_retrieve(self): def test_reverse_many_to_many_retrieve(self):
queryset = ManyToManyTarget.objects.all() queryset = ManyToManyTarget.objects.all()
@ -72,7 +72,7 @@ class PKManyToManyTests(TestCase):
{'id': 2, 'name': 'target-2', 'sources': [2, 3]}, {'id': 2, 'name': 'target-2', 'sources': [2, 3]},
{'id': 3, 'name': 'target-3', 'sources': [3]} {'id': 3, 'name': 'target-3', 'sources': [3]}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_many_to_many_update(self): def test_many_to_many_update(self):
data = {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]} data = {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]}
@ -80,7 +80,7 @@ class PKManyToManyTests(TestCase):
serializer = ManyToManySourceSerializer(instance, data=data) serializer = ManyToManySourceSerializer(instance, data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
serializer.save() serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
queryset = ManyToManySource.objects.all() queryset = ManyToManySource.objects.all()
@ -90,7 +90,7 @@ class PKManyToManyTests(TestCase):
{'id': 2, 'name': 'source-2', 'targets': [1, 2]}, {'id': 2, 'name': 'source-2', 'targets': [1, 2]},
{'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_many_to_many_update(self): def test_reverse_many_to_many_update(self):
data = {'id': 1, 'name': 'target-1', 'sources': [1]} data = {'id': 1, 'name': 'target-1', 'sources': [1]}
@ -98,7 +98,7 @@ class PKManyToManyTests(TestCase):
serializer = ManyToManyTargetSerializer(instance, data=data) serializer = ManyToManyTargetSerializer(instance, data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
serializer.save() serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
# Ensure target 1 is updated, and everything else is as expected # Ensure target 1 is updated, and everything else is as expected
queryset = ManyToManyTarget.objects.all() queryset = ManyToManyTarget.objects.all()
@ -108,14 +108,14 @@ class PKManyToManyTests(TestCase):
{'id': 2, 'name': 'target-2', 'sources': [2, 3]}, {'id': 2, 'name': 'target-2', 'sources': [2, 3]},
{'id': 3, 'name': 'target-3', 'sources': [3]} {'id': 3, 'name': 'target-3', 'sources': [3]}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_many_to_many_create(self): def test_many_to_many_create(self):
data = {'id': 4, 'name': 'source-4', 'targets': [1, 3]} data = {'id': 4, 'name': 'source-4', 'targets': [1, 3]}
serializer = ManyToManySourceSerializer(data=data) serializer = ManyToManySourceSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is added, and everything else is as expected # Ensure source 4 is added, and everything else is as expected
@ -127,14 +127,14 @@ class PKManyToManyTests(TestCase):
{'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}, {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]},
{'id': 4, 'name': 'source-4', 'targets': [1, 3]}, {'id': 4, 'name': 'source-4', 'targets': [1, 3]},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_many_to_many_create(self): def test_reverse_many_to_many_create(self):
data = {'id': 4, 'name': 'target-4', 'sources': [1, 3]} data = {'id': 4, 'name': 'target-4', 'sources': [1, 3]}
serializer = ManyToManyTargetSerializer(data=data) serializer = ManyToManyTargetSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'target-4') self.assertEqual(obj.name, 'target-4')
# Ensure target 4 is added, and everything else is as expected # Ensure target 4 is added, and everything else is as expected
@ -146,7 +146,7 @@ class PKManyToManyTests(TestCase):
{'id': 3, 'name': 'target-3', 'sources': [3]}, {'id': 3, 'name': 'target-3', 'sources': [3]},
{'id': 4, 'name': 'target-4', 'sources': [1, 3]} {'id': 4, 'name': 'target-4', 'sources': [1, 3]}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
class PKForeignKeyTests(TestCase): class PKForeignKeyTests(TestCase):
@ -167,7 +167,7 @@ class PKForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 1}, {'id': 2, 'name': 'source-2', 'target': 1},
{'id': 3, 'name': 'source-3', 'target': 1} {'id': 3, 'name': 'source-3', 'target': 1}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_foreign_key_retrieve(self): def test_reverse_foreign_key_retrieve(self):
queryset = ForeignKeyTarget.objects.all() queryset = ForeignKeyTarget.objects.all()
@ -176,14 +176,14 @@ class PKForeignKeyTests(TestCase):
{'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]},
{'id': 2, 'name': 'target-2', 'sources': []}, {'id': 2, 'name': 'target-2', 'sources': []},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update(self): def test_foreign_key_update(self):
data = {'id': 1, 'name': 'source-1', 'target': 2} data = {'id': 1, 'name': 'source-1', 'target': 2}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data) serializer = ForeignKeySourceSerializer(instance, data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -194,14 +194,14 @@ class PKForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 1}, {'id': 2, 'name': 'source-2', 'target': 1},
{'id': 3, 'name': 'source-3', 'target': 1} {'id': 3, 'name': 'source-3', 'target': 1}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_incorrect_type(self): def test_foreign_key_update_incorrect_type(self):
data = {'id': 1, 'name': 'source-1', 'target': 'foo'} data = {'id': 1, 'name': 'source-1', 'target': 'foo'}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data) serializer = ForeignKeySourceSerializer(instance, data=data)
self.assertFalse(serializer.is_valid()) self.assertFalse(serializer.is_valid())
self.assertEquals(serializer.errors, {'target': ['Incorrect type. Expected pk value, received %s.' % six.text_type.__name__]}) self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected pk value, received %s.' % six.text_type.__name__]})
def test_reverse_foreign_key_update(self): def test_reverse_foreign_key_update(self):
data = {'id': 2, 'name': 'target-2', 'sources': [1, 3]} data = {'id': 2, 'name': 'target-2', 'sources': [1, 3]}
@ -216,10 +216,10 @@ class PKForeignKeyTests(TestCase):
{'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]},
{'id': 2, 'name': 'target-2', 'sources': []}, {'id': 2, 'name': 'target-2', 'sources': []},
] ]
self.assertEquals(new_serializer.data, expected) self.assertEqual(new_serializer.data, expected)
serializer.save() serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
# Ensure target 2 is update, and everything else is as expected # Ensure target 2 is update, and everything else is as expected
queryset = ForeignKeyTarget.objects.all() queryset = ForeignKeyTarget.objects.all()
@ -228,14 +228,14 @@ class PKForeignKeyTests(TestCase):
{'id': 1, 'name': 'target-1', 'sources': [2]}, {'id': 1, 'name': 'target-1', 'sources': [2]},
{'id': 2, 'name': 'target-2', 'sources': [1, 3]}, {'id': 2, 'name': 'target-2', 'sources': [1, 3]},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create(self): def test_foreign_key_create(self):
data = {'id': 4, 'name': 'source-4', 'target': 2} data = {'id': 4, 'name': 'source-4', 'target': 2}
serializer = ForeignKeySourceSerializer(data=data) serializer = ForeignKeySourceSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is added, and everything else is as expected # Ensure source 4 is added, and everything else is as expected
@ -247,14 +247,14 @@ class PKForeignKeyTests(TestCase):
{'id': 3, 'name': 'source-3', 'target': 1}, {'id': 3, 'name': 'source-3', 'target': 1},
{'id': 4, 'name': 'source-4', 'target': 2}, {'id': 4, 'name': 'source-4', 'target': 2},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_foreign_key_create(self): def test_reverse_foreign_key_create(self):
data = {'id': 3, 'name': 'target-3', 'sources': [1, 3]} data = {'id': 3, 'name': 'target-3', 'sources': [1, 3]}
serializer = ForeignKeyTargetSerializer(data=data) serializer = ForeignKeyTargetSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'target-3') self.assertEqual(obj.name, 'target-3')
# Ensure target 3 is added, and everything else is as expected # Ensure target 3 is added, and everything else is as expected
@ -265,14 +265,14 @@ class PKForeignKeyTests(TestCase):
{'id': 2, 'name': 'target-2', 'sources': []}, {'id': 2, 'name': 'target-2', 'sources': []},
{'id': 3, 'name': 'target-3', 'sources': [1, 3]}, {'id': 3, 'name': 'target-3', 'sources': [1, 3]},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_invalid_null(self): def test_foreign_key_update_with_invalid_null(self):
data = {'id': 1, 'name': 'source-1', 'target': None} data = {'id': 1, 'name': 'source-1', 'target': None}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data) serializer = ForeignKeySourceSerializer(instance, data=data)
self.assertFalse(serializer.is_valid()) self.assertFalse(serializer.is_valid())
self.assertEquals(serializer.errors, {'target': ['This field is required.']}) self.assertEqual(serializer.errors, {'target': ['This field is required.']})
class PKNullableForeignKeyTests(TestCase): class PKNullableForeignKeyTests(TestCase):
@ -293,14 +293,14 @@ class PKNullableForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 1}, {'id': 2, 'name': 'source-2', 'target': 1},
{'id': 3, 'name': 'source-3', 'target': None}, {'id': 3, 'name': 'source-3', 'target': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create_with_valid_null(self): def test_foreign_key_create_with_valid_null(self):
data = {'id': 4, 'name': 'source-4', 'target': None} data = {'id': 4, 'name': 'source-4', 'target': None}
serializer = NullableForeignKeySourceSerializer(data=data) serializer = NullableForeignKeySourceSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is created, and everything else is as expected # Ensure source 4 is created, and everything else is as expected
@ -312,7 +312,7 @@ class PKNullableForeignKeyTests(TestCase):
{'id': 3, 'name': 'source-3', 'target': None}, {'id': 3, 'name': 'source-3', 'target': None},
{'id': 4, 'name': 'source-4', 'target': None} {'id': 4, 'name': 'source-4', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create_with_valid_emptystring(self): def test_foreign_key_create_with_valid_emptystring(self):
""" """
@ -324,7 +324,7 @@ class PKNullableForeignKeyTests(TestCase):
serializer = NullableForeignKeySourceSerializer(data=data) serializer = NullableForeignKeySourceSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, expected_data) self.assertEqual(serializer.data, expected_data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is created, and everything else is as expected # Ensure source 4 is created, and everything else is as expected
@ -336,14 +336,14 @@ class PKNullableForeignKeyTests(TestCase):
{'id': 3, 'name': 'source-3', 'target': None}, {'id': 3, 'name': 'source-3', 'target': None},
{'id': 4, 'name': 'source-4', 'target': None} {'id': 4, 'name': 'source-4', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_valid_null(self): def test_foreign_key_update_with_valid_null(self):
data = {'id': 1, 'name': 'source-1', 'target': None} data = {'id': 1, 'name': 'source-1', 'target': None}
instance = NullableForeignKeySource.objects.get(pk=1) instance = NullableForeignKeySource.objects.get(pk=1)
serializer = NullableForeignKeySourceSerializer(instance, data=data) serializer = NullableForeignKeySourceSerializer(instance, data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -354,7 +354,7 @@ class PKNullableForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 1}, {'id': 2, 'name': 'source-2', 'target': 1},
{'id': 3, 'name': 'source-3', 'target': None} {'id': 3, 'name': 'source-3', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_valid_emptystring(self): def test_foreign_key_update_with_valid_emptystring(self):
""" """
@ -366,7 +366,7 @@ class PKNullableForeignKeyTests(TestCase):
instance = NullableForeignKeySource.objects.get(pk=1) instance = NullableForeignKeySource.objects.get(pk=1)
serializer = NullableForeignKeySourceSerializer(instance, data=data) serializer = NullableForeignKeySourceSerializer(instance, data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, expected_data) self.assertEqual(serializer.data, expected_data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -377,7 +377,7 @@ class PKNullableForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 1}, {'id': 2, 'name': 'source-2', 'target': 1},
{'id': 3, 'name': 'source-3', 'target': None} {'id': 3, 'name': 'source-3', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
# reverse foreign keys MUST be read_only # reverse foreign keys MUST be read_only
# In the general case they do not provide .remove() or .clear() # In the general case they do not provide .remove() or .clear()
@ -388,7 +388,7 @@ class PKNullableForeignKeyTests(TestCase):
# instance = ForeignKeyTarget.objects.get(pk=1) # instance = ForeignKeyTarget.objects.get(pk=1)
# serializer = ForeignKeyTargetSerializer(instance, data=data) # serializer = ForeignKeyTargetSerializer(instance, data=data)
# self.assertTrue(serializer.is_valid()) # self.assertTrue(serializer.is_valid())
# self.assertEquals(serializer.data, data) # self.assertEqual(serializer.data, data)
# serializer.save() # serializer.save()
# # Ensure target 1 is updated, and everything else is as expected # # Ensure target 1 is updated, and everything else is as expected
@ -398,7 +398,7 @@ class PKNullableForeignKeyTests(TestCase):
# {'id': 1, 'name': 'target-1', 'sources': [1]}, # {'id': 1, 'name': 'target-1', 'sources': [1]},
# {'id': 2, 'name': 'target-2', 'sources': []}, # {'id': 2, 'name': 'target-2', 'sources': []},
# ] # ]
# self.assertEquals(serializer.data, expected) # self.assertEqual(serializer.data, expected)
class PKNullableOneToOneTests(TestCase): class PKNullableOneToOneTests(TestCase):
@ -417,4 +417,4 @@ class PKNullableOneToOneTests(TestCase):
{'id': 1, 'name': 'target-1', 'nullable_source': 1}, {'id': 1, 'name': 'target-1', 'nullable_source': 1},
{'id': 2, 'name': 'target-2', 'nullable_source': None}, {'id': 2, 'name': 'target-2', 'nullable_source': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)

44
rest_framework/tests/relations_slug.py
View File

@ -43,7 +43,7 @@ class SlugForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 'target-1'}, {'id': 2, 'name': 'source-2', 'target': 'target-1'},
{'id': 3, 'name': 'source-3', 'target': 'target-1'} {'id': 3, 'name': 'source-3', 'target': 'target-1'}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_foreign_key_retrieve(self): def test_reverse_foreign_key_retrieve(self):
queryset = ForeignKeyTarget.objects.all() queryset = ForeignKeyTarget.objects.all()
@ -52,14 +52,14 @@ class SlugForeignKeyTests(TestCase):
{'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
{'id': 2, 'name': 'target-2', 'sources': []}, {'id': 2, 'name': 'target-2', 'sources': []},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update(self): def test_foreign_key_update(self):
data = {'id': 1, 'name': 'source-1', 'target': 'target-2'} data = {'id': 1, 'name': 'source-1', 'target': 'target-2'}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data) serializer = ForeignKeySourceSerializer(instance, data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -70,14 +70,14 @@ class SlugForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 'target-1'}, {'id': 2, 'name': 'source-2', 'target': 'target-1'},
{'id': 3, 'name': 'source-3', 'target': 'target-1'} {'id': 3, 'name': 'source-3', 'target': 'target-1'}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_incorrect_type(self): def test_foreign_key_update_incorrect_type(self):
data = {'id': 1, 'name': 'source-1', 'target': 123} data = {'id': 1, 'name': 'source-1', 'target': 123}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data) serializer = ForeignKeySourceSerializer(instance, data=data)
self.assertFalse(serializer.is_valid()) self.assertFalse(serializer.is_valid())
self.assertEquals(serializer.errors, {'target': ['Object with name=123 does not exist.']}) self.assertEqual(serializer.errors, {'target': ['Object with name=123 does not exist.']})
def test_reverse_foreign_key_update(self): def test_reverse_foreign_key_update(self):
data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']} data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}
@ -92,10 +92,10 @@ class SlugForeignKeyTests(TestCase):
{'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']},
{'id': 2, 'name': 'target-2', 'sources': []}, {'id': 2, 'name': 'target-2', 'sources': []},
] ]
self.assertEquals(new_serializer.data, expected) self.assertEqual(new_serializer.data, expected)
serializer.save() serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
# Ensure target 2 is update, and everything else is as expected # Ensure target 2 is update, and everything else is as expected
queryset = ForeignKeyTarget.objects.all() queryset = ForeignKeyTarget.objects.all()
@ -104,7 +104,7 @@ class SlugForeignKeyTests(TestCase):
{'id': 1, 'name': 'target-1', 'sources': ['source-2']}, {'id': 1, 'name': 'target-1', 'sources': ['source-2']},
{'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}, {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create(self): def test_foreign_key_create(self):
data = {'id': 4, 'name': 'source-4', 'target': 'target-2'} data = {'id': 4, 'name': 'source-4', 'target': 'target-2'}
@ -112,7 +112,7 @@ class SlugForeignKeyTests(TestCase):
serializer.is_valid() serializer.is_valid()
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is added, and everything else is as expected # Ensure source 4 is added, and everything else is as expected
@ -124,14 +124,14 @@ class SlugForeignKeyTests(TestCase):
{'id': 3, 'name': 'source-3', 'target': 'target-1'}, {'id': 3, 'name': 'source-3', 'target': 'target-1'},
{'id': 4, 'name': 'source-4', 'target': 'target-2'}, {'id': 4, 'name': 'source-4', 'target': 'target-2'},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_reverse_foreign_key_create(self): def test_reverse_foreign_key_create(self):
data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']} data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}
serializer = ForeignKeyTargetSerializer(data=data) serializer = ForeignKeyTargetSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'target-3') self.assertEqual(obj.name, 'target-3')
# Ensure target 3 is added, and everything else is as expected # Ensure target 3 is added, and everything else is as expected
@ -142,14 +142,14 @@ class SlugForeignKeyTests(TestCase):
{'id': 2, 'name': 'target-2', 'sources': []}, {'id': 2, 'name': 'target-2', 'sources': []},
{'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}, {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_invalid_null(self): def test_foreign_key_update_with_invalid_null(self):
data = {'id': 1, 'name': 'source-1', 'target': None} data = {'id': 1, 'name': 'source-1', 'target': None}
instance = ForeignKeySource.objects.get(pk=1) instance = ForeignKeySource.objects.get(pk=1)
serializer = ForeignKeySourceSerializer(instance, data=data) serializer = ForeignKeySourceSerializer(instance, data=data)
self.assertFalse(serializer.is_valid()) self.assertFalse(serializer.is_valid())
self.assertEquals(serializer.errors, {'target': ['This field is required.']}) self.assertEqual(serializer.errors, {'target': ['This field is required.']})
class SlugNullableForeignKeyTests(TestCase): class SlugNullableForeignKeyTests(TestCase):
@ -170,14 +170,14 @@ class SlugNullableForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 'target-1'}, {'id': 2, 'name': 'source-2', 'target': 'target-1'},
{'id': 3, 'name': 'source-3', 'target': None}, {'id': 3, 'name': 'source-3', 'target': None},
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create_with_valid_null(self): def test_foreign_key_create_with_valid_null(self):
data = {'id': 4, 'name': 'source-4', 'target': None} data = {'id': 4, 'name': 'source-4', 'target': None}
serializer = NullableForeignKeySourceSerializer(data=data) serializer = NullableForeignKeySourceSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is created, and everything else is as expected # Ensure source 4 is created, and everything else is as expected
@ -189,7 +189,7 @@ class SlugNullableForeignKeyTests(TestCase):
{'id': 3, 'name': 'source-3', 'target': None}, {'id': 3, 'name': 'source-3', 'target': None},
{'id': 4, 'name': 'source-4', 'target': None} {'id': 4, 'name': 'source-4', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_create_with_valid_emptystring(self): def test_foreign_key_create_with_valid_emptystring(self):
""" """
@ -201,7 +201,7 @@ class SlugNullableForeignKeyTests(TestCase):
serializer = NullableForeignKeySourceSerializer(data=data) serializer = NullableForeignKeySourceSerializer(data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
obj = serializer.save() obj = serializer.save()
self.assertEquals(serializer.data, expected_data) self.assertEqual(serializer.data, expected_data)
self.assertEqual(obj.name, 'source-4') self.assertEqual(obj.name, 'source-4')
# Ensure source 4 is created, and everything else is as expected # Ensure source 4 is created, and everything else is as expected
@ -213,14 +213,14 @@ class SlugNullableForeignKeyTests(TestCase):
{'id': 3, 'name': 'source-3', 'target': None}, {'id': 3, 'name': 'source-3', 'target': None},
{'id': 4, 'name': 'source-4', 'target': None} {'id': 4, 'name': 'source-4', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_valid_null(self): def test_foreign_key_update_with_valid_null(self):
data = {'id': 1, 'name': 'source-1', 'target': None} data = {'id': 1, 'name': 'source-1', 'target': None}
instance = NullableForeignKeySource.objects.get(pk=1) instance = NullableForeignKeySource.objects.get(pk=1)
serializer = NullableForeignKeySourceSerializer(instance, data=data) serializer = NullableForeignKeySourceSerializer(instance, data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, data) self.assertEqual(serializer.data, data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -231,7 +231,7 @@ class SlugNullableForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 'target-1'}, {'id': 2, 'name': 'source-2', 'target': 'target-1'},
{'id': 3, 'name': 'source-3', 'target': None} {'id': 3, 'name': 'source-3', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)
def test_foreign_key_update_with_valid_emptystring(self): def test_foreign_key_update_with_valid_emptystring(self):
""" """
@ -243,7 +243,7 @@ class SlugNullableForeignKeyTests(TestCase):
instance = NullableForeignKeySource.objects.get(pk=1) instance = NullableForeignKeySource.objects.get(pk=1)
serializer = NullableForeignKeySourceSerializer(instance, data=data) serializer = NullableForeignKeySourceSerializer(instance, data=data)
self.assertTrue(serializer.is_valid()) self.assertTrue(serializer.is_valid())
self.assertEquals(serializer.data, expected_data) self.assertEqual(serializer.data, expected_data)
serializer.save() serializer.save()
# Ensure source 1 is updated, and everything else is as expected # Ensure source 1 is updated, and everything else is as expected
@ -254,4 +254,4 @@ class SlugNullableForeignKeyTests(TestCase):
{'id': 2, 'name': 'source-2', 'target': 'target-1'}, {'id': 2, 'name': 'source-2', 'target': 'target-1'},
{'id': 3, 'name': 'source-3', 'target': None} {'id': 3, 'name': 'source-3', 'target': None}
] ]
self.assertEquals(serializer.data, expected) self.assertEqual(serializer.data, expected)

84
rest_framework/tests/renderers.py
View File

@ -34,7 +34,7 @@ class BasicRendererTests(TestCase):
def test_expected_results(self): def test_expected_results(self):
for value, renderer_cls, expected in expected_results: for value, renderer_cls, expected in expected_results:
output = renderer_cls().render(value) output = renderer_cls().render(value)
self.assertEquals(output, expected) self.assertEqual(output, expected)
class RendererA(BaseRenderer): class RendererA(BaseRenderer):
@ -134,39 +134,39 @@ class RendererEndToEndTests(TestCase):
def test_default_renderer_serializes_content(self): def test_default_renderer_serializes_content(self):
"""If the Accept header is not set the default renderer should serialize the response.""" """If the Accept header is not set the default renderer should serialize the response."""
resp = self.client.get('/') resp = self.client.get('/')
self.assertEquals(resp['Content-Type'], RendererA.media_type) self.assertEqual(resp['Content-Type'], RendererA.media_type)
self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_head_method_serializes_no_content(self): def test_head_method_serializes_no_content(self):
"""No response must be included in HEAD requests.""" """No response must be included in HEAD requests."""
resp = self.client.head('/') resp = self.client.head('/')
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
self.assertEquals(resp['Content-Type'], RendererA.media_type) self.assertEqual(resp['Content-Type'], RendererA.media_type)
self.assertEquals(resp.content, six.b('')) self.assertEqual(resp.content, six.b(''))
def test_default_renderer_serializes_content_on_accept_any(self): def test_default_renderer_serializes_content_on_accept_any(self):
"""If the Accept header is set to */* the default renderer should serialize the response.""" """If the Accept header is set to */* the default renderer should serialize the response."""
resp = self.client.get('/', HTTP_ACCEPT='*/*') resp = self.client.get('/', HTTP_ACCEPT='*/*')
self.assertEquals(resp['Content-Type'], RendererA.media_type) self.assertEqual(resp['Content-Type'], RendererA.media_type)
self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_default_case(self): def test_specified_renderer_serializes_content_default_case(self):
"""If the Accept header is set the specified renderer should serialize the response. """If the Accept header is set the specified renderer should serialize the response.
(In this case we check that works for the default renderer)""" (In this case we check that works for the default renderer)"""
resp = self.client.get('/', HTTP_ACCEPT=RendererA.media_type) resp = self.client.get('/', HTTP_ACCEPT=RendererA.media_type)
self.assertEquals(resp['Content-Type'], RendererA.media_type) self.assertEqual(resp['Content-Type'], RendererA.media_type)
self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_non_default_case(self): def test_specified_renderer_serializes_content_non_default_case(self):
"""If the Accept header is set the specified renderer should serialize the response. """If the Accept header is set the specified renderer should serialize the response.
(In this case we check that works for a non-default renderer)""" (In this case we check that works for a non-default renderer)"""
resp = self.client.get('/', HTTP_ACCEPT=RendererB.media_type) resp = self.client.get('/', HTTP_ACCEPT=RendererB.media_type)
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_on_accept_query(self): def test_specified_renderer_serializes_content_on_accept_query(self):
"""The '_accept' query string should behave in the same way as the Accept header.""" """The '_accept' query string should behave in the same way as the Accept header."""
@ -175,14 +175,14 @@ class RendererEndToEndTests(TestCase):
RendererB.media_type RendererB.media_type
) )
resp = self.client.get('/' + param) resp = self.client.get('/' + param)
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_unsatisfiable_accept_header_on_request_returns_406_status(self): def test_unsatisfiable_accept_header_on_request_returns_406_status(self):
"""If the Accept header is unsatisfiable we should return a 406 Not Acceptable response.""" """If the Accept header is unsatisfiable we should return a 406 Not Acceptable response."""
resp = self.client.get('/', HTTP_ACCEPT='foo/bar') resp = self.client.get('/', HTTP_ACCEPT='foo/bar')
self.assertEquals(resp.status_code, status.HTTP_406_NOT_ACCEPTABLE) self.assertEqual(resp.status_code, status.HTTP_406_NOT_ACCEPTABLE)
def test_specified_renderer_serializes_content_on_format_query(self): def test_specified_renderer_serializes_content_on_format_query(self):
"""If a 'format' query is specified, the renderer with the matching """If a 'format' query is specified, the renderer with the matching
@ -192,17 +192,17 @@ class RendererEndToEndTests(TestCase):
RendererB.format RendererB.format
) )
resp = self.client.get('/' + param) resp = self.client.get('/' + param)
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_on_format_kwargs(self): def test_specified_renderer_serializes_content_on_format_kwargs(self):
"""If a 'format' keyword arg is specified, the renderer with the matching """If a 'format' keyword arg is specified, the renderer with the matching
format attribute should serialize the response.""" format attribute should serialize the response."""
resp = self.client.get('/something.formatb') resp = self.client.get('/something.formatb')
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_is_used_on_format_query_with_matching_accept(self): def test_specified_renderer_is_used_on_format_query_with_matching_accept(self):
"""If both a 'format' query and a matching Accept header specified, """If both a 'format' query and a matching Accept header specified,
@ -213,9 +213,9 @@ class RendererEndToEndTests(TestCase):
) )
resp = self.client.get('/' + param, resp = self.client.get('/' + param,
HTTP_ACCEPT=RendererB.media_type) HTTP_ACCEPT=RendererB.media_type)
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
_flat_repr = '{"foo": ["bar", "baz"]}' _flat_repr = '{"foo": ["bar", "baz"]}'
@ -243,7 +243,7 @@ class JSONRendererTests(TestCase):
renderer = JSONRenderer() renderer = JSONRenderer()
content = renderer.render(obj, 'application/json') content = renderer.render(obj, 'application/json')
# Fix failing test case which depends on version of JSON library. # Fix failing test case which depends on version of JSON library.
self.assertEquals(content, _flat_repr) self.assertEqual(content, _flat_repr)
def test_with_content_type_args(self): def test_with_content_type_args(self):
""" """
@ -252,7 +252,7 @@ class JSONRendererTests(TestCase):
obj = {'foo': ['bar', 'baz']} obj = {'foo': ['bar', 'baz']}
renderer = JSONRenderer() renderer = JSONRenderer()
content = renderer.render(obj, 'application/json; indent=2') content = renderer.render(obj, 'application/json; indent=2')
self.assertEquals(strip_trailing_whitespace(content), _indented_repr) self.assertEqual(strip_trailing_whitespace(content), _indented_repr)
class JSONPRendererTests(TestCase): class JSONPRendererTests(TestCase):
@ -268,9 +268,9 @@ class JSONPRendererTests(TestCase):
""" """
resp = self.client.get('/jsonp/jsonrenderer', resp = self.client.get('/jsonp/jsonrenderer',
HTTP_ACCEPT='application/javascript') HTTP_ACCEPT='application/javascript')
self.assertEquals(resp.status_code, status.HTTP_200_OK) self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEquals(resp['Content-Type'], 'application/javascript') self.assertEqual(resp['Content-Type'], 'application/javascript')
self.assertEquals(resp.content, self.assertEqual(resp.content,
('callback(%s);' % _flat_repr).encode('ascii')) ('callback(%s);' % _flat_repr).encode('ascii'))
def test_without_callback_without_json_renderer(self): def test_without_callback_without_json_renderer(self):
@ -279,9 +279,9 @@ class JSONPRendererTests(TestCase):
""" """
resp = self.client.get('/jsonp/nojsonrenderer', resp = self.client.get('/jsonp/nojsonrenderer',
HTTP_ACCEPT='application/javascript') HTTP_ACCEPT='application/javascript')
self.assertEquals(resp.status_code, status.HTTP_200_OK) self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEquals(resp['Content-Type'], 'application/javascript') self.assertEqual(resp['Content-Type'], 'application/javascript')
self.assertEquals(resp.content, self.assertEqual(resp.content,
('callback(%s);' % _flat_repr).encode('ascii')) ('callback(%s);' % _flat_repr).encode('ascii'))
def test_with_callback(self): def test_with_callback(self):
@ -291,9 +291,9 @@ class JSONPRendererTests(TestCase):
callback_func = 'myjsonpcallback' callback_func = 'myjsonpcallback'
resp = self.client.get('/jsonp/nojsonrenderer?callback=' + callback_func, resp = self.client.get('/jsonp/nojsonrenderer?callback=' + callback_func,
HTTP_ACCEPT='application/javascript') HTTP_ACCEPT='application/javascript')
self.assertEquals(resp.status_code, status.HTTP_200_OK) self.assertEqual(resp.status_code, status.HTTP_200_OK)
self.assertEquals(resp['Content-Type'], 'application/javascript') self.assertEqual(resp['Content-Type'], 'application/javascript')
self.assertEquals(resp.content, self.assertEqual(resp.content,
('%s(%s);' % (callback_func, _flat_repr)).encode('ascii')) ('%s(%s);' % (callback_func, _flat_repr)).encode('ascii'))
@ -312,7 +312,7 @@ if yaml:
obj = {'foo': ['bar', 'baz']} obj = {'foo': ['bar', 'baz']}
renderer = YAMLRenderer() renderer = YAMLRenderer()
content = renderer.render(obj, 'application/yaml') content = renderer.render(obj, 'application/yaml')
self.assertEquals(content, _yaml_repr) self.assertEqual(content, _yaml_repr)
def test_render_and_parse(self): def test_render_and_parse(self):
""" """
@ -326,7 +326,7 @@ if yaml:
content = renderer.render(obj, 'application/yaml') content = renderer.render(obj, 'application/yaml')
data = parser.parse(StringIO(content)) data = parser.parse(StringIO(content))
self.assertEquals(obj, data) self.assertEqual(obj, data)
class XMLRendererTestCase(TestCase): class XMLRendererTestCase(TestCase):

54
rest_framework/tests/response.py
View File

@ -85,39 +85,39 @@ class RendererIntegrationTests(TestCase):
def test_default_renderer_serializes_content(self): def test_default_renderer_serializes_content(self):
"""If the Accept header is not set the default renderer should serialize the response.""" """If the Accept header is not set the default renderer should serialize the response."""
resp = self.client.get('/') resp = self.client.get('/')
self.assertEquals(resp['Content-Type'], RendererA.media_type) self.assertEqual(resp['Content-Type'], RendererA.media_type)
self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_head_method_serializes_no_content(self): def test_head_method_serializes_no_content(self):
"""No response must be included in HEAD requests.""" """No response must be included in HEAD requests."""
resp = self.client.head('/') resp = self.client.head('/')
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
self.assertEquals(resp['Content-Type'], RendererA.media_type) self.assertEqual(resp['Content-Type'], RendererA.media_type)
self.assertEquals(resp.content, six.b('')) self.assertEqual(resp.content, six.b(''))
def test_default_renderer_serializes_content_on_accept_any(self): def test_default_renderer_serializes_content_on_accept_any(self):
"""If the Accept header is set to */* the default renderer should serialize the response.""" """If the Accept header is set to */* the default renderer should serialize the response."""
resp = self.client.get('/', HTTP_ACCEPT='*/*') resp = self.client.get('/', HTTP_ACCEPT='*/*')
self.assertEquals(resp['Content-Type'], RendererA.media_type) self.assertEqual(resp['Content-Type'], RendererA.media_type)
self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_default_case(self): def test_specified_renderer_serializes_content_default_case(self):
"""If the Accept header is set the specified renderer should serialize the response. """If the Accept header is set the specified renderer should serialize the response.
(In this case we check that works for the default renderer)""" (In this case we check that works for the default renderer)"""
resp = self.client.get('/', HTTP_ACCEPT=RendererA.media_type) resp = self.client.get('/', HTTP_ACCEPT=RendererA.media_type)
self.assertEquals(resp['Content-Type'], RendererA.media_type) self.assertEqual(resp['Content-Type'], RendererA.media_type)
self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_non_default_case(self): def test_specified_renderer_serializes_content_non_default_case(self):
"""If the Accept header is set the specified renderer should serialize the response. """If the Accept header is set the specified renderer should serialize the response.
(In this case we check that works for a non-default renderer)""" (In this case we check that works for a non-default renderer)"""
resp = self.client.get('/', HTTP_ACCEPT=RendererB.media_type) resp = self.client.get('/', HTTP_ACCEPT=RendererB.media_type)
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_on_accept_query(self): def test_specified_renderer_serializes_content_on_accept_query(self):
"""The '_accept' query string should behave in the same way as the Accept header.""" """The '_accept' query string should behave in the same way as the Accept header."""
@ -126,34 +126,34 @@ class RendererIntegrationTests(TestCase):
RendererB.media_type RendererB.media_type
) )
resp = self.client.get('/' + param) resp = self.client.get('/' + param)
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_on_format_query(self): def test_specified_renderer_serializes_content_on_format_query(self):
"""If a 'format' query is specified, the renderer with the matching """If a 'format' query is specified, the renderer with the matching
format attribute should serialize the response.""" format attribute should serialize the response."""
resp = self.client.get('/?format=%s' % RendererB.format) resp = self.client.get('/?format=%s' % RendererB.format)
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_serializes_content_on_format_kwargs(self): def test_specified_renderer_serializes_content_on_format_kwargs(self):
"""If a 'format' keyword arg is specified, the renderer with the matching """If a 'format' keyword arg is specified, the renderer with the matching
format attribute should serialize the response.""" format attribute should serialize the response."""
resp = self.client.get('/something.formatb') resp = self.client.get('/something.formatb')
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
def test_specified_renderer_is_used_on_format_query_with_matching_accept(self): def test_specified_renderer_is_used_on_format_query_with_matching_accept(self):
"""If both a 'format' query and a matching Accept header specified, """If both a 'format' query and a matching Accept header specified,
the renderer with the matching format attribute should serialize the response.""" the renderer with the matching format attribute should serialize the response."""
resp = self.client.get('/?format=%s' % RendererB.format, resp = self.client.get('/?format=%s' % RendererB.format,
HTTP_ACCEPT=RendererB.media_type) HTTP_ACCEPT=RendererB.media_type)
self.assertEquals(resp['Content-Type'], RendererB.media_type) self.assertEqual(resp['Content-Type'], RendererB.media_type)
self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT)) self.assertEqual(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
self.assertEquals(resp.status_code, DUMMYSTATUS) self.assertEqual(resp.status_code, DUMMYSTATUS)
class Issue122Tests(TestCase): class Issue122Tests(TestCase):

212
rest_framework/tests/serializer.py
View File

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

4
rest_framework/tests/status.py
View File

@ -9,5 +9,5 @@ class TestStatus(TestCase):
def test_status(self): def test_status(self):
"""Ensure the status module is present and correct.""" """Ensure the status module is present and correct."""
self.assertEquals(200, status.HTTP_200_OK) self.assertEqual(200, status.HTTP_200_OK)
self.assertEquals(404, status.HTTP_404_NOT_FOUND) self.assertEqual(404, status.HTTP_404_NOT_FOUND)

2
rest_framework/tests/throttling.py
View File

@ -103,7 +103,7 @@ class ThrottlingTests(TestCase):
self.set_throttle_timer(view, timer) self.set_throttle_timer(view, timer)
response = view.as_view()(request) response = view.as_view()(request)
if expect is not None: if expect is not None:
self.assertEquals(response['X-Throttle-Wait-Seconds'], expect) self.assertEqual(response['X-Throttle-Wait-Seconds'], expect)
else: else:
self.assertFalse('X-Throttle-Wait-Seconds' in response) self.assertFalse('X-Throttle-Wait-Seconds' in response)

4
rest_framework/tests/urlpatterns.py
View File

@ -32,8 +32,8 @@ class FormatSuffixTests(TestCase):
callback, callback_args, callback_kwargs = resolver.resolve(request.path_info) callback, callback_args, callback_kwargs = resolver.resolve(request.path_info)
except Exception: except Exception:
self.fail("Failed to resolve URL: %s" % request.path_info) self.fail("Failed to resolve URL: %s" % request.path_info)
self.assertEquals(callback_args, test_path.args) self.assertEqual(callback_args, test_path.args)
self.assertEquals(callback_kwargs, test_path.kwargs) self.assertEqual(callback_kwargs, test_path.kwargs)
def test_format_suffix(self): def test_format_suffix(self):
urlpatterns = patterns( urlpatterns = patterns(

4
rest_framework/tests/validation.py
View File

@ -37,7 +37,7 @@ class TestPreSaveValidationExclusions(TestCase):
content_type='application/json') content_type='application/json')
view = UpdateValidationModel().as_view() view = UpdateValidationModel().as_view()
response = view(request, pk=obj.pk).render() response = view(request, pk=obj.pk).render()
self.assertEquals(response.status_code, status.HTTP_200_OK) self.assertEqual(response.status_code, status.HTTP_200_OK)
# Regression for #653 # Regression for #653
@ -62,4 +62,4 @@ class TestPreSaveValidationExclusions(TestCase):
# We've set `required=False` on the serializer, but the model # We've set `required=False` on the serializer, but the model
# does not have `blank=True`, so this serializer should not validate. # does not have `blank=True`, so this serializer should not validate.
serializer = ShouldValidateModelSerializer(data={'renamed': ''}) serializer = ShouldValidateModelSerializer(data={'renamed': ''})
self.assertEquals(serializer.is_valid(), False) self.assertEqual(serializer.is_valid(), False)

16
rest_framework/tests/views.py
View File

@ -52,8 +52,8 @@ class ClassBasedViewIntegrationTests(TestCase):
expected = { expected = {
'detail': 'JSON parse error - No JSON object could be decoded' 'detail': 'JSON parse error - No JSON object could be decoded'
} }
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEquals(sanitise_json_error(response.data), expected) self.assertEqual(sanitise_json_error(response.data), expected)
def test_400_parse_error_tunneled_content(self): def test_400_parse_error_tunneled_content(self):
content = 'f00bar' content = 'f00bar'
@ -67,8 +67,8 @@ class ClassBasedViewIntegrationTests(TestCase):
expected = { expected = {
'detail': 'JSON parse error - No JSON object could be decoded' 'detail': 'JSON parse error - No JSON object could be decoded'
} }
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEquals(sanitise_json_error(response.data), expected) self.assertEqual(sanitise_json_error(response.data), expected)
class FunctionBasedViewIntegrationTests(TestCase): class FunctionBasedViewIntegrationTests(TestCase):
@ -81,8 +81,8 @@ class FunctionBasedViewIntegrationTests(TestCase):
expected = { expected = {
'detail': 'JSON parse error - No JSON object could be decoded' 'detail': 'JSON parse error - No JSON object could be decoded'
} }
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEquals(sanitise_json_error(response.data), expected) self.assertEqual(sanitise_json_error(response.data), expected)
def test_400_parse_error_tunneled_content(self): def test_400_parse_error_tunneled_content(self):
content = 'f00bar' content = 'f00bar'
@ -96,5 +96,5 @@ class FunctionBasedViewIntegrationTests(TestCase):
expected = { expected = {
'detail': 'JSON parse error - No JSON object could be decoded' 'detail': 'JSON parse error - No JSON object could be decoded'
} }
self.assertEquals(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
self.assertEquals(sanitise_json_error(response.data), expected) self.assertEqual(sanitise_json_error(response.data), expected)

8
tox.ini
View File

@ -7,24 +7,24 @@ commands = {envpython} rest_framework/runtests/runtests.py
[testenv:py3.3-django1.5] [testenv:py3.3-django1.5]
basepython = python3.3 basepython = python3.3
deps = https://www.djangoproject.com/download/1.5c1/tarball/ deps = django==1.5
https://github.com/alex/django-filter/archive/master.tar.gz https://github.com/alex/django-filter/archive/master.tar.gz
defusedxml==0.3 defusedxml==0.3
[testenv:py3.2-django1.5] [testenv:py3.2-django1.5]
basepython = python3.2 basepython = python3.2
deps = https://www.djangoproject.com/download/1.5c1/tarball/ deps = django==1.5
https://github.com/alex/django-filter/archive/master.tar.gz https://github.com/alex/django-filter/archive/master.tar.gz
defusedxml==0.3 defusedxml==0.3
[testenv:py2.7-django1.5] [testenv:py2.7-django1.5]
basepython = python2.7 basepython = python2.7
deps = https://www.djangoproject.com/download/1.5c1/tarball/ deps = django==1.5
django-filter==0.5.4 django-filter==0.5.4
[testenv:py2.6-django1.5] [testenv:py2.6-django1.5]
basepython = python2.6 basepython = python2.6
deps = https://www.djangoproject.com/download/1.5c1/tarball/ deps = django==1.5
django-filter==0.5.4 django-filter==0.5.4
defusedxml==0.3 defusedxml==0.3