django-rest-framework/tests/test_fields.py

from decimal import Decimal
from django.utils import timezone
from rest_framework import fields
import datetime
import pytest


def get_items(mapping_or_list_of_two_tuples):
    # Tests accept either lists of two tuples, or dictionaries.
    if isinstance(mapping_or_list_of_two_tuples, dict):
        # {value: expected}
        return mapping_or_list_of_two_tuples.items()
    # [(value, expected), ...]
    return mapping_or_list_of_two_tuples


class FieldValues:
    """
    Base class for testing valid and invalid input values.
    """
    def test_valid_inputs(self):
        """
        Ensure that valid values return the expected validated data.
        """
        for input_value, expected_output in get_items(self.valid_inputs):
            assert self.field.run_validation(input_value) == expected_output

    def test_invalid_inputs(self):
        """
        Ensure that invalid values raise the expected validation error.
        """
        for input_value, expected_failure in get_items(self.invalid_inputs):
            with pytest.raises(fields.ValidationError) as exc_info:
                self.field.run_validation(input_value)
            assert exc_info.value.messages == expected_failure

    def test_outputs(self):
        for output_value, expected_output in get_items(self.outputs):
            assert self.field.to_representation(output_value) == expected_output


# Boolean types...

class TestBooleanField(FieldValues):
    valid_inputs = {
        'true': True,
        'false': False,
        '1': True,
        '0': False,
        1: True,
        0: False,
        True: True,
        False: False,
    }
    invalid_inputs = {
        'foo': ['`foo` is not a valid boolean.']
    }
    outputs = {
        'true': True,
        'false': False,
        '1': True,
        '0': False,
        1: True,
        0: False,
        True: True,
        False: False,
        'other': True
    }
    field = fields.BooleanField()


# String types...

class TestCharField(FieldValues):
    valid_inputs = {
        1: '1',
        'abc': 'abc'
    }
    invalid_inputs = {
        '': ['This field may not be blank.']
    }
    outputs = {
        1: '1',
        'abc': 'abc'
    }
    field = fields.CharField()


class TestEmailField(FieldValues):
    valid_inputs = {
        'example@example.com': 'example@example.com',
        ' example@example.com ': 'example@example.com',
    }
    invalid_inputs = {
        'example.com': ['Enter a valid email address.']
    }
    outputs = {}
    field = fields.EmailField()


class TestRegexField(FieldValues):
    valid_inputs = {
        'a9': 'a9',
    }
    invalid_inputs = {
        'A9': ["This value does not match the required pattern."]
    }
    outputs = {}
    field = fields.RegexField(regex='[a-z][0-9]')


class TestSlugField(FieldValues):
    valid_inputs = {
        'slug-99': 'slug-99',
    }
    invalid_inputs = {
        'slug 99': ["Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."]
    }
    outputs = {}
    field = fields.SlugField()


class TestURLField(FieldValues):
    valid_inputs = {
        'http://example.com': 'http://example.com',
    }
    invalid_inputs = {
        'example.com': ['Enter a valid URL.']
    }
    outputs = {}
    field = fields.URLField()


# Number types...

class TestIntegerField(FieldValues):
    """
    Valid and invalid values for `IntegerField`.
    """
    valid_inputs = {
        '1': 1,
        '0': 0,
        1: 1,
        0: 0,
        1.0: 1,
        0.0: 0
    }
    invalid_inputs = {
        'abc': ['A valid integer is required.']
    }
    outputs = {
        '1': 1,
        '0': 0,
        1: 1,
        0: 0,
        1.0: 1,
        0.0: 0
    }
    field = fields.IntegerField()


class TestMinMaxIntegerField(FieldValues):
    """
    Valid and invalid values for `IntegerField` with min and max limits.
    """
    valid_inputs = {
        '1': 1,
        '3': 3,
        1: 1,
        3: 3,
    }
    invalid_inputs = {
        0: ['Ensure this value is greater than or equal to 1.'],
        4: ['Ensure this value is less than or equal to 3.'],
        '0': ['Ensure this value is greater than or equal to 1.'],
        '4': ['Ensure this value is less than or equal to 3.'],
    }
    outputs = {}
    field = fields.IntegerField(min_value=1, max_value=3)


class TestFloatField(FieldValues):
    """
    Valid and invalid values for `FloatField`.
    """
    valid_inputs = {
        '1': 1.0,
        '0': 0.0,
        1: 1.0,
        0: 0.0,
        1.0: 1.0,
        0.0: 0.0,
    }
    invalid_inputs = {
        'abc': ["A valid number is required."]
    }
    outputs = {
        '1': 1.0,
        '0': 0.0,
        1: 1.0,
        0: 0.0,
        1.0: 1.0,
        0.0: 0.0,
    }
    field = fields.FloatField()


class TestMinMaxFloatField(FieldValues):
    """
    Valid and invalid values for `FloatField` with min and max limits.
    """
    valid_inputs = {
        '1': 1,
        '3': 3,
        1: 1,
        3: 3,
        1.0: 1.0,
        3.0: 3.0,
    }
    invalid_inputs = {
        0.9: ['Ensure this value is greater than or equal to 1.'],
        3.1: ['Ensure this value is less than or equal to 3.'],
        '0.0': ['Ensure this value is greater than or equal to 1.'],
        '3.1': ['Ensure this value is less than or equal to 3.'],
    }
    outputs = {}
    field = fields.FloatField(min_value=1, max_value=3)


