diff options
Diffstat (limited to 'tests')
| -rw-r--r-- | tests/test_fields.py | 140 | ||||
| -rw-r--r-- | tests/test_generics.py | 2 | ||||
| -rw-r--r-- | tests/test_serializer.py | 62 |
3 files changed, 201 insertions, 3 deletions
diff --git a/tests/test_fields.py b/tests/test_fields.py index b29acad8..1539a210 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -9,7 +9,10 @@ import pytest # Tests for field keyword arguments and core functionality. # --------------------------------------------------------- -class TestFieldOptions: +class TestEmpty: + """ + Tests for `required`, `allow_null`, `allow_blank`, `default`. + """ def test_required(self): """ By default a field must be included in the input. @@ -69,6 +72,17 @@ class TestFieldOptions: output = field.run_validation() assert output is 123 + +class TestSource: + def test_source(self): + class ExampleSerializer(serializers.Serializer): + example_field = serializers.CharField(source='other') + serializer = ExampleSerializer(data={'example_field': 'abc'}) + print serializer.is_valid() + print serializer.data + assert serializer.is_valid() + assert serializer.validated_data == {'other': 'abc'} + def test_redundant_source(self): class ExampleSerializer(serializers.Serializer): example_field = serializers.CharField(source='example_field') @@ -81,6 +95,128 @@ class TestFieldOptions: ) +class TestReadOnly: + def setup(self): + class TestSerializer(serializers.Serializer): + read_only = fields.ReadOnlyField() + writable = fields.IntegerField() + self.Serializer = TestSerializer + + def test_validate_read_only(self): + """ + Read-only fields should not be included in validation. + """ + data = {'read_only': 123, 'writable': 456} + serializer = self.Serializer(data=data) + assert serializer.is_valid() + assert serializer.validated_data == {'writable': 456} + + def test_serialize_read_only(self): + """ + Read-only fields should be serialized. + """ + instance = {'read_only': 123, 'writable': 456} + serializer = self.Serializer(instance) + assert serializer.data == {'read_only': 123, 'writable': 456} + + +class TestWriteOnly: + def setup(self): + class TestSerializer(serializers.Serializer): + write_only = fields.IntegerField(write_only=True) + readable = fields.IntegerField() + self.Serializer = TestSerializer + + def test_validate_write_only(self): + """ + Write-only fields should be included in validation. + """ + data = {'write_only': 123, 'readable': 456} + serializer = self.Serializer(data=data) + assert serializer.is_valid() + assert serializer.validated_data == {'write_only': 123, 'readable': 456} + + def test_serialize_write_only(self): + """ + Write-only fields should not be serialized. + """ + instance = {'write_only': 123, 'readable': 456} + serializer = self.Serializer(instance) + assert serializer.data == {'readable': 456} + + +class TestInitial: + def setup(self): + class TestSerializer(serializers.Serializer): + initial_field = fields.IntegerField(initial=123) + blank_field = fields.IntegerField() + self.serializer = TestSerializer() + + def test_initial(self): + """ + Initial values should be included when serializing a new representation. + """ + assert self.serializer.data == { + 'initial_field': 123, + 'blank_field': None + } + + +class TestLabel: + def setup(self): + class TestSerializer(serializers.Serializer): + labeled = fields.IntegerField(label='My label') + self.serializer = TestSerializer() + + def test_label(self): + """ + A field's label may be set with the `label` argument. + """ + fields = self.serializer.fields + assert fields['labeled'].label == 'My label' + + +class TestInvalidErrorKey: + def setup(self): + class ExampleField(serializers.Field): + def to_native(self, data): + self.fail('incorrect') + self.field = ExampleField() + + def test_invalid_error_key(self): + """ + If a field raises a validation error, but does not have a corresponding + error message, then raise an appropriate assertion error. + """ + with pytest.raises(AssertionError) as exc_info: + self.field.to_native(123) + expected = ( + 'ValidationError raised by `ExampleField`, but error key ' + '`incorrect` does not exist in the `error_messages` dictionary.' + ) + assert str(exc_info.value) == expected + + +class TestBooleanHTMLInput: + def setup(self): + class TestSerializer(serializers.Serializer): + archived = fields.BooleanField() + self.Serializer = TestSerializer + + def test_empty_html_checkbox(self): + """ + HTML checkboxes do not send any value, but should be treated + as `False` by BooleanField. + """ + # This class mocks up a dictionary like object, that behaves + # as if it was returned for multipart or urlencoded data. + class MockHTMLDict(dict): + getlist = None + serializer = self.Serializer(data=MockHTMLDict()) + assert serializer.is_valid() + assert serializer.validated_data == {'archived': False} + + # Tests for field input and output values. # ---------------------------------------- @@ -495,7 +631,7 @@ class TestDateTimeField(FieldValues): '2001-01-01T13:00Z': 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()), - # Note that 1.4 does not support timezone string parsing. + # Django 1.4 does not support timezone string parsing. '2001-01-01T14:00+01:00' if (django.VERSION > (1, 4)) else '2001-01-01T13:00Z': datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()) } invalid_inputs = { diff --git a/tests/test_generics.py b/tests/test_generics.py index 89f9def0..2690fb47 100644 --- a/tests/test_generics.py +++ b/tests/test_generics.py @@ -38,7 +38,7 @@ class FKInstanceView(generics.RetrieveUpdateDestroyAPIView): class SlugSerializer(serializers.ModelSerializer): - slug = serializers.Field(read_only=True) + slug = serializers.ReadOnlyField() class Meta: model = SlugBasedModel diff --git a/tests/test_serializer.py b/tests/test_serializer.py index 5646f994..256a12e6 100644 --- a/tests/test_serializer.py +++ b/tests/test_serializer.py @@ -1,4 +1,5 @@ from rest_framework import serializers +import pytest # Tests for core functionality. @@ -29,6 +30,67 @@ class TestSerializer: assert serializer.validated_data == {'char': 'abc'} assert serializer.errors == {} + def test_empty_serializer(self): + serializer = self.Serializer() + assert serializer.data == {'char': '', 'integer': None} + + def test_missing_attribute_during_serialization(self): + class MissingAttributes: + pass + instance = MissingAttributes() + serializer = self.Serializer(instance) + with pytest.raises(AttributeError): + serializer.data + + +class TestStarredSource: + """ + Tests for `source='*'` argument, which is used for nested representations. + + For example: + + nested_field = NestedField(source='*') + """ + data = { + 'nested1': {'a': 1, 'b': 2}, + 'nested2': {'c': 3, 'd': 4} + } + + def setup(self): + class NestedSerializer1(serializers.Serializer): + a = serializers.IntegerField() + b = serializers.IntegerField() + + class NestedSerializer2(serializers.Serializer): + c = serializers.IntegerField() + d = serializers.IntegerField() + + class TestSerializer(serializers.Serializer): + nested1 = NestedSerializer1(source='*') + nested2 = NestedSerializer2(source='*') + + self.Serializer = TestSerializer + + def test_nested_validate(self): + """ + A nested representation is validated into a flat internal object. + """ + serializer = self.Serializer(data=self.data) + assert serializer.is_valid() + assert serializer.validated_data == { + 'a': 1, + 'b': 2, + 'c': 3, + 'd': 4 + } + + def test_nested_serialize(self): + """ + An object can be serialized into a nested representation. + """ + instance = {'a': 1, 'b': 2, 'c': 3, 'd': 4} + serializer = self.Serializer(instance) + assert serializer.data == self.data # # -*- coding: utf-8 -*- # from __future__ import unicode_literals |