Drop defunct tests

13 files changed, 0 insertions, 3872 deletions

diff --git a/tests/test_files.py b/tests/test_files.py
deleted file mode 100644
index a5613fcb..00000000
--- a/tests/test_files.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# from __future__ import unicode_literals
-# from django.test import TestCase
-# from django.utils import six
-# from rest_framework import serializers
-# from rest_framework.compat import BytesIO
-# import datetime
-
-
-# class UploadedFile(object):
-#     def __init__(self, file=None, created=None):
-#         self.file = file
-#         self.created = created or datetime.datetime.now()
-
-
-# class UploadedFileSerializer(serializers.Serializer):
-#     file = serializers.FileField(required=False)
-#     created = serializers.DateTimeField()
-
-#     def restore_object(self, attrs, instance=None):
-#         if instance:
-#             instance.file = attrs['file']
-#             instance.created = attrs['created']
-#             return instance
-#         return UploadedFile(**attrs)
-
-
-# class FileSerializerTests(TestCase):
-#     def test_create(self):
-#         now = datetime.datetime.now()
-#         file = BytesIO(six.b('stuff'))
-#         file.name = 'stuff.txt'
-#         file.size = len(file.getvalue())
-#         serializer = UploadedFileSerializer(data={'created': now}, files={'file': file})
-#         uploaded_file = UploadedFile(file=file, created=now)
-#         self.assertTrue(serializer.is_valid())
-#         self.assertEqual(serializer.object.created, uploaded_file.created)
-#         self.assertEqual(serializer.object.file, uploaded_file.file)
-#         self.assertFalse(serializer.object is uploaded_file)
-
-#     def test_creation_failure(self):
-#         """
-#         Passing files=None should result in an ValidationError
-
-#         Regression test for:
-#         https://github.com/tomchristie/django-rest-framework/issues/542
-#         """
-#         now = datetime.datetime.now()
-
-#         serializer = UploadedFileSerializer(data={'created': now})
-#         self.assertTrue(serializer.is_valid())
-#         self.assertEqual(serializer.object.created, now)
-#         self.assertIsNone(serializer.object.file)
-
-#     def test_remove_with_empty_string(self):
-#         """
-#         Passing empty string as data should cause file to be removed
-
-#         Test for:
-#         https://github.com/tomchristie/django-rest-framework/issues/937
-#         """
-#         now = datetime.datetime.now()
-#         file = BytesIO(six.b('stuff'))
-#         file.name = 'stuff.txt'
-#         file.size = len(file.getvalue())
-
-#         uploaded_file = UploadedFile(file=file, created=now)
-
-#         serializer = UploadedFileSerializer(instance=uploaded_file, data={'created': now, 'file': ''})
-#         self.assertTrue(serializer.is_valid())
-#         self.assertEqual(serializer.object.created, uploaded_file.created)
-#         self.assertIsNone(serializer.object.file)
-
-#     def test_validation_error_with_non_file(self):
-#         """
-#         Passing non-files should raise a validation error.
-#         """
-#         now = datetime.datetime.now()
-#         errmsg = 'No file was submitted. Check the encoding type on the form.'
-
-#         serializer = UploadedFileSerializer(data={'created': now, 'file': 'abc'})
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'file': [errmsg]})
-
-#     def test_validation_with_no_data(self):
-#         """
-#         Validation should still function when no data dictionary is provided.
-#         """
-#         uploaded_file = BytesIO(six.b('stuff'))
-#         uploaded_file.name = 'stuff.txt'
-#         uploaded_file.size = len(uploaded_file.getvalue())
-#         serializer = UploadedFileSerializer(files={'file': uploaded_file})
-#         self.assertFalse(serializer.is_valid())
diff --git a/tests/test_hyperlinkedserializers.py b/tests/test_hyperlinkedserializers.py
deleted file mode 100644
index ff3663dd..00000000
--- a/tests/test_hyperlinkedserializers.py
+++ /dev/null
@@ -1,406 +0,0 @@
-# from __future__ import unicode_literals
-# import json
-# from django.test import TestCase
-# from rest_framework import generics, status, serializers
-# from django.conf.urls import patterns, url
-# from rest_framework.settings import api_settings
-# from rest_framework.test import APIRequestFactory
-# from tests.models import (
-#     Anchor, BasicModel, ManyToManyModel, BlogPost, BlogPostComment,
-#     Album, Photo, OptionalRelationModel
-# )
-
-# factory = APIRequestFactory()
-
-
-# class BlogPostCommentSerializer(serializers.ModelSerializer):
-#     url = serializers.HyperlinkedIdentityField(view_name='blogpostcomment-detail')
-#     text = serializers.CharField()
-#     blog_post_url = serializers.HyperlinkedRelatedField(source='blog_post', view_name='blogpost-detail')
-
-#     class Meta:
-#         model = BlogPostComment
-#         fields = ('text', 'blog_post_url', 'url')
-
-
-# class PhotoSerializer(serializers.Serializer):
-#     description = serializers.CharField()
-#     album_url = serializers.HyperlinkedRelatedField(source='album', view_name='album-detail', queryset=Album.objects.all(), lookup_field='title')
-
-#     def restore_object(self, attrs, instance=None):
-#         return Photo(**attrs)
-
-
-# class AlbumSerializer(serializers.ModelSerializer):
-#     url = serializers.HyperlinkedIdentityField(view_name='album-detail', lookup_field='title')
-
-#     class Meta:
-#         model = Album
-#         fields = ('title', 'url')
-
-
-# class BasicSerializer(serializers.HyperlinkedModelSerializer):
-#     class Meta:
-#         model = BasicModel
-
-
-# class AnchorSerializer(serializers.HyperlinkedModelSerializer):
-#     class Meta:
-#         model = Anchor
-
-
-# class ManyToManySerializer(serializers.HyperlinkedModelSerializer):
-#     class Meta:
-#         model = ManyToManyModel
-
-
-# class BlogPostSerializer(serializers.ModelSerializer):
-#     class Meta:
-#         model = BlogPost
-
-
-# class OptionalRelationSerializer(serializers.HyperlinkedModelSerializer):
-#     class Meta:
-#         model = OptionalRelationModel
-
-
-# class BasicList(generics.ListCreateAPIView):
-#     queryset = BasicModel.objects.all()
-#     serializer_class = BasicSerializer
-
-
-# class BasicDetail(generics.RetrieveUpdateDestroyAPIView):
-#     queryset = BasicModel.objects.all()
-#     serializer_class = BasicSerializer
-
-
-# class AnchorDetail(generics.RetrieveAPIView):
-#     queryset = Anchor.objects.all()
-#     serializer_class = AnchorSerializer
-
-
-# class ManyToManyList(generics.ListAPIView):
-#     queryset = ManyToManyModel.objects.all()
-#     serializer_class = ManyToManySerializer
-
-
-# class ManyToManyDetail(generics.RetrieveAPIView):
-#     queryset = ManyToManyModel.objects.all()
-#     serializer_class = ManyToManySerializer
-
-
-# class BlogPostCommentListCreate(generics.ListCreateAPIView):
-#     queryset = BlogPostComment.objects.all()
-#     serializer_class = BlogPostCommentSerializer
-
-
-# class BlogPostCommentDetail(generics.RetrieveAPIView):
-#     queryset = BlogPostComment.objects.all()
-#     serializer_class = BlogPostCommentSerializer
-
-
-# class BlogPostDetail(generics.RetrieveAPIView):
-#     queryset = BlogPost.objects.all()
-#     serializer_class = BlogPostSerializer
-
-
-# class PhotoListCreate(generics.ListCreateAPIView):
-#     queryset = Photo.objects.all()
-#     serializer_class = PhotoSerializer
-
-
-# class AlbumDetail(generics.RetrieveAPIView):
-#     queryset = Album.objects.all()
-#     serializer_class = AlbumSerializer
-#     lookup_field = 'title'
-
-
-# class OptionalRelationDetail(generics.RetrieveUpdateDestroyAPIView):
-#     queryset = OptionalRelationModel.objects.all()
-#     serializer_class = OptionalRelationSerializer
-
-
-# urlpatterns = patterns(
-#     '',
-#     url(r'^basic/$', BasicList.as_view(), name='basicmodel-list'),
-#     url(r'^basic/(?P<pk>\d+)/$', BasicDetail.as_view(), name='basicmodel-detail'),
-#     url(r'^anchor/(?P<pk>\d+)/$', AnchorDetail.as_view(), name='anchor-detail'),
-#     url(r'^manytomany/$', ManyToManyList.as_view(), name='manytomanymodel-list'),
-#     url(r'^manytomany/(?P<pk>\d+)/$', ManyToManyDetail.as_view(), name='manytomanymodel-detail'),
-#     url(r'^posts/(?P<pk>\d+)/$', BlogPostDetail.as_view(), name='blogpost-detail'),
-#     url(r'^comments/$', BlogPostCommentListCreate.as_view(), name='blogpostcomment-list'),
-#     url(r'^comments/(?P<pk>\d+)/$', BlogPostCommentDetail.as_view(), name='blogpostcomment-detail'),
-#     url(r'^albums/(?P<title>\w[\w-]*)/$', AlbumDetail.as_view(), name='album-detail'),
-#     url(r'^photos/$', PhotoListCreate.as_view(), name='photo-list'),
-#     url(r'^optionalrelation/(?P<pk>\d+)/$', OptionalRelationDetail.as_view(), name='optionalrelationmodel-detail'),
-# )
-
-
-# class TestBasicHyperlinkedView(TestCase):
-#     urls = 'tests.test_hyperlinkedserializers'
-
-#     def setUp(self):
-#         """
-#         Create 3 BasicModel instances.
-#         """
-#         items = ['foo', 'bar', 'baz']
-#         for item in items:
-#             BasicModel(text=item).save()
-#         self.objects = BasicModel.objects
-#         self.data = [
-#             {'url': 'http://testserver/basic/%d/' % obj.id, 'text': obj.text}
-#             for obj in self.objects.all()
-#         ]
-#         self.list_view = BasicList.as_view()
-#         self.detail_view = BasicDetail.as_view()
-
-#     def test_get_list_view(self):
-#         """
-#         GET requests to ListCreateAPIView should return list of objects.
-#         """
-#         request = factory.get('/basic/')
-#         response = self.list_view(request).render()
-#         self.assertEqual(response.status_code, status.HTTP_200_OK)
-#         self.assertEqual(response.data, self.data)
-
-#     def test_get_detail_view(self):
-#         """
-#         GET requests to ListCreateAPIView should return list of objects.
-#         """
-#         request = factory.get('/basic/1')
-#         response = self.detail_view(request, pk=1).render()
-#         self.assertEqual(response.status_code, status.HTTP_200_OK)
-#         self.assertEqual(response.data, self.data[0])
-
-
-# class TestManyToManyHyperlinkedView(TestCase):
-#     urls = 'tests.test_hyperlinkedserializers'
-
-#     def setUp(self):
-#         """
-#         Create 3 BasicModel instances.
-#         """
-#         items = ['foo', 'bar', 'baz']
-#         anchors = []
-#         for item in items:
-#             anchor = Anchor(text=item)
-#             anchor.save()
-#             anchors.append(anchor)
-
-#         manytomany = ManyToManyModel()
-#         manytomany.save()
-#         manytomany.rel.add(*anchors)
-
-#         self.data = [{
-#             'url': 'http://testserver/manytomany/1/',
-#             'rel': [
-#                 'http://testserver/anchor/1/',
-#                 'http://testserver/anchor/2/',
-#                 'http://testserver/anchor/3/',
-#             ]
-#         }]
-#         self.list_view = ManyToManyList.as_view()
-#         self.detail_view = ManyToManyDetail.as_view()
-
-#     def test_get_list_view(self):
-#         """
-#         GET requests to ListCreateAPIView should return list of objects.
-#         """
-#         request = factory.get('/manytomany/')
-#         response = self.list_view(request)
-#         self.assertEqual(response.status_code, status.HTTP_200_OK)
-#         self.assertEqual(response.data, self.data)
-
-#     def test_get_detail_view(self):
-#         """
-#         GET requests to ListCreateAPIView should return list of objects.
-#         """
-#         request = factory.get('/manytomany/1/')
-#         response = self.detail_view(request, pk=1)
-#         self.assertEqual(response.status_code, status.HTTP_200_OK)
-#         self.assertEqual(response.data, self.data[0])
-
-
-# class TestHyperlinkedIdentityFieldLookup(TestCase):
-#     urls = 'tests.test_hyperlinkedserializers'
-
-#     def setUp(self):
-#         """
-#         Create 3 Album instances.
-#         """
-#         titles = ['foo', 'bar', 'baz']
-#         for title in titles:
-#             album = Album(title=title)
-#             album.save()
-#         self.detail_view = AlbumDetail.as_view()
-#         self.data = {
-#             'foo': {'title': 'foo', 'url': 'http://testserver/albums/foo/'},
-#             'bar': {'title': 'bar', 'url': 'http://testserver/albums/bar/'},
-#             'baz': {'title': 'baz', 'url': 'http://testserver/albums/baz/'}
-#         }
-
-#     def test_lookup_field(self):
-#         """
-#         GET requests to AlbumDetail view should return serialized Albums
-#         with a url field keyed by `title`.
-#         """
-#         for album in Album.objects.all():
-#             request = factory.get('/albums/{0}/'.format(album.title))
-#             response = self.detail_view(request, title=album.title)
-#             self.assertEqual(response.status_code, status.HTTP_200_OK)
-#             self.assertEqual(response.data, self.data[album.title])
-
-
-# class TestCreateWithForeignKeys(TestCase):
-#     urls = 'tests.test_hyperlinkedserializers'
-
-#     def setUp(self):
-#         """
-#         Create a blog post
-#         """
-#         self.post = BlogPost.objects.create(title="Test post")
-#         self.create_view = BlogPostCommentListCreate.as_view()
-
-#     def test_create_comment(self):
-
-#         data = {
-#             'text': 'A test comment',
-#             'blog_post_url': 'http://testserver/posts/1/'
-#         }
-
-#         request = factory.post('/comments/', data=data)
-#         response = self.create_view(request)
-#         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-#         self.assertEqual(response['Location'], 'http://testserver/comments/1/')
-#         self.assertEqual(self.post.blogpostcomment_set.count(), 1)
-#         self.assertEqual(self.post.blogpostcomment_set.all()[0].text, 'A test comment')
-
-
-# class TestCreateWithForeignKeysAndCustomSlug(TestCase):
-#     urls = 'tests.test_hyperlinkedserializers'
-
-#     def setUp(self):
-#         """
-#         Create an Album
-#         """
-#         self.post = Album.objects.create(title='test-album')
-#         self.list_create_view = PhotoListCreate.as_view()
-
-#     def test_create_photo(self):
-
-#         data = {
-#             'description': 'A test photo',
-#             'album_url': 'http://testserver/albums/test-album/'
-#         }
-
-#         request = factory.post('/photos/', data=data)
-#         response = self.list_create_view(request)
-#         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-#         self.assertNotIn('Location', response, msg='Location should only be included if there is a "url" field on the serializer')
-#         self.assertEqual(self.post.photo_set.count(), 1)
-#         self.assertEqual(self.post.photo_set.all()[0].description, 'A test photo')
-
-
-# class TestOptionalRelationHyperlinkedView(TestCase):
-#     urls = 'tests.test_hyperlinkedserializers'
-
-#     def setUp(self):
-#         """
-#         Create 1 OptionalRelationModel instances.
-#         """
-#         OptionalRelationModel().save()
-#         self.objects = OptionalRelationModel.objects
-#         self.detail_view = OptionalRelationDetail.as_view()
-#         self.data = {"url": "http://testserver/optionalrelation/1/", "other": None}
-
-#     def test_get_detail_view(self):
-#         """
-#         GET requests to RetrieveAPIView with optional relations should return None
-#         for non existing relations.
-#         """
-#         request = factory.get('/optionalrelationmodel-detail/1')
-#         response = self.detail_view(request, pk=1)
-#         self.assertEqual(response.status_code, status.HTTP_200_OK)
-#         self.assertEqual(response.data, self.data)
-
-#     def test_put_detail_view(self):
-#         """
-#         PUT requests to RetrieveUpdateDestroyAPIView with optional relations
-#         should accept None for non existing relations.
-#         """
-#         response = self.client.put('/optionalrelation/1/',
-#                                    data=json.dumps(self.data),
-#                                    content_type='application/json')
-#         self.assertEqual(response.status_code, status.HTTP_200_OK)
-
-
-# class TestOverriddenURLField(TestCase):
-#     def setUp(self):
-#         class OverriddenURLSerializer(serializers.HyperlinkedModelSerializer):
-#             url = serializers.SerializerMethodField('get_url')
-
-#             class Meta:
-#                 model = BlogPost
-#                 fields = ('title', 'url')
-
-#             def get_url(self, obj):
-#                 return 'foo bar'
-
-#         self.Serializer = OverriddenURLSerializer
-#         self.obj = BlogPost.objects.create(title='New blog post')
-
-#     def test_overridden_url_field(self):
-#         """
-#         The 'url' field should respect overriding.
-#         Regression test for #936.
-#         """
-#         serializer = self.Serializer(self.obj)
-#         self.assertEqual(
-#             serializer.data,
-#             {'title': 'New blog post', 'url': 'foo bar'}
-#         )
-
-
-# class TestURLFieldNameBySettings(TestCase):
-#     urls = 'tests.test_hyperlinkedserializers'
-
-#     def setUp(self):
-#         self.saved_url_field_name = api_settings.URL_FIELD_NAME
-#         api_settings.URL_FIELD_NAME = 'global_url_field'
-
-#         class Serializer(serializers.HyperlinkedModelSerializer):
-
-#             class Meta:
-#                 model = BlogPost
-#                 fields = ('title', api_settings.URL_FIELD_NAME)
-
-#         self.Serializer = Serializer
-#         self.obj = BlogPost.objects.create(title="New blog post")
-
-#     def tearDown(self):
-#         api_settings.URL_FIELD_NAME = self.saved_url_field_name
-
-#     def test_overridden_url_field_name(self):
-#         request = factory.get('/posts/')
-#         serializer = self.Serializer(self.obj, context={'request': request})
-#         self.assertIn(api_settings.URL_FIELD_NAME, serializer.data)
-
-
-# class TestURLFieldNameByOptions(TestCase):
-#     urls = 'tests.test_hyperlinkedserializers'
-
-#     def setUp(self):
-#         class Serializer(serializers.HyperlinkedModelSerializer):
-
-#             class Meta:
-#                 model = BlogPost
-#                 fields = ('title', 'serializer_url_field')
-#                 url_field_name = 'serializer_url_field'
-
-#         self.Serializer = Serializer
-#         self.obj = BlogPost.objects.create(title="New blog post")
-
-#     def test_overridden_url_field_name(self):
-#         request = factory.get('/posts/')
-#         serializer = self.Serializer(self.obj, context={'request': request})
-#         self.assertIn(self.Serializer.Meta.url_field_name, serializer.data)
diff --git a/tests/test_nullable_fields.py b/tests/test_nullable_fields.py
deleted file mode 100644
index 9843182a..00000000
--- a/tests/test_nullable_fields.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# from django.core.urlresolvers import reverse
-
-# from django.conf.urls import patterns, url
-# from rest_framework import serializers, generics
-# from rest_framework.test import APITestCase
-# from tests.models import NullableForeignKeySource
-
-
-# class NullableFKSourceSerializer(serializers.ModelSerializer):
-#     class Meta:
-#         model = NullableForeignKeySource
-
-
-# class NullableFKSourceDetail(generics.RetrieveUpdateDestroyAPIView):
-#     queryset = NullableForeignKeySource.objects.all()
-#     serializer_class = NullableFKSourceSerializer
-
-
-# urlpatterns = patterns(
-#     '',
-#     url(r'^objects/(?P<pk>\d+)/$', NullableFKSourceDetail.as_view(), name='object-detail'),
-# )
-
-
-# class NullableForeignKeyTests(APITestCase):
-#     """
-#     DRF should be able to handle nullable foreign keys when a test
-#     Client POST/PUT request is made with its own serialized object.
-#     """
-#     urls = 'tests.test_nullable_fields'
-
-#     def test_updating_object_with_null_fk(self):
-#         obj = NullableForeignKeySource(name='example', target=None)
-#         obj.save()
-#         serialized_data = NullableFKSourceSerializer(obj).data
-
-#         response = self.client.put(reverse('object-detail', args=[obj.pk]), serialized_data)
-
-#         self.assertEqual(response.data, serialized_data)
diff --git a/tests/test_relations.py b/tests/test_relations.py
index 16ead1f2..62353dc2 100644
--- a/tests/test_relations.py
+++ b/tests/test_relations.py
@@ -134,155 +134,3 @@ class TestSlugRelatedField(APISimpleTestCase):
     def test_representation(self):
         representation = self.field.to_representation(self.instance)
         assert representation == self.instance.name