class TestDecimalField(FieldValues):
    """
    Valid and invalid values for `DecimalField`.
    """
    valid_inputs = {
        '12.3': Decimal('12.3'),
        '0.1': Decimal('0.1'),
        10: Decimal('10'),
        0: Decimal('0'),
        12.3: Decimal('12.3'),
        0.1: Decimal('0.1'),
    }
    invalid_inputs = (
        ('abc', ["A valid number is required."]),
        (Decimal('Nan'), ["A valid number is required."]),
        (Decimal('Inf'), ["A valid number is required."]),
        ('12.345', ["Ensure that there are no more than 3 digits in total."]),
        ('0.01', ["Ensure that there are no more than 1 decimal places."]),
        (123, ["Ensure that there are no more than 2 digits before the decimal point."])
    )
    outputs = {
        '1': '1.0',
        '0': '0.0',
        '1.09': '1.1',
        '0.04': '0.0',
        1: '1.0',
        0: '0.0',
        Decimal('1.0'): '1.0',
        Decimal('0.0'): '0.0',
        Decimal('1.09'): '1.1',
        Decimal('0.04'): '0.0',
    }
    field = fields.DecimalField(max_digits=3, decimal_places=1)


class TestMinMaxDecimalField(FieldValues):
    """
    Valid and invalid values for `DecimalField` with min and max limits.
    """
    valid_inputs = {
        '10.0': 10.0,
        '20.0': 20.0,
    }
    invalid_inputs = {
        '9.9': ['Ensure this value is greater than or equal to 10.'],
        '20.1': ['Ensure this value is less than or equal to 20.'],
    }
    outputs = {}
    field = fields.DecimalField(
        max_digits=3, decimal_places=1,
        min_value=10, max_value=20
    )


class TestNoStringCoercionDecimalField(FieldValues):
    """
    Output values for `DecimalField` with `coerce_to_string=False`.
    """
    valid_inputs = {}
    invalid_inputs = {}
    outputs = {
        1.09: Decimal('1.1'),
        0.04: Decimal('0.0'),
        '1.09': Decimal('1.1'),
        '0.04': Decimal('0.0'),
        Decimal('1.09'): Decimal('1.1'),
        Decimal('0.04'): Decimal('0.0'),
    }
    field = fields.DecimalField(
        max_digits=3, decimal_places=1,
        coerce_to_string=False
    )


# Date & time fields...

class TestDateField(FieldValues):
    """
    Valid and invalid values for `DateField`.
    """
    valid_inputs = {
        '2001-01-01': datetime.date(2001, 1, 1),
        datetime.date(2001, 1, 1): datetime.date(2001, 1, 1),
    }
    invalid_inputs = {
        'abc': ['Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]'],
        '2001-99-99': ['Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]'],
        datetime.datetime(2001, 1, 1, 12, 00): ['Expected a date but got a datetime.'],
    }
    outputs = {}
    field = fields.DateField()


class TestCustomInputFormatDateField(FieldValues):
    """
    Valid and invalid values for `DateField` with a cutom input format.
    """
    valid_inputs = {
        '1 Jan 2001': datetime.date(2001, 1, 1),
    }
    invalid_inputs = {
        '2001-01-01': ['Date has wrong format. Use one of these formats instead: DD [Jan-Dec] YYYY']
    }
    outputs = {}
    field = fields.DateField(input_formats=['%d %b %Y'])


class TestDateTimeField(FieldValues):
    """
    Valid and invalid values for `DateTimeField`.
    """
    valid_inputs = {
        '2001-01-01 13:00': datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
        '2001-01-01T13:00': datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
        '2001-01-01T13:00Z': datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
        '2001-01-01T14:00+0100': datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
        datetime.datetime(2001, 1, 1, 13, 00): datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
        datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()),
    }
    invalid_inputs = {
        'abc': ['Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]'],
        '2001-99-99T99:00': ['Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]'],
        datetime.date(2001, 1, 1): ['Expected a datetime but got a date.'],
    }
    outputs = {}
    field = fields.DateTimeField(default_timezone=timezone.UTC())


class TestCustomInputFormatDateTimeField(FieldValues):
    """
    Valid and invalid values for `DateTimeField` with a cutom input format.
    """
    valid_inputs = {
        '1:35pm, 1 Jan 2001': datetime.datetime(2001, 1, 1, 13, 35, tzinfo=timezone.UTC()),
    }
    invalid_inputs = {
        '2001-01-01T20:50': ['Datetime has wrong format. Use one of these formats instead: hh:mm[AM|PM], DD [Jan-Dec] YYYY']
    }
    outputs = {}
    field = fields.DateTimeField(default_timezone=timezone.UTC(), input_formats=['%I:%M%p, %d %b %Y'])


class TestNaiveDateTimeField(FieldValues):
    """
    Valid and invalid values for `DateTimeField` with naive datetimes.
    """
    valid_inputs = {
        datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): datetime.datetime(2001, 1, 1, 13, 00),
        '2001-01-01 13:00': datetime.datetime(2001, 1, 1, 13, 00),
    }
    invalid_inputs = {}
    outputs = {}
    field = fields.DateTimeField(default_timezone=None)


class TestTimeField(FieldValues):
    """
    Valid and invalid values for `TimeField`.
    """
    valid_inputs = {
        '13:00': datetime.time(13, 00),
        datetime.time(13, 00): datetime.time(13, 00),
    }
    invalid_inputs = {
        'abc': ['Time has wrong format. Use one of these formats instead: hh:mm[:ss[.uuuuuu]]'],
        '99:99': ['Time has wrong format. Use one of these formats instead: hh:mm[:ss[.uuuuuu]]'],
    }
    outputs = {}
    field = fields.TimeField()


class TestCustomInputFormatTimeField(FieldValues):
    """
    Valid and invalid values for `TimeField` with a custom input format.
    """
    valid_inputs = {
        '1:00pm': datetime.time(13, 00),
    }
    invalid_inputs = {
        '13:00': ['Time has wrong format. Use one of these formats instead: hh:mm[AM|PM]'],
    }
    outputs = {}
    field = fields.TimeField(input_formats=['%I:%M%p'])


# Choice types...

