from rest_framework import serializers
import pytest


# Tests for core functionality.
# -----------------------------

class TestSerializer:
    def setup(self):
        class ExampleSerializer(serializers.Serializer):
            char = serializers.CharField()
            integer = serializers.IntegerField()
        self.Serializer = ExampleSerializer

    def test_valid_serializer(self):
        serializer = self.Serializer(data={'char': 'abc', 'integer': 123})
        assert serializer.is_valid()
        assert serializer.validated_data == {'char': 'abc', 'integer': 123}
        assert serializer.errors == {}

    def test_invalid_serializer(self):
        serializer = self.Serializer(data={'char': 'abc'})
        assert not serializer.is_valid()
        assert serializer.validated_data == {}
        assert serializer.errors == {'integer': ['This field is required.']}

    def test_partial_validation(self):
        serializer = self.Serializer(data={'char': 'abc'}, partial=True)
        assert serializer.is_valid()
        assert serializer.validated_data == {'char': 'abc'}
        assert serializer.errors == {}

    def test_empty_serializer(self):
        serializer = self.Serializer()
        assert serializer.data == {'char': '', 'integer': None}

    def test_missing_attribute_during_serialization(self):
        class MissingAttributes:
            pass
        instance = MissingAttributes()
        serializer = self.Serializer(instance)
        with pytest.raises(AttributeError):
            serializer.data


class TestBaseSerializer:
    def setup(self):
        class ExampleSerializer(serializers.BaseSerializer):
            def to_representation(self, obj):
                return {
                    'id': obj['id'],
                    'email': obj['name'] + '@' + obj['domain']
                }

            def to_internal_value(self, data):
                name, domain = str(data['email']).split('@')
                return {
                    'id': int(data['id']),
                    'name': name,
                    'domain': domain,
                }

        self.Serializer = ExampleSerializer

    def test_serialize_instance(self):
        instance = {'id': 1, 'name': 'tom', 'domain': 'example.com'}
        serializer = self.Serializer(instance)
        assert serializer.data == {'id': 1, 'email': 'tom@example.com'}

    def test_serialize_list(self):
        instances = [
            {'id': 1, 'name': 'tom', 'domain': 'example.com'},
            {'id': 2, 'name': 'ann', 'domain': 'example.com'},
        ]
        serializer = self.Serializer(instances, many=True)
        assert serializer.data == [
            {'id': 1, 'email': 'tom@example.com'},
            {'id': 2, 'email': 'ann@example.com'}
        ]

    def test_validate_data(self):
        data = {'id': 1, 'email': 'tom@example.com'}
        serializer = self.Serializer(data=data)
        assert serializer.is_valid()
        assert serializer.validated_data == {
            'id': 1,
            'name': 'tom',
            'domain': 'example.com'
        }

    def test_validate_list(self):
        data = [
            {'id': 1, 'email': 'tom@example.com'},
            {'id': 2, 'email': 'ann@example.com'},
        ]
        serializer = self.Serializer(data=data, many=True)
        assert serializer.is_valid()
        assert serializer.validated_data == [
            {'id': 1, 'name': 'tom', 'domain': 'example.com'},
            {'id': 2, 'name': 'ann', 'domain': 'example.com'}
        ]


class TestStarredSource:
    """
    Tests for `source='*'` argument, which is used for nested representations.

    For example:

        nested_field = NestedField(source='*')
    """
    data = {
        'nested1': {'a': 1, 'b': 2},
        'nested2': {'c': 3, 'd': 4}
    }

    def setup(self):
        class NestedSerializer1(serializers.Serializer):
            a = serializers.IntegerField()
            b = serializers.IntegerField()

        class NestedSerializer2(serializers.Serializer):
            c = serializers.IntegerField()
            d = serializers.IntegerField()

        class TestSerializer(serializers.Serializer):
            nested1 = NestedSerializer1(source='*')
            nested2 = NestedSerializer2(source='*')

        self.Serializer = TestSerializer

    def test_nested_validate(self):
        """
        A nested representation is validated into a flat internal object.
        """
        serializer = self.Serializer(data=self.data)
        assert serializer.is_valid()
        assert serializer.validated_data == {
            'a': 1,
            'b': 2,
            'c': 3,
            'd': 4
        }

    def test_nested_serialize(self):
        """
        An object can be serialized into a nested representation.
        """
        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)