-
-# Older tests, for review...
-
-# """
-# General tests for relational fields.
-# """
-# from __future__ import unicode_literals
-# from django import get_version
-# from django.db import models
-# from django.test import TestCase
-# from django.utils import unittest
-# from rest_framework import serializers
-# from tests.models import BlogPost
-
-
-# class NullModel(models.Model):
-#     pass
-
-
-# class FieldTests(TestCase):
-#     def test_pk_related_field_with_empty_string(self):
-#         """
-#         Regression test for #446
-
-#         https://github.com/tomchristie/django-rest-framework/issues/446
-#         """
-#         field = serializers.PrimaryKeyRelatedField(queryset=NullModel.objects.all())
-#         self.assertRaises(serializers.ValidationError, field.to_primitive, '')
-#         self.assertRaises(serializers.ValidationError, field.to_primitive, [])
-
-#     def test_hyperlinked_related_field_with_empty_string(self):
-#         field = serializers.HyperlinkedRelatedField(queryset=NullModel.objects.all(), view_name='')
-#         self.assertRaises(serializers.ValidationError, field.to_primitive, '')
-#         self.assertRaises(serializers.ValidationError, field.to_primitive, [])
-
-#     def test_slug_related_field_with_empty_string(self):
-#         field = serializers.SlugRelatedField(queryset=NullModel.objects.all(), slug_field='pk')
-#         self.assertRaises(serializers.ValidationError, field.to_primitive, '')
-#         self.assertRaises(serializers.ValidationError, field.to_primitive, [])
-
-
-# class TestManyRelatedMixin(TestCase):
-#     def test_missing_many_to_many_related_field(self):
-#         '''
-#         Regression test for #632
-
-#         https://github.com/tomchristie/django-rest-framework/pull/632
-#         '''
-#         field = serializers.RelatedField(many=True, read_only=False)
-
-#         into = {}
-#         field.field_from_native({}, None, 'field_name', into)
-#         self.assertEqual(into['field_name'], [])
-
-
-# # Regression tests for #694 (`source` attribute on related fields)
-
-# class RelatedFieldSourceTests(TestCase):
-#     def test_related_manager_source(self):
-#         """
-#         Relational fields should be able to use manager-returning methods as their source.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.RelatedField(many=True, source='get_blogposts_manager')
-
-#         class ClassWithManagerMethod(object):
-#             def get_blogposts_manager(self):
-#                 return BlogPost.objects
-
-#         obj = ClassWithManagerMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, ['BlogPost object'])
-
-#     def test_related_queryset_source(self):
-#         """
-#         Relational fields should be able to use queryset-returning methods as their source.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.RelatedField(many=True, source='get_blogposts_queryset')
-
-#         class ClassWithQuerysetMethod(object):
-#             def get_blogposts_queryset(self):
-#                 return BlogPost.objects.all()
-
-#         obj = ClassWithQuerysetMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, ['BlogPost object'])
-
-#     def test_dotted_source(self):
-#         """
-#         Source argument should support dotted.source notation.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.RelatedField(many=True, source='a.b.c')
-
-#         class ClassWithQuerysetMethod(object):
-#             a = {
-#                 'b': {
-#                     'c': BlogPost.objects.all()
-#                 }
-#             }
-
-#         obj = ClassWithQuerysetMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, ['BlogPost object'])
-
-#     # Regression for #1129
-#     def test_exception_for_incorect_fk(self):
-#         """
-#         Check that the exception message are correct if the source field
-#         doesn't exist.
-#         """
-#         from tests.models import ManyToManySource
-
-#         class Meta:
-#             model = ManyToManySource
-
-#         attrs = {
-#             'name': serializers.SlugRelatedField(
-#                 slug_field='name', source='banzai'),
-#             'Meta': Meta,
-#         }
-
-#         TestSerializer = type(
-#             str('TestSerializer'),
-#             (serializers.ModelSerializer,),
-#             attrs
-#         )
-#         with self.assertRaises(AttributeError):
-#             TestSerializer(data={'name': 'foo'})
-
-
-# @unittest.skipIf(get_version() < '1.6.0', 'Upstream behaviour changed in v1.6')
-# class RelatedFieldChoicesTests(TestCase):
-#     """
-#     Tests for #1408 "Web browseable API doesn't have blank option on drop down list box"
-#     https://github.com/tomchristie/django-rest-framework/issues/1408
-#     """
-#     def test_blank_option_is_added_to_choice_if_required_equals_false(self):
-#         """
-
-#         """
-#         post = BlogPost(title="Checking blank option is added")
-#         post.save()
-
-#         queryset = BlogPost.objects.all()
-#         field = serializers.RelatedField(required=False, queryset=queryset)
-
-#         choice_count = BlogPost.objects.count()
-#         widget_count = len(field.widget.choices)
-
-#         self.assertEqual(widget_count, choice_count + 1, 'BLANK_CHOICE_DASH option should have been added')
diff --git a/tests/test_relations_hyperlink.py b/tests/test_relations_hyperlink.py
index 0337f359..b938e385 100644
--- a/tests/test_relations_hyperlink.py
+++ b/tests/test_relations_hyperlink.py
@@ -411,30 +411,6 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
         ]
         self.assertEqual(serializer.data, expected)
 
-#     # reverse foreign keys MUST be read_only
-#     # In the general case they do not provide .remove() or .clear()
-#     # and cannot be arbitrarily set.
-
-    # def test_reverse_foreign_key_update(self):
-    #     data = {'id': 1, 'name': 'target-1', 'sources': [1]}
-    #     instance = ForeignKeyTarget.objects.get(pk=1)
-    #     serializer = ForeignKeyTargetSerializer(instance, data=data)
-    #     print serializer.is_valid()
-    #     print serializer.errors
-    #     print serializer
-    #     self.assertTrue(serializer.is_valid())
-    #     serializer.save()
-    #     self.assertEqual(serializer.data, data)
-
-    #     # Ensure target 1 is updated, and everything else is as expected
-    #     queryset = ForeignKeyTarget.objects.all()
-    #     serializer = ForeignKeyTargetSerializer(queryset, many=True)
-    #     expected = [
-    #         {'id': 1, 'name': 'target-1', 'sources': [1]},
-    #         {'id': 2, 'name': 'target-2', 'sources': []},
-    #     ]
-    #     self.assertEqual(serializer.data, expected)
-
 
 class HyperlinkedNullableOneToOneTests(TestCase):
     urls = 'tests.test_relations_hyperlink'
@@ -455,72 +431,3 @@ class HyperlinkedNullableOneToOneTests(TestCase):
             {'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None},
         ]
         self.assertEqual(serializer.data, expected)