class TestChoiceField(FieldValues):
    """
    Valid and invalid values for `ChoiceField`.
    """
    valid_inputs = {
        'poor': 'poor',
        'medium': 'medium',
        'good': 'good',
    }
    invalid_inputs = {
        'awful': ['`awful` is not a valid choice.']
    }
    outputs = {}
    field = fields.ChoiceField(
        choices=[
            ('poor', 'Poor quality'),
            ('medium', 'Medium quality'),
            ('good', 'Good quality'),
        ]
    )


class TestChoiceFieldWithType(FieldValues):
    """
    Valid and invalid values for a `Choice` field that uses an integer type,
    instead of a char type.
    """
    valid_inputs = {
        '1': 1,
        3: 3,
    }
    invalid_inputs = {
        5: ['`5` is not a valid choice.'],
        'abc': ['`abc` is not a valid choice.']
    }
    outputs = {}
    field = fields.ChoiceField(
        choices=[
            (1, 'Poor quality'),
            (2, 'Medium quality'),
            (3, 'Good quality'),
        ]
    )


class TestChoiceFieldWithListChoices(FieldValues):
    """
    Valid and invalid values for a `Choice` field that uses a flat list for the
    choices, rather than a list of pairs of (`value`, `description`).
    """
    valid_inputs = {
        'poor': 'poor',
        'medium': 'medium',
        'good': 'good',
    }
    invalid_inputs = {
        'awful': ['`awful` is not a valid choice.']
    }
    outputs = {}
    field = fields.ChoiceField(choices=('poor', 'medium', 'good'))


class TestMultipleChoiceField(FieldValues):
    """
    Valid and invalid values for `MultipleChoiceField`.
    """
    valid_inputs = {
        (): set(),
        ('aircon',): set(['aircon']),
        ('aircon', 'manual'): set(['aircon', 'manual']),
    }
    invalid_inputs = {
        'abc': ['Expected a list of items but got type `str`'],
        ('aircon', 'incorrect'): ['`incorrect` is not a valid choice.']
    }
    outputs = {}
    field = fields.MultipleChoiceField(
        choices=[
            ('aircon', 'AirCon'),
            ('manual', 'Manual drive'),
            ('diesel', 'Diesel'),
        ]
    )


# """
# General serializer field tests.
# """
# from __future__ import unicode_literals

# import datetime
# import re
# from decimal import Decimal
# from uuid import uuid4
# from django.core import validators
# from django.db import models
# from django.test import TestCase
# from django.utils.datastructures import SortedDict
# from rest_framework import serializers
# from tests.models import RESTFrameworkModel


# class TimestampedModel(models.Model):
#     added = models.DateTimeField(auto_now_add=True)
#     updated = models.DateTimeField(auto_now=True)


# class CharPrimaryKeyModel(models.Model):
#     id = models.CharField(max_length=20, primary_key=True)


# class TimestampedModelSerializer(serializers.ModelSerializer):
#     class Meta:
#         model = TimestampedModel


# class CharPrimaryKeyModelSerializer(serializers.ModelSerializer):
#     class Meta:
#         model = CharPrimaryKeyModel


# class TimeFieldModel(models.Model):
#     clock = models.TimeField()


# class TimeFieldModelSerializer(serializers.ModelSerializer):
#     class Meta:
#         model = TimeFieldModel


# SAMPLE_CHOICES = [
#     ('red', 'Red'),
#     ('green', 'Green'),
#     ('blue', 'Blue'),
# ]


# class ChoiceFieldModel(models.Model):
#     choice = models.CharField(choices=SAMPLE_CHOICES, blank=True, max_length=255)


# class ChoiceFieldModelSerializer(serializers.ModelSerializer):
#     class Meta:
#         model = ChoiceFieldModel


# class ChoiceFieldModelWithNull(models.Model):
#     choice = models.CharField(choices=SAMPLE_CHOICES, blank=True, null=True, max_length=255)


# class ChoiceFieldModelWithNullSerializer(serializers.ModelSerializer):
#     class Meta:
#         model = ChoiceFieldModelWithNull


# class BasicFieldTests(TestCase):
#     def test_auto_now_fields_read_only(self):
#         """
#         auto_now and auto_now_add fields should be read_only by default.
#         """
#         serializer = TimestampedModelSerializer()
#         self.assertEqual(serializer.fields['added'].read_only, True)

#     def test_auto_pk_fields_read_only(self):
#         """
#         AutoField fields should be read_only by default.
#         """
#         serializer = TimestampedModelSerializer()
#         self.assertEqual(serializer.fields['id'].read_only, True)

#     def test_non_auto_pk_fields_not_read_only(self):
#         """
#         PK fields other than AutoField fields should not be read_only by default.
#         """
#         serializer = CharPrimaryKeyModelSerializer()
#         self.assertEqual(serializer.fields['id'].read_only, False)

#     def test_dict_field_ordering(self):
#         """
#         Field should preserve dictionary ordering, if it exists.
#         See: https://github.com/tomchristie/django-rest-framework/issues/832
#         """
#         ret = SortedDict()
#         ret['c'] = 1
#         ret['b'] = 1
#         ret['a'] = 1
#         ret['z'] = 1
#         field = serializers.Field()
#         keys = list(field.to_native(ret).keys())
#         self.assertEqual(keys, ['c', 'b', 'a', 'z'])

#     def test_widget_html_attributes(self):
#         """
#         Make sure widget_html() renders the correct attributes
#         """
#         r = re.compile('(\S+)=["\']?((?:.(?!["\']?\s+(?:\S+)=|[>"\']))+.)["\']?')
#         form = TimeFieldModelSerializer().data
#         attributes = r.findall(form.fields['clock'].widget_html())
#         self.assertIn(('name', 'clock'), attributes)
#         self.assertIn(('id', 'clock'), attributes)


