2013-01-12 13:32:53 +04:00
|
|
|
"""
|
2013-01-15 14:51:10 +04:00
|
|
|
General serializer field tests.
|
2013-01-12 13:32:53 +04:00
|
|
|
"""
|
2013-02-05 00:55:35 +04:00
|
|
|
from __future__ import unicode_literals
|
2013-02-15 00:19:51 +04:00
|
|
|
import datetime
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-01-12 13:32:53 +04:00
|
|
|
from django.db import models
|
|
|
|
from django.test import TestCase
|
2013-02-15 00:19:51 +04:00
|
|
|
from django.core import validators
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-01-12 13:32:53 +04:00
|
|
|
from rest_framework import serializers
|
|
|
|
|
|
|
|
|
|
|
|
class TimestampedModel(models.Model):
|
|
|
|
added = models.DateTimeField(auto_now_add=True)
|
|
|
|
updated = models.DateTimeField(auto_now=True)
|
|
|
|
|
|
|
|
|
2013-01-12 13:43:07 +04:00
|
|
|
class CharPrimaryKeyModel(models.Model):
|
|
|
|
id = models.CharField(max_length=20, primary_key=True)
|
|
|
|
|
|
|
|
|
2013-01-12 13:32:53 +04:00
|
|
|
class TimestampedModelSerializer(serializers.ModelSerializer):
|
|
|
|
class Meta:
|
|
|
|
model = TimestampedModel
|
|
|
|
|
|
|
|
|
2013-01-12 13:43:07 +04:00
|
|
|
class CharPrimaryKeyModelSerializer(serializers.ModelSerializer):
|
|
|
|
class Meta:
|
|
|
|
model = CharPrimaryKeyModel
|
|
|
|
|
|
|
|
|
2013-02-15 00:19:51 +04:00
|
|
|
class TimeFieldModel(models.Model):
|
|
|
|
clock = models.TimeField()
|
|
|
|
|
|
|
|
|
|
|
|
class TimeFieldModelSerializer(serializers.ModelSerializer):
|
|
|
|
class Meta:
|
|
|
|
model = TimeFieldModel
|
|
|
|
|
|
|
|
|
|
|
|
class BasicFieldTests(TestCase):
|
2013-01-12 13:32:53 +04:00
|
|
|
def test_auto_now_fields_read_only(self):
|
|
|
|
"""
|
2013-01-15 14:51:10 +04:00
|
|
|
auto_now and auto_now_add fields should be read_only by default.
|
2013-01-12 13:32:53 +04:00
|
|
|
"""
|
|
|
|
serializer = TimestampedModelSerializer()
|
2013-02-28 01:15:00 +04:00
|
|
|
self.assertEqual(serializer.fields['added'].read_only, True)
|
2013-01-12 13:43:07 +04:00
|
|
|
|
|
|
|
def test_auto_pk_fields_read_only(self):
|
2013-01-15 14:51:10 +04:00
|
|
|
"""
|
|
|
|
AutoField fields should be read_only by default.
|
|
|
|
"""
|
2013-01-12 13:43:07 +04:00
|
|
|
serializer = TimestampedModelSerializer()
|
2013-02-28 01:15:00 +04:00
|
|
|
self.assertEqual(serializer.fields['id'].read_only, True)
|
2013-01-12 13:43:07 +04:00
|
|
|
|
|
|
|
def test_non_auto_pk_fields_not_read_only(self):
|
2013-01-15 14:51:10 +04:00
|
|
|
"""
|
|
|
|
PK fields other than AutoField fields should not be read_only by default.
|
|
|
|
"""
|
2013-01-12 13:43:07 +04:00
|
|
|
serializer = CharPrimaryKeyModelSerializer()
|
2013-03-06 16:19:39 +04:00
|
|
|
self.assertEqual(serializer.fields['id'].read_only, False)
|
2013-02-15 00:19:51 +04:00
|
|
|
|
2013-02-26 14:09:54 +04:00
|
|
|
|
|
|
|
class DateFieldTest(TestCase):
|
2013-03-01 16:16:00 +04:00
|
|
|
"""
|
|
|
|
Tests for the DateFieldTest from_native() and to_native() behavior
|
|
|
|
"""
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_from_native_string(self):
|
|
|
|
"""
|
|
|
|
Make sure from_native() accepts default iso input formats.
|
|
|
|
"""
|
2013-02-26 14:09:54 +04:00
|
|
|
f = serializers.DateField()
|
2013-03-01 16:16:00 +04:00
|
|
|
result_1 = f.from_native('1984-07-31')
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
self.assertEqual(datetime.date(1984, 7, 31), result_1)
|
2013-02-26 14:09:54 +04:00
|
|
|
|
|
|
|
def test_from_native_datetime_date(self):
|
|
|
|
"""
|
|
|
|
Make sure from_native() accepts a datetime.date instance.
|
|
|
|
"""
|
|
|
|
f = serializers.DateField()
|
2013-03-01 16:16:00 +04:00
|
|
|
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')
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
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")
|
2013-02-26 14:09:54 +04:00
|
|
|
|
|
|
|
def test_from_native_empty(self):
|
2013-03-01 16:16:00 +04:00
|
|
|
"""
|
|
|
|
Make sure from_native() returns None on empty param.
|
|
|
|
"""
|
2013-02-26 14:09:54 +04:00
|
|
|
f = serializers.DateField()
|
|
|
|
result = f.from_native('')
|
|
|
|
|
|
|
|
self.assertEqual(result, None)
|
|
|
|
|
2013-03-01 20:04:30 +04:00
|
|
|
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)
|
|
|
|
|
2013-02-26 14:09:54 +04:00
|
|
|
def test_from_native_invalid_date(self):
|
2013-03-01 16:16:00 +04:00
|
|
|
"""
|
|
|
|
Make sure from_native() raises a ValidationError on passing an invalid date.
|
|
|
|
"""
|
2013-02-26 14:09:54 +04:00
|
|
|
f = serializers.DateField()
|
|
|
|
|
|
|
|
try:
|
2013-03-01 16:16:00 +04:00
|
|
|
f.from_native('1984-13-31')
|
2013-02-26 14:09:54 +04:00
|
|
|
except validators.ValidationError as e:
|
2013-03-06 16:19:39 +04:00
|
|
|
self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]"])
|
2013-02-26 14:09:54 +04:00
|
|
|
else:
|
|
|
|
self.fail("ValidationError was not properly raised")
|
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_from_native_invalid_format(self):
|
|
|
|
"""
|
|
|
|
Make sure from_native() raises a ValidationError on passing an invalid format.
|
|
|
|
"""
|
|
|
|
f = serializers.DateField()
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
try:
|
|
|
|
f.from_native('1984 -- 31')
|
|
|
|
except validators.ValidationError as e:
|
2013-03-06 16:19:39 +04:00
|
|
|
self.assertEqual(e.messages, ["Date has wrong format. Use one of these formats instead: YYYY[-MM[-DD]]"])
|
2013-03-01 16:16:00 +04:00
|
|
|
else:
|
|
|
|
self.fail("ValidationError was not properly raised")
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_to_native(self):
|
|
|
|
"""
|
|
|
|
Make sure to_native() returns isoformat as default.
|
|
|
|
"""
|
|
|
|
f = serializers.DateField()
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
result_1 = f.to_native(datetime.date(1984, 7, 31))
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
self.assertEqual('1984-07-31', result_1)
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_to_native_custom_format(self):
|
|
|
|
"""
|
|
|
|
Make sure to_native() returns correct custom format.
|
|
|
|
"""
|
2013-03-06 16:19:39 +04:00
|
|
|
f = serializers.DateField(format="%Y - %m.%d")
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
result_1 = f.to_native(datetime.date(1984, 7, 31))
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
self.assertEqual('1984 - 07.31', result_1)
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-07 03:15:19 +04:00
|
|
|
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))
|
|
|
|
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
class DateTimeFieldTest(TestCase):
|
|
|
|
"""
|
|
|
|
Tests for the DateTimeField from_native() and to_native() behavior
|
|
|
|
"""
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_from_native_string(self):
|
|
|
|
"""
|
|
|
|
Make sure from_native() accepts default iso input formats.
|
|
|
|
"""
|
|
|
|
f = serializers.DateTimeField()
|
2013-03-01 19:24:25 +04:00
|
|
|
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')
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 19:24:25 +04:00
|
|
|
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)
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_from_native_datetime_datetime(self):
|
|
|
|
"""
|
|
|
|
Make sure from_native() accepts a datetime.datetime instance.
|
|
|
|
"""
|
|
|
|
f = serializers.DateTimeField()
|
2013-03-01 19:24:25 +04:00
|
|
|
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))
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 19:24:25 +04:00
|
|
|
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))
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
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')
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
self.assertEqual(datetime.datetime(1984, 1, 1, 4, 59), result)
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_from_native_invalid_default_on_custom_format(self):
|
2013-02-26 14:09:54 +04:00
|
|
|
"""
|
2013-03-01 16:16:00 +04:00
|
|
|
Make sure from_native() don't accept default formats if custom format is preset
|
2013-02-26 14:09:54 +04:00
|
|
|
"""
|
2013-03-01 16:16:00 +04:00
|
|
|
f = serializers.DateTimeField(input_formats=['%Y -- %H:%M'])
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
try:
|
|
|
|
f.from_native('1984-07-31 04:31:59')
|
|
|
|
except validators.ValidationError as e:
|
2013-03-06 16:19:39 +04:00
|
|
|
self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: YYYY -- hh:mm"])
|
2013-03-01 16:16:00 +04:00
|
|
|
else:
|
|
|
|
self.fail("ValidationError was not properly raised")
|
2013-02-26 14:09:54 +04:00
|
|
|
|
|
|
|
def test_from_native_empty(self):
|
2013-03-01 16:16:00 +04:00
|
|
|
"""
|
|
|
|
Make sure from_native() returns None on empty param.
|
|
|
|
"""
|
2013-02-26 14:09:54 +04:00
|
|
|
f = serializers.DateTimeField()
|
|
|
|
result = f.from_native('')
|
|
|
|
|
|
|
|
self.assertEqual(result, None)
|
|
|
|
|
2013-03-01 20:04:30 +04:00
|
|
|
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)
|
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_from_native_invalid_datetime(self):
|
|
|
|
"""
|
|
|
|
Make sure from_native() raises a ValidationError on passing an invalid datetime.
|
|
|
|
"""
|
2013-02-26 14:09:54 +04:00
|
|
|
f = serializers.DateTimeField()
|
|
|
|
|
|
|
|
try:
|
2013-03-01 16:16:00 +04:00
|
|
|
f.from_native('04:61:59')
|
2013-02-26 14:09:54 +04:00
|
|
|
except validators.ValidationError as e:
|
2013-03-01 16:16:00 +04:00
|
|
|
self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: "
|
2013-03-06 16:19:39 +04:00
|
|
|
"YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HHMM|-HHMM|Z]"])
|
2013-02-26 14:09:54 +04:00
|
|
|
else:
|
|
|
|
self.fail("ValidationError was not properly raised")
|
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_from_native_invalid_format(self):
|
|
|
|
"""
|
|
|
|
Make sure from_native() raises a ValidationError on passing an invalid format.
|
|
|
|
"""
|
2013-02-26 14:09:54 +04:00
|
|
|
f = serializers.DateTimeField()
|
|
|
|
|
|
|
|
try:
|
2013-03-01 16:16:00 +04:00
|
|
|
f.from_native('04 -- 31')
|
2013-02-26 14:09:54 +04:00
|
|
|
except validators.ValidationError as e:
|
2013-03-01 16:16:00 +04:00
|
|
|
self.assertEqual(e.messages, ["Datetime has wrong format. Use one of these formats instead: "
|
2013-03-06 16:19:39 +04:00
|
|
|
"YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HHMM|-HHMM|Z]"])
|
2013-02-26 14:09:54 +04:00
|
|
|
else:
|
|
|
|
self.fail("ValidationError was not properly raised")
|
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_to_native(self):
|
|
|
|
"""
|
|
|
|
Make sure to_native() returns isoformat as default.
|
|
|
|
"""
|
|
|
|
f = serializers.DateTimeField()
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
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))
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
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)
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
def test_to_native_custom_format(self):
|
|
|
|
"""
|
|
|
|
Make sure to_native() returns correct custom format.
|
|
|
|
"""
|
2013-03-06 16:19:39 +04:00
|
|
|
f = serializers.DateTimeField(format="%Y - %H:%M")
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
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))
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
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)
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-07 03:15:19 +04:00
|
|
|
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))
|
|
|
|
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
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.
|
|
|
|
"""
|
2013-02-15 00:19:51 +04:00
|
|
|
f = serializers.TimeField()
|
2013-03-01 16:16:00 +04:00
|
|
|
result_1 = f.from_native('04:31')
|
|
|
|
result_2 = f.from_native('04:31:59')
|
|
|
|
result_3 = f.from_native('04:31:59.000200')
|
2013-02-15 00:19:51 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
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)
|
2013-02-15 00:19:51 +04:00
|
|
|
|
2013-02-26 14:09:54 +04:00
|
|
|
def test_from_native_datetime_time(self):
|
2013-02-15 00:19:51 +04:00
|
|
|
"""
|
|
|
|
Make sure from_native() accepts a datetime.time instance.
|
|
|
|
"""
|
|
|
|
f = serializers.TimeField()
|
2013-03-01 16:16:00 +04:00
|
|
|
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'])
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-03-01 16:16:00 +04:00
|
|
|
try:
|
|
|
|
f.from_native('04:31:59')
|
|
|
|
except validators.ValidationError as e:
|
2013-03-06 16:19:39 +04:00
|
|
|
self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: hh -- mm"])
|
2013-03-01 16:16:00 +04:00
|
|
|
else:
|
|
|
|
self.fail("ValidationError was not properly raised")
|
2013-02-15 00:19:51 +04:00
|
|
|
|
2013-02-26 14:09:54 +04:00
|
|
|
def test_from_native_empty(self):
|
2013-03-01 16:16:00 +04:00
|
|
|
"""
|
|
|
|
Make sure from_native() returns None on empty param.
|
|
|
|
"""
|
2013-02-15 00:19:51 +04:00
|
|
|
f = serializers.TimeField()
|
|
|
|
result = f.from_native('')
|
2013-02-26 14:09:54 +04:00
|
|
|
|
2013-02-15 00:19:51 +04:00
|
|
|
self.assertEqual(result, None)
|
|
|
|
|
2013-03-01 20:04:30 +04:00
|
|
|
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)
|
|
|
|
|
2013-02-26 14:09:54 +04:00
|
|
|
def test_from_native_invalid_time(self):
|
2013-03-01 16:16:00 +04:00
|
|
|
"""
|
|
|
|
Make sure from_native() raises a ValidationError on passing an invalid time.
|
|
|
|
"""
|
2013-02-15 00:19:51 +04:00
|
|
|
f = serializers.TimeField()
|
|
|
|
|
|
|
|
try:
|
2013-03-01 16:16:00 +04:00
|
|
|
f.from_native('04:61:59')
|
2013-02-15 00:19:51 +04:00
|
|
|
except validators.ValidationError as e:
|
2013-03-01 16:16:00 +04:00
|
|
|
self.assertEqual(e.messages, ["Time has wrong format. Use one of these formats instead: "
|
2013-03-06 16:19:39 +04:00
|
|
|
"hh:mm[:ss[.uuuuuu]]"])
|
2013-02-15 00:19:51 +04:00
|
|
|
else:
|
|
|
|
self.fail("ValidationError was not properly raised")
|
2013-03-01 16:16:00 +04:00
|
|
|
|
|
|
|
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: "
|
2013-03-06 16:19:39 +04:00
|
|
|
"hh:mm[:ss[.uuuuuu]]"])
|
2013-03-01 16:16:00 +04:00
|
|
|
else:
|
|
|
|
self.fail("ValidationError was not properly raised")
|
|
|
|
|
|
|
|
def test_to_native(self):
|
|
|
|
"""
|
|
|
|
Make sure to_native() returns isoformat 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('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.
|
|
|
|
"""
|
2013-03-06 16:19:39 +04:00
|
|
|
f = serializers.TimeField(format="%H - %S [%f]")
|
2013-03-01 16:16:00 +04:00
|
|
|
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)
|
2013-03-06 16:19:39 +04:00
|
|
|
self.assertEqual('04 - 59 [000200]', result_3)
|