-
-
-# # Regression tests for #694 (`source` attribute on related fields)
-
-# class HyperlinkedRelatedFieldSourceTests(TestCase):
-#     urls = 'tests.test_relations_hyperlink'
-
-#     def test_related_manager_source(self):
-#         """
-#         Relational fields should be able to use manager-returning methods as their source.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.HyperlinkedRelatedField(
-#             many=True,
-#             source='get_blogposts_manager',
-#             view_name='dummy-url',
-#         )
-#         field.context = {'request': request}
-
-#         class ClassWithManagerMethod(object):
-#             def get_blogposts_manager(self):
-#                 return BlogPost.objects
-
-#         obj = ClassWithManagerMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, ['http://testserver/dummyurl/1/'])
-
-#     def test_related_queryset_source(self):
-#         """
-#         Relational fields should be able to use queryset-returning methods as their source.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.HyperlinkedRelatedField(
-#             many=True,
-#             source='get_blogposts_queryset',
-#             view_name='dummy-url',
-#         )
-#         field.context = {'request': request}
-
-#         class ClassWithQuerysetMethod(object):
-#             def get_blogposts_queryset(self):
-#                 return BlogPost.objects.all()
-
-#         obj = ClassWithQuerysetMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, ['http://testserver/dummyurl/1/'])
-
-#     def test_dotted_source(self):
-#         """
-#         Source argument should support dotted.source notation.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.HyperlinkedRelatedField(
-#             many=True,
-#             source='a.b.c',
-#             view_name='dummy-url',
-#         )
-#         field.context = {'request': request}
-
-#         class ClassWithQuerysetMethod(object):
-#             a = {
-#                 'b': {
-#                     'c': BlogPost.objects.all()
-#                 }
-#             }
-
-#         obj = ClassWithQuerysetMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, ['http://testserver/dummyurl/1/'])
diff --git a/tests/test_relations_nested.py b/tests/test_relations_nested.py
deleted file mode 100644
index 4a99fee9..00000000
--- a/tests/test_relations_nested.py
+++ /dev/null
@@ -1,326 +0,0 @@
-# from __future__ import unicode_literals
-# from django.db import models
-# from django.test import TestCase
-# from rest_framework import serializers
-
-# from .models import OneToOneTarget
-
-
-# class OneToOneSource(models.Model):
-#     name = models.CharField(max_length=100)
-#     target = models.OneToOneField(OneToOneTarget, related_name='source',
-#                                   null=True, blank=True)
-
-
-# class OneToManyTarget(models.Model):
-#     name = models.CharField(max_length=100)
-
-
-# class OneToManySource(models.Model):
-#     name = models.CharField(max_length=100)
-#     target = models.ForeignKey(OneToManyTarget, related_name='sources')
-
-
-# class ReverseNestedOneToOneTests(TestCase):
-#     def setUp(self):
-#         class OneToOneSourceSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = OneToOneSource
-#                 fields = ('id', 'name')
-
-#         class OneToOneTargetSerializer(serializers.ModelSerializer):
-#             source = OneToOneSourceSerializer()
-
-#             class Meta:
-#                 model = OneToOneTarget
-#                 fields = ('id', 'name', 'source')
-
-#         self.Serializer = OneToOneTargetSerializer
-
-#         for idx in range(1, 4):
-#             target = OneToOneTarget(name='target-%d' % idx)
-#             target.save()
-#             source = OneToOneSource(name='source-%d' % idx, target=target)
-#             source.save()
-
-#     def test_one_to_one_retrieve(self):
-#         queryset = OneToOneTarget.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}},
-#             {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}},
-#             {'id': 3, 'name': 'target-3', 'source': {'id': 3, 'name': 'source-3'}}
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_one_to_one_create(self):
-#         data = {'id': 4, 'name': 'target-4', 'source': {'id': 4, 'name': 'source-4'}}
-#         serializer = self.Serializer(data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-#         self.assertEqual(serializer.data, data)
-#         self.assertEqual(obj.name, 'target-4')
-
-#         # Ensure (target 4, target_source 4, source 4) are added, and
-#         # everything else is as expected.
-#         queryset = OneToOneTarget.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}},
-#             {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}},
-#             {'id': 3, 'name': 'target-3', 'source': {'id': 3, 'name': 'source-3'}},
-#             {'id': 4, 'name': 'target-4', 'source': {'id': 4, 'name': 'source-4'}}
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_one_to_one_create_with_invalid_data(self):
-#         data = {'id': 4, 'name': 'target-4', 'source': {'id': 4}}
-#         serializer = self.Serializer(data=data)
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'source': [{'name': ['This field is required.']}]})
-
-#     def test_one_to_one_update(self):
-#         data = {'id': 3, 'name': 'target-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}}
-#         instance = OneToOneTarget.objects.get(pk=3)
-#         serializer = self.Serializer(instance, data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-#         self.assertEqual(serializer.data, data)
-#         self.assertEqual(obj.name, 'target-3-updated')
-
-#         # Ensure (target 3, target_source 3, source 3) are updated,
-#         # and everything else is as expected.
-#         queryset = OneToOneTarget.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}},
-#             {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}},
-#             {'id': 3, 'name': 'target-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}}
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-
-# class ForwardNestedOneToOneTests(TestCase):
-#     def setUp(self):
-#         class OneToOneTargetSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = OneToOneTarget
-#                 fields = ('id', 'name')
-
-#         class OneToOneSourceSerializer(serializers.ModelSerializer):
-#             target = OneToOneTargetSerializer()
-
-#             class Meta:
-#                 model = OneToOneSource
-#                 fields = ('id', 'name', 'target')
-
-#         self.Serializer = OneToOneSourceSerializer
-
-#         for idx in range(1, 4):
-#             target = OneToOneTarget(name='target-%d' % idx)
-#             target.save()
-#             source = OneToOneSource(name='source-%d' % idx, target=target)
-#             source.save()
-
-#     def test_one_to_one_retrieve(self):
-#         queryset = OneToOneSource.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}},
-#             {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}},
-#             {'id': 3, 'name': 'source-3', 'target': {'id': 3, 'name': 'target-3'}}
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_one_to_one_create(self):
-#         data = {'id': 4, 'name': 'source-4', 'target': {'id': 4, 'name': 'target-4'}}
-#         serializer = self.Serializer(data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-#         self.assertEqual(serializer.data, data)
-#         self.assertEqual(obj.name, 'source-4')
-
-#         # Ensure (target 4, target_source 4, source 4) are added, and
-#         # everything else is as expected.
-#         queryset = OneToOneSource.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}},
-#             {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}},
-#             {'id': 3, 'name': 'source-3', 'target': {'id': 3, 'name': 'target-3'}},
-#             {'id': 4, 'name': 'source-4', 'target': {'id': 4, 'name': 'target-4'}}
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_one_to_one_create_with_invalid_data(self):
-#         data = {'id': 4, 'name': 'source-4', 'target': {'id': 4}}
-#         serializer = self.Serializer(data=data)
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'target': [{'name': ['This field is required.']}]})
-
-#     def test_one_to_one_update(self):
-#         data = {'id': 3, 'name': 'source-3-updated', 'target': {'id': 3, 'name': 'target-3-updated'}}
-#         instance = OneToOneSource.objects.get(pk=3)
-#         serializer = self.Serializer(instance, data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-#         self.assertEqual(serializer.data, data)
-#         self.assertEqual(obj.name, 'source-3-updated')
-
-#         # Ensure (target 3, target_source 3, source 3) are updated,
-#         # and everything else is as expected.
-#         queryset = OneToOneSource.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}},
-#             {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}},
-#             {'id': 3, 'name': 'source-3-updated', 'target': {'id': 3, 'name': 'target-3-updated'}}
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_one_to_one_update_to_null(self):
-#         data = {'id': 3, 'name': 'source-3-updated', 'target': None}
-#         instance = OneToOneSource.objects.get(pk=3)
-#         serializer = self.Serializer(instance, data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-
-#         self.assertEqual(serializer.data, data)
-#         self.assertEqual(obj.name, 'source-3-updated')
-#         self.assertEqual(obj.target, None)
-
-#         queryset = OneToOneSource.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}},
-#             {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}},
-#             {'id': 3, 'name': 'source-3-updated', 'target': None}
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     # TODO: Nullable 1-1 tests
-#     # def test_one_to_one_delete(self):
-#     #     data = {'id': 3, 'name': 'target-3', 'target_source': None}
-#     #     instance = OneToOneTarget.objects.get(pk=3)
-#     #     serializer = self.Serializer(instance, data=data)
-#     #     self.assertTrue(serializer.is_valid())
-#     #     serializer.save()
-
-#     #     # Ensure (target_source 3, source 3) are deleted,
-#     #     # and everything else is as expected.
-#     #     queryset = OneToOneTarget.objects.all()
-#     #     serializer = self.Serializer(queryset)
-#     #     expected = [
-#     #         {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}},
-#     #         {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}},
-#     #         {'id': 3, 'name': 'target-3', 'source': None}
-#     #     ]
-#     #     self.assertEqual(serializer.data, expected)
-
-
-# class ReverseNestedOneToManyTests(TestCase):
-#     def setUp(self):
-#         class OneToManySourceSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = OneToManySource
-#                 fields = ('id', 'name')
-
-#         class OneToManyTargetSerializer(serializers.ModelSerializer):
-#             sources = OneToManySourceSerializer(many=True, allow_add_remove=True)
-
-#             class Meta:
-#                 model = OneToManyTarget
-#                 fields = ('id', 'name', 'sources')
-
-#         self.Serializer = OneToManyTargetSerializer
-
-#         target = OneToManyTarget(name='target-1')
-#         target.save()
-#         for idx in range(1, 4):
-#             source = OneToManySource(name='source-%d' % idx, target=target)
-#             source.save()
-
-#     def test_one_to_many_retrieve(self):
-#         queryset = OneToManyTarget.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'},
-#                                                       {'id': 2, 'name': 'source-2'},
-#                                                       {'id': 3, 'name': 'source-3'}]},
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_one_to_many_create(self):
-#         data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'},
-#                                                          {'id': 2, 'name': 'source-2'},
-#                                                          {'id': 3, 'name': 'source-3'},
-#                                                          {'id': 4, 'name': 'source-4'}]}
-#         instance = OneToManyTarget.objects.get(pk=1)
-#         serializer = self.Serializer(instance, data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-#         self.assertEqual(serializer.data, data)
-#         self.assertEqual(obj.name, 'target-1')
-
-#         # Ensure source 4 is added, and everything else is as
-#         # expected.
-#         queryset = OneToManyTarget.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'},
-#                                                       {'id': 2, 'name': 'source-2'},
-#                                                       {'id': 3, 'name': 'source-3'},
-#                                                       {'id': 4, 'name': 'source-4'}]}
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_one_to_many_create_with_invalid_data(self):
-#         data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'},
-#                                                          {'id': 2, 'name': 'source-2'},
-#                                                          {'id': 3, 'name': 'source-3'},
-#                                                          {'id': 4}]}
-#         serializer = self.Serializer(data=data)
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'sources': [{}, {}, {}, {'name': ['This field is required.']}]})
-
-#     def test_one_to_many_update(self):
-#         data = {'id': 1, 'name': 'target-1-updated', 'sources': [{'id': 1, 'name': 'source-1-updated'},
-#                                                                  {'id': 2, 'name': 'source-2'},
-#                                                                  {'id': 3, 'name': 'source-3'}]}
-#         instance = OneToManyTarget.objects.get(pk=1)
-#         serializer = self.Serializer(instance, data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-#         self.assertEqual(serializer.data, data)
-#         self.assertEqual(obj.name, 'target-1-updated')
-
-#         # Ensure (target 1, source 1) are updated,
-#         # and everything else is as expected.
-#         queryset = OneToManyTarget.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'target-1-updated', 'sources': [{'id': 1, 'name': 'source-1-updated'},
-#                                                               {'id': 2, 'name': 'source-2'},
-#                                                               {'id': 3, 'name': 'source-3'}]}
-
-#         ]
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_one_to_many_delete(self):
-#         data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'},
-#                                                          {'id': 3, 'name': 'source-3'}]}
-#         instance = OneToManyTarget.objects.get(pk=1)
-#         serializer = self.Serializer(instance, data=data)
-#         self.assertTrue(serializer.is_valid())
-#         serializer.save()
-
-#         # Ensure source 2 is deleted, and everything else is as
-#         # expected.
-#         queryset = OneToManyTarget.objects.all()
-#         serializer = self.Serializer(queryset, many=True)
-#         expected = [
-#             {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'},
-#                                                       {'id': 3, 'name': 'source-3'}]}
-
-#         ]
-#         self.assertEqual(serializer.data, expected)
diff --git a/tests/test_relations_pk.py b/tests/test_relations_pk.py
index ba5f6c17..e95a877e 100644
--- a/tests/test_relations_pk.py
+++ b/tests/test_relations_pk.py
@@ -398,27 +398,6 @@ class PKNullableForeignKeyTests(TestCase):
         ]
         self.assertEqual(serializer.data, expected)
 
-    # reverse foreign keys MUST be read_only
-    # In the general case they do not provide .remove() or .clear()
-    # and cannot be arbitrarily set.
-
-    # def test_reverse_foreign_key_update(self):
-    #     data = {'id': 1, 'name': 'target-1', 'sources': [1]}
-    #     instance = ForeignKeyTarget.objects.get(pk=1)
-    #     serializer = ForeignKeyTargetSerializer(instance, data=data)
-    #     self.assertTrue(serializer.is_valid())
-    #     self.assertEqual(serializer.data, data)
-    #     serializer.save()
-
-    #     # Ensure target 1 is updated, and everything else is as expected
-    #     queryset = ForeignKeyTarget.objects.all()
-    #     serializer = ForeignKeyTargetSerializer(queryset, many=True)
-    #     expected = [
-    #         {'id': 1, 'name': 'target-1', 'sources': [1]},
-    #         {'id': 2, 'name': 'target-2', 'sources': []},
-    #     ]
-    #     self.assertEqual(serializer.data, expected)
-
 
 class PKNullableOneToOneTests(TestCase):
     def setUp(self):
@@ -437,113 +416,3 @@ class PKNullableOneToOneTests(TestCase):
             {'id': 2, 'name': 'target-2', 'nullable_source': 1},
         ]
         self.assertEqual(serializer.data, expected)
-
-
-# The below models and tests ensure that serializer fields corresponding
-# to a ManyToManyField field with a user-specified ``through`` model are
-# set to read only
-
-
-# class ManyToManyThroughTarget(models.Model):
-#     name = models.CharField(max_length=100)
-
-
-# class ManyToManyThrough(models.Model):
-#     source = models.ForeignKey('ManyToManyThroughSource')
-#     target = models.ForeignKey(ManyToManyThroughTarget)
-
-
-# class ManyToManyThroughSource(models.Model):
-#     name = models.CharField(max_length=100)
-#     targets = models.ManyToManyField(ManyToManyThroughTarget,
-#                                      related_name='sources',
-#                                      through='ManyToManyThrough')
-
-
-# class ManyToManyThroughTargetSerializer(serializers.ModelSerializer):
-#     class Meta:
-#         model = ManyToManyThroughTarget
-#         fields = ('id', 'name', 'sources')
-
-
-# class ManyToManyThroughSourceSerializer(serializers.ModelSerializer):
-#     class Meta:
-#         model = ManyToManyThroughSource
-#         fields = ('id', 'name', 'targets')
-
-
-# class PKManyToManyThroughTests(TestCase):
-#     def setUp(self):
-#         self.source = ManyToManyThroughSource.objects.create(
-#             name='through-source-1')
-#         self.target = ManyToManyThroughTarget.objects.create(
-#             name='through-target-1')
-
-#     def test_many_to_many_create(self):
-#         data = {'id': 2, 'name': 'source-2', 'targets': [self.target.pk]}
-#         serializer = ManyToManyThroughSourceSerializer(data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-#         self.assertEqual(obj.name, 'source-2')
-#         self.assertEqual(obj.targets.count(), 0)
-
-#     def test_many_to_many_reverse_create(self):
-#         data = {'id': 2, 'name': 'target-2', 'sources': [self.source.pk]}
-#         serializer = ManyToManyThroughTargetSerializer(data=data)
-#         self.assertTrue(serializer.is_valid())
-#         obj = serializer.save()
-#         self.assertEqual(obj.name, 'target-2')
-#         self.assertEqual(obj.sources.count(), 0)
-
-
-# # Regression tests for #694 (`source` attribute on related fields)
-
-
-# class PrimaryKeyRelatedFieldSourceTests(TestCase):
-#     def test_related_manager_source(self):
-#         """
-#         Relational fields should be able to use manager-returning methods as their source.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.PrimaryKeyRelatedField(many=True, source='get_blogposts_manager')
-
-#         class ClassWithManagerMethod(object):
-#             def get_blogposts_manager(self):
-#                 return BlogPost.objects
-
-#         obj = ClassWithManagerMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, [1])
-
-#     def test_related_queryset_source(self):
-#         """
-#         Relational fields should be able to use queryset-returning methods as their source.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.PrimaryKeyRelatedField(many=True, source='get_blogposts_queryset')
-
-#         class ClassWithQuerysetMethod(object):
-#             def get_blogposts_queryset(self):
-#                 return BlogPost.objects.all()
-
-#         obj = ClassWithQuerysetMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, [1])
-
-#     def test_dotted_source(self):
-#         """
-#         Source argument should support dotted.source notation.
-#         """
-#         BlogPost.objects.create(title='blah')
-#         field = serializers.PrimaryKeyRelatedField(many=True, source='a.b.c')
-
-#         class ClassWithQuerysetMethod(object):
-#             a = {
-#                 'b': {
-#                     'c': BlogPost.objects.all()
-#                 }
-#             }
-
-#         obj = ClassWithQuerysetMethod()
-#         value = field.field_to_native(obj, 'field_name')
-#         self.assertEqual(value, [1])
diff --git a/tests/test_request.py b/tests/test_request.py
index 8ddaf0a7..44afd243 100644
--- a/tests/test_request.py
+++ b/tests/test_request.py
@@ -179,89 +179,6 @@ class TestContentParsing(TestCase):
         self.assertEqual(request._data, Empty)
         self.assertEqual(request._files, Empty)
 
-    # def test_accessing_post_after_data_form(self):
-    #     """
-    #     Ensures request.POST can be accessed after request.DATA in
-    #     form request.
-    #     """
-    #     data = {'qwerty': 'uiop'}
-    #     request = factory.post('/', data=data)
-    #     self.assertEqual(request.DATA.items(), data.items())
-    #     self.assertEqual(request.POST.items(), data.items())
-
-    # def test_accessing_post_after_data_for_json(self):
-    #     """
-    #     Ensures request.POST can be accessed after request.DATA in
-    #     json request.
-    #     """
-    #     data = {'qwerty': 'uiop'}
-    #     content = json.dumps(data)
-    #     content_type = 'application/json'
-    #     parsers = (JSONParser, )
-
-    #     request = factory.post('/', content, content_type=content_type,
-    #                            parsers=parsers)
-    #     self.assertEqual(request.DATA.items(), data.items())
-    #     self.assertEqual(request.POST.items(), [])
-
-    # def test_accessing_post_after_data_for_overloaded_json(self):
-    #     """
-    #     Ensures request.POST can be accessed after request.DATA in overloaded
-    #     json request.
-    #     """
-    #     data = {'qwerty': 'uiop'}
-    #     content = json.dumps(data)
-    #     content_type = 'application/json'
-    #     parsers = (JSONParser, )
-    #     form_data = {Request._CONTENT_PARAM: content,
-    #                  Request._CONTENTTYPE_PARAM: content_type}
-
-    #     request = factory.post('/', form_data, parsers=parsers)
-    #     self.assertEqual(request.DATA.items(), data.items())
-    #     self.assertEqual(request.POST.items(), form_data.items())
-
-    # def test_accessing_data_after_post_form(self):
-    #     """
-    #     Ensures request.DATA can be accessed after request.POST in
-    #     form request.
-    #     """
-    #     data = {'qwerty': 'uiop'}
-    #     parsers = (FormParser, MultiPartParser)
-    #     request = factory.post('/', data, parsers=parsers)
-
-    #     self.assertEqual(request.POST.items(), data.items())
-    #     self.assertEqual(request.DATA.items(), data.items())
-
-    # def test_accessing_data_after_post_for_json(self):
-    #     """
-    #     Ensures request.DATA can be accessed after request.POST in
-    #     json request.
-    #     """
-    #     data = {'qwerty': 'uiop'}
-    #     content = json.dumps(data)
-    #     content_type = 'application/json'
-    #     parsers = (JSONParser, )
-    #     request = factory.post('/', content, content_type=content_type,
-    #                            parsers=parsers)
-    #     self.assertEqual(request.POST.items(), [])
-    #     self.assertEqual(request.DATA.items(), data.items())
-
-    # def test_accessing_data_after_post_for_overloaded_json(self):
-    #     """
-    #     Ensures request.DATA can be accessed after request.POST in overloaded
-    #     json request
-    #     """
-    #     data = {'qwerty': 'uiop'}
-    #     content = json.dumps(data)
-    #     content_type = 'application/json'
-    #     parsers = (JSONParser, )
-    #     form_data = {Request._CONTENT_PARAM: content,
-    #                  Request._CONTENTTYPE_PARAM: content_type}
-
-    #     request = factory.post('/', form_data, parsers=parsers)
-    #     self.assertEqual(request.POST.items(), form_data.items())
-    #     self.assertEqual(request.DATA.items(), data.items())
-
 
 class MockView(APIView):
     authentication_classes = (SessionAuthentication,)
@@ -301,18 +218,6 @@ class TestContentParsingWithAuthentication(TestCase):
         response = self.csrf_client.post('/', content)
         self.assertEqual(status.HTTP_200_OK, response.status_code)
 
-    # def test_user_logged_in_authentication_has_post_when_logged_in(self):
-    #     """Ensures request.POST exists after UserLoggedInAuthentication when user does log in"""
-    #     self.client.login(username='john', password='password')
-    #     self.csrf_client.login(username='john', password='password')
-    #     content = {'example': 'example'}
-
-    #     response = self.client.post('/', content)
-    #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")
-
-    #     response = self.csrf_client.post('/', content)
-    #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")
-
 
 class TestUserSetter(TestCase):
 
diff --git a/tests/test_serializer.py b/tests/test_serializer.py
index 77d5c319..6dabaf42 100644
--- a/tests/test_serializer.py
+++ b/tests/test_serializer.py
@@ -175,2007 +175,3 @@ class TestStarredSource:
         instance = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
         serializer = self.Serializer(instance)
         assert serializer.data == self.data