# class DateFieldTest(TestCase):
#     """
#     Tests for the DateFieldTest from_native() and to_native() behavior
#     """

#     def test_from_native_string(self):
#         """
#         Make sure from_native() accepts default iso input formats.
#         """
#         f = serializers.DateField()
#         result_1 = f.from_native('1984-07-31')

#         self.assertEqual(datetime.date(1984, 7, 31), result_1)

#     def test_from_native_datetime_date(self):
#         """
#         Make sure from_native() accepts a datetime.date instance.
#         """
#         f = serializers.DateField()
#         result_1 = f.from_native(datetime.date(1984, 7, 31))

#         self.assertEqual(result_1, datetime.date(1984, 7, 31))

#     def test_from_native_custom_format(self):
#         """
#         Make sure from_native() accepts custom input formats.
#         """
#         f = serializers.DateField(input_formats=['%Y -- %d'])
#         result = f.from_native('1984 -- 31')

#         self.assertEqual(datetime.date(1984, 1, 31), result)

#     def test_from_native_invalid_default_on_custom_format(self):
#         """
#         Make sure from_native() don't accept default formats if custom format is preset
#         """
#         f = serializers.DateField(input_formats=['%Y -- %d'])

#         try:
#             f.from_native('1984-07-31')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY -- DD"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_from_native_empty(self):
#         """
#         Make sure from_native() returns None on empty param.
#         """
#         f = serializers.DateField()
#         result = f.from_native('')

#         self.assertEqual(result, None)

#     def test_from_native_none(self):
#         """
#         Make sure from_native() returns None on None param.
#         """
#         f = serializers.DateField()
#         result = f.from_native(None)

#         self.assertEqual(result, None)

#     def test_from_native_invalid_date(self):
#         """
#         Make sure from_native() raises a ValidationError on passing an invalid date.
#         """
#         f = serializers.DateField()

#         try:
#             f.from_native('1984-13-31')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_from_native_invalid_format(self):
#         """
#         Make sure from_native() raises a ValidationError on passing an invalid format.
#         """
#         f = serializers.DateField()

#         try:
#             f.from_native('1984 -- 31')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_to_native(self):
#         """
#         Make sure to_native() returns datetime as default.
#         """
#         f = serializers.DateField()

#         result_1 = f.to_native(datetime.date(1984, 7, 31))

#         self.assertEqual(datetime.date(1984, 7, 31), result_1)

#     def test_to_native_iso(self):
#         """
#         Make sure to_native() with 'iso-8601' returns iso formated date.
#         """
#         f = serializers.DateField(format='iso-8601')

#         result_1 = f.to_native(datetime.date(1984, 7, 31))

#         self.assertEqual('1984-07-31', result_1)

#     def test_to_native_custom_format(self):
#         """
#         Make sure to_native() returns correct custom format.
#         """
#         f = serializers.DateField(format="%Y - %m.%d")

#         result_1 = f.to_native(datetime.date(1984, 7, 31))

#         self.assertEqual('1984 - 07.31', result_1)

#     def test_to_native_none(self):
#         """
#         Make sure from_native() returns None on None param.
#         """
#         f = serializers.DateField(required=False)
#         self.assertEqual(None, f.to_native(None))


# class DateTimeFieldTest(TestCase):
#     """
#     Tests for the DateTimeField from_native() and to_native() behavior
#     """

#     def test_from_native_string(self):
#         """
#         Make sure from_native() accepts default iso input formats.
#         """
#         f = serializers.DateTimeField()
#         result_1 = f.from_native('1984-07-31 04:31')
#         result_2 = f.from_native('1984-07-31 04:31:59')
#         result_3 = f.from_native('1984-07-31 04:31:59.000200')

#         self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31), result_1)
#         self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59), result_2)
#         self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59, 200), result_3)

#     def test_from_native_datetime_datetime(self):
#         """
#         Make sure from_native() accepts a datetime.datetime instance.
#         """
#         f = serializers.DateTimeField()
#         result_1 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31))
#         result_2 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31, 59))
#         result_3 = f.from_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200))

#         self.assertEqual(result_1, datetime.datetime(1984, 7, 31, 4, 31))
#         self.assertEqual(result_2, datetime.datetime(1984, 7, 31, 4, 31, 59))
#         self.assertEqual(result_3, datetime.datetime(1984, 7, 31, 4, 31, 59, 200))

#     def test_from_native_custom_format(self):
#         """
#         Make sure from_native() accepts custom input formats.
#         """
#         f = serializers.DateTimeField(input_formats=['%Y -- %H:%M'])
#         result = f.from_native('1984 -- 04:59')

#         self.assertEqual(datetime.datetime(1984, 1, 1, 4, 59), result)

#     def test_from_native_invalid_default_on_custom_format(self):
#         """
#         Make sure from_native() don't accept default formats if custom format is preset
#         """
#         f = serializers.DateTimeField(input_formats=['%Y -- %H:%M'])

#         try:
#             f.from_native('1984-07-31 04:31:59')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: YYYY -- hh:mm"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_from_native_empty(self):
#         """
#         Make sure from_native() returns None on empty param.
#         """
#         f = serializers.DateTimeField()
#         result = f.from_native('')

#         self.assertEqual(result, None)

#     def test_from_native_none(self):
#         """
#         Make sure from_native() returns None on None param.
#         """
#         f = serializers.DateTimeField()
#         result = f.from_native(None)

#         self.assertEqual(result, None)

#     def test_from_native_invalid_datetime(self):
#         """
#         Make sure from_native() raises a ValidationError on passing an invalid datetime.
#         """
#         f = serializers.DateTimeField()

#         try:
#             f.from_native('04:61:59')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: "
#                                           "YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_from_native_invalid_format(self):
#         """
#         Make sure from_native() raises a ValidationError on passing an invalid format.
#         """
#         f = serializers.DateTimeField()

