2012-09-20 16:06:27 +04:00
|
|
|
import datetime
|
|
|
|
from django.test import TestCase
|
|
|
|
from rest_framework import serializers
|
2012-10-03 13:51:38 +04:00
|
|
|
from rest_framework.tests.models import *
|
2012-09-20 16:06:27 +04:00
|
|
|
|
|
|
|
|
2012-10-19 02:45:16 +04:00
|
|
|
class SubComment(object):
|
|
|
|
def __init__(self, sub_comment):
|
|
|
|
self.sub_comment = sub_comment
|
2012-10-26 16:20:30 +04:00
|
|
|
|
2012-10-19 02:45:16 +04:00
|
|
|
|
2012-09-20 16:06:27 +04:00
|
|
|
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')])
|
2012-10-26 16:20:30 +04:00
|
|
|
|
2012-10-19 02:45:16 +04:00
|
|
|
def get_sub_comment(self):
|
|
|
|
sub_comment = SubComment('And Merry Christmas!')
|
|
|
|
return sub_comment
|
2012-09-20 16:06:27 +04:00
|
|
|
|
|
|
|
|
|
|
|
class CommentSerializer(serializers.Serializer):
|
|
|
|
email = serializers.EmailField()
|
|
|
|
content = serializers.CharField(max_length=1000)
|
|
|
|
created = serializers.DateTimeField()
|
2012-10-19 02:45:16 +04:00
|
|
|
sub_comment = serializers.Field(source='get_sub_comment.sub_comment')
|
2012-10-26 16:20:30 +04:00
|
|
|
|
2012-09-20 16:06:27 +04:00
|
|
|
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
|
|
|
|
|
|
|
|
|
2012-10-17 22:12:34 +04:00
|
|
|
class ActionItemSerializer(serializers.ModelSerializer):
|
|
|
|
class Meta:
|
|
|
|
model = ActionItem
|
|
|
|
|
2012-10-26 16:20:30 +04:00
|
|
|
|
2012-09-20 16:06:27 +04:00
|
|
|
class BasicTests(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': 'Happy new year!',
|
2012-10-19 02:45:16 +04:00
|
|
|
'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!'
|
2012-09-20 16:06:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
def test_empty(self):
|
|
|
|
serializer = CommentSerializer()
|
|
|
|
expected = {
|
|
|
|
'email': '',
|
|
|
|
'content': '',
|
2012-10-19 02:45:16 +04:00
|
|
|
'created': None,
|
|
|
|
'sub_comment': ''
|
2012-09-20 16:06:27 +04:00
|
|
|
}
|
|
|
|
self.assertEquals(serializer.data, expected)
|
|
|
|
|
2012-10-03 14:14:47 +04:00
|
|
|
def test_retrieve(self):
|
2012-10-26 16:20:30 +04:00
|
|
|
serializer = CommentSerializer(instance=self.comment)
|
2012-10-19 02:45:16 +04:00
|
|
|
self.assertEquals(serializer.data, self.expected)
|
2012-09-20 16:06:27 +04:00
|
|
|
|
2012-10-03 14:14:47 +04:00
|
|
|
def test_create(self):
|
2012-09-20 16:06:27 +04:00
|
|
|
serializer = CommentSerializer(self.data)
|
|
|
|
expected = self.comment
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
self.assertEquals(serializer.object, expected)
|
|
|
|
self.assertFalse(serializer.object is expected)
|
2012-10-19 02:45:16 +04:00
|
|
|
self.assertEquals(serializer.data['sub_comment'], 'And Merry Christmas!')
|
2012-09-20 16:06:27 +04:00
|
|
|
|
2012-10-03 14:14:47 +04:00
|
|
|
def test_update(self):
|
2012-09-20 16:06:27 +04:00
|
|
|
serializer = CommentSerializer(self.data, instance=self.comment)
|
|
|
|
expected = self.comment
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
self.assertEquals(serializer.object, expected)
|
|
|
|
self.assertTrue(serializer.object is expected)
|
2012-10-19 02:45:16 +04:00
|
|
|
self.assertEquals(serializer.data['sub_comment'], 'And Merry Christmas!')
|
2012-09-20 16:06:27 +04:00
|
|
|
|
|
|
|
|
|
|
|
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)
|
2012-10-26 16:20:30 +04:00
|
|
|
}
|
2012-10-17 22:12:34 +04:00
|
|
|
self.actionitem = ActionItem('Some to do item',
|
|
|
|
)
|
2012-09-20 16:06:27 +04:00
|
|
|
|
2012-10-03 14:14:47 +04:00
|
|
|
def test_create(self):
|
2012-09-20 16:06:27 +04:00
|
|
|
serializer = CommentSerializer(self.data)
|
|
|
|
self.assertEquals(serializer.is_valid(), False)
|
|
|
|
self.assertEquals(serializer.errors, {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
|
|
|
|
|
2012-10-03 14:14:47 +04:00
|
|
|
def test_update(self):
|
2012-09-20 16:06:27 +04:00
|
|
|
serializer = CommentSerializer(self.data, instance=self.comment)
|
|
|
|
self.assertEquals(serializer.is_valid(), False)
|
|
|
|
self.assertEquals(serializer.errors, {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
|
|
|
|
|
2012-10-08 20:53:18 +04:00
|
|
|
def test_update_missing_field(self):
|
|
|
|
data = {
|
|
|
|
'content': 'xxx',
|
|
|
|
'created': datetime.datetime(2012, 1, 1)
|
|
|
|
}
|
|
|
|
serializer = CommentSerializer(data, instance=self.comment)
|
|
|
|
self.assertEquals(serializer.is_valid(), False)
|
|
|
|
self.assertEquals(serializer.errors, {'email': [u'This field is required.']})
|
|
|
|
|
2012-10-17 22:12:34 +04:00
|
|
|
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 = {
|
2012-10-26 16:20:30 +04:00
|
|
|
'title': 'Some action item',
|
2012-10-17 22:12:34 +04:00
|
|
|
#No 'done' value.
|
|
|
|
}
|
|
|
|
serializer = ActionItemSerializer(data, instance=self.actionitem)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
self.assertEquals(serializer.errors, {})
|
|
|
|
|
2012-10-24 12:28:10 +04:00
|
|
|
def test_field_validation(self):
|
|
|
|
|
|
|
|
class CommentSerializerWithFieldValidator(CommentSerializer):
|
|
|
|
|
2012-10-24 14:27:01 +04:00
|
|
|
def validate_content(self, attrs, source):
|
2012-10-24 12:28:10 +04:00
|
|
|
value = attrs[source]
|
|
|
|
if "test" not in value:
|
|
|
|
raise serializers.ValidationError("Test not in value")
|
|
|
|
return attrs
|
|
|
|
|
|
|
|
data = {
|
|
|
|
'email': 'tom@example.com',
|
|
|
|
'content': 'A test comment',
|
|
|
|
'created': datetime.datetime(2012, 1, 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
serializer = CommentSerializerWithFieldValidator(data)
|
|
|
|
self.assertTrue(serializer.is_valid())
|
|
|
|
|
|
|
|
data['content'] = 'This should not validate'
|
|
|
|
|
|
|
|
serializer = CommentSerializerWithFieldValidator(data)
|
|
|
|
self.assertFalse(serializer.is_valid())
|
|
|
|
self.assertEquals(serializer.errors, {'content': [u'Test not in value']})
|
|
|
|
|
2012-10-24 14:39:17 +04:00
|
|
|
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)
|
|
|
|
self.assertTrue(serializer.is_valid())
|
|
|
|
|
|
|
|
data['content'] = 'A comment from foo@bar.com'
|
|
|
|
|
|
|
|
serializer = CommentSerializerWithCrossFieldValidator(data)
|
|
|
|
self.assertFalse(serializer.is_valid())
|
|
|
|
self.assertEquals(serializer.errors, {'non_field_errors': [u'Email address not in content']})
|
|
|
|
|
2012-09-20 16:06:27 +04:00
|
|
|
|
|
|
|
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))
|
2012-10-03 13:51:38 +04:00
|
|
|
|
|
|
|
|
|
|
|
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):
|
2012-10-03 14:14:47 +04:00
|
|
|
"""
|
|
|
|
Serialize an instance of a model with a ManyToMany relationship.
|
|
|
|
"""
|
2012-10-03 13:51:38 +04:00
|
|
|
serializer = self.serializer_class(instance=self.instance)
|
|
|
|
expected = self.data
|
|
|
|
self.assertEquals(serializer.data, expected)
|
|
|
|
|
|
|
|
def test_create(self):
|
2012-10-03 14:14:47 +04:00
|
|
|
"""
|
|
|
|
Create an instance of a model with a ManyToMany relationship.
|
|
|
|
"""
|
2012-10-03 13:51:38 +04:00
|
|
|
data = {'rel': [self.anchor.id]}
|
|
|
|
serializer = self.serializer_class(data)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
2012-10-03 14:08:02 +04:00
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(ManyToManyModel.objects.all()), 2)
|
|
|
|
self.assertEquals(instance.pk, 2)
|
|
|
|
self.assertEquals(list(instance.rel.all()), [self.anchor])
|
2012-10-03 14:14:47 +04:00
|
|
|
|
|
|
|
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(data, instance=self.instance)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(ManyToManyModel.objects.all()), 1)
|
|
|
|
self.assertEquals(instance.pk, 1)
|
|
|
|
self.assertEquals(list(instance.rel.all()), [self.anchor, new_anchor])
|
2012-10-03 13:51:38 +04:00
|
|
|
|
2012-10-03 14:50:08 +04:00
|
|
|
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)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(ManyToManyModel.objects.all()), 2)
|
|
|
|
self.assertEquals(instance.pk, 2)
|
|
|
|
self.assertEquals(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(data, instance=self.instance)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(ManyToManyModel.objects.all()), 1)
|
|
|
|
self.assertEquals(instance.pk, 1)
|
|
|
|
self.assertEquals(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 = {'rel': ''}
|
|
|
|
serializer = self.serializer_class(data)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(ManyToManyModel.objects.all()), 2)
|
|
|
|
self.assertEquals(instance.pk, 2)
|
|
|
|
self.assertEquals(list(instance.rel.all()), [])
|
2012-10-26 16:20:30 +04:00
|
|
|
|
|
|
|
|
2012-10-23 01:24:26 +04:00
|
|
|
class ReadOnlyManyToManyTests(TestCase):
|
|
|
|
def setUp(self):
|
|
|
|
class ReadOnlyManyToManySerializer(serializers.ModelSerializer):
|
2012-10-29 00:21:45 +04:00
|
|
|
rel = serializers.ManyRelatedField(read_only=True)
|
2012-10-26 16:20:30 +04:00
|
|
|
|
2012-10-23 01:24:26 +04:00
|
|
|
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
|
2012-10-29 00:21:45 +04:00
|
|
|
relationship. Not updated due to read_only=True
|
2012-10-23 01:24:26 +04:00
|
|
|
"""
|
|
|
|
new_anchor = Anchor()
|
|
|
|
new_anchor.save()
|
|
|
|
data = {'rel': [self.anchor.id, new_anchor.id]}
|
|
|
|
serializer = self.serializer_class(data, instance=self.instance)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(ReadOnlyManyToManyModel.objects.all()), 1)
|
|
|
|
self.assertEquals(instance.pk, 1)
|
|
|
|
# rel is still as original (1 entry)
|
|
|
|
self.assertEquals(list(instance.rel.all()), [self.anchor])
|
|
|
|
|
|
|
|
def test_update_without_relationship(self):
|
|
|
|
"""
|
|
|
|
Attempt to update an instance of a model where many to ManyToMany
|
2012-10-29 00:21:45 +04:00
|
|
|
relationship is not supplied. Not updated due to read_only=True
|
2012-10-23 01:24:26 +04:00
|
|
|
"""
|
|
|
|
new_anchor = Anchor()
|
|
|
|
new_anchor.save()
|
|
|
|
data = {}
|
|
|
|
serializer = self.serializer_class(data, instance=self.instance)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(ReadOnlyManyToManyModel.objects.all()), 1)
|
|
|
|
self.assertEquals(instance.pk, 1)
|
|
|
|
# rel is still as original (1 entry)
|
|
|
|
self.assertEquals(list(instance.rel.all()), [self.anchor])
|
2012-10-03 15:16:30 +04:00
|
|
|
|
2012-10-04 12:29:12 +04:00
|
|
|
|
|
|
|
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)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(self.objects.all()), 1)
|
|
|
|
self.assertEquals(instance.pk, 1)
|
|
|
|
self.assertEquals(instance.text, 'foobar')
|
|
|
|
|
|
|
|
def test_create_overriding_default(self):
|
|
|
|
data = {'text': 'overridden'}
|
|
|
|
serializer = self.serializer_class(data)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(self.objects.all()), 1)
|
|
|
|
self.assertEquals(instance.pk, 1)
|
|
|
|
self.assertEquals(instance.text, 'overridden')
|
|
|
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(self.objects.all()), 1)
|
|
|
|
self.assertEquals(instance.pk, 1)
|
|
|
|
self.assertEquals(instance.text, 'foobar')
|
|
|
|
|
|
|
|
def test_create_overriding_default(self):
|
|
|
|
data = {'text': 'overridden'}
|
|
|
|
serializer = self.serializer_class(data)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
instance = serializer.save()
|
|
|
|
self.assertEquals(len(self.objects.all()), 1)
|
|
|
|
self.assertEquals(instance.pk, 1)
|
|
|
|
self.assertEquals(instance.text, 'overridden')
|
2012-10-22 18:12:25 +04:00
|
|
|
|
|
|
|
|
|
|
|
class ManyRelatedTests(TestCase):
|
|
|
|
def setUp(self):
|
|
|
|
|
|
|
|
class BlogPostCommentSerializer(serializers.Serializer):
|
|
|
|
text = serializers.CharField()
|
|
|
|
|
|
|
|
class BlogPostSerializer(serializers.Serializer):
|
|
|
|
title = serializers.CharField()
|
|
|
|
comments = BlogPostCommentSerializer(source='blogpostcomment_set')
|
|
|
|
|
|
|
|
self.serializer_class = BlogPostSerializer
|
|
|
|
|
|
|
|
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")
|
|
|
|
|
|
|
|
serializer = self.serializer_class(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)
|
2012-10-27 18:37:02 +04:00
|
|
|
|
|
|
|
|
|
|
|
# Test for issue #324
|
|
|
|
class BlankFieldTests(TestCase):
|
|
|
|
def setUp(self):
|
|
|
|
|
|
|
|
class BlankFieldModelSerializer(serializers.ModelSerializer):
|
|
|
|
class Meta:
|
|
|
|
model = BlankFieldModel
|
|
|
|
|
2012-10-30 01:23:24 +04:00
|
|
|
class BlankFieldSerializer(serializers.Serializer):
|
|
|
|
title = serializers.CharField(blank=True)
|
|
|
|
|
|
|
|
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': ''}
|
2012-10-27 18:37:02 +04:00
|
|
|
|
|
|
|
def test_create_blank_field(self):
|
2012-10-30 01:23:24 +04:00
|
|
|
serializer = self.serializer_class(self.data)
|
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
|
|
|
|
|
|
|
def test_create_model_blank_field(self):
|
|
|
|
serializer = self.model_serializer_class(self.data)
|
2012-10-27 18:37:02 +04:00
|
|
|
self.assertEquals(serializer.is_valid(), True)
|
2012-10-30 01:23:24 +04:00
|
|
|
|
|
|
|
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(self.data)
|
|
|
|
self.assertEquals(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(self.data)
|
|
|
|
self.assertEquals(serializer.is_valid(), False)
|