-
-# # -*- coding: utf-8 -*-
-# from __future__ import unicode_literals
-# from django.db import models
-# from django.db.models.fields import BLANK_CHOICE_DASH
-# from django.test import TestCase
-# from django.utils import unittest
-# from django.utils.datastructures import MultiValueDict
-# from django.utils.translation import ugettext_lazy as _
-# from rest_framework import serializers, fields, relations
-# from tests.models import (
-#     HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel,
-#     BlankFieldModel, BlogPost, BlogPostComment, Book, CallableDefaultValueModel,
-#     DefaultValueModel, ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo,
-#     RESTFrameworkModel, ForeignKeySource
-# )
-# from tests.models import BasicModelSerializer
-# import datetime
-# import pickle
-# try:
-#     import PIL
-# except:
-#     PIL = None
-
-
-# if PIL is not None:
-#     class AMOAFModel(RESTFrameworkModel):
-#         char_field = models.CharField(max_length=1024, blank=True)
-#         comma_separated_integer_field = models.CommaSeparatedIntegerField(max_length=1024, blank=True)
-#         decimal_field = models.DecimalField(max_digits=64, decimal_places=32, blank=True)
-#         email_field = models.EmailField(max_length=1024, blank=True)
-#         file_field = models.FileField(upload_to='test', max_length=1024, blank=True)
-#         image_field = models.ImageField(upload_to='test', max_length=1024, blank=True)
-#         slug_field = models.SlugField(max_length=1024, blank=True)
-#         url_field = models.URLField(max_length=1024, blank=True)
-#         nullable_char_field = models.CharField(max_length=1024, blank=True, null=True)
-
-#     class DVOAFModel(RESTFrameworkModel):
-#         positive_integer_field = models.PositiveIntegerField(blank=True)
-#         positive_small_integer_field = models.PositiveSmallIntegerField(blank=True)
-#         email_field = models.EmailField(blank=True)
-#         file_field = models.FileField(upload_to='test', blank=True)
-#         image_field = models.ImageField(upload_to='test', blank=True)
-#         slug_field = models.SlugField(blank=True)
-#         url_field = models.URLField(blank=True)
-
-
-# class SubComment(object):
-#     def __init__(self, sub_comment):
-#         self.sub_comment = sub_comment
-
-
-# class Comment(object):
-#     def __init__(self, email, content, created):
-#         self.email = email
-#         self.content = content
-#         self.created = created or datetime.datetime.now()
-
-#     def __eq__(self, other):
-#         return all([getattr(self, attr) == getattr(other, attr)
-#                     for attr in ('email', 'content', 'created')])
-
-#     def get_sub_comment(self):
-#         sub_comment = SubComment('And Merry Christmas!')
-#         return sub_comment
-
-
-# class CommentSerializer(serializers.Serializer):
-#     email = serializers.EmailField()
-#     content = serializers.CharField(max_length=1000)
-#     created = serializers.DateTimeField()
-#     sub_comment = serializers.Field(source='get_sub_comment.sub_comment')
-
-#     def restore_object(self, data, instance=None):
-#         if instance is None:
-#             return Comment(**data)
-#         for key, val in data.items():
-#             setattr(instance, key, val)
-#         return instance
-
-
-# class NamesSerializer(serializers.Serializer):
-#     first = serializers.CharField()
-#     last = serializers.CharField(required=False, default='')
-#     initials = serializers.CharField(required=False, default='')
-
-
-# class PersonIdentifierSerializer(serializers.Serializer):
-#     ssn = serializers.CharField()
-#     names = NamesSerializer(source='names', required=False)
-
-
-# class BookSerializer(serializers.ModelSerializer):
-#     isbn = serializers.RegexField(regex=r'^[0-9]{13}$', error_messages={'invalid': 'isbn has to be exact 13 numbers'})
-
-#     class Meta:
-#         model = Book
-
-
-# class ActionItemSerializer(serializers.ModelSerializer):
-
-#     class Meta:
-#         model = ActionItem
-
-
-# class ActionItemSerializerOptionalFields(serializers.ModelSerializer):
-#     """
-#     Intended to test that fields with `required=False` are excluded from validation.
-#     """
-#     title = serializers.CharField(required=False)
-
-#     class Meta:
-#         model = ActionItem
-#         fields = ('title',)
-
-
-# class ActionItemSerializerCustomRestore(serializers.ModelSerializer):
-
-#     class Meta:
-#         model = ActionItem
-
-#     def restore_object(self, data, instance=None):
-#         if instance is None:
-#             return ActionItem(**data)
-#         for key, val in data.items():
-#             setattr(instance, key, val)
-#         return instance
-
-
-# class PersonSerializer(serializers.ModelSerializer):
-#     info = serializers.Field(source='info')
-
-#     class Meta:
-#         model = Person
-#         fields = ('name', 'age', 'info')
-#         read_only_fields = ('age',)
-
-
-# class NestedSerializer(serializers.Serializer):
-#     info = serializers.Field()
-
-
-# class ModelSerializerWithNestedSerializer(serializers.ModelSerializer):
-#     nested = NestedSerializer(source='*')
-
-#     class Meta:
-#         model = Person
-
-
-# class NestedSerializerWithRenamedField(serializers.Serializer):
-#     renamed_info = serializers.Field(source='info')
-
-
-# class ModelSerializerWithNestedSerializerWithRenamedField(serializers.ModelSerializer):
-#     nested = NestedSerializerWithRenamedField(source='*')
-
-#     class Meta:
-#         model = Person
-
-
-# class PersonSerializerInvalidReadOnly(serializers.ModelSerializer):
-#     """
-#     Testing for #652.
-#     """
-#     info = serializers.Field(source='info')
-
-#     class Meta:
-#         model = Person
-#         fields = ('name', 'age', 'info')
-#         read_only_fields = ('age', 'info')
-
-
-# class AlbumsSerializer(serializers.ModelSerializer):
-
-#     class Meta:
-#         model = Album
-#         fields = ['title', 'ref']  # lists are also valid options
-
-
-# class PositiveIntegerAsChoiceSerializer(serializers.ModelSerializer):
-#     class Meta:
-#         model = HasPositiveIntegerAsChoice
-#         fields = ['some_integer']
-
-
-# class ForeignKeySourceSerializer(serializers.ModelSerializer):
-#     class Meta:
-#         model = ForeignKeySource
-
-
-# class HyperlinkedForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer):
-#     class Meta:
-#         model = ForeignKeySource
-
-
-# class BasicTests(TestCase):
-#     def setUp(self):
-#         self.comment = Comment(
-#             'tom@example.com',
-#             'Happy new year!',
-#             datetime.datetime(2012, 1, 1)
-#         )
-#         self.actionitem = ActionItem(title='Some to do item',)
-#         self.data = {
-#             'email': 'tom@example.com',
-#             'content': 'Happy new year!',
-#             'created': datetime.datetime(2012, 1, 1),
-#             'sub_comment': 'This wont change'
-#         }
-#         self.expected = {
-#             'email': 'tom@example.com',
-#             'content': 'Happy new year!',
-#             'created': datetime.datetime(2012, 1, 1),
-#             'sub_comment': 'And Merry Christmas!'
-#         }
-#         self.person_data = {'name': 'dwight', 'age': 35}
-#         self.person = Person(**self.person_data)
-#         self.person.save()
-
-#     def test_empty(self):
-#         serializer = CommentSerializer()
-#         expected = {
-#             'email': '',
-#             'content': '',
-#             'created': None
-#         }
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_retrieve(self):
-#         serializer = CommentSerializer(self.comment)
-#         self.assertEqual(serializer.data, self.expected)
-
-#     def test_create(self):
-#         serializer = CommentSerializer(data=self.data)
-#         expected = self.comment
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, expected)
-#         self.assertFalse(serializer.object is expected)
-#         self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!')
-
-#     def test_create_nested(self):
-#         """Test a serializer with nested data."""
-#         names = {'first': 'John', 'last': 'Doe', 'initials': 'jd'}
-#         data = {'ssn': '1234567890', 'names': names}
-#         serializer = PersonIdentifierSerializer(data=data)
-
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, data)
-#         self.assertFalse(serializer.object is data)
-#         self.assertEqual(serializer.data['names'], names)
-
-#     def test_create_partial_nested(self):
-#         """Test a serializer with nested data which has missing fields."""
-#         names = {'first': 'John'}
-#         data = {'ssn': '1234567890', 'names': names}
-#         serializer = PersonIdentifierSerializer(data=data)
-
-#         expected_names = {'first': 'John', 'last': '', 'initials': ''}
-#         data['names'] = expected_names
-
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, data)
-#         self.assertFalse(serializer.object is expected_names)
-#         self.assertEqual(serializer.data['names'], expected_names)
-
-#     def test_null_nested(self):
-#         """Test a serializer with a nonexistent nested field"""
-#         data = {'ssn': '1234567890'}
-#         serializer = PersonIdentifierSerializer(data=data)
-
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, data)
-#         self.assertFalse(serializer.object is data)
-#         expected = {'ssn': '1234567890', 'names': None}
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_update(self):
-#         serializer = CommentSerializer(self.comment, data=self.data)
-#         expected = self.comment
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, expected)
-#         self.assertTrue(serializer.object is expected)
-#         self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!')
-
-#     def test_partial_update(self):
-#         msg = 'Merry New Year!'
-#         partial_data = {'content': msg}
-#         serializer = CommentSerializer(self.comment, data=partial_data)
-#         self.assertEqual(serializer.is_valid(), False)
-#         serializer = CommentSerializer(self.comment, data=partial_data, partial=True)
-#         expected = self.comment
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, expected)
-#         self.assertTrue(serializer.object is expected)
-#         self.assertEqual(serializer.data['content'], msg)
-
-#     def test_model_fields_as_expected(self):
-#         """
-#         Make sure that the fields returned are the same as defined
-#         in the Meta data
-#         """
-#         serializer = PersonSerializer(self.person)
-#         self.assertEqual(
-#             set(serializer.data.keys()),
-#             set(['name', 'age', 'info'])
-#         )
-
-#     def test_field_with_dictionary(self):
-#         """
-#         Make sure that dictionaries from fields are left intact
-#         """
-#         serializer = PersonSerializer(self.person)
-#         expected = self.person_data
-#         self.assertEqual(serializer.data['info'], expected)
-
-#     def test_read_only_fields(self):
-#         """
-#         Attempting to update fields set as read_only should have no effect.
-#         """
-#         serializer = PersonSerializer(self.person, data={'name': 'dwight', 'age': 99})
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(serializer.errors, {})
-#         # Assert age is unchanged (35)
-#         self.assertEqual(instance.age, self.person_data['age'])
-
-#     def test_invalid_read_only_fields(self):
-#         """
-#         Regression test for #652.
-#         """
-#         self.assertRaises(AssertionError, PersonSerializerInvalidReadOnly, [])
-
-#     def test_serializer_data_is_cleared_on_save(self):
-#         """
-#         Check _data attribute is cleared on `save()`
-
-#         Regression test for #1116
-#         """
-#         serializer = ActionItemSerializer(self.actionitem)
-#         self.assertIsNone(serializer.data.get('id', None), 'New instance. `id` should not be set.')
-#         serializer.save()
-#         self.assertIsNotNone(serializer.data.get('id', None), 'Model is saved. `id` should be set.')
-
-#     def test_fields_marked_as_not_required_are_excluded_from_validation(self):
-#         """
-#         Check that fields with `required=False` are included in list of exclusions.
-#         """
-#         serializer = ActionItemSerializerOptionalFields(self.actionitem)
-#         exclusions = serializer.get_validation_exclusions()
-#         self.assertTrue('title' in exclusions, '`title` field was marked `required=False` and should be excluded')
-
-
-# class DictStyleSerializer(serializers.Serializer):
-#     """
-#     Note that we don't have any `restore_object` method, so the default
-#     case of simply returning a dict will apply.
-#     """
-#     email = serializers.EmailField()
-
-
-# class DictStyleSerializerTests(TestCase):
-#     def test_dict_style_deserialize(self):
-#         """
-#         Ensure serializers can deserialize into a dict.
-#         """
-#         data = {'email': 'foo@example.com'}
-#         serializer = DictStyleSerializer(data=data)
-#         self.assertTrue(serializer.is_valid())
-#         self.assertEqual(serializer.data, data)
-
-#     def test_dict_style_serialize(self):
-#         """
-#         Ensure serializers can serialize dict objects.
-#         """
-#         data = {'email': 'foo@example.com'}
-#         serializer = DictStyleSerializer(data)
-#         self.assertEqual(serializer.data, data)
-
-
-# class ValidationTests(TestCase):
-#     def setUp(self):
-#         self.comment = Comment(
-#             'tom@example.com',
-#             'Happy new year!',
-#             datetime.datetime(2012, 1, 1)
-#         )
-#         self.data = {
-#             'email': 'tom@example.com',
-#             'content': 'x' * 1001,
-#             'created': datetime.datetime(2012, 1, 1)
-#         }
-#         self.actionitem = ActionItem(title='Some to do item',)
-
-#     def test_create(self):
-#         serializer = CommentSerializer(data=self.data)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']})
-
-#     def test_update(self):
-#         serializer = CommentSerializer(self.comment, data=self.data)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']})
-
-#     def test_update_missing_field(self):
-#         data = {
-#             'content': 'xxx',
-#             'created': datetime.datetime(2012, 1, 1)
-#         }
-#         serializer = CommentSerializer(self.comment, data=data)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, {'email': ['This field is required.']})
-
-#     def test_missing_bool_with_default(self):
-#         """Make sure that a boolean value with a 'False' value is not
-#         mistaken for not having a default."""
-#         data = {
-#             'title': 'Some action item',
-#             # No 'done' value.
-#         }
-#         serializer = ActionItemSerializer(self.actionitem, data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.errors, {})
-
-#     def test_cross_field_validation(self):
-
-#         class CommentSerializerWithCrossFieldValidator(CommentSerializer):
-
-#             def validate(self, attrs):
-#                 if attrs["email"] not in attrs["content"]:
-#                     raise serializers.ValidationError("Email address not in content")
-#                 return attrs
-
-#         data = {
-#             'email': 'tom@example.com',
-#             'content': 'A comment from tom@example.com',
-#             'created': datetime.datetime(2012, 1, 1)
-#         }
-
-#         serializer = CommentSerializerWithCrossFieldValidator(data=data)
-#         self.assertTrue(serializer.is_valid())
-
-#         data['content'] = 'A comment from foo@bar.com'
-
-#         serializer = CommentSerializerWithCrossFieldValidator(data=data)
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'non_field_errors': ['Email address not in content']})
-
-#     def test_null_is_true_fields(self):
-#         """
-#         Omitting a value for null-field should validate.
-#         """
-#         serializer = PersonSerializer(data={'name': 'marko'})
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.errors, {})
-
-#     def test_modelserializer_max_length_exceeded(self):
-#         data = {
-#             'title': 'x' * 201,
-#         }
-#         serializer = ActionItemSerializer(data=data)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']})
-
-#     def test_modelserializer_max_length_exceeded_with_custom_restore(self):
-#         """
-#         When overriding ModelSerializer.restore_object, validation tests should still apply.
-#         Regression test for #623.
-
-#         https://github.com/tomchristie/django-rest-framework/pull/623
-#         """
-#         data = {
-#             'title': 'x' * 201,
-#         }
-#         serializer = ActionItemSerializerCustomRestore(data=data)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']})
-
-#     def test_default_modelfield_max_length_exceeded(self):
-#         data = {
-#             'title': 'Testing "info" field...',
-#             'info': 'x' * 13,
-#         }
-#         serializer = ActionItemSerializer(data=data)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, {'info': ['Ensure this value has at most 12 characters (it has 13).']})
-
-#     def test_datetime_validation_failure(self):
-#         """
-#         Test DateTimeField validation errors on non-str values.
-#         Regression test for #669.
-
-#         https://github.com/tomchristie/django-rest-framework/issues/669
-#         """
-#         data = self.data
-#         data['created'] = 0
-
-#         serializer = CommentSerializer(data=data)
-#         self.assertEqual(serializer.is_valid(), False)
-
-#         self.assertIn('created', serializer.errors)
-
-#     def test_missing_model_field_exception_msg(self):
-#         """
-#         Assert that a meaningful exception message is outputted when the model
-#         field is missing (e.g. when mistyping ``model``).
-#         """
-#         class BrokenModelSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 fields = ['some_field']
-
-#         try:
-#             BrokenModelSerializer()
-#         except AssertionError as e:
-#             self.assertEqual(e.args[0], "Serializer class 'BrokenModelSerializer' is missing 'model' Meta option")
-#         except:
-#             self.fail('Wrong exception type thrown.')
-
-#     def test_writable_star_source_on_nested_serializer(self):
-#         """
-#         Assert that a nested serializer instantiated with source='*' correctly
-#         expands the data into the outer serializer.
-#         """
-#         serializer = ModelSerializerWithNestedSerializer(data={
-#             'name': 'marko',
-#             'nested': {'info': 'hi'}},
-#         )
-#         self.assertEqual(serializer.is_valid(), True)
-
-#     def test_writable_star_source_on_nested_serializer_with_parent_object(self):
-#         class TitleSerializer(serializers.Serializer):
-#             title = serializers.WritableField(source='title')
-
-#         class AlbumSerializer(serializers.ModelSerializer):
-#             nested = TitleSerializer(source='*')
-
-#             class Meta:
-#                 model = Album
-#                 fields = ('nested',)
-
-#         class PhotoSerializer(serializers.ModelSerializer):
-#             album = AlbumSerializer(source='album')
-
-#             class Meta:
-#                 model = Photo
-#                 fields = ('album', )
-
-#         photo = Photo(album=Album())
-
-#         data = {'album': {'nested': {'title': 'test'}}}
-
-#         serializer = PhotoSerializer(photo, data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.data, data)
-
-#     def test_writable_star_source_with_inner_source_fields(self):
-#         """
-#         Tests that a serializer with source="*" correctly expands the
-#         it's fields into the outer serializer even if they have their
-#         own 'source' parameters.
-#         """
-
-#         serializer = ModelSerializerWithNestedSerializerWithRenamedField(data={
-#             'name': 'marko',
-#             'nested': {'renamed_info': 'hi'}},
-#         )
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.errors, {})
-
-
-# class CustomValidationTests(TestCase):
-#     class CommentSerializerWithFieldValidator(CommentSerializer):
-
-#         def validate_email(self, attrs, source):
-#             attrs[source]
-#             return attrs
-
-#         def validate_content(self, attrs, source):
-#             value = attrs[source]
-#             if "test" not in value:
-#                 raise serializers.ValidationError("Test not in value")
-#             return attrs
-
-#     def test_field_validation(self):
-#         data = {
-#             'email': 'tom@example.com',
-#             'content': 'A test comment',
-#             'created': datetime.datetime(2012, 1, 1)
-#         }
-
-#         serializer = self.CommentSerializerWithFieldValidator(data=data)
-#         self.assertTrue(serializer.is_valid())
-
-#         data['content'] = 'This should not validate'
-
-#         serializer = self.CommentSerializerWithFieldValidator(data=data)
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'content': ['Test not in value']})
-
-#     def test_missing_data(self):
-#         """
-#         Make sure that validate_content isn't called if the field is missing
-#         """
-#         incomplete_data = {
-#             'email': 'tom@example.com',
-#             'created': datetime.datetime(2012, 1, 1)
-#         }
-#         serializer = self.CommentSerializerWithFieldValidator(data=incomplete_data)
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'content': ['This field is required.']})
-
-#     def test_wrong_data(self):
-#         """
-#         Make sure that validate_content isn't called if the field input is wrong
-#         """
-#         wrong_data = {
-#             'email': 'not an email',
-#             'content': 'A test comment',
-#             'created': datetime.datetime(2012, 1, 1)
-#         }
-#         serializer = self.CommentSerializerWithFieldValidator(data=wrong_data)
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'email': ['Enter a valid email address.']})
-
-#     def test_partial_update(self):
-#         """
-#         Make sure that validate_email isn't called when partial=True and email
-#         isn't found in data.
-#         """
-#         initial_data = {
-#             'email': 'tom@example.com',
-#             'content': 'A test comment',
-#             'created': datetime.datetime(2012, 1, 1)
-#         }
-
-#         serializer = self.CommentSerializerWithFieldValidator(data=initial_data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.object
-
-#         new_content = 'An *updated* test comment'
-#         partial_data = {
-#             'content': new_content
-#         }
-
-#         serializer = self.CommentSerializerWithFieldValidator(instance=instance,
-#                                                               data=partial_data,
-#                                                               partial=True)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.object
-#         self.assertEqual(instance.content, new_content)
-
-
-# class PositiveIntegerAsChoiceTests(TestCase):
-#     def test_positive_integer_in_json_is_correctly_parsed(self):
-#         data = {'some_integer': 1}
-#         serializer = PositiveIntegerAsChoiceSerializer(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-
-
-# class ModelValidationTests(TestCase):
-#     def test_validate_unique(self):
-#         """
-#         Just check if serializers.ModelSerializer handles unique checks via .full_clean()
-#         """
-#         serializer = AlbumsSerializer(data={'title': 'a', 'ref': '1'})
-#         serializer.is_valid()
-#         serializer.save()
-#         second_serializer = AlbumsSerializer(data={'title': 'a'})
-#         self.assertFalse(second_serializer.is_valid())
-#         self.assertEqual(second_serializer.errors, {'title': ['Album with this Title already exists.']})
-#         third_serializer = AlbumsSerializer(data=[{'title': 'b', 'ref': '1'}, {'title': 'c'}], many=True)
-#         self.assertFalse(third_serializer.is_valid())
-#         self.assertEqual(third_serializer.errors, [{'ref': ['Album with this Ref already exists.']}, {}])
-
-#     def test_foreign_key_is_null_with_partial(self):
-#         """
-#         Test ModelSerializer validation with partial=True
-
-#         Specifically test that a null foreign key does not pass validation
-#         """
-#         album = Album(title='test')
-#         album.save()
-
-#         class PhotoSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = Photo
-
-#         photo_serializer = PhotoSerializer(data={'description': 'test', 'album': album.pk})
-#         self.assertTrue(photo_serializer.is_valid())
-#         photo = photo_serializer.save()
-
-#         # Updating only the album (foreign key)
-#         photo_serializer = PhotoSerializer(instance=photo, data={'album': ''}, partial=True)
-#         self.assertFalse(photo_serializer.is_valid())
-#         self.assertTrue('album' in photo_serializer.errors)
-#         self.assertEqual(photo_serializer.errors['album'], [photo_serializer.error_messages['required']])
-
-#     def test_foreign_key_with_partial(self):
-#         """
-#         Test ModelSerializer validation with partial=True
-
-#         Specifically test foreign key validation.
-#         """
-
-#         album = Album(title='test')
-#         album.save()
-
-#         class PhotoSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = Photo
-
-#         photo_serializer = PhotoSerializer(data={'description': 'test', 'album': album.pk})
-#         self.assertTrue(photo_serializer.is_valid())
-#         photo = photo_serializer.save()
-
-#         # Updating only the album (foreign key)
-#         photo_serializer = PhotoSerializer(instance=photo, data={'album': album.pk}, partial=True)
-#         self.assertTrue(photo_serializer.is_valid())
-#         self.assertTrue(photo_serializer.save())
-
-#         # Updating only the description
-#         photo_serializer = PhotoSerializer(instance=photo,
-#                                            data={'description': 'new'},
-#                                            partial=True)
-
-#         self.assertTrue(photo_serializer.is_valid())
-#         self.assertTrue(photo_serializer.save())
-
-
-# class RegexValidationTest(TestCase):
-#     def test_create_failed(self):
-#         serializer = BookSerializer(data={'isbn': '1234567890'})
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
-
-#         serializer = BookSerializer(data={'isbn': '12345678901234'})
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
-
-#         serializer = BookSerializer(data={'isbn': 'abcdefghijklm'})
-#         self.assertFalse(serializer.is_valid())
-#         self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']})
-
-#     def test_create_success(self):
-#         serializer = BookSerializer(data={'isbn': '1234567890123'})
-#         self.assertTrue(serializer.is_valid())
-
-
-# class MetadataTests(TestCase):
-#     def test_empty(self):
-#         serializer = CommentSerializer()
-#         expected = {
-#             'email': serializers.CharField,
-#             'content': serializers.CharField,
-#             'created': serializers.DateTimeField
-#         }
-#         for field_name, field in expected.items():
-#             self.assertTrue(isinstance(serializer.data.fields[field_name], field))
-
-
-# class ManyToManyTests(TestCase):
-#     def setUp(self):
-#         class ManyToManySerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = ManyToManyModel
-
-#         self.serializer_class = ManyToManySerializer
-
-#         # An anchor instance to use for the relationship
-#         self.anchor = Anchor()
-#         self.anchor.save()
-
-#         # A model instance with a many to many relationship to the anchor
-#         self.instance = ManyToManyModel()
-#         self.instance.save()
-#         self.instance.rel.add(self.anchor)
-
-#         # A serialized representation of the model instance
-#         self.data = {'id': 1, 'rel': [self.anchor.id]}
-
-#     def test_retrieve(self):
-#         """
-#         Serialize an instance of a model with a ManyToMany relationship.
-#         """
-#         serializer = self.serializer_class(instance=self.instance)
-#         expected = self.data
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_create(self):
-#         """
-#         Create an instance of a model with a ManyToMany relationship.
-#         """
-#         data = {'rel': [self.anchor.id]}
-#         serializer = self.serializer_class(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(ManyToManyModel.objects.all()), 2)
-#         self.assertEqual(instance.pk, 2)
-#         self.assertEqual(list(instance.rel.all()), [self.anchor])
-
-#     def test_update(self):
-#         """
-#         Update an instance of a model with a ManyToMany relationship.
-#         """
-#         new_anchor = Anchor()
-#         new_anchor.save()
-#         data = {'rel': [self.anchor.id, new_anchor.id]}
-#         serializer = self.serializer_class(self.instance, data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(ManyToManyModel.objects.all()), 1)
-#         self.assertEqual(instance.pk, 1)
-#         self.assertEqual(list(instance.rel.all()), [self.anchor, new_anchor])
-
-#     def test_create_empty_relationship(self):
-#         """
-#         Create an instance of a model with a ManyToMany relationship,
-#         containing no items.
-#         """
-#         data = {'rel': []}
-#         serializer = self.serializer_class(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(ManyToManyModel.objects.all()), 2)
-#         self.assertEqual(instance.pk, 2)
-#         self.assertEqual(list(instance.rel.all()), [])
-
-#     def test_update_empty_relationship(self):
-#         """
-#         Update an instance of a model with a ManyToMany relationship,
-#         containing no items.
-#         """
-#         new_anchor = Anchor()
-#         new_anchor.save()
-#         data = {'rel': []}
-#         serializer = self.serializer_class(self.instance, data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(ManyToManyModel.objects.all()), 1)
-#         self.assertEqual(instance.pk, 1)
-#         self.assertEqual(list(instance.rel.all()), [])
-
-#     def test_create_empty_relationship_flat_data(self):
-#         """
-#         Create an instance of a model with a ManyToMany relationship,
-#         containing no items, using a representation that does not support
-#         lists (eg form data).
-#         """
-#         data = MultiValueDict()
-#         data.setlist('rel', [''])
-#         serializer = self.serializer_class(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(ManyToManyModel.objects.all()), 2)
-#         self.assertEqual(instance.pk, 2)
-#         self.assertEqual(list(instance.rel.all()), [])
-
-
-# class ReadOnlyManyToManyTests(TestCase):
-#     def setUp(self):
-#         class ReadOnlyManyToManySerializer(serializers.ModelSerializer):
-#             rel = serializers.RelatedField(many=True, read_only=True)
-
-#             class Meta:
-#                 model = ReadOnlyManyToManyModel
-
-#         self.serializer_class = ReadOnlyManyToManySerializer
-
-#         # An anchor instance to use for the relationship
-#         self.anchor = Anchor()
-#         self.anchor.save()
-
-#         # A model instance with a many to many relationship to the anchor
-#         self.instance = ReadOnlyManyToManyModel()
-#         self.instance.save()
-#         self.instance.rel.add(self.anchor)
-
-#         # A serialized representation of the model instance
-#         self.data = {'rel': [self.anchor.id], 'id': 1, 'text': 'anchor'}
-
-#     def test_update(self):
-#         """
-#         Attempt to update an instance of a model with a ManyToMany
-#         relationship.  Not updated due to read_only=True
-#         """
-#         new_anchor = Anchor()
-#         new_anchor.save()
-#         data = {'rel': [self.anchor.id, new_anchor.id]}
-#         serializer = self.serializer_class(self.instance, data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1)
-#         self.assertEqual(instance.pk, 1)
-#         # rel is still as original (1 entry)
-#         self.assertEqual(list(instance.rel.all()), [self.anchor])
-
-#     def test_update_without_relationship(self):
-#         """
-#         Attempt to update an instance of a model where many to ManyToMany
-#         relationship is not supplied.  Not updated due to read_only=True
-#         """
-#         new_anchor = Anchor()
-#         new_anchor.save()
-#         data = {}
-#         serializer = self.serializer_class(self.instance, data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1)
-#         self.assertEqual(instance.pk, 1)
-#         # rel is still as original (1 entry)
-#         self.assertEqual(list(instance.rel.all()), [self.anchor])
-
-
-# class DefaultValueTests(TestCase):
-#     def setUp(self):
-#         class DefaultValueSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = DefaultValueModel
-
-#         self.serializer_class = DefaultValueSerializer
-#         self.objects = DefaultValueModel.objects
-
-#     def test_create_using_default(self):
-#         data = {}
-#         serializer = self.serializer_class(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(self.objects.all()), 1)
-#         self.assertEqual(instance.pk, 1)
-#         self.assertEqual(instance.text, 'foobar')
-
-#     def test_create_overriding_default(self):
-#         data = {'text': 'overridden'}
-#         serializer = self.serializer_class(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(self.objects.all()), 1)
-#         self.assertEqual(instance.pk, 1)
-#         self.assertEqual(instance.text, 'overridden')
-
-#     def test_partial_update_default(self):
-#         """ Regression test for issue #532 """
-#         data = {'text': 'overridden'}
-#         serializer = self.serializer_class(data=data, partial=True)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-
-#         data = {'extra': 'extra_value'}
-#         serializer = self.serializer_class(instance=instance, data=data, partial=True)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-
-#         self.assertEqual(instance.extra, 'extra_value')
-#         self.assertEqual(instance.text, 'overridden')
-
-
-# class WritableFieldDefaultValueTests(TestCase):
-
-#     def setUp(self):
-#         self.expected = {'default': 'value'}
-#         self.create_field = fields.WritableField
-
-#     def test_get_default_value_with_noncallable(self):
-#         field = self.create_field(default=self.expected)
-#         got = field.get_default_value()
-#         self.assertEqual(got, self.expected)
-
-#     def test_get_default_value_with_callable(self):
-#         field = self.create_field(default=lambda: self.expected)
-#         got = field.get_default_value()
-#         self.assertEqual(got, self.expected)
-
-#     def test_get_default_value_when_not_required(self):
-#         field = self.create_field(default=self.expected, required=False)
-#         got = field.get_default_value()
-#         self.assertEqual(got, self.expected)
-
-#     def test_get_default_value_returns_None(self):
-#         field = self.create_field()
-#         got = field.get_default_value()
-#         self.assertIsNone(got)
-
-#     def test_get_default_value_returns_non_True_values(self):
-#         values = [None, '', False, 0, [], (), {}]  # values that assumed as 'False' in the 'if' clause
-#         for expected in values:
-#             field = self.create_field(default=expected)
-#             got = field.get_default_value()
-#             self.assertEqual(got, expected)
-
-
-# class RelatedFieldDefaultValueTests(WritableFieldDefaultValueTests):
-
-#     def setUp(self):
-#         self.expected = {'foo': 'bar'}
-#         self.create_field = relations.RelatedField
-
-#     def test_get_default_value_returns_empty_list(self):
-#         field = self.create_field(many=True)
-#         got = field.get_default_value()
-#         self.assertListEqual(got, [])
-
-#     def test_get_default_value_returns_expected(self):
-#         expected = [1, 2, 3]
-#         field = self.create_field(many=True, default=expected)
-#         got = field.get_default_value()
-#         self.assertListEqual(got, expected)
-
-
-# class CallableDefaultValueTests(TestCase):
-#     def setUp(self):
-#         class CallableDefaultValueSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = CallableDefaultValueModel
-
-#         self.serializer_class = CallableDefaultValueSerializer
-#         self.objects = CallableDefaultValueModel.objects
-
-#     def test_create_using_default(self):
-#         data = {}
-#         serializer = self.serializer_class(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(self.objects.all()), 1)
-#         self.assertEqual(instance.pk, 1)
-#         self.assertEqual(instance.text, 'foobar')
-
-#     def test_create_overriding_default(self):
-#         data = {'text': 'overridden'}
-#         serializer = self.serializer_class(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         instance = serializer.save()
-#         self.assertEqual(len(self.objects.all()), 1)
-#         self.assertEqual(instance.pk, 1)
-#         self.assertEqual(instance.text, 'overridden')
-
-
-# class ManyRelatedTests(TestCase):
-#     def test_reverse_relations(self):
-#         post = BlogPost.objects.create(title="Test blog post")
-#         post.blogpostcomment_set.create(text="I hate this blog post")
-#         post.blogpostcomment_set.create(text="I love this blog post")
-
-#         class BlogPostCommentSerializer(serializers.Serializer):
-#             text = serializers.CharField()
-
-#         class BlogPostSerializer(serializers.Serializer):
-#             title = serializers.CharField()
-#             comments = BlogPostCommentSerializer(source='blogpostcomment_set')
-
-#         serializer = BlogPostSerializer(instance=post)
-#         expected = {
-#             'title': 'Test blog post',
-#             'comments': [
-#                 {'text': 'I hate this blog post'},
-#                 {'text': 'I love this blog post'}
-#             ]
-#         }
-
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_include_reverse_relations(self):
-#         post = BlogPost.objects.create(title="Test blog post")
-#         post.blogpostcomment_set.create(text="I hate this blog post")
-#         post.blogpostcomment_set.create(text="I love this blog post")
-
-#         class BlogPostSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = BlogPost
-#                 fields = ('id', 'title', 'blogpostcomment_set')
-
-#         serializer = BlogPostSerializer(instance=post)
-#         expected = {
-#             'id': 1, 'title': 'Test blog post', 'blogpostcomment_set': [1, 2]
-#         }
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_depth_include_reverse_relations(self):
-#         post = BlogPost.objects.create(title="Test blog post")
-#         post.blogpostcomment_set.create(text="I hate this blog post")
-#         post.blogpostcomment_set.create(text="I love this blog post")
-
-#         class BlogPostSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = BlogPost
-#                 fields = ('id', 'title', 'blogpostcomment_set')
-#                 depth = 1
-
-#         serializer = BlogPostSerializer(instance=post)
-#         expected = {
-#             'id': 1, 'title': 'Test blog post',
-#             'blogpostcomment_set': [
-#                 {'id': 1, 'text': 'I hate this blog post', 'blog_post': 1},
-#                 {'id': 2, 'text': 'I love this blog post', 'blog_post': 1}
-#             ]
-#         }
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_callable_source(self):
-#         post = BlogPost.objects.create(title="Test blog post")
-#         post.blogpostcomment_set.create(text="I love this blog post")
-
-#         class BlogPostCommentSerializer(serializers.Serializer):
-#             text = serializers.CharField()
-
-#         class BlogPostSerializer(serializers.Serializer):
-#             title = serializers.CharField()
-#             first_comment = BlogPostCommentSerializer(source='get_first_comment')
-
-#         serializer = BlogPostSerializer(post)
-
-#         expected = {
-#             'title': 'Test blog post',
-#             'first_comment': {'text': 'I love this blog post'}
-#         }
-#         self.assertEqual(serializer.data, expected)
-
-
-# class RelatedTraversalTest(TestCase):
-#     def test_nested_traversal(self):
-#         """
-#         Source argument should support dotted.source notation.
-#         """
-#         user = Person.objects.create(name="django")
-#         post = BlogPost.objects.create(title="Test blog post", writer=user)
-#         post.blogpostcomment_set.create(text="I love this blog post")
-
-#         class PersonSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = Person
-#                 fields = ("name", "age")
-
-#         class BlogPostCommentSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = BlogPostComment
-#                 fields = ("text", "post_owner")
-
-#             text = serializers.CharField()
-#             post_owner = PersonSerializer(source='blog_post.writer')
-
-#         class BlogPostSerializer(serializers.Serializer):
-#             title = serializers.CharField()
-#             comments = BlogPostCommentSerializer(source='blogpostcomment_set')
-
-#         serializer = BlogPostSerializer(instance=post)
-
-#         expected = {
-#             'title': 'Test blog post',
-#             'comments': [{
-#                 'text': 'I love this blog post',
-#                 'post_owner': {
-#                     "name": "django",
-#                     "age": None
-#                 }
-#             }]
-#         }
-
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_nested_traversal_with_none(self):
-#         """
-#         If a component of the dotted.source is None, return None for the field.
-#         """
-#         from tests.models import NullableForeignKeySource
-#         instance = NullableForeignKeySource.objects.create(name='Source with null FK')
-
-#         class NullableSourceSerializer(serializers.Serializer):
-#             target_name = serializers.Field(source='target.name')
-
-#         serializer = NullableSourceSerializer(instance=instance)
-
-#         expected = {
-#             'target_name': None,
-#         }
-
-#         self.assertEqual(serializer.data, expected)
-
-
-# class SerializerMethodFieldTests(TestCase):
-#     def setUp(self):
-
-#         class BoopSerializer(serializers.Serializer):
-#             beep = serializers.SerializerMethodField('get_beep')
-#             boop = serializers.Field()
-#             boop_count = serializers.SerializerMethodField('get_boop_count')
-
-#             def get_beep(self, obj):
-#                 return 'hello!'
-
-#             def get_boop_count(self, obj):
-#                 return len(obj.boop)
-
-#         self.serializer_class = BoopSerializer
-
-#     def test_serializer_method_field(self):
-
-#         class MyModel(object):
-#             boop = ['a', 'b', 'c']
-
-#         source_data = MyModel()
-
-#         serializer = self.serializer_class(source_data)
-
-#         expected = {
-#             'beep': 'hello!',
-#             'boop': ['a', 'b', 'c'],
-#             'boop_count': 3,
-#         }
-
-#         self.assertEqual(serializer.data, expected)
-
-
-# # Test for issue #324
-# class BlankFieldTests(TestCase):
-#     def setUp(self):
-
-#         class BlankFieldModelSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = BlankFieldModel
-
-#         class BlankFieldSerializer(serializers.Serializer):
-#             title = serializers.CharField(required=False)
-
-#         class NotBlankFieldModelSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = BasicModel
-
-#         class NotBlankFieldSerializer(serializers.Serializer):
-#             title = serializers.CharField()
-
-#         self.model_serializer_class = BlankFieldModelSerializer
-#         self.serializer_class = BlankFieldSerializer
-#         self.not_blank_model_serializer_class = NotBlankFieldModelSerializer
-#         self.not_blank_serializer_class = NotBlankFieldSerializer
-#         self.data = {'title': ''}
-
-#     def test_create_blank_field(self):
-#         serializer = self.serializer_class(data=self.data)
-#         self.assertEqual(serializer.is_valid(), True)
-
-#     def test_create_model_blank_field(self):
-#         serializer = self.model_serializer_class(data=self.data)
-#         self.assertEqual(serializer.is_valid(), True)
-
-#     def test_create_model_null_field(self):
-#         serializer = self.model_serializer_class(data={'title': None})
-#         self.assertEqual(serializer.is_valid(), True)
-#         serializer.save()
-#         self.assertIsNot(serializer.object.pk, None)
-#         self.assertEqual(serializer.object.title, '')
-
-#     def test_create_not_blank_field(self):
-#         """
-#         Test to ensure blank data in a field not marked as blank=True
-#         is considered invalid in a non-model serializer
-#         """
-#         serializer = self.not_blank_serializer_class(data=self.data)
-#         self.assertEqual(serializer.is_valid(), False)
-
-#     def test_create_model_not_blank_field(self):
-#         """
-#         Test to ensure blank data in a field not marked as blank=True
-#         is considered invalid in a model serializer
-#         """
-#         serializer = self.not_blank_model_serializer_class(data=self.data)
-#         self.assertEqual(serializer.is_valid(), False)
-
-#     def test_create_model_empty_field(self):
-#         serializer = self.model_serializer_class(data={})
-#         self.assertEqual(serializer.is_valid(), True)
-
-#     def test_create_model_null_field_save(self):
-#         """
-#         Regression test for #1330.
-
-#         https://github.com/tomchristie/django-rest-framework/pull/1330
-#         """
-#         serializer = self.model_serializer_class(data={'title': None})
-#         self.assertEqual(serializer.is_valid(), True)
-
-#         try:
-#             serializer.save()
-#         except Exception:
-#             self.fail('Exception raised on save() after validation passes')
-
-
-# # Test for issue #460
-# class SerializerPickleTests(TestCase):
-#     """
-#     Test pickleability of the output of Serializers
-#     """
-#     def test_pickle_simple_model_serializer_data(self):
-#         """
-#         Test simple serializer
-#         """
-#         pickle.dumps(PersonSerializer(Person(name="Methusela", age=969)).data)
-
-#     def test_pickle_inner_serializer(self):
-#         """
-#         Test pickling a serializer whose resulting .data (a SortedDictWithMetadata) will
-#         have unpickleable meta data--in order to make sure metadata doesn't get pulled into the pickle.
-#         See DictWithMetadata.__getstate__
-#         """
-#         class InnerPersonSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = Person
-#                 fields = ('name', 'age')
-#         pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data, 0)
-
-#     def test_getstate_method_should_not_return_none(self):
-#         """
-#         Regression test for #645.
-#         """
-#         data = serializers.DictWithMetadata({1: 1})
-#         self.assertEqual(data.__getstate__(), serializers.SortedDict({1: 1}))
-
-#     def test_serializer_data_is_pickleable(self):
-#         """
-#         Another regression test for #645.
-#         """
-#         data = serializers.SortedDictWithMetadata({1: 1})
-#         repr(pickle.loads(pickle.dumps(data, 0)))
-
-
-# # test for issue #725
-# class SeveralChoicesModel(models.Model):
-#     color = models.CharField(
-#         max_length=10,
-#         choices=[('red', 'Red'), ('green', 'Green'), ('blue', 'Blue')],
-#         blank=False
-#     )
-#     drink = models.CharField(
-#         max_length=10,
-#         choices=[('beer', 'Beer'), ('wine', 'Wine'), ('cider', 'Cider')],
-#         blank=False,
-#         default='beer'
-#     )
-#     os = models.CharField(
-#         max_length=10,
-#         choices=[('linux', 'Linux'), ('osx', 'OSX'), ('windows', 'Windows')],
-#         blank=True
-#     )
-#     music_genre = models.CharField(
-#         max_length=10,
-#         choices=[('rock', 'Rock'), ('metal', 'Metal'), ('grunge', 'Grunge')],
-#         blank=True,
-#         default='metal'
-#     )
-
-
-# class SerializerChoiceFields(TestCase):
-
-#     def setUp(self):
-#         super(SerializerChoiceFields, self).setUp()
-
-#         class SeveralChoicesSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = SeveralChoicesModel
-#                 fields = ('color', 'drink', 'os', 'music_genre')
-
-#         self.several_choices_serializer = SeveralChoicesSerializer
-
-#     def test_choices_blank_false_not_default(self):
-#         serializer = self.several_choices_serializer()
-#         self.assertEqual(
-#             serializer.fields['color'].choices,
-#             [('red', 'Red'), ('green', 'Green'), ('blue', 'Blue')]
-#         )
-
-#     def test_choices_blank_false_with_default(self):
-#         serializer = self.several_choices_serializer()
-#         self.assertEqual(
-#             serializer.fields['drink'].choices,
-#             [('beer', 'Beer'), ('wine', 'Wine'), ('cider', 'Cider')]
-#         )
-
-#     def test_choices_blank_true_not_default(self):
-#         serializer = self.several_choices_serializer()
-#         self.assertEqual(
-#             serializer.fields['os'].choices,
-#             BLANK_CHOICE_DASH + [('linux', 'Linux'), ('osx', 'OSX'), ('windows', 'Windows')]
-#         )
-
-#     def test_choices_blank_true_with_default(self):
-#         serializer = self.several_choices_serializer()
-#         self.assertEqual(
-#             serializer.fields['music_genre'].choices,
-#             BLANK_CHOICE_DASH + [('rock', 'Rock'), ('metal', 'Metal'), ('grunge', 'Grunge')]
-#         )
-
-
-# # Regression tests for #675
-# class Ticket(models.Model):
-#     assigned = models.ForeignKey(
-#         Person, related_name='assigned_tickets')
-#     reviewer = models.ForeignKey(
-#         Person, blank=True, null=True, related_name='reviewed_tickets')
-
-
-# class SerializerRelatedChoicesTest(TestCase):
-
-#     def setUp(self):
-#         super(SerializerRelatedChoicesTest, self).setUp()
-
-#         class RelatedChoicesSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = Ticket
-#                 fields = ('assigned', 'reviewer')
-
-#         self.related_fields_serializer = RelatedChoicesSerializer
-
-#     def test_empty_queryset_required(self):
-#         serializer = self.related_fields_serializer()
-#         self.assertEqual(serializer.fields['assigned'].queryset.count(), 0)
-#         self.assertEqual(
-#             [x for x in serializer.fields['assigned'].widget.choices],
-#             []
-#         )
-
-#     def test_empty_queryset_not_required(self):
-#         serializer = self.related_fields_serializer()
-#         self.assertEqual(serializer.fields['reviewer'].queryset.count(), 0)
-#         self.assertEqual(
-#             [x for x in serializer.fields['reviewer'].widget.choices],
-#             [('', '---------')]
-#         )
-
-#     def test_with_some_persons_required(self):
-#         Person.objects.create(name="Lionel Messi")
-#         Person.objects.create(name="Xavi Hernandez")
-#         serializer = self.related_fields_serializer()
-#         self.assertEqual(serializer.fields['assigned'].queryset.count(), 2)
-#         self.assertEqual(
-#             [x for x in serializer.fields['assigned'].widget.choices],
-#             [(1, 'Person object - 1'), (2, 'Person object - 2')]
-#         )
-
-#     def test_with_some_persons_not_required(self):
-#         Person.objects.create(name="Lionel Messi")
-#         Person.objects.create(name="Xavi Hernandez")
-#         serializer = self.related_fields_serializer()
-#         self.assertEqual(serializer.fields['reviewer'].queryset.count(), 2)
-#         self.assertEqual(
-#             [x for x in serializer.fields['reviewer'].widget.choices],
-#             [('', '---------'), (1, 'Person object - 1'), (2, 'Person object - 2')]
-#         )
-
-
-# class DepthTest(TestCase):
-#     def test_implicit_nesting(self):
-
-#         writer = Person.objects.create(name="django", age=1)
-#         post = BlogPost.objects.create(title="Test blog post", writer=writer)
-#         comment = BlogPostComment.objects.create(text="Test blog post comment", blog_post=post)
-
-#         class BlogPostCommentSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = BlogPostComment
-#                 depth = 2
-
-#         serializer = BlogPostCommentSerializer(instance=comment)
-#         expected = {'id': 1, 'text': 'Test blog post comment', 'blog_post': {'id': 1, 'title': 'Test blog post',
-#                     'writer': {'id': 1, 'name': 'django', 'age': 1}}}
-
-#         self.assertEqual(serializer.data, expected)
-
-#     def test_explicit_nesting(self):
-#         writer = Person.objects.create(name="django", age=1)
-#         post = BlogPost.objects.create(title="Test blog post", writer=writer)
-#         comment = BlogPostComment.objects.create(text="Test blog post comment", blog_post=post)
-
-#         class PersonSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = Person
-
-#         class BlogPostSerializer(serializers.ModelSerializer):
-#             writer = PersonSerializer()
-
-#             class Meta:
-#                 model = BlogPost
-
-#         class BlogPostCommentSerializer(serializers.ModelSerializer):
-#             blog_post = BlogPostSerializer()
-
-#             class Meta:
-#                 model = BlogPostComment
-
-#         serializer = BlogPostCommentSerializer(instance=comment)
-#         expected = {'id': 1, 'text': 'Test blog post comment', 'blog_post': {'id': 1, 'title': 'Test blog post',
-#                     'writer': {'id': 1, 'name': 'django', 'age': 1}}}
-
-#         self.assertEqual(serializer.data, expected)
-
-
-# class NestedSerializerContextTests(TestCase):
-
-#     def test_nested_serializer_context(self):
-#         """
-#         Regression for #497
-
-#         https://github.com/tomchristie/django-rest-framework/issues/497
-#         """
-#         class PhotoSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = Photo
-#                 fields = ("description", "callable")
-
-#             callable = serializers.SerializerMethodField('_callable')
-
-#             def _callable(self, instance):
-#                 if 'context_item' not in self.context:
-#                     raise RuntimeError("context isn't getting passed into 2nd level nested serializer")
-#                 return "success"
-
-#         class AlbumSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = Album
-#                 fields = ("photo_set", "callable")
-
-#             photo_set = PhotoSerializer(source="photo_set", many=True)
-#             callable = serializers.SerializerMethodField("_callable")
-
-#             def _callable(self, instance):
-#                 if 'context_item' not in self.context:
-#                     raise RuntimeError("context isn't getting passed into 1st level nested serializer")
-#                 return "success"
-
-#         class AlbumCollection(object):
-#             albums = None
-
-#         class AlbumCollectionSerializer(serializers.Serializer):
-#             albums = AlbumSerializer(source="albums", many=True)
-
-#         album1 = Album.objects.create(title="album 1")
-#         album2 = Album.objects.create(title="album 2")
-#         Photo.objects.create(description="Bigfoot", album=album1)
-#         Photo.objects.create(description="Unicorn", album=album1)
-#         Photo.objects.create(description="Yeti", album=album2)
-#         Photo.objects.create(description="Sasquatch", album=album2)
-#         album_collection = AlbumCollection()
-#         album_collection.albums = [album1, album2]
-
-#         # This will raise RuntimeError if context doesn't get passed correctly to the nested Serializers
-#         AlbumCollectionSerializer(album_collection, context={'context_item': 'album context'}).data
-
-
-# class DeserializeListTestCase(TestCase):
-
-#     def setUp(self):
-#         self.data = {
-#             'email': 'nobody@nowhere.com',
-#             'content': 'This is some test content',
-#             'created': datetime.datetime(2013, 3, 7),
-#         }
-
-#     def test_no_errors(self):
-#         data = [self.data.copy() for x in range(0, 3)]
-#         serializer = CommentSerializer(data=data, many=True)
-#         self.assertTrue(serializer.is_valid())
-#         self.assertTrue(isinstance(serializer.object, list))
-#         self.assertTrue(
-#             all((isinstance(item, Comment) for item in serializer.object))
-#         )
-
-#     def test_errors_return_as_list(self):
-#         invalid_item = self.data.copy()
-#         invalid_item['email'] = ''
-#         data = [self.data.copy(), invalid_item, self.data.copy()]
-
-#         serializer = CommentSerializer(data=data, many=True)
-#         self.assertFalse(serializer.is_valid())
-#         expected = [{}, {'email': ['This field is required.']}, {}]
-#         self.assertEqual(serializer.errors, expected)
-
-
-# # Test for issue 747
-
-# class LazyStringModel(object):
-#     def __init__(self, lazystring):
-#         self.lazystring = lazystring
-
-
-# class LazyStringSerializer(serializers.Serializer):
-#     lazystring = serializers.Field()
-
-#     def restore_object(self, attrs, instance=None):
-#         if instance is not None:
-#             instance.lazystring = attrs.get('lazystring', instance.lazystring)
-#             return instance
-#         return LazyStringModel(**attrs)
-
-
-# class LazyStringsTestCase(TestCase):
-#     def setUp(self):
-#         self.model = LazyStringModel(lazystring=_('lazystring'))
-
-#     def test_lazy_strings_are_translated(self):
-#         serializer = LazyStringSerializer(self.model)
-#         self.assertEqual(type(serializer.data['lazystring']),
-#                          type('lazystring'))
-
-
-# # Test for issue #467
-
-# class FieldLabelTest(TestCase):
-#     def setUp(self):
-#         self.serializer_class = BasicModelSerializer
-
-#     def test_label_from_model(self):
-#         """
-#         Validates that label and help_text are correctly copied from the model class.
-#         """
-#         serializer = self.serializer_class()
-#         text_field = serializer.fields['text']
-
-#         self.assertEqual('Text comes here', text_field.label)
-#         self.assertEqual('Text description.', text_field.help_text)
-
-#     def test_field_ctor(self):
-#         """
-#         This is check that ctor supports both label and help_text.
-#         """
-#         self.assertEqual('Label', fields.Field(label='Label', help_text='Help').label)
-#         self.assertEqual('Help', fields.CharField(label='Label', help_text='Help').help_text)
-#         self.assertEqual('Label', relations.HyperlinkedRelatedField(view_name='fake', label='Label', help_text='Help', many=True).label)
-
-
-# # Test for issue #961
-
-# class ManyFieldHelpTextTest(TestCase):
-#     def test_help_text_no_hold_down_control_msg(self):
-#         """
-#         Validate that help_text doesn't contain the 'Hold down "Control" ...'
-#         message that Django appends to choice fields.
-#         """
-#         rel_field = fields.Field(help_text=ManyToManyModel._meta.get_field('rel').help_text)
-#         self.assertEqual('Some help text.', rel_field.help_text)
-
-
-# class AttributeMappingOnAutogeneratedRelatedFields(TestCase):
-
-#     def test_primary_key_related_field(self):
-#         serializer = ForeignKeySourceSerializer()
-#         self.assertEqual(serializer.fields['target'].help_text, 'Target')
-#         self.assertEqual(serializer.fields['target'].label, 'Target')
-
-#     def test_hyperlinked_related_field(self):
-#         serializer = HyperlinkedForeignKeySourceSerializer()
-#         self.assertEqual(serializer.fields['target'].help_text, 'Target')
-#         self.assertEqual(serializer.fields['target'].label, 'Target')
-
-
-# @unittest.skipUnless(PIL is not None, 'PIL is not installed')
-# class AttributeMappingOnAutogeneratedFieldsTests(TestCase):
-
-#     def setUp(self):
-
-#         class AMOAFSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = AMOAFModel
-
-#         self.serializer_class = AMOAFSerializer
-#         self.fields_attributes = {
-#             'char_field': [
-#                 ('max_length', 1024),
-#             ],
-#             'comma_separated_integer_field': [
-#                 ('max_length', 1024),
-#             ],
-#             'decimal_field': [
-#                 ('max_digits', 64),
-#                 ('decimal_places', 32),
-#             ],
-#             'email_field': [
-#                 ('max_length', 1024),
-#             ],
-#             'file_field': [
-#                 ('max_length', 1024),
-#             ],
-#             'image_field': [
-#                 ('max_length', 1024),
-#             ],
-#             'slug_field': [
-#                 ('max_length', 1024),
-#             ],
-#             'url_field': [
-#                 ('max_length', 1024),
-#             ],
-#             'nullable_char_field': [
-#                 ('max_length', 1024),
-#                 ('allow_none', True),
-#             ],
-#         }
-
-#     def field_test(self, field):
-#         serializer = self.serializer_class(data={})
-#         self.assertEqual(serializer.is_valid(), True)
-
-#         for attribute in self.fields_attributes[field]:
-#             self.assertEqual(
-#                 getattr(serializer.fields[field], attribute[0]),
-#                 attribute[1]
-#             )
-
-#     def test_char_field(self):
-#         self.field_test('char_field')
-
-#     def test_comma_separated_integer_field(self):
-#         self.field_test('comma_separated_integer_field')
-
-#     def test_decimal_field(self):
-#         self.field_test('decimal_field')
-
-#     def test_email_field(self):
-#         self.field_test('email_field')
-
-#     def test_file_field(self):
-#         self.field_test('file_field')
-
-#     def test_image_field(self):
-#         self.field_test('image_field')
-
-#     def test_slug_field(self):
-#         self.field_test('slug_field')
-
-#     def test_url_field(self):
-#         self.field_test('url_field')
-
-#     def test_nullable_char_field(self):
-#         self.field_test('nullable_char_field')
-
-
-# @unittest.skipUnless(PIL is not None, 'PIL is not installed')
-# class DefaultValuesOnAutogeneratedFieldsTests(TestCase):
-
-#     def setUp(self):
-
-#         class DVOAFSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = DVOAFModel
-
-#         self.serializer_class = DVOAFSerializer
-#         self.fields_attributes = {
-#             'positive_integer_field': [
-#                 ('min_value', 0),
-#             ],
-#             'positive_small_integer_field': [
-#                 ('min_value', 0),
-#             ],
-#             'email_field': [
-#                 ('max_length', 75),
-#             ],
-#             'file_field': [
-#                 ('max_length', 100),
-#             ],
-#             'image_field': [
-#                 ('max_length', 100),
-#             ],
-#             'slug_field': [
-#                 ('max_length', 50),
-#             ],
-#             'url_field': [
-#                 ('max_length', 200),
-#             ],
-#         }
-
-#     def field_test(self, field):
-#         serializer = self.serializer_class(data={})
-#         self.assertEqual(serializer.is_valid(), True)
-
-#         for attribute in self.fields_attributes[field]:
-#             self.assertEqual(
-#                 getattr(serializer.fields[field], attribute[0]),
-#                 attribute[1]
-#             )
-
-#     def test_positive_integer_field(self):
-#         self.field_test('positive_integer_field')
-
-#     def test_positive_small_integer_field(self):
-#         self.field_test('positive_small_integer_field')
-
-#     def test_email_field(self):
-#         self.field_test('email_field')
-
-#     def test_file_field(self):
-#         self.field_test('file_field')
-
-#     def test_image_field(self):
-#         self.field_test('image_field')
-
-#     def test_slug_field(self):
-#         self.field_test('slug_field')
-
-#     def test_url_field(self):
-#         self.field_test('url_field')
-
-
-# class MetadataSerializer(serializers.Serializer):
-#     field1 = serializers.CharField(max_length=3, required=True)
-#     field2 = serializers.CharField(max_length=10, required=False)
-
-
-# class MetadataSerializerTestCase(TestCase):
-#     def setUp(self):
-#         self.serializer = MetadataSerializer()
-
-#     def test_serializer_metadata(self):
-#         metadata = self.serializer.metadata()
-#         expected = {
-#             'field1': {
-#                 'required': True,
-#                 'max_length': 3,
-#                 'type': 'string',
-#                 'read_only': False
-#             },
-#             'field2': {
-#                 'required': False,
-#                 'max_length': 10,
-#                 'type': 'string',
-#                 'read_only': False
-#             }
-#         }
-#         self.assertEqual(expected, metadata)
-
-
-# # Regression test for #840
-
-# class SimpleModel(models.Model):
-#     text = models.CharField(max_length=100)
-
-
-# class SimpleModelSerializer(serializers.ModelSerializer):
-#     text = serializers.CharField()
-#     other = serializers.CharField()
-
-#     class Meta:
-#         model = SimpleModel
-
-#     def validate_other(self, attrs, source):
-#         del attrs['other']
-#         return attrs
-
-
-# class FieldValidationRemovingAttr(TestCase):
-#     def test_removing_non_model_field_in_validation(self):
-#         """
-#         Removing an attr during field valiation should ensure that it is not
-#         passed through when restoring the object.
-
-#         This allows additional non-model fields to be supported.
-
-#         Regression test for #840.
-#         """
-#         serializer = SimpleModelSerializer(data={'text': 'foo', 'other': 'bar'})
-#         self.assertTrue(serializer.is_valid())
-#         serializer.save()
-#         self.assertEqual(serializer.object.text, 'foo')
-
-
-# # Regression test for #878
-
-# class SimpleTargetModel(models.Model):
-#     text = models.CharField(max_length=100)
-
-
-# class SimplePKSourceModelSerializer(serializers.Serializer):
-#     targets = serializers.PrimaryKeyRelatedField(queryset=SimpleTargetModel.objects.all(), many=True)
-#     text = serializers.CharField()
-
-
-# class SimpleSlugSourceModelSerializer(serializers.Serializer):
-#     targets = serializers.SlugRelatedField(queryset=SimpleTargetModel.objects.all(), many=True, slug_field='pk')
-#     text = serializers.CharField()
-
-
-# class SerializerSupportsManyRelationships(TestCase):
-#     def setUp(self):
-#         SimpleTargetModel.objects.create(text='foo')
-#         SimpleTargetModel.objects.create(text='bar')
-
-#     def test_serializer_supports_pk_many_relationships(self):
-#         """
-#         Regression test for #878.
-
-#         Note that pk behavior has a different code path to usual cases,
-#         for performance reasons.
-#         """
-#         serializer = SimplePKSourceModelSerializer(data={'text': 'foo', 'targets': [1, 2]})
-#         self.assertTrue(serializer.is_valid())
-#         self.assertEqual(serializer.data, {'text': 'foo', 'targets': [1, 2]})
-
-#     def test_serializer_supports_slug_many_relationships(self):
-#         """
-#         Regression test for #878.
-#         """
-#         serializer = SimpleSlugSourceModelSerializer(data={'text': 'foo', 'targets': [1, 2]})
-#         self.assertTrue(serializer.is_valid())
-#         self.assertEqual(serializer.data, {'text': 'foo', 'targets': [1, 2]})
-
-
-# class TransformMethodsSerializer(serializers.Serializer):
-#     a = serializers.CharField()
-#     b_renamed = serializers.CharField(source='b')
-
-#     def transform_a(self, obj, value):
-#         return value.lower()
-
-#     def transform_b_renamed(self, obj, value):
-#         if value is not None:
-#             return 'and ' + value
-
-
-# class TestSerializerTransformMethods(TestCase):
-#     def setUp(self):
-#         self.s = TransformMethodsSerializer()
-
-#     def test_transform_methods(self):
-#         self.assertEqual(
-#             self.s.to_native({'a': 'GREEN EGGS', 'b': 'HAM'}),
-#             {
-#                 'a': 'green eggs',
-#                 'b_renamed': 'and HAM',
-#             }
-#         )
-
-#     def test_missing_fields(self):
-#         self.assertEqual(
-#             self.s.to_native({'a': 'GREEN EGGS'}),
-#             {
-#                 'a': 'green eggs',
-#                 'b_renamed': None,
-#             }
-#         )
-
-
-# class DefaultTrueBooleanModel(models.Model):
-#     cat = models.BooleanField(default=True)
-#     dog = models.BooleanField(default=False)
-
-
-# class SerializerDefaultTrueBoolean(TestCase):
-
-#     def setUp(self):
-#         super(SerializerDefaultTrueBoolean, self).setUp()
-
-#         class DefaultTrueBooleanSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = DefaultTrueBooleanModel
-#                 fields = ('cat', 'dog')
-
-#         self.default_true_boolean_serializer = DefaultTrueBooleanSerializer
-
-#     def test_enabled_as_false(self):
-#         serializer = self.default_true_boolean_serializer(data={'cat': False,
-#                                                                 'dog': False})
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.data['cat'], False)
-#         self.assertEqual(serializer.data['dog'], False)
-
-#     def test_enabled_as_true(self):
-#         serializer = self.default_true_boolean_serializer(data={'cat': True,
-#                                                                 'dog': True})
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.data['cat'], True)
-#         self.assertEqual(serializer.data['dog'], True)
-
-#     def test_enabled_partial(self):
-#         serializer = self.default_true_boolean_serializer(data={'cat': False},
-#                                                           partial=True)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.data['cat'], False)
-#         self.assertEqual(serializer.data['dog'], False)
-
-
-# class BoolenFieldTypeTest(TestCase):
-#     '''
-#     Ensure the various Boolean based model fields are rendered as the proper
-#     field type
-
-#     '''
-
-#     def setUp(self):
-#         '''
-#         Setup an ActionItemSerializer for BooleanTesting
-#         '''
-#         data = {
-#             'title': 'b' * 201,
-#         }
-#         self.serializer = ActionItemSerializer(data=data)
-
-#     def test_booleanfield_type(self):
-#         '''
-#         Test that BooleanField is infered from models.BooleanField
-#         '''
-#         bfield = self.serializer.get_fields()['done']
-#         self.assertEqual(type(bfield), fields.BooleanField)
-
-#     def test_nullbooleanfield_type(self):
-#         '''
-#         Test that BooleanField is infered from models.NullBooleanField
-
-#         https://groups.google.com/forum/#!topic/django-rest-framework/D9mXEftpuQ8
-#         '''
-#         bfield = self.serializer.get_fields()['started']
-#         self.assertEqual(type(bfield), fields.BooleanField)
diff --git a/tests/test_serializer_bulk_update.py b/tests/test_serializer_bulk_update.py
index 2259ee31..fb881a75 100644
--- a/tests/test_serializer_bulk_update.py
+++ b/tests/test_serializer_bulk_update.py
@@ -121,161 +121,3 @@ class BulkCreateSerializerTests(TestCase):
         expected_errors = {'non_field_errors': ['Expected a list of items but got type `dict`.']}
 
         self.assertEqual(serializer.errors, expected_errors)