#         try:
#             f.from_native('04 -- 31')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: "
#                                           "YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_to_native(self):
#         """
#         Make sure to_native() returns isoformat as default.
#         """
#         f = serializers.DateTimeField()

#         result_1 = f.to_native(datetime.datetime(1984, 7, 31))
#         result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31))
#         result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59))
#         result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200))

#         self.assertEqual(datetime.datetime(1984, 7, 31), result_1)
#         self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31), result_2)
#         self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59), result_3)
#         self.assertEqual(datetime.datetime(1984, 7, 31, 4, 31, 59, 200), result_4)

#     def test_to_native_iso(self):
#         """
#         Make sure to_native() with format=iso-8601 returns iso formatted datetime.
#         """
#         f = serializers.DateTimeField(format='iso-8601')

#         result_1 = f.to_native(datetime.datetime(1984, 7, 31))
#         result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31))
#         result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59))
#         result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200))

#         self.assertEqual('1984-07-31T00:00:00', result_1)
#         self.assertEqual('1984-07-31T04:31:00', result_2)
#         self.assertEqual('1984-07-31T04:31:59', result_3)
#         self.assertEqual('1984-07-31T04:31:59.000200', result_4)

#     def test_to_native_custom_format(self):
#         """
#         Make sure to_native() returns correct custom format.
#         """
#         f = serializers.DateTimeField(format="%Y - %H:%M")

#         result_1 = f.to_native(datetime.datetime(1984, 7, 31))
#         result_2 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31))
#         result_3 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59))
#         result_4 = f.to_native(datetime.datetime(1984, 7, 31, 4, 31, 59, 200))

#         self.assertEqual('1984 - 00:00', result_1)
#         self.assertEqual('1984 - 04:31', result_2)
#         self.assertEqual('1984 - 04:31', result_3)
#         self.assertEqual('1984 - 04:31', result_4)

#     def test_to_native_none(self):
#         """
#         Make sure from_native() returns None on None param.
#         """
#         f = serializers.DateTimeField(required=False)
#         self.assertEqual(None, f.to_native(None))


# class TimeFieldTest(TestCase):
#     """
#     Tests for the TimeField from_native() and to_native() behavior
#     """

#     def test_from_native_string(self):
#         """
#         Make sure from_native() accepts default iso input formats.
#         """
#         f = serializers.TimeField()
#         result_1 = f.from_native('04:31')
#         result_2 = f.from_native('04:31:59')
#         result_3 = f.from_native('04:31:59.000200')

#         self.assertEqual(datetime.time(4, 31), result_1)
#         self.assertEqual(datetime.time(4, 31, 59), result_2)
#         self.assertEqual(datetime.time(4, 31, 59, 200), result_3)

#     def test_from_native_datetime_time(self):
#         """
#         Make sure from_native() accepts a datetime.time instance.
#         """
#         f = serializers.TimeField()
#         result_1 = f.from_native(datetime.time(4, 31))
#         result_2 = f.from_native(datetime.time(4, 31, 59))
#         result_3 = f.from_native(datetime.time(4, 31, 59, 200))

#         self.assertEqual(result_1, datetime.time(4, 31))
#         self.assertEqual(result_2, datetime.time(4, 31, 59))
#         self.assertEqual(result_3, datetime.time(4, 31, 59, 200))

#     def test_from_native_custom_format(self):
#         """
#         Make sure from_native() accepts custom input formats.
#         """
#         f = serializers.TimeField(input_formats=['%H -- %M'])
#         result = f.from_native('04 -- 31')

#         self.assertEqual(datetime.time(4, 31), result)

#     def test_from_native_invalid_default_on_custom_format(self):
#         """
#         Make sure from_native() don't accept default formats if custom format is preset
#         """
#         f = serializers.TimeField(input_formats=['%H -- %M'])

#         try:
#             f.from_native('04:31:59')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: hh -- mm"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_from_native_empty(self):
#         """
#         Make sure from_native() returns None on empty param.
#         """
#         f = serializers.TimeField()
#         result = f.from_native('')

#         self.assertEqual(result, None)

#     def test_from_native_none(self):
#         """
#         Make sure from_native() returns None on None param.
#         """
#         f = serializers.TimeField()
#         result = f.from_native(None)

#         self.assertEqual(result, None)

#     def test_from_native_invalid_time(self):
#         """
#         Make sure from_native() raises a ValidationError on passing an invalid time.
#         """
#         f = serializers.TimeField()

#         try:
#             f.from_native('04:61:59')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: "
#                                           "hh:mm[:ss[.uuuuuu]]"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_from_native_invalid_format(self):
#         """
#         Make sure from_native() raises a ValidationError on passing an invalid format.
#         """
#         f = serializers.TimeField()

#         try:
#             f.from_native('04 -- 31')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: "
#                                           "hh:mm[:ss[.uuuuuu]]"])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_to_native(self):
#         """
#         Make sure to_native() returns time object as default.
#         """
#         f = serializers.TimeField()
#         result_1 = f.to_native(datetime.time(4, 31))
#         result_2 = f.to_native(datetime.time(4, 31, 59))
#         result_3 = f.to_native(datetime.time(4, 31, 59, 200))

#         self.assertEqual(datetime.time(4, 31), result_1)
#         self.assertEqual(datetime.time(4, 31, 59), result_2)
#         self.assertEqual(datetime.time(4, 31, 59, 200), result_3)

#     def test_to_native_iso(self):
#         """
#         Make sure to_native() with format='iso-8601' returns iso formatted time.
#         """
#         f = serializers.TimeField(format='iso-8601')
#         result_1 = f.to_native(datetime.time(4, 31))
#         result_2 = f.to_native(datetime.time(4, 31, 59))
#         result_3 = f.to_native(datetime.time(4, 31, 59, 200))

#         self.assertEqual('04:31:00', result_1)
#         self.assertEqual('04:31:59', result_2)
#         self.assertEqual('04:31:59.000200', result_3)

#     def test_to_native_custom_format(self):
#         """
#         Make sure to_native() returns correct custom format.
#         """
#         f = serializers.TimeField(format="%H - %S [%f]")
#         result_1 = f.to_native(datetime.time(4, 31))
#         result_2 = f.to_native(datetime.time(4, 31, 59))
#         result_3 = f.to_native(datetime.time(4, 31, 59, 200))

#         self.assertEqual('04 - 00 [000000]', result_1)
#         self.assertEqual('04 - 59 [000000]', result_2)
#         self.assertEqual('04 - 59 [000200]', result_3)


# class DecimalFieldTest(TestCase):
#     """
#     Tests for the DecimalField from_native() and to_native() behavior
#     """

#     def test_from_native_string(self):
#         """
#         Make sure from_native() accepts string values
#         """
#         f = serializers.DecimalField()
#         result_1 = f.from_native('9000')
#         result_2 = f.from_native('1.00000001')

#         self.assertEqual(Decimal('9000'), result_1)
#         self.assertEqual(Decimal('1.00000001'), result_2)

#     def test_from_native_invalid_string(self):
#         """
#         Make sure from_native() raises ValidationError on passing invalid string
#         """
#         f = serializers.DecimalField()

#         try:
#             f.from_native('123.45.6')
#         except validators.ValidationError as e:
#             self.assertEqual(e.messages, ["Enter a number."])
#         else:
#             self.fail("ValidationError was not properly raised")

#     def test_from_native_integer(self):
#         """
#         Make sure from_native() accepts integer values
#         """
#         f = serializers.DecimalField()
#         result = f.from_native(9000)

#         self.assertEqual(Decimal('9000'), result)

#     def test_from_native_float(self):
#         """
#         Make sure from_native() accepts float values
#         """
#         f = serializers.DecimalField()
#         result = f.from_native(1.00000001)

#         self.assertEqual(Decimal('1.00000001'), result)

#     def test_from_native_empty(self):
#         """
#         Make sure from_native() returns None on empty param.
#         """
#         f = serializers.DecimalField()
#         result = f.from_native('')

#         self.assertEqual(result, None)

#     def test_from_native_none(self):
#         """
#         Make sure from_native() returns None on None param.
#         """
#         f = serializers.DecimalField()
#         result = f.from_native(None)

#         self.assertEqual(result, None)

#     def test_to_native(self):
#         """
#         Make sure to_native() returns Decimal as string.
#         """
#         f = serializers.DecimalField()

#         result_1 = f.to_native(Decimal('9000'))
#         result_2 = f.to_native(Decimal('1.00000001'))

#         self.assertEqual(Decimal('9000'), result_1)
#         self.assertEqual(Decimal('1.00000001'), result_2)

#     def test_to_native_none(self):
#         """
#         Make sure from_native() returns None on None param.
#         """
#         f = serializers.DecimalField(required=False)
#         self.assertEqual(None, f.to_native(None))

#     def test_valid_serialization(self):
#         """
#         Make sure the serializer works correctly
#         """
#         class DecimalSerializer(serializers.Serializer):
#             decimal_field = serializers.DecimalField(max_value=9010,
#                                                      min_value=9000,
#                                                      max_digits=6,
#                                                      decimal_places=2)

#         self.assertTrue(DecimalSerializer(data={'decimal_field': '9001'}).is_valid())
#         self.assertTrue(DecimalSerializer(data={'decimal_field': '9001.2'}).is_valid())
#         self.assertTrue(DecimalSerializer(data={'decimal_field': '9001.23'}).is_valid())

#         self.assertFalse(DecimalSerializer(data={'decimal_field': '8000'}).is_valid())
#         self.assertFalse(DecimalSerializer(data={'decimal_field': '9900'}).is_valid())
#         self.assertFalse(DecimalSerializer(data={'decimal_field': '9001.234'}).is_valid())

#     def test_raise_max_value(self):
#         """
#         Make sure max_value violations raises ValidationError
#         """
#         class DecimalSerializer(serializers.Serializer):
#             decimal_field = serializers.DecimalField(max_value=100)

#         s = DecimalSerializer(data={'decimal_field': '123'})

#         self.assertFalse(s.is_valid())
#         self.assertEqual(s.errors, {'decimal_field': ['Ensure this value is less than or equal to 100.']})

#     def test_raise_min_value(self):
#         """
#         Make sure min_value violations raises ValidationError
#         """
#         class DecimalSerializer(serializers.Serializer):
#             decimal_field = serializers.DecimalField(min_value=100)

#         s = DecimalSerializer(data={'decimal_field': '99'})

#         self.assertFalse(s.is_valid())
#         self.assertEqual(s.errors, {'decimal_field': ['Ensure this value is greater than or equal to 100.']})

#     def test_raise_max_digits(self):
#         """
#         Make sure max_digits violations raises ValidationError
#         """
#         class DecimalSerializer(serializers.Serializer):
#             decimal_field = serializers.DecimalField(max_digits=5)

#         s = DecimalSerializer(data={'decimal_field': '123.456'})

#         self.assertFalse(s.is_valid())
#         self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 5 digits in total.']})

#     def test_raise_max_decimal_places(self):
#         """
#         Make sure max_decimal_places violations raises ValidationError
#         """
#         class DecimalSerializer(serializers.Serializer):
#             decimal_field = serializers.DecimalField(decimal_places=3)

#         s = DecimalSerializer(data={'decimal_field': '123.4567'})

#         self.assertFalse(s.is_valid())
#         self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 3 decimal places.']})