-
-
-# class BulkUpdateSerializerTests(TestCase):
-#     """
-#     Updating multiple instances using serializers.
-#     """
-
-#     def setUp(self):
-#         class Book(object):
-#             """
-#             A data type that can be persisted to a mock storage backend
-#             with `.save()` and `.delete()`.
-#             """
-#             object_map = {}
-
-#             def __init__(self, id, title, author):
-#                 self.id = id
-#                 self.title = title
-#                 self.author = author
-
-#             def save(self):
-#                 Book.object_map[self.id] = self
-
-#             def delete(self):
-#                 del Book.object_map[self.id]
-
-#         class BookSerializer(serializers.Serializer):
-#             id = serializers.IntegerField()
-#             title = serializers.CharField(max_length=100)
-#             author = serializers.CharField(max_length=100)
-
-#             def restore_object(self, attrs, instance=None):
-#                 if instance:
-#                     instance.id = attrs['id']
-#                     instance.title = attrs['title']
-#                     instance.author = attrs['author']
-#                     return instance
-#                 return Book(**attrs)
-
-#         self.Book = Book
-#         self.BookSerializer = BookSerializer
-
-#         data = [
-#             {
-#                 'id': 0,
-#                 'title': 'The electric kool-aid acid test',
-#                 'author': 'Tom Wolfe'
-#             }, {
-#                 'id': 1,
-#                 'title': 'If this is a man',
-#                 'author': 'Primo Levi'
-#             }, {
-#                 'id': 2,
-#                 'title': 'The wind-up bird chronicle',
-#                 'author': 'Haruki Murakami'
-#             }
-#         ]
-
-#         for item in data:
-#             book = Book(item['id'], item['title'], item['author'])
-#             book.save()
-
-#     def books(self):
-#         """
-#         Return all the objects in the mock storage backend.
-#         """
-#         return self.Book.object_map.values()
-
-#     def test_bulk_update_success(self):
-#         """
-#         Correct bulk update serialization should return the input data.
-#         """
-#         data = [
-#             {
-#                 'id': 0,
-#                 'title': 'The electric kool-aid acid test',
-#                 'author': 'Tom Wolfe'
-#             }, {
-#                 'id': 2,
-#                 'title': 'Kafka on the shore',
-#                 'author': 'Haruki Murakami'
-#             }
-#         ]
-#         serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.data, data)
-#         serializer.save()
-#         new_data = self.BookSerializer(self.books(), many=True).data
-
-#         self.assertEqual(data, new_data)
-
-#     def test_bulk_update_and_create(self):
-#         """
-#         Bulk update serialization may also include created items.
-#         """
-#         data = [
-#             {
-#                 'id': 0,
-#                 'title': 'The electric kool-aid acid test',
-#                 'author': 'Tom Wolfe'
-#             }, {
-#                 'id': 3,
-#                 'title': 'Kafka on the shore',
-#                 'author': 'Haruki Murakami'
-#             }
-#         ]
-#         serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.data, data)
-#         serializer.save()
-#         new_data = self.BookSerializer(self.books(), many=True).data
-#         self.assertEqual(data, new_data)
-
-#     def test_bulk_update_invalid_create(self):
-#         """
-#         Bulk update serialization without allow_add_remove may not create items.
-#         """
-#         data = [
-#             {
-#                 'id': 0,
-#                 'title': 'The electric kool-aid acid test',
-#                 'author': 'Tom Wolfe'
-#             }, {
-#                 'id': 3,
-#                 'title': 'Kafka on the shore',
-#                 'author': 'Haruki Murakami'
-#             }
-#         ]
-#         expected_errors = [
-#             {},
-#             {'non_field_errors': ['Cannot create a new item, only existing items may be updated.']}
-#         ]
-#         serializer = self.BookSerializer(self.books(), data=data, many=True)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, expected_errors)
-
-#     def test_bulk_update_error(self):
-#         """
-#         Incorrect bulk update serialization should return error data.
-#         """
-#         data = [
-#             {
-#                 'id': 0,
-#                 'title': 'The electric kool-aid acid test',
-#                 'author': 'Tom Wolfe'
-#             }, {
-#                 'id': 'foo',
-#                 'title': 'Kafka on the shore',
-#                 'author': 'Haruki Murakami'
-#             }
-#         ]
-#         expected_errors = [
-#             {},
-#             {'id': ['Enter a whole number.']}
-#         ]
-#         serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, expected_errors)
diff --git a/tests/test_serializer_empty.py b/tests/test_serializer_empty.py
deleted file mode 100644
index 805ac7d4..00000000
--- a/tests/test_serializer_empty.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# from django.test import TestCase
-# from rest_framework import serializers
-
-
-# class EmptySerializerTestCase(TestCase):
-#     def test_empty_serializer(self):
-#         class FooBarSerializer(serializers.Serializer):
-#             foo = serializers.IntegerField()
-#             bar = serializers.SerializerMethodField()
-
-#             def get_bar(self, obj):
-#                 return 'bar'
-
-#         serializer = FooBarSerializer()
-#         self.assertEquals(serializer.data, {'foo': 0})
diff --git a/tests/test_serializer_nested.py b/tests/test_serializer_nested.py
index 5e207449..f5e4b26a 100644
--- a/tests/test_serializer_nested.py
+++ b/tests/test_serializer_nested.py
@@ -38,353 +38,3 @@ class TestNestedSerializer:
         }
         serializer = self.Serializer()
         assert serializer.data == expected_data