#     def test_raise_max_whole_digits(self):
#         """
#         Make sure max_whole_digits violations raises ValidationError
#         """
#         class DecimalSerializer(serializers.Serializer):
#             decimal_field = serializers.DecimalField(max_digits=4, decimal_places=3)

#         s = DecimalSerializer(data={'decimal_field': '12345.6'})

#         self.assertFalse(s.is_valid())
#         self.assertEqual(s.errors, {'decimal_field': ['Ensure that there are no more than 4 digits in total.']})


# class ChoiceFieldTests(TestCase):
#     """
#     Tests for the ChoiceField options generator
#     """
#     def test_choices_required(self):
#         """
#         Make sure proper choices are rendered if field is required
#         """
#         f = serializers.ChoiceField(required=True, choices=SAMPLE_CHOICES)
#         self.assertEqual(f.choices, SAMPLE_CHOICES)

#     def test_choices_not_required(self):
#         """
#         Make sure proper choices (plus blank) are rendered if the field isn't required
#         """
#         f = serializers.ChoiceField(required=False, choices=SAMPLE_CHOICES)
#         self.assertEqual(f.choices, models.fields.BLANK_CHOICE_DASH + SAMPLE_CHOICES)

#     def test_blank_choice_display(self):
#         blank = 'No Preference'
#         f = serializers.ChoiceField(
#             required=False,
#             choices=SAMPLE_CHOICES,
#             blank_display_value=blank,
#         )
#         self.assertEqual(f.choices, [('', blank)] + SAMPLE_CHOICES)

#     def test_invalid_choice_model(self):
#         s = ChoiceFieldModelSerializer(data={'choice': 'wrong_value'})
#         self.assertFalse(s.is_valid())
#         self.assertEqual(s.errors, {'choice': ['Select a valid choice. wrong_value is not one of the available choices.']})
#         self.assertEqual(s.data['choice'], '')

#     def test_empty_choice_model(self):
#         """
#         Test that the 'empty' value is correctly passed and used depending on
#         the 'null' property on the model field.
#         """
#         s = ChoiceFieldModelSerializer(data={'choice': ''})
#         self.assertTrue(s.is_valid())
#         self.assertEqual(s.data['choice'], '')

#         s = ChoiceFieldModelWithNullSerializer(data={'choice': ''})
#         self.assertTrue(s.is_valid())
#         self.assertEqual(s.data['choice'], None)

#     def test_from_native_empty(self):
#         """
#         Make sure from_native() returns an empty string on empty param by default.
#         """
#         f = serializers.ChoiceField(choices=SAMPLE_CHOICES)
#         self.assertEqual(f.from_native(''), '')
#         self.assertEqual(f.from_native(None), '')

#     def test_from_native_empty_override(self):
#         """
#         Make sure you can override from_native() behavior regarding empty values.
#         """
#         f = serializers.ChoiceField(choices=SAMPLE_CHOICES, empty=None)
#         self.assertEqual(f.from_native(''), None)
#         self.assertEqual(f.from_native(None), None)

#     def test_metadata_choices(self):
#         """
#         Make sure proper choices are included in the field's metadata.
#         """
#         choices = [{'value': v, 'display_name': n} for v, n in SAMPLE_CHOICES]
#         f = serializers.ChoiceField(choices=SAMPLE_CHOICES)
#         self.assertEqual(f.metadata()['choices'], choices)

#     def test_metadata_choices_not_required(self):
#         """
#         Make sure proper choices are included in the field's metadata.
#         """
#         choices = [{'value': v, 'display_name': n}
#                    for v, n in models.fields.BLANK_CHOICE_DASH + SAMPLE_CHOICES]
#         f = serializers.ChoiceField(required=False, choices=SAMPLE_CHOICES)
#         self.assertEqual(f.metadata()['choices'], choices)


# class EmailFieldTests(TestCase):
#     """
#     Tests for EmailField attribute values
#     """

#     class EmailFieldModel(RESTFrameworkModel):
#         email_field = models.EmailField(blank=True)

#     class EmailFieldWithGivenMaxLengthModel(RESTFrameworkModel):
#         email_field = models.EmailField(max_length=150, blank=True)

#     def test_default_model_value(self):
#         class EmailFieldSerializer(serializers.ModelSerializer):
#             class Meta:
#                 model = self.EmailFieldModel

#         serializer = EmailFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 75)

#     def test_given_model_value(self):
#         class EmailFieldSerializer(serializers.ModelSerializer):
#             class Meta:
#                 model = self.EmailFieldWithGivenMaxLengthModel

#         serializer = EmailFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 150)

#     def test_given_serializer_value(self):
#         class EmailFieldSerializer(serializers.ModelSerializer):
#             email_field = serializers.EmailField(source='email_field', max_length=20, required=False)

#             class Meta:
#                 model = self.EmailFieldModel

#         serializer = EmailFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['email_field'], 'max_length'), 20)


# class SlugFieldTests(TestCase):
#     """
#     Tests for SlugField attribute values
#     """

#     class SlugFieldModel(RESTFrameworkModel):
#         slug_field = models.SlugField(blank=True)

#     class SlugFieldWithGivenMaxLengthModel(RESTFrameworkModel):
#         slug_field = models.SlugField(max_length=84, blank=True)

#     def test_default_model_value(self):
#         class SlugFieldSerializer(serializers.ModelSerializer):
#             class Meta:
#                 model = self.SlugFieldModel

#         serializer = SlugFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['slug_field'], 'max_length'), 50)

#     def test_given_model_value(self):
#         class SlugFieldSerializer(serializers.ModelSerializer):
#             class Meta:
#                 model = self.SlugFieldWithGivenMaxLengthModel

#         serializer = SlugFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['slug_field'], 'max_length'), 84)

#     def test_given_serializer_value(self):
#         class SlugFieldSerializer(serializers.ModelSerializer):
#             slug_field = serializers.SlugField(source='slug_field',
#                                                max_length=20, required=False)

#             class Meta:
#                 model = self.SlugFieldModel

#         serializer = SlugFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['slug_field'],
#                                  'max_length'), 20)

#     def test_invalid_slug(self):
#         """
#         Make sure an invalid slug raises ValidationError
#         """
#         class SlugFieldSerializer(serializers.ModelSerializer):
#             slug_field = serializers.SlugField(source='slug_field', max_length=20, required=True)

#             class Meta:
#                 model = self.SlugFieldModel

#         s = SlugFieldSerializer(data={'slug_field': 'a b'})

#         self.assertEqual(s.is_valid(), False)
#         self.assertEqual(s.errors, {'slug_field': ["Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."]})


# class URLFieldTests(TestCase):
#     """
#     Tests for URLField attribute values.

#     (Includes test for #1210, checking that validators can be overridden.)
#     """

#     class URLFieldModel(RESTFrameworkModel):
#         url_field = models.URLField(blank=True)

#     class URLFieldWithGivenMaxLengthModel(RESTFrameworkModel):
#         url_field = models.URLField(max_length=128, blank=True)

#     def test_default_model_value(self):
#         class URLFieldSerializer(serializers.ModelSerializer):
#             class Meta:
#                 model = self.URLFieldModel

#         serializer = URLFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['url_field'],
#                                  'max_length'), 200)

#     def test_given_model_value(self):
#         class URLFieldSerializer(serializers.ModelSerializer):
#             class Meta:
#                 model = self.URLFieldWithGivenMaxLengthModel

#         serializer = URLFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['url_field'],
#                                  'max_length'), 128)

#     def test_given_serializer_value(self):
#         class URLFieldSerializer(serializers.ModelSerializer):
#             url_field = serializers.URLField(source='url_field',
#                                              max_length=20, required=False)

#             class Meta:
#                 model = self.URLFieldWithGivenMaxLengthModel

#         serializer = URLFieldSerializer(data={})
#         self.assertEqual(serializer.is_valid(), True)
#         self.assertEqual(getattr(serializer.fields['url_field'],
#                          'max_length'), 20)

#     def test_validators_can_be_overridden(self):
#         url_field = serializers.URLField(validators=[])
#         validators = url_field.validators
#         self.assertEqual([], validators, 'Passing `validators` kwarg should have overridden default validators')


# class FieldMetadata(TestCase):
#     def setUp(self):
#         self.required_field = serializers.Field()
#         self.required_field.label = uuid4().hex
#         self.required_field.required = True

#         self.optional_field = serializers.Field()
#         self.optional_field.label = uuid4().hex
#         self.optional_field.required = False

#     def test_required(self):
#         self.assertEqual(self.required_field.metadata()['required'], True)

#     def test_optional(self):
#         self.assertEqual(self.optional_field.metadata()['required'], False)

#     def test_label(self):
#         for field in (self.required_field, self.optional_field):
#             self.assertEqual(field.metadata()['label'], field.label)


# class FieldCallableDefault(TestCase):
#     def setUp(self):
#         self.simple_callable = lambda: 'foo bar'

#     def test_default_can_be_simple_callable(self):
#         """
#         Ensure that the 'default' argument can also be a simple callable.
#         """
#         field = serializers.WritableField(default=self.simple_callable)
#         into = {}
#         field.field_from_native({}, {}, 'field', into)
#         self.assertEqual(into, {'field': 'foo bar'})


# class CustomIntegerField(TestCase):
#     """
#         Test that custom fields apply min_value and max_value constraints
#     """
#     def test_custom_fields_can_be_validated_for_value(self):

#         class MoneyField(models.PositiveIntegerField):
#             pass

#         class EntryModel(models.Model):
#             bank = MoneyField(validators=[validators.MaxValueValidator(100)])

#         class EntrySerializer(serializers.ModelSerializer):
#             class Meta:
#                 model = EntryModel

#         entry = EntryModel(bank=1)

#         serializer = EntrySerializer(entry, data={"bank": 11})
#         self.assertTrue(serializer.is_valid())

#         serializer = EntrySerializer(entry, data={"bank": -1})
#         self.assertFalse(serializer.is_valid())

#         serializer = EntrySerializer(entry, data={"bank": 101})
#         self.assertFalse(serializer.is_valid())


# class BooleanField(TestCase):
#     """
#         Tests for BooleanField
#     """
#     def test_boolean_required(self):
#         class BooleanRequiredSerializer(serializers.Serializer):
#             bool_field = serializers.BooleanField(required=True)

#         self.assertFalse(BooleanRequiredSerializer(data={}).is_valid())


# class SerializerMethodFieldTest(TestCase):
#     """
#         Tests for the SerializerMethodField field_to_native() behavior
#     """
#     class SerializerTest(serializers.Serializer):
#         def get_my_test(self, obj):
#             return obj.my_test[0:5]

# class ModelCharField(TestCase):
#     """
#         Tests for CharField
#     """
#     def test_none_serializing(self):
#         class CharFieldSerializer(serializers.Serializer):
#             char = serializers.CharField(allow_none=True, required=False)
#         serializer = CharFieldSerializer(data={'char': None})
#         self.assertTrue(serializer.is_valid())
#         self.assertIsNone(serializer.object['char'])


# class SerializerMethodFieldTest(TestCase):
#     """
#         Tests for the SerializerMethodField field_to_native() behavior
#     """
#     class SerializerTest(serializers.Serializer):
#         def get_my_test(self, obj):
#             return obj.my_test[0:5]

#     class Example():
#         my_test = 'Hey, this is a test !'

#     def test_field_to_native(self):
#         s = serializers.SerializerMethodField('get_my_test')
#         s.initialize(self.SerializerTest(), 'name')
#         result = s.field_to_native(self.Example(), None)
#         self.assertEqual(result, 'Hey, ')