-
-# """
-# Tests to cover nested serializers.
-
-# Doesn't cover model serializers.
-# """
-# from __future__ import unicode_literals
-# from django.test import TestCase
-# from rest_framework import serializers
-# from . import models
-
-
-# class WritableNestedSerializerBasicTests(TestCase):
-#     """
-#     Tests for deserializing nested entities.
-#     Basic tests that use serializers that simply restore to dicts.
-#     """
-
-#     def setUp(self):
-#         class TrackSerializer(serializers.Serializer):
-#             order = serializers.IntegerField()
-#             title = serializers.CharField(max_length=100)
-#             duration = serializers.IntegerField()
-
-#         class AlbumSerializer(serializers.Serializer):
-#             album_name = serializers.CharField(max_length=100)
-#             artist = serializers.CharField(max_length=100)
-#             tracks = TrackSerializer(many=True)
-
-#         self.AlbumSerializer = AlbumSerializer
-
-#     def test_nested_validation_success(self):
-#         """
-#         Correct nested serialization should return the input data.
-#         """
-
-#         data = {
-#             'album_name': 'Discovery',
-#             'artist': 'Daft Punk',
-#             'tracks': [
-#                 {'order': 1, 'title': 'One More Time', 'duration': 235},
-#                 {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
-#                 {'order': 3, 'title': 'Digital Love', 'duration': 239}
-#             ]
-#         }
-
-#         serializer = self.AlbumSerializer(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, data)
-
-#     def test_nested_validation_error(self):
-#         """
-#         Incorrect nested serialization should return appropriate error data.
-#         """
-
-#         data = {
-#             'album_name': 'Discovery',
-#             'artist': 'Daft Punk',
-#             'tracks': [
-#                 {'order': 1, 'title': 'One More Time', 'duration': 235},
-#                 {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
-#                 {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'}
-#             ]
-#         }
-#         expected_errors = {
-#             'tracks': [
-#                 {},
-#                 {},
-#                 {'duration': ['Enter a whole number.']}
-#             ]
-#         }
-
-#         serializer = self.AlbumSerializer(data=data)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, expected_errors)
-
-#     def test_many_nested_validation_error(self):
-#         """
-#         Incorrect nested serialization should return appropriate error data
-#         when multiple entities are being deserialized.
-#         """
-
-#         data = [
-#             {
-#                 'album_name': 'Russian Red',
-#                 'artist': 'I Love Your Glasses',
-#                 'tracks': [
-#                     {'order': 1, 'title': 'Cigarettes', 'duration': 121},
-#                     {'order': 2, 'title': 'No Past Land', 'duration': 198},
-#                     {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191}
-#                 ]
-#             },
-#             {
-#                 'album_name': 'Discovery',
-#                 'artist': 'Daft Punk',
-#                 'tracks': [
-#                     {'order': 1, 'title': 'One More Time', 'duration': 235},
-#                     {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
-#                     {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'}
-#                 ]
-#             }
-#         ]
-#         expected_errors = [
-#             {},
-#             {
-#                 'tracks': [
-#                     {},
-#                     {},
-#                     {'duration': ['Enter a whole number.']}
-#                 ]
-#             }
-#         ]
-
-#         serializer = self.AlbumSerializer(data=data, many=True)
-#         self.assertEqual(serializer.is_valid(), False)
-#         self.assertEqual(serializer.errors, expected_errors)
-
-
-# class WritableNestedSerializerObjectTests(TestCase):
-#     """
-#     Tests for deserializing nested entities.
-#     These tests use serializers that restore to concrete objects.
-#     """
-
-#     def setUp(self):
-#         # Couple of concrete objects that we're going to deserialize into
-#         class Track(object):
-#             def __init__(self, order, title, duration):
-#                 self.order, self.title, self.duration = order, title, duration
-
-#             def __eq__(self, other):
-#                 return (
-#                     self.order == other.order and
-#                     self.title == other.title and
-#                     self.duration == other.duration
-#                 )
-
-#         class Album(object):
-#             def __init__(self, album_name, artist, tracks):
-#                 self.album_name, self.artist, self.tracks = album_name, artist, tracks
-
-#             def __eq__(self, other):
-#                 return (
-#                     self.album_name == other.album_name and
-#                     self.artist == other.artist and
-#                     self.tracks == other.tracks
-#                 )
-
-#         # And their corresponding serializers
-#         class TrackSerializer(serializers.Serializer):
-#             order = serializers.IntegerField()
-#             title = serializers.CharField(max_length=100)
-#             duration = serializers.IntegerField()
-
-#             def restore_object(self, attrs, instance=None):
-#                 return Track(attrs['order'], attrs['title'], attrs['duration'])
-
-#         class AlbumSerializer(serializers.Serializer):
-#             album_name = serializers.CharField(max_length=100)
-#             artist = serializers.CharField(max_length=100)
-#             tracks = TrackSerializer(many=True)
-
-#             def restore_object(self, attrs, instance=None):
-#                 return Album(attrs['album_name'], attrs['artist'], attrs['tracks'])
-
-#         self.Album, self.Track = Album, Track
-#         self.AlbumSerializer = AlbumSerializer
-
-#     def test_nested_validation_success(self):
-#         """
-#         Correct nested serialization should return a restored object
-#         that corresponds to the input data.
-#         """
-
-#         data = {
-#             'album_name': 'Discovery',
-#             'artist': 'Daft Punk',
-#             'tracks': [
-#                 {'order': 1, 'title': 'One More Time', 'duration': 235},
-#                 {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
-#                 {'order': 3, 'title': 'Digital Love', 'duration': 239}
-#             ]
-#         }
-#         expected_object = self.Album(
-#             album_name='Discovery',
-#             artist='Daft Punk',
-#             tracks=[
-#                 self.Track(order=1, title='One More Time', duration=235),
-#                 self.Track(order=2, title='Aerodynamic', duration=184),
-#                 self.Track(order=3, title='Digital Love', duration=239),
-#             ]
-#         )
-
-#         serializer = self.AlbumSerializer(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, expected_object)
-
-#     def test_many_nested_validation_success(self):
-#         """
-#         Correct nested serialization should return multiple restored objects
-#         that corresponds to the input data when multiple objects are
-#         being deserialized.
-#         """
-
-#         data = [
-#             {
-#                 'album_name': 'Russian Red',
-#                 'artist': 'I Love Your Glasses',
-#                 'tracks': [
-#                     {'order': 1, 'title': 'Cigarettes', 'duration': 121},
-#                     {'order': 2, 'title': 'No Past Land', 'duration': 198},
-#                     {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191}
-#                 ]
-#             },
-#             {
-#                 'album_name': 'Discovery',
-#                 'artist': 'Daft Punk',
-#                 'tracks': [
-#                     {'order': 1, 'title': 'One More Time', 'duration': 235},
-#                     {'order': 2, 'title': 'Aerodynamic', 'duration': 184},
-#                     {'order': 3, 'title': 'Digital Love', 'duration': 239}
-#                 ]
-#             }
-#         ]
-#         expected_object = [
-#             self.Album(
-#                 album_name='Russian Red',
-#                 artist='I Love Your Glasses',
-#                 tracks=[
-#                     self.Track(order=1, title='Cigarettes', duration=121),
-#                     self.Track(order=2, title='No Past Land', duration=198),
-#                     self.Track(order=3, title='They Don\'t Believe', duration=191),
-#                 ]
-#             ),
-#             self.Album(
-#                 album_name='Discovery',
-#                 artist='Daft Punk',
-#                 tracks=[
-#                     self.Track(order=1, title='One More Time', duration=235),
-#                     self.Track(order=2, title='Aerodynamic', duration=184),
-#                     self.Track(order=3, title='Digital Love', duration=239),
-#                 ]
-#             )
-#         ]
-
-#         serializer = self.AlbumSerializer(data=data, many=True)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, expected_object)
-
-
-# class ForeignKeyNestedSerializerUpdateTests(TestCase):
-#     def setUp(self):
-#         class Artist(object):
-#             def __init__(self, name):
-#                 self.name = name
-
-#             def __eq__(self, other):
-#                 return self.name == other.name
-
-#         class Album(object):
-#             def __init__(self, name, artist):
-#                 self.name, self.artist = name, artist
-
-#             def __eq__(self, other):
-#                 return self.name == other.name and self.artist == other.artist
-
-#         class ArtistSerializer(serializers.Serializer):
-#             name = serializers.CharField()
-
-#             def restore_object(self, attrs, instance=None):
-#                 if instance:
-#                     instance.name = attrs['name']
-#                 else:
-#                     instance = Artist(attrs['name'])
-#                 return instance
-
-#         class AlbumSerializer(serializers.Serializer):
-#             name = serializers.CharField()
-#             by = ArtistSerializer(source='artist')
-
-#             def restore_object(self, attrs, instance=None):
-#                 if instance:
-#                     instance.name = attrs['name']
-#                     instance.artist = attrs['artist']
-#                 else:
-#                     instance = Album(attrs['name'], attrs['artist'])
-#                 return instance
-
-#         self.Artist = Artist
-#         self.Album = Album
-#         self.AlbumSerializer = AlbumSerializer
-
-#     def test_create_via_foreign_key_with_source(self):
-#         """
-#         Check that we can both *create* and *update* into objects across
-#         ForeignKeys that have a `source` specified.
-#         Regression test for #1170
-#         """
-#         data = {
-#             'name': 'Discovery',
-#             'by': {'name': 'Daft Punk'},
-#         }
-
-#         expected = self.Album(artist=self.Artist('Daft Punk'), name='Discovery')
-
-#         # create
-#         serializer = self.AlbumSerializer(data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, expected)
-
-#         # update
-#         original = self.Album(artist=self.Artist('The Bats'), name='Free All the Monsters')
-#         serializer = self.AlbumSerializer(instance=original, data=data)
-#         self.assertEqual(serializer.is_valid(), True)
-#         self.assertEqual(serializer.object, expected)
-
-
-# class NestedModelSerializerUpdateTests(TestCase):
-#     def test_second_nested_level(self):
-#         john = models.Person.objects.create(name="john")
-
-#         post = john.blogpost_set.create(title="Test blog post")
-#         post.blogpostcomment_set.create(text="I hate this blog post")
-#         post.blogpostcomment_set.create(text="I love this blog post")
-
-#         class BlogPostCommentSerializer(serializers.ModelSerializer):
-#             class Meta:
-#                 model = models.BlogPostComment
-
-#         class BlogPostSerializer(serializers.ModelSerializer):
-#             comments = BlogPostCommentSerializer(many=True, source='blogpostcomment_set')
-
-#             class Meta:
-#                 model = models.BlogPost
-#                 fields = ('id', 'title', 'comments')
-
-#         class PersonSerializer(serializers.ModelSerializer):
-#             posts = BlogPostSerializer(many=True, source='blogpost_set')
-
-#             class Meta:
-#                 model = models.Person
-#                 fields = ('id', 'name', 'age', 'posts')
-
-#         serialize = PersonSerializer(instance=john)
-#         deserialize = PersonSerializer(data=serialize.data, instance=john)
-#         self.assertTrue(deserialize.is_valid())
-
-#         result = deserialize.object
-#         result.save()
-#         self.assertEqual(result.id, john.id)
diff --git a/tests/test_validation.py b/tests/test_validation.py
index 3db82555..4234efd3 100644
--- a/tests/test_validation.py
+++ b/tests/test_validation.py
@@ -165,17 +165,6 @@ class TestChoiceFieldChoicesValidate(TestCase):
         except serializers.ValidationError:
             self.fail("Value %s does not validate" % str(value))
 
-    # def test_nested_choices(self):
-    #     """
-    #     Make sure a nested value for choices works as expected.
-    #     """
-    #     f = serializers.ChoiceField(choices=self.CHOICES_NESTED)
-    #     value = self.CHOICES_NESTED[0][1][0][0]
-    #     try:
-    #         f.to_native(value)
-    #     except ValidationError:
-    #         self.fail("Value %s does not validate" % str(value))
-
 
 class RegexSerializer(serializers.Serializer):
     pin = serializers.CharField(