From f27a28682bdb1b4eea0ec9afca2eb2835c735f55 Mon Sep 17 00:00:00 2001 From: Greg Doermann Date: Wed, 20 Aug 2014 11:00:37 -0600 Subject: Frameworks throws AssertionError saying you cannot set required=True and read_only=True on editable=False model fields. We should not make the field required if editable=False. --- rest_framework/serializers.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index be8ad3f2..27af7ef3 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -831,7 +831,7 @@ class ModelSerializer(Serializer): } if model_field: - kwargs['required'] = not(model_field.null or model_field.blank) + kwargs['required'] = not(model_field.null or model_field.blank) and model_field.editable if model_field.help_text is not None: kwargs['help_text'] = model_field.help_text if model_field.verbose_name is not None: @@ -854,7 +854,7 @@ class ModelSerializer(Serializer): """ kwargs = {} - if model_field.null or model_field.blank: + if model_field.null or model_field.blank and model_field.editable: kwargs['required'] = False if isinstance(model_field, models.AutoField) or not model_field.editable: @@ -1110,7 +1110,7 @@ class HyperlinkedModelSerializer(ModelSerializer): } if model_field: - kwargs['required'] = not(model_field.null or model_field.blank) + kwargs['required'] = not(model_field.null or model_field.blank) and model_field.editable if model_field.help_text is not None: kwargs['help_text'] = model_field.help_text if model_field.verbose_name is not None: -- cgit v1.2.3 From 20424251a3da82681fee04c66b7be0c7d3a40fec Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 19 Sep 2014 14:26:28 +0100 Subject: Version 2.4.3 --- docs/topics/release-notes.md | 23 ++++++++++++++++++++--- rest_framework/__init__.py | 2 +- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/docs/topics/release-notes.md b/docs/topics/release-notes.md index d758ae6a..2174cdda 100644 --- a/docs/topics/release-notes.md +++ b/docs/topics/release-notes.md @@ -40,21 +40,37 @@ You can determine your currently installed version using `pip freeze`: ## 2.4.x series +### 2.4.3 + +**Date**: [19th September 2014](https://github.com/tomchristie/django-rest-framework/issues?q=milestone%3A%222.4.3+Release%22+). + +* Support translatable view docstrings being displayed in the browsable API. +* Support [encoded `filename*`][rfc-6266] in raw file uploads with `FileUploadParser`. +* Allow routers to support viewsets that don't include any list routes or that don't include any detail routes. +* Don't render an empty login control in browsable API if `login` view is not included. +* CSRF exemption performed in `.as_view()` to prevent accidental omission if overriding `.dispatch()`. +* Login on browsable API now displays validation errors. +* Bugfix: Fix migration in `authtoken` application. +* Bugfix: Allow selection of integer keys in nested choices. +* Bugfix: Return `None` instead of `'None'` in `CharField` with `allow_none=True`. +* Bugfix: Ensure custom model fields map to equivelent serializer fields more reliably. +* Bugfix: `DjangoFilterBackend` no longer quietly changes queryset ordering. + ### 2.4.2 -**Date**: 3rd September 2014 +**Date**: [3rd September 2014](https://github.com/tomchristie/django-rest-framework/issues?q=milestone%3A%222.4.2+Release%22+). * Bugfix: Fix broken pagination for 2.4.x series. ### 2.4.1 -**Date**: 1st September 2014 +**Date**: [1st September 2014](https://github.com/tomchristie/django-rest-framework/issues?q=milestone%3A%222.4.1+Release%22+). * Bugfix: Fix broken login template for browsable API. ### 2.4.0 -**Date**: 29th August 2014 +**Date**: [29th August 2014](https://github.com/tomchristie/django-rest-framework/issues?q=milestone%3A%222.4.0+Release%22+). **Django version requirements**: The lowest supported version of Django is now 1.4.2. @@ -717,3 +733,4 @@ This change will not affect user code, so long as it's following the recommended [2.1.0-notes]: https://groups.google.com/d/topic/django-rest-framework/Vv2M0CMY9bg/discussion [announcement]: rest-framework-2-announcement.md [#582]: https://github.com/tomchristie/django-rest-framework/issues/582 +[rfc-6266]: http://tools.ietf.org/html/rfc6266#section-4.3 diff --git a/rest_framework/__init__.py b/rest_framework/__init__.py index 8d82a4b9..7f724c18 100644 --- a/rest_framework/__init__.py +++ b/rest_framework/__init__.py @@ -8,7 +8,7 @@ ______ _____ _____ _____ __ """ __title__ = 'Django REST framework' -__version__ = '2.4.2' +__version__ = '2.4.3' __author__ = 'Tom Christie' __license__ = 'BSD 2-Clause' __copyright__ = 'Copyright 2011-2014 Tom Christie' -- cgit v1.2.3 From 8495cd898a5d34f00858a379b54e39cd19ded215 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 19 Sep 2014 14:31:28 +0100 Subject: Drop 'No major point releases are currently planned.', cos they are. --- docs/topics/release-notes.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/topics/release-notes.md b/docs/topics/release-notes.md index 2174cdda..16589f3b 100644 --- a/docs/topics/release-notes.md +++ b/docs/topics/release-notes.md @@ -10,7 +10,7 @@ Minor version numbers (0.0.x) are used for changes that are API compatible. You Medium version numbers (0.x.0) may include API changes, in line with the [deprecation policy][deprecation-policy]. You should read the release notes carefully before upgrading between medium point releases. -Major version numbers (x.0.0) are reserved for substantial project milestones. No major point releases are currently planned. +Major version numbers (x.0.0) are reserved for substantial project milestones. ## Deprecation policy -- cgit v1.2.3 From c0150e619ca02a69d87c335a70c47644e9b2e509 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 19 Sep 2014 14:59:59 +0100 Subject: Add BaseSerializer heading --- docs/topics/3.0-announcement.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 029d9896..cd883cdd 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -30,6 +30,10 @@ See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-fr **TODO**: Drop`.object`, use `.validated_data` or get the instance with `.save()`. +#### The `BaseSerializer` class. + +**TODO** + #### Always use `fields`, not `exclude`. The `exclude` option is no longer available. You should use the more explicit `fields` option instead. -- cgit v1.2.3 From b361c54c5c198583e5085cf49ef44291ec09d2e8 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 19 Sep 2014 15:46:32 +0100 Subject: Test rejigging --- tests/test_breadcrumbs.py | 100 ------------------------------- tests/test_model_serializer.py | 5 ++ tests/test_modelinfo.py | 31 ---------- tests/test_templatetags.py | 35 +++++++++++ tests/test_urlizer.py | 37 ------------ tests/test_utils.py | 132 +++++++++++++++++++++++++++++++++++++++++ 6 files changed, 172 insertions(+), 168 deletions(-) delete mode 100644 tests/test_breadcrumbs.py delete mode 100644 tests/test_modelinfo.py delete mode 100644 tests/test_urlizer.py create mode 100644 tests/test_utils.py diff --git a/tests/test_breadcrumbs.py b/tests/test_breadcrumbs.py deleted file mode 100644 index 780fd5c4..00000000 --- a/tests/test_breadcrumbs.py +++ /dev/null @@ -1,100 +0,0 @@ -from __future__ import unicode_literals -from django.conf.urls import patterns, url -from django.test import TestCase -from rest_framework.utils.breadcrumbs import get_breadcrumbs -from rest_framework.views import APIView - - -class Root(APIView): - pass - - -class ResourceRoot(APIView): - pass - - -class ResourceInstance(APIView): - pass - - -class NestedResourceRoot(APIView): - pass - - -class NestedResourceInstance(APIView): - pass - -urlpatterns = patterns( - '', - url(r'^$', Root.as_view()), - url(r'^resource/$', ResourceRoot.as_view()), - url(r'^resource/(?P[0-9]+)$', ResourceInstance.as_view()), - url(r'^resource/(?P[0-9]+)/$', NestedResourceRoot.as_view()), - url(r'^resource/(?P[0-9]+)/(?P[A-Za-z]+)$', NestedResourceInstance.as_view()), -) - - -class BreadcrumbTests(TestCase): - """Tests the breadcrumb functionality used by the HTML renderer.""" - - urls = 'tests.test_breadcrumbs' - - def test_root_breadcrumbs(self): - url = '/' - self.assertEqual( - get_breadcrumbs(url), - [('Root', '/')] - ) - - def test_resource_root_breadcrumbs(self): - url = '/resource/' - self.assertEqual( - get_breadcrumbs(url), - [ - ('Root', '/'), - ('Resource Root', '/resource/') - ] - ) - - def test_resource_instance_breadcrumbs(self): - url = '/resource/123' - self.assertEqual( - get_breadcrumbs(url), - [ - ('Root', '/'), - ('Resource Root', '/resource/'), - ('Resource Instance', '/resource/123') - ] - ) - - def test_nested_resource_breadcrumbs(self): - url = '/resource/123/' - self.assertEqual( - get_breadcrumbs(url), - [ - ('Root', '/'), - ('Resource Root', '/resource/'), - ('Resource Instance', '/resource/123'), - ('Nested Resource Root', '/resource/123/') - ] - ) - - def test_nested_resource_instance_breadcrumbs(self): - url = '/resource/123/abc' - self.assertEqual( - get_breadcrumbs(url), - [ - ('Root', '/'), - ('Resource Root', '/resource/'), - ('Resource Instance', '/resource/123'), - ('Nested Resource Root', '/resource/123/'), - ('Nested Resource Instance', '/resource/123/abc') - ] - ) - - def test_broken_url_breadcrumbs_handled_gracefully(self): - url = '/foobar' - self.assertEqual( - get_breadcrumbs(url), - [('Root', '/')] - ) diff --git a/tests/test_model_serializer.py b/tests/test_model_serializer.py index ec922b6d..d518dd58 100644 --- a/tests/test_model_serializer.py +++ b/tests/test_model_serializer.py @@ -24,6 +24,9 @@ class CustomField(models.Field): pass +COLOR_CHOICES = (('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')) + + class RegularFieldsModel(models.Model): """ A model class for testing regular flat fields. @@ -32,6 +35,7 @@ class RegularFieldsModel(models.Model): big_integer_field = models.BigIntegerField() boolean_field = models.BooleanField(default=False) char_field = models.CharField(max_length=100) + choices_field = models.CharField(max_length=100, choices=COLOR_CHOICES) comma_seperated_integer_field = models.CommaSeparatedIntegerField(max_length=100) date_field = models.DateField() datetime_field = models.DateTimeField() @@ -68,6 +72,7 @@ class TestRegularFieldMappings(TestCase): big_integer_field = IntegerField() boolean_field = BooleanField(default=False) char_field = CharField(max_length=100) + choices_field = ChoiceField(choices=[('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')]) comma_seperated_integer_field = CharField(max_length=100, validators=[]) date_field = DateField() datetime_field = DateTimeField() diff --git a/tests/test_modelinfo.py b/tests/test_modelinfo.py deleted file mode 100644 index 04b67f04..00000000 --- a/tests/test_modelinfo.py +++ /dev/null @@ -1,31 +0,0 @@ -from django.test import TestCase -from django.utils import six -from rest_framework.utils.model_meta import _resolve_model -from tests.models import BasicModel - - -class ResolveModelTests(TestCase): - """ - `_resolve_model` should return a Django model class given the - provided argument is a Django model class itself, or a properly - formatted string representation of one. - """ - def test_resolve_django_model(self): - resolved_model = _resolve_model(BasicModel) - self.assertEqual(resolved_model, BasicModel) - - def test_resolve_string_representation(self): - resolved_model = _resolve_model('tests.BasicModel') - self.assertEqual(resolved_model, BasicModel) - - def test_resolve_unicode_representation(self): - resolved_model = _resolve_model(six.text_type('tests.BasicModel')) - self.assertEqual(resolved_model, BasicModel) - - def test_resolve_non_django_model(self): - with self.assertRaises(ValueError): - _resolve_model(TestCase) - - def test_resolve_improper_string_representation(self): - with self.assertRaises(ValueError): - _resolve_model('BasicModel') diff --git a/tests/test_templatetags.py b/tests/test_templatetags.py index 75ee0eaa..b04a937e 100644 --- a/tests/test_templatetags.py +++ b/tests/test_templatetags.py @@ -4,6 +4,7 @@ from django.test import TestCase from rest_framework.test import APIRequestFactory from rest_framework.templatetags.rest_framework import add_query_param, urlize_quoted_links + factory = APIRequestFactory() @@ -49,3 +50,37 @@ class Issue1386Tests(TestCase): # example from issue #1386, this shouldn't raise an exception urlize_quoted_links("asdf:[/p]zxcv.com") + + +class URLizerTests(TestCase): + """ + Test if both JSON and YAML URLs are transformed into links well + """ + def _urlize_dict_check(self, data): + """ + For all items in dict test assert that the value is urlized key + """ + for original, urlized in data.items(): + assert urlize_quoted_links(original, nofollow=False) == urlized + + def test_json_with_url(self): + """ + Test if JSON URLs are transformed into links well + """ + data = {} + data['"url": "http://api/users/1/", '] = \ + '"url": "http://api/users/1/", ' + data['"foo_set": [\n "http://api/foos/1/"\n], '] = \ + '"foo_set": [\n "http://api/foos/1/"\n], ' + self._urlize_dict_check(data) + + def test_yaml_with_url(self): + """ + Test if YAML URLs are transformed into links well + """ + data = {} + data['''{users: 'http://api/users/'}'''] = \ + '''{users: 'http://api/users/'}''' + data['''foo_set: ['http://api/foos/1/']'''] = \ + '''foo_set: ['http://api/foos/1/']''' + self._urlize_dict_check(data) diff --git a/tests/test_urlizer.py b/tests/test_urlizer.py deleted file mode 100644 index a77aa22a..00000000 --- a/tests/test_urlizer.py +++ /dev/null @@ -1,37 +0,0 @@ -from __future__ import unicode_literals -from django.test import TestCase -from rest_framework.templatetags.rest_framework import urlize_quoted_links - - -class URLizerTests(TestCase): - """ - Test if both JSON and YAML URLs are transformed into links well - """ - def _urlize_dict_check(self, data): - """ - For all items in dict test assert that the value is urlized key - """ - for original, urlized in data.items(): - assert urlize_quoted_links(original, nofollow=False) == urlized - - def test_json_with_url(self): - """ - Test if JSON URLs are transformed into links well - """ - data = {} - data['"url": "http://api/users/1/", '] = \ - '"url": "http://api/users/1/", ' - data['"foo_set": [\n "http://api/foos/1/"\n], '] = \ - '"foo_set": [\n "http://api/foos/1/"\n], ' - self._urlize_dict_check(data) - - def test_yaml_with_url(self): - """ - Test if YAML URLs are transformed into links well - """ - data = {} - data['''{users: 'http://api/users/'}'''] = \ - '''{users: 'http://api/users/'}''' - data['''foo_set: ['http://api/foos/1/']'''] = \ - '''foo_set: ['http://api/foos/1/']''' - self._urlize_dict_check(data) diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 00000000..96c5f997 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,132 @@ +from __future__ import unicode_literals +from django.conf.urls import patterns, url +from django.test import TestCase +from django.utils import six +from rest_framework.utils.model_meta import _resolve_model +from rest_framework.utils.breadcrumbs import get_breadcrumbs +from rest_framework.views import APIView +from tests.models import BasicModel + + +class Root(APIView): + pass + + +class ResourceRoot(APIView): + pass + + +class ResourceInstance(APIView): + pass + + +class NestedResourceRoot(APIView): + pass + + +class NestedResourceInstance(APIView): + pass + + +urlpatterns = patterns( + '', + url(r'^$', Root.as_view()), + url(r'^resource/$', ResourceRoot.as_view()), + url(r'^resource/(?P[0-9]+)$', ResourceInstance.as_view()), + url(r'^resource/(?P[0-9]+)/$', NestedResourceRoot.as_view()), + url(r'^resource/(?P[0-9]+)/(?P[A-Za-z]+)$', NestedResourceInstance.as_view()), +) + + +class BreadcrumbTests(TestCase): + """ + Tests the breadcrumb functionality used by the HTML renderer. + """ + urls = 'tests.test_utils' + + def test_root_breadcrumbs(self): + url = '/' + self.assertEqual( + get_breadcrumbs(url), + [('Root', '/')] + ) + + def test_resource_root_breadcrumbs(self): + url = '/resource/' + self.assertEqual( + get_breadcrumbs(url), + [ + ('Root', '/'), + ('Resource Root', '/resource/') + ] + ) + + def test_resource_instance_breadcrumbs(self): + url = '/resource/123' + self.assertEqual( + get_breadcrumbs(url), + [ + ('Root', '/'), + ('Resource Root', '/resource/'), + ('Resource Instance', '/resource/123') + ] + ) + + def test_nested_resource_breadcrumbs(self): + url = '/resource/123/' + self.assertEqual( + get_breadcrumbs(url), + [ + ('Root', '/'), + ('Resource Root', '/resource/'), + ('Resource Instance', '/resource/123'), + ('Nested Resource Root', '/resource/123/') + ] + ) + + def test_nested_resource_instance_breadcrumbs(self): + url = '/resource/123/abc' + self.assertEqual( + get_breadcrumbs(url), + [ + ('Root', '/'), + ('Resource Root', '/resource/'), + ('Resource Instance', '/resource/123'), + ('Nested Resource Root', '/resource/123/'), + ('Nested Resource Instance', '/resource/123/abc') + ] + ) + + def test_broken_url_breadcrumbs_handled_gracefully(self): + url = '/foobar' + self.assertEqual( + get_breadcrumbs(url), + [('Root', '/')] + ) + + +class ResolveModelTests(TestCase): + """ + `_resolve_model` should return a Django model class given the + provided argument is a Django model class itself, or a properly + formatted string representation of one. + """ + def test_resolve_django_model(self): + resolved_model = _resolve_model(BasicModel) + self.assertEqual(resolved_model, BasicModel) + + def test_resolve_string_representation(self): + resolved_model = _resolve_model('tests.BasicModel') + self.assertEqual(resolved_model, BasicModel) + + def test_resolve_unicode_representation(self): + resolved_model = _resolve_model(six.text_type('tests.BasicModel')) + self.assertEqual(resolved_model, BasicModel) + + def test_resolve_non_django_model(self): + with self.assertRaises(ValueError): + _resolve_model(TestCase) + + def test_resolve_improper_string_representation(self): + with self.assertRaises(ValueError): + _resolve_model('BasicModel') -- cgit v1.2.3 From cf72b9a8b755652cec4ad19a27488e3a79c2e401 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 19 Sep 2014 16:43:13 +0100 Subject: Moar tests --- rest_framework/serializers.py | 2 ++ tests/test_model_serializer.py | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 35 insertions(+) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index d2740fc2..d9f9c8cb 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -24,6 +24,7 @@ from rest_framework.utils.field_mapping import ( lookup_class ) import copy +import inspect # Note: We do the following so that users of the framework can use this style: # @@ -268,6 +269,7 @@ class ListSerializer(BaseSerializer): def __init__(self, *args, **kwargs): self.child = kwargs.pop('child', copy.deepcopy(self.child)) assert self.child is not None, '`child` is a required argument.' + assert not inspect.isclass(self.child), '`child` has not been instantiated.' self.context = kwargs.pop('context', {}) kwargs.pop('partial', None) diff --git a/tests/test_model_serializer.py b/tests/test_model_serializer.py index d518dd58..d9f9efbe 100644 --- a/tests/test_model_serializer.py +++ b/tests/test_model_serializer.py @@ -473,3 +473,36 @@ class TestIntegration(TestCase): 'through': [] } self.assertEqual(serializer.data, expected) + + +# Tests for bulk create using `ListSerializer`. + +class BulkCreateModel(models.Model): + name = models.CharField(max_length=10) + + +class TestBulkCreate(TestCase): + def test_bulk_create(self): + class BasicModelSerializer(serializers.ModelSerializer): + class Meta: + model = BulkCreateModel + fields = ('name',) + + class BulkCreateSerializer(serializers.ListSerializer): + child = BasicModelSerializer() + + data = [{'name': 'a'}, {'name': 'b'}, {'name': 'c'}] + serializer = BulkCreateSerializer(data=data) + assert serializer.is_valid() + + # Objects are returned by save(). + instances = serializer.save() + assert len(instances) == 3 + assert [item.name for item in instances] == ['a', 'b', 'c'] + + # Objects have been created in the database. + assert BulkCreateModel.objects.count() == 3 + assert list(BulkCreateModel.objects.values_list('name', flat=True)) == ['a', 'b', 'c'] + + # Serializer returns correct data. + assert serializer.data == data -- cgit v1.2.3 From af46fd6b00f1d7f018049c19094af58acb1415fb Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 12:25:57 +0100 Subject: Field tests and associated cleanup --- rest_framework/fields.py | 64 +++++---- tests/test_fields.py | 334 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 365 insertions(+), 33 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 0c78b3fb..db75ddf9 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -12,7 +12,6 @@ from rest_framework.utils import html, representation, humanize_datetime import datetime import decimal import inspect -import warnings class empty: @@ -395,7 +394,7 @@ class IntegerField(Field): class FloatField(Field): default_error_messages = { - 'invalid': _("'%s' value must be a float."), + 'invalid': _("A valid number is required."), } def __init__(self, **kwargs): @@ -410,20 +409,20 @@ class FloatField(Field): def to_internal_value(self, value): if value is None: return None - return float(value) + try: + return float(value) + except (TypeError, ValueError): + self.fail('invalid') def to_representation(self, value): if value is None: return None - try: - return float(value) - except (TypeError, ValueError): - self.fail('invalid', value=value) + return float(value) class DecimalField(Field): default_error_messages = { - 'invalid': _('Enter a number.'), + 'invalid': _('A valid number is required.'), 'max_value': _('Ensure this value is less than or equal to {max_value}.'), 'min_value': _('Ensure this value is greater than or equal to {min_value}.'), 'max_digits': _('Ensure that there are no more than {max_digits} digits in total.'), @@ -485,7 +484,7 @@ class DecimalField(Field): if self.decimal_places is not None and decimals > self.decimal_places: self.fail('max_decimal_places', max_decimal_places=self.decimal_places) if self.max_digits is not None and self.decimal_places is not None and whole_digits > (self.max_digits - self.decimal_places): - self.fail('max_whole_digits', max_while_digits=self.max_digits - self.decimal_places) + self.fail('max_whole_digits', max_whole_digits=self.max_digits - self.decimal_places) return value @@ -511,6 +510,7 @@ class DecimalField(Field): class DateField(Field): default_error_messages = { 'invalid': _('Date has wrong format. Use one of these formats instead: {format}'), + 'datetime': _('Expected a date but got a datetime.'), } format = api_settings.DATE_FORMAT input_formats = api_settings.DATE_INPUT_FORMATS @@ -525,12 +525,7 @@ class DateField(Field): return None if isinstance(value, datetime.datetime): - if timezone and settings.USE_TZ and timezone.is_aware(value): - # Convert aware datetimes to the default time zone - # before casting them to dates (#17742). - default_timezone = timezone.get_default_timezone() - value = timezone.make_naive(value, default_timezone) - return value.date() + self.fail('datetime') if isinstance(value, datetime.date): return value @@ -570,35 +565,38 @@ class DateField(Field): class DateTimeField(Field): default_error_messages = { 'invalid': _('Datetime has wrong format. Use one of these formats instead: {format}'), + 'date': _('Expected a datetime but got a date.'), } format = api_settings.DATETIME_FORMAT input_formats = api_settings.DATETIME_INPUT_FORMATS + default_timezone = timezone.get_default_timezone() if settings.USE_TZ else None - def __init__(self, format=None, input_formats=None, *args, **kwargs): + def __init__(self, format=None, input_formats=None, default_timezone=None, *args, **kwargs): self.format = format if format is not None else self.format self.input_formats = input_formats if input_formats is not None else self.input_formats + self.default_timezone = default_timezone if default_timezone is not None else self.default_timezone super(DateTimeField, self).__init__(*args, **kwargs) + def enforce_timezone(self, value): + """ + When `self.default_timezone` is `None`, always return naive datetimes. + When `self.default_timezone` is not `None`, always return aware datetimes. + """ + if (self.default_timezone is not None) and not timezone.is_aware(value): + return timezone.make_aware(value, self.default_timezone) + elif (self.default_timezone is None) and timezone.is_aware(value): + return timezone.make_naive(value, timezone.UTC()) + return value + def to_internal_value(self, value): if value in (None, ''): return None - if isinstance(value, datetime.datetime): - return value + if isinstance(value, datetime.date) and not isinstance(value, datetime.datetime): + self.fail('date') - if isinstance(value, datetime.date): - value = datetime.datetime(value.year, value.month, value.day) - if settings.USE_TZ: - # For backwards compatibility, interpret naive datetimes in - # local time. This won't work during DST change, but we can't - # do much about it, so we let the exceptions percolate up the - # call stack. - warnings.warn("DateTimeField received a naive datetime (%s)" - " while time zone support is active." % value, - RuntimeWarning) - default_timezone = timezone.get_default_timezone() - value = timezone.make_aware(value, default_timezone) - return value + if isinstance(value, datetime.datetime): + return self.enforce_timezone(value) for format in self.input_formats: if format.lower() == ISO_8601: @@ -608,14 +606,14 @@ class DateTimeField(Field): pass else: if parsed is not None: - return parsed + return self.enforce_timezone(parsed) else: try: parsed = datetime.datetime.strptime(value, format) except (ValueError, TypeError): pass else: - return parsed + return self.enforce_timezone(parsed) humanized_format = humanize_datetime.datetime_formats(self.input_formats) self.fail('invalid', format=humanized_format) diff --git a/tests/test_fields.py b/tests/test_fields.py index a92fafbc..6ec18041 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -1,3 +1,337 @@ +from decimal import Decimal +from django.utils import timezone +from rest_framework import fields +import datetime +import pytest + + +class ValidAndInvalidValues: + """ + Base class for testing valid and invalid field values. + """ + def test_valid_values(self): + """ + Ensure that valid values return the expected validated data. + """ + for input_value, expected_output in self.valid_mappings.items(): + assert self.field.run_validation(input_value) == expected_output + + def test_invalid_values(self): + """ + Ensure that invalid values raise the expected validation error. + """ + for input_value, expected_failure in self.invalid_mappings.items(): + with pytest.raises(fields.ValidationError) as exc_info: + self.field.run_validation(input_value) + assert exc_info.value.messages == expected_failure + + +class TestCharField(ValidAndInvalidValues): + valid_mappings = { + 1: '1', + 'abc': 'abc' + } + invalid_mappings = { + '': ['This field may not be blank.'] + } + field = fields.CharField() + + +class TestBooleanField(ValidAndInvalidValues): + valid_mappings = { + 'true': True, + 'false': False, + '1': True, + '0': False, + 1: True, + 0: False, + True: True, + False: False, + } + invalid_mappings = { + 'foo': ['`foo` is not a valid boolean.'] + } + field = fields.BooleanField() + + +# Number types... + +class TestIntegerField(ValidAndInvalidValues): + """ + Valid and invalid values for `IntegerField`. + """ + valid_mappings = { + '1': 1, + '0': 0, + 1: 1, + 0: 0, + 1.0: 1, + 0.0: 0 + } + invalid_mappings = { + 'abc': ['A valid integer is required.'] + } + field = fields.IntegerField() + + +class TestMinMaxIntegerField(ValidAndInvalidValues): + """ + Valid and invalid values for `IntegerField` with min and max limits. + """ + valid_mappings = { + '1': 1, + '3': 3, + 1: 1, + 3: 3, + } + invalid_mappings = { + 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.'], + } + field = fields.IntegerField(min_value=1, max_value=3) + + +class TestFloatField(ValidAndInvalidValues): + """ + Valid and invalid values for `FloatField`. + """ + valid_mappings = { + '1': 1.0, + '0': 0.0, + 1: 1.0, + 0: 0.0, + 1.0: 1.0, + 0.0: 0.0, + } + invalid_mappings = { + 'abc': ["A valid number is required."] + } + field = fields.FloatField() + + +class TestMinMaxFloatField(ValidAndInvalidValues): + """ + Valid and invalid values for `FloatField` with min and max limits. + """ + valid_mappings = { + '1': 1, + '3': 3, + 1: 1, + 3: 3, + 1.0: 1.0, + 3.0: 3.0, + } + invalid_mappings = { + 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.'], + } + field = fields.FloatField(min_value=1, max_value=3) + + +class TestDecimalField(ValidAndInvalidValues): + """ + Valid and invalid values for `DecimalField`. + """ + valid_mappings = { + '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_mappings = { + '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."] + } + field = fields.DecimalField(max_digits=3, decimal_places=1) + + +class TestMinMaxDecimalField(ValidAndInvalidValues): + """ + Valid and invalid values for `DecimalField` with min and max limits. + """ + valid_mappings = { + '10.0': 10.0, + '20.0': 20.0, + } + invalid_mappings = { + '9.9': ['Ensure this value is greater than or equal to 10.'], + '20.1': ['Ensure this value is less than or equal to 20.'], + } + field = fields.DecimalField( + max_digits=3, decimal_places=1, + min_value=10, max_value=20 + ) + + +# Date & time fields... + +class TestDateField(ValidAndInvalidValues): + """ + Valid and invalid values for `DateField`. + """ + valid_mappings = { + '2001-01-01': datetime.date(2001, 1, 1), + datetime.date(2001, 1, 1): datetime.date(2001, 1, 1), + } + invalid_mappings = { + '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.'], + } + field = fields.DateField() + + +class TestCustomInputFormatDateField(ValidAndInvalidValues): + """ + Valid and invalid values for `DateField` with a cutom input format. + """ + valid_mappings = { + '1 Jan 2001': datetime.date(2001, 1, 1), + } + invalid_mappings = { + '2001-01-01': ['Date has wrong format. Use one of these formats instead: DD [Jan-Dec] YYYY'] + } + field = fields.DateField(input_formats=['%d %b %Y']) + + +class TestDateTimeField(ValidAndInvalidValues): + """ + Valid and invalid values for `DateTimeField`. + """ + valid_mappings = { + '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_mappings = { + '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.'], + } + field = fields.DateTimeField(default_timezone=timezone.UTC()) + + +class TestCustomInputFormatDateTimeField(ValidAndInvalidValues): + """ + Valid and invalid values for `DateTimeField` with a cutom input format. + """ + valid_mappings = { + '1:35pm, 1 Jan 2001': datetime.datetime(2001, 1, 1, 13, 35, tzinfo=timezone.UTC()), + } + invalid_mappings = { + '2001-01-01T20:50': ['Datetime has wrong format. Use one of these formats instead: hh:mm[AM|PM], DD [Jan-Dec] YYYY'] + } + field = fields.DateTimeField(default_timezone=timezone.UTC(), input_formats=['%I:%M%p, %d %b %Y']) + + +class TestNaiveDateTimeField(ValidAndInvalidValues): + """ + Valid and invalid values for `DateTimeField` with naive datetimes. + """ + valid_mappings = { + 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_mappings = {} + field = fields.DateTimeField(default_timezone=None) + + +# Choice types... + +class TestChoiceField(ValidAndInvalidValues): + """ + Valid and invalid values for `ChoiceField`. + """ + valid_mappings = { + 'poor': 'poor', + 'medium': 'medium', + 'good': 'good', + } + invalid_mappings = { + 'awful': ['`awful` is not a valid choice.'] + } + field = fields.ChoiceField( + choices=[ + ('poor', 'Poor quality'), + ('medium', 'Medium quality'), + ('good', 'Good quality'), + ] + ) + + +class TestChoiceFieldWithType(ValidAndInvalidValues): + """ + Valid and invalid values for a `Choice` field that uses an integer type, + instead of a char type. + """ + valid_mappings = { + '1': 1, + 3: 3, + } + invalid_mappings = { + 5: ['`5` is not a valid choice.'], + 'abc': ['`abc` is not a valid choice.'] + } + field = fields.ChoiceField( + choices=[ + (1, 'Poor quality'), + (2, 'Medium quality'), + (3, 'Good quality'), + ] + ) + + +class TestChoiceFieldWithListChoices(ValidAndInvalidValues): + """ + 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_mappings = { + 'poor': 'poor', + 'medium': 'medium', + 'good': 'good', + } + invalid_mappings = { + 'awful': ['`awful` is not a valid choice.'] + } + field = fields.ChoiceField(choices=('poor', 'medium', 'good')) + + +class TestMultipleChoiceField(ValidAndInvalidValues): + """ + Valid and invalid values for `MultipleChoiceField`. + """ + valid_mappings = { + (): set(), + ('aircon',): set(['aircon']), + ('aircon', 'manual'): set(['aircon', 'manual']), + } + invalid_mappings = { + 'abc': ['Expected a list of items but got type `str`'], + ('aircon', 'incorrect'): ['`incorrect` is not a valid choice.'] + } + field = fields.MultipleChoiceField( + choices=[ + ('aircon', 'AirCon'), + ('manual', 'Manual drive'), + ('diesel', 'Diesel'), + ] + ) + + # """ # General serializer field tests. # """ -- cgit v1.2.3 From afb3f8ab0ad6c33b147292e9777ba0ddf3871d14 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 13:26:47 +0100 Subject: Tests and tweaks for text fields --- rest_framework/fields.py | 32 ++++++++++++----- tests/test_fields.py | 93 ++++++++++++++++++++++++++++++++++++++++++------ 2 files changed, 107 insertions(+), 18 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index db75ddf9..35bd5c4b 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -12,6 +12,7 @@ from rest_framework.utils import html, representation, humanize_datetime import datetime import decimal import inspect +import re class empty: @@ -325,7 +326,11 @@ class EmailField(CharField): default_error_messages = { 'invalid': _('Enter a valid email address.') } - default_validators = [validators.validate_email] + + def __init__(self, **kwargs): + super(EmailField, self).__init__(**kwargs) + validator = validators.EmailValidator(message=self.error_messages['invalid']) + self.validators = [validator] + self.validators def to_internal_value(self, data): if data == '' and not self.allow_blank: @@ -341,26 +346,37 @@ class EmailField(CharField): class RegexField(CharField): + default_error_messages = { + 'invalid': _('This value does not match the required pattern.') + } + def __init__(self, regex, **kwargs): - kwargs['validators'] = ( - [validators.RegexValidator(regex)] + - kwargs.get('validators', []) - ) super(RegexField, self).__init__(**kwargs) + validator = validators.RegexValidator(regex, message=self.error_messages['invalid']) + self.validators = [validator] + self.validators class SlugField(CharField): default_error_messages = { 'invalid': _("Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens.") } - default_validators = [validators.validate_slug] + + def __init__(self, **kwargs): + super(SlugField, self).__init__(**kwargs) + slug_regex = re.compile(r'^[-a-zA-Z0-9_]+$') + validator = validators.RegexValidator(slug_regex, message=self.error_messages['invalid']) + self.validators = [validator] + self.validators class URLField(CharField): default_error_messages = { 'invalid': _("Enter a valid URL.") } - default_validators = [validators.URLValidator()] + + def __init__(self, **kwargs): + super(URLField, self).__init__(**kwargs) + validator = validators.URLValidator(message=self.error_messages['invalid']) + self.validators = [validator] + self.validators # Number types... @@ -642,7 +658,7 @@ class TimeField(Field): self.input_formats = input_formats if input_formats is not None else self.input_formats super(TimeField, self).__init__(*args, **kwargs) - def from_native(self, value): + def to_internal_value(self, value): if value in (None, ''): return None diff --git a/tests/test_fields.py b/tests/test_fields.py index 6ec18041..ae7f1919 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -26,16 +26,7 @@ class ValidAndInvalidValues: assert exc_info.value.messages == expected_failure -class TestCharField(ValidAndInvalidValues): - valid_mappings = { - 1: '1', - 'abc': 'abc' - } - invalid_mappings = { - '': ['This field may not be blank.'] - } - field = fields.CharField() - +# Boolean types... class TestBooleanField(ValidAndInvalidValues): valid_mappings = { @@ -54,6 +45,60 @@ class TestBooleanField(ValidAndInvalidValues): field = fields.BooleanField() +# String types... + +class TestCharField(ValidAndInvalidValues): + valid_mappings = { + 1: '1', + 'abc': 'abc' + } + invalid_mappings = { + '': ['This field may not be blank.'] + } + field = fields.CharField() + + +class TestEmailField(ValidAndInvalidValues): + valid_mappings = { + 'example@example.com': 'example@example.com', + ' example@example.com ': 'example@example.com', + } + invalid_mappings = { + 'example.com': ['Enter a valid email address.'] + } + field = fields.EmailField() + + +class TestRegexField(ValidAndInvalidValues): + valid_mappings = { + 'a9': 'a9', + } + invalid_mappings = { + 'A9': ["This value does not match the required pattern."] + } + field = fields.RegexField(regex='[a-z][0-9]') + + +class TestSlugField(ValidAndInvalidValues): + valid_mappings = { + 'slug-99': 'slug-99', + } + invalid_mappings = { + 'slug 99': ["Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."] + } + field = fields.SlugField() + + +class TestURLField(ValidAndInvalidValues): + valid_mappings = { + 'http://example.com': 'http://example.com', + } + invalid_mappings = { + 'example.com': ['Enter a valid URL.'] + } + field = fields.URLField() + + # Number types... class TestIntegerField(ValidAndInvalidValues): @@ -249,6 +294,34 @@ class TestNaiveDateTimeField(ValidAndInvalidValues): field = fields.DateTimeField(default_timezone=None) +class TestTimeField(ValidAndInvalidValues): + """ + Valid and invalid values for `TimeField`. + """ + valid_mappings = { + '13:00': datetime.time(13, 00), + datetime.time(13, 00): datetime.time(13, 00), + } + invalid_mappings = { + '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]]'], + } + field = fields.TimeField() + + +class TestCustomInputFormatTimeField(ValidAndInvalidValues): + """ + Valid and invalid values for `TimeField` with a custom input format. + """ + valid_mappings = { + '1:00pm': datetime.time(13, 00), + } + invalid_mappings = { + '13:00': ['Time has wrong format. Use one of these formats instead: hh:mm[AM|PM]'], + } + field = fields.TimeField(input_formats=['%I:%M%p']) + + # Choice types... class TestChoiceField(ValidAndInvalidValues): -- cgit v1.2.3 From c54f394904c3f93211b8aa073de4e9e50110f831 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 13:57:45 +0100 Subject: Ensure 'messages' in fields are respected in preference to default validator messages --- rest_framework/compat.py | 19 +++++++++++++++++++ rest_framework/fields.py | 34 ++++++++++++++++++++++------------ 2 files changed, 41 insertions(+), 12 deletions(-) diff --git a/rest_framework/compat.py b/rest_framework/compat.py index 7c05bed9..2b4ddb02 100644 --- a/rest_framework/compat.py +++ b/rest_framework/compat.py @@ -121,6 +121,25 @@ else: return [m.upper() for m in self.http_method_names if hasattr(self, m)] + +# MinValueValidator and MaxValueValidator only accept `message` in 1.8+ +if django.VERSION >= (1, 8): + from django.core.validators import MinValueValidator, MaxValueValidator +else: + from django.core.validators import MinValueValidator as DjangoMinValueValidator + from django.core.validators import MaxValueValidator as DjangoMaxValueValidator + + class MinValueValidator(DjangoMinValueValidator): + def __init__(self, *args, **kwargs): + self.message = kwargs.pop('message', self.message) + super(MinValueValidator, self).__init__(*args, **kwargs) + + class MaxValueValidator(DjangoMaxValueValidator): + def __init__(self, *args, **kwargs): + self.message = kwargs.pop('message', self.message) + super(MaxValueValidator, self).__init__(*args, **kwargs) + + # PATCH method is not implemented by Django if 'patch' not in View.http_method_names: View.http_method_names = View.http_method_names + ['patch'] diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 35bd5c4b..5105dfcb 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -6,7 +6,7 @@ from django.utils.dateparse import parse_date, parse_datetime, parse_time from django.utils.encoding import is_protected_type from django.utils.translation import ugettext_lazy as _ from rest_framework import ISO_8601 -from rest_framework.compat import smart_text +from rest_framework.compat import smart_text, MinValueValidator, MaxValueValidator from rest_framework.settings import api_settings from rest_framework.utils import html, representation, humanize_datetime import datetime @@ -330,7 +330,7 @@ class EmailField(CharField): def __init__(self, **kwargs): super(EmailField, self).__init__(**kwargs) validator = validators.EmailValidator(message=self.error_messages['invalid']) - self.validators = [validator] + self.validators + self.validators.append(validator) def to_internal_value(self, data): if data == '' and not self.allow_blank: @@ -353,7 +353,7 @@ class RegexField(CharField): def __init__(self, regex, **kwargs): super(RegexField, self).__init__(**kwargs) validator = validators.RegexValidator(regex, message=self.error_messages['invalid']) - self.validators = [validator] + self.validators + self.validators.append(validator) class SlugField(CharField): @@ -365,7 +365,7 @@ class SlugField(CharField): super(SlugField, self).__init__(**kwargs) slug_regex = re.compile(r'^[-a-zA-Z0-9_]+$') validator = validators.RegexValidator(slug_regex, message=self.error_messages['invalid']) - self.validators = [validator] + self.validators + self.validators.append(validator) class URLField(CharField): @@ -376,14 +376,16 @@ class URLField(CharField): def __init__(self, **kwargs): super(URLField, self).__init__(**kwargs) validator = validators.URLValidator(message=self.error_messages['invalid']) - self.validators = [validator] + self.validators + self.validators.append(validator) # Number types... class IntegerField(Field): default_error_messages = { - 'invalid': _('A valid integer is required.') + 'invalid': _('A valid integer is required.'), + 'max_value': _('Ensure this value is less than or equal to {max_value}.'), + 'min_value': _('Ensure this value is greater than or equal to {min_value}.'), } def __init__(self, **kwargs): @@ -391,9 +393,11 @@ class IntegerField(Field): min_value = kwargs.pop('min_value', None) super(IntegerField, self).__init__(**kwargs) if max_value is not None: - self.validators.append(validators.MaxValueValidator(max_value)) + message = self.error_messages['max_value'].format(max_value=max_value) + self.validators.append(MaxValueValidator(max_value, message=message)) if min_value is not None: - self.validators.append(validators.MinValueValidator(min_value)) + message = self.error_messages['min_value'].format(min_value=min_value) + self.validators.append(MinValueValidator(min_value, message=message)) def to_internal_value(self, data): try: @@ -411,6 +415,8 @@ class IntegerField(Field): class FloatField(Field): default_error_messages = { 'invalid': _("A valid number is required."), + 'max_value': _('Ensure this value is less than or equal to {max_value}.'), + 'min_value': _('Ensure this value is greater than or equal to {min_value}.'), } def __init__(self, **kwargs): @@ -418,9 +424,11 @@ class FloatField(Field): min_value = kwargs.pop('min_value', None) super(FloatField, self).__init__(**kwargs) if max_value is not None: - self.validators.append(validators.MaxValueValidator(max_value)) + message = self.error_messages['max_value'].format(max_value=max_value) + self.validators.append(MaxValueValidator(max_value, message=message)) if min_value is not None: - self.validators.append(validators.MinValueValidator(min_value)) + message = self.error_messages['min_value'].format(min_value=min_value) + self.validators.append(MinValueValidator(min_value, message=message)) def to_internal_value(self, value): if value is None: @@ -454,9 +462,11 @@ class DecimalField(Field): self.coerce_to_string = coerce_to_string if (coerce_to_string is not None) else self.coerce_to_string super(DecimalField, self).__init__(**kwargs) if max_value is not None: - self.validators.append(validators.MaxValueValidator(max_value)) + message = self.error_messages['max_value'].format(max_value=max_value) + self.validators.append(MaxValueValidator(max_value, message=message)) if min_value is not None: - self.validators.append(validators.MinValueValidator(min_value)) + message = self.error_messages['min_value'].format(min_value=min_value) + self.validators.append(MinValueValidator(min_value, message=message)) def to_internal_value(self, value): """ -- cgit v1.2.3 From 249253a144ba4381581809fb3f27959c7bd6e577 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 14:54:33 +0100 Subject: Fix compat issues --- rest_framework/fields.py | 13 ++++++++++--- tests/test_fields.py | 31 ++++++++++++++++++++----------- 2 files changed, 30 insertions(+), 14 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 5105dfcb..5fb99a42 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -209,8 +209,10 @@ class Field(object): """ Validate a simple representation and return the internal value. - The provided data may be `empty` if no representation was included. - May return `empty` if the field should not be included in the + The provided data may be `empty` if no representation was included + in the input. + + May raise `SkipField` if the field should not be included in the validated data. """ if data is empty: @@ -223,6 +225,10 @@ class Field(object): return value def run_validators(self, value): + """ + Test the given value against all the validators on the field, + and either raise a `ValidationError` or simply return. + """ if value in (None, '', [], (), {}): return @@ -753,8 +759,9 @@ class MultipleChoiceField(ChoiceField): } def to_internal_value(self, data): - if not hasattr(data, '__iter__'): + if isinstance(data, type('')) or not hasattr(data, '__iter__'): self.fail('not_a_list', input_type=type(data).__name__) + return set([ super(MultipleChoiceField, self).to_internal_value(item) for item in data diff --git a/tests/test_fields.py b/tests/test_fields.py index ae7f1919..e03ece54 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -5,22 +5,31 @@ 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 ValidAndInvalidValues: """ - Base class for testing valid and invalid field values. + Base class for testing valid and invalid input values. """ def test_valid_values(self): """ Ensure that valid values return the expected validated data. """ - for input_value, expected_output in self.valid_mappings.items(): + for input_value, expected_output in get_items(self.valid_mappings): assert self.field.run_validation(input_value) == expected_output def test_invalid_values(self): """ Ensure that invalid values raise the expected validation error. """ - for input_value, expected_failure in self.invalid_mappings.items(): + for input_value, expected_failure in get_items(self.invalid_mappings): with pytest.raises(fields.ValidationError) as exc_info: self.field.run_validation(input_value) assert exc_info.value.messages == expected_failure @@ -189,14 +198,14 @@ class TestDecimalField(ValidAndInvalidValues): 12.3: Decimal('12.3'), 0.1: Decimal('0.1'), } - invalid_mappings = { - '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."] - } + invalid_mappings = ( + ('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."]) + ) field = fields.DecimalField(max_digits=3, decimal_places=1) -- cgit v1.2.3 From 4db23cae213decc3e8a8613ad5c76a545f8cfb1a Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 15:34:06 +0100 Subject: Tweaks to DecimalField --- rest_framework/fields.py | 25 ++--- tests/test_fields.py | 233 ++++++++++++++++++++++++++++++++--------------- 2 files changed, 172 insertions(+), 86 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 5fb99a42..db7ceabb 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -521,20 +521,21 @@ class DecimalField(Field): return value def to_representation(self, value): - if isinstance(value, decimal.Decimal): - context = decimal.getcontext().copy() - context.prec = self.max_digits - quantized = value.quantize( - decimal.Decimal('.1') ** self.decimal_places, - context=context - ) - if not self.coerce_to_string: - return quantized - return '{0:f}'.format(quantized) + if value in (None, ''): + return None + if not isinstance(value, decimal.Decimal): + value = decimal.Decimal(value) + + context = decimal.getcontext().copy() + context.prec = self.max_digits + quantized = value.quantize( + decimal.Decimal('.1') ** self.decimal_places, + context=context + ) if not self.coerce_to_string: - return value - return '%.*f' % (self.max_decimal_places, value) + return quantized + return '{0:f}'.format(quantized) # Date & time fields... diff --git a/tests/test_fields.py b/tests/test_fields.py index e03ece54..0f445d41 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -14,31 +14,35 @@ def get_items(mapping_or_list_of_two_tuples): return mapping_or_list_of_two_tuples -class ValidAndInvalidValues: +class FieldValues: """ Base class for testing valid and invalid input values. """ - def test_valid_values(self): + def test_valid_inputs(self): """ Ensure that valid values return the expected validated data. """ - for input_value, expected_output in get_items(self.valid_mappings): + for input_value, expected_output in get_items(self.valid_inputs): assert self.field.run_validation(input_value) == expected_output - def test_invalid_values(self): + def test_invalid_inputs(self): """ Ensure that invalid values raise the expected validation error. """ - for input_value, expected_failure in get_items(self.invalid_mappings): + 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(ValidAndInvalidValues): - valid_mappings = { +class TestBooleanField(FieldValues): + valid_inputs = { 'true': True, 'false': False, '1': True, @@ -48,73 +52,92 @@ class TestBooleanField(ValidAndInvalidValues): True: True, False: False, } - invalid_mappings = { + 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(ValidAndInvalidValues): - valid_mappings = { +class TestCharField(FieldValues): + valid_inputs = { 1: '1', 'abc': 'abc' } - invalid_mappings = { + invalid_inputs = { '': ['This field may not be blank.'] } + outputs = { + 1: '1', + 'abc': 'abc' + } field = fields.CharField() -class TestEmailField(ValidAndInvalidValues): - valid_mappings = { +class TestEmailField(FieldValues): + valid_inputs = { 'example@example.com': 'example@example.com', ' example@example.com ': 'example@example.com', } - invalid_mappings = { + invalid_inputs = { 'example.com': ['Enter a valid email address.'] } + outputs = {} field = fields.EmailField() -class TestRegexField(ValidAndInvalidValues): - valid_mappings = { +class TestRegexField(FieldValues): + valid_inputs = { 'a9': 'a9', } - invalid_mappings = { + invalid_inputs = { 'A9': ["This value does not match the required pattern."] } + outputs = {} field = fields.RegexField(regex='[a-z][0-9]') -class TestSlugField(ValidAndInvalidValues): - valid_mappings = { +class TestSlugField(FieldValues): + valid_inputs = { 'slug-99': 'slug-99', } - invalid_mappings = { + invalid_inputs = { 'slug 99': ["Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens."] } + outputs = {} field = fields.SlugField() -class TestURLField(ValidAndInvalidValues): - valid_mappings = { +class TestURLField(FieldValues): + valid_inputs = { 'http://example.com': 'http://example.com', } - invalid_mappings = { + invalid_inputs = { 'example.com': ['Enter a valid URL.'] } + outputs = {} field = fields.URLField() # Number types... -class TestIntegerField(ValidAndInvalidValues): +class TestIntegerField(FieldValues): """ Valid and invalid values for `IntegerField`. """ - valid_mappings = { + valid_inputs = { '1': 1, '0': 0, 1: 1, @@ -122,36 +145,45 @@ class TestIntegerField(ValidAndInvalidValues): 1.0: 1, 0.0: 0 } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestMinMaxIntegerField(FieldValues): """ Valid and invalid values for `IntegerField` with min and max limits. """ - valid_mappings = { + valid_inputs = { '1': 1, '3': 3, 1: 1, 3: 3, } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestFloatField(FieldValues): """ Valid and invalid values for `FloatField`. """ - valid_mappings = { + valid_inputs = { '1': 1.0, '0': 0.0, 1: 1.0, @@ -159,17 +191,25 @@ class TestFloatField(ValidAndInvalidValues): 1.0: 1.0, 0.0: 0.0, } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestMinMaxFloatField(FieldValues): """ Valid and invalid values for `FloatField` with min and max limits. """ - valid_mappings = { + valid_inputs = { '1': 1, '3': 3, 1: 1, @@ -177,20 +217,21 @@ class TestMinMaxFloatField(ValidAndInvalidValues): 1.0: 1.0, 3.0: 3.0, } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestDecimalField(FieldValues): """ Valid and invalid values for `DecimalField`. """ - valid_mappings = { + valid_inputs = { '12.3': Decimal('12.3'), '0.1': Decimal('0.1'), 10: Decimal('10'), @@ -198,7 +239,7 @@ class TestDecimalField(ValidAndInvalidValues): 12.3: Decimal('12.3'), 0.1: Decimal('0.1'), } - invalid_mappings = ( + invalid_inputs = ( ('abc', ["A valid number is required."]), (Decimal('Nan'), ["A valid number is required."]), (Decimal('Inf'), ["A valid number is required."]), @@ -206,63 +247,98 @@ class TestDecimalField(ValidAndInvalidValues): ('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(ValidAndInvalidValues): +class TestMinMaxDecimalField(FieldValues): """ Valid and invalid values for `DecimalField` with min and max limits. """ - valid_mappings = { + valid_inputs = { '10.0': 10.0, '20.0': 20.0, } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestDateField(FieldValues): """ Valid and invalid values for `DateField`. """ - valid_mappings = { + valid_inputs = { '2001-01-01': datetime.date(2001, 1, 1), datetime.date(2001, 1, 1): datetime.date(2001, 1, 1), } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestCustomInputFormatDateField(FieldValues): """ Valid and invalid values for `DateField` with a cutom input format. """ - valid_mappings = { + valid_inputs = { '1 Jan 2001': datetime.date(2001, 1, 1), } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestDateTimeField(FieldValues): """ Valid and invalid values for `DateTimeField`. """ - valid_mappings = { + 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()), @@ -270,81 +346,87 @@ class TestDateTimeField(ValidAndInvalidValues): 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_mappings = { + 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(ValidAndInvalidValues): +class TestCustomInputFormatDateTimeField(FieldValues): """ Valid and invalid values for `DateTimeField` with a cutom input format. """ - valid_mappings = { + valid_inputs = { '1:35pm, 1 Jan 2001': datetime.datetime(2001, 1, 1, 13, 35, tzinfo=timezone.UTC()), } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestNaiveDateTimeField(FieldValues): """ Valid and invalid values for `DateTimeField` with naive datetimes. """ - valid_mappings = { + 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_mappings = {} + invalid_inputs = {} + outputs = {} field = fields.DateTimeField(default_timezone=None) -class TestTimeField(ValidAndInvalidValues): +class TestTimeField(FieldValues): """ Valid and invalid values for `TimeField`. """ - valid_mappings = { + valid_inputs = { '13:00': datetime.time(13, 00), datetime.time(13, 00): datetime.time(13, 00), } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestCustomInputFormatTimeField(FieldValues): """ Valid and invalid values for `TimeField` with a custom input format. """ - valid_mappings = { + valid_inputs = { '1:00pm': datetime.time(13, 00), } - invalid_mappings = { + 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(ValidAndInvalidValues): +class TestChoiceField(FieldValues): """ Valid and invalid values for `ChoiceField`. """ - valid_mappings = { + valid_inputs = { 'poor': 'poor', 'medium': 'medium', 'good': 'good', } - invalid_mappings = { + invalid_inputs = { 'awful': ['`awful` is not a valid choice.'] } + outputs = {} field = fields.ChoiceField( choices=[ ('poor', 'Poor quality'), @@ -354,19 +436,20 @@ class TestChoiceField(ValidAndInvalidValues): ) -class TestChoiceFieldWithType(ValidAndInvalidValues): +class TestChoiceFieldWithType(FieldValues): """ Valid and invalid values for a `Choice` field that uses an integer type, instead of a char type. """ - valid_mappings = { + valid_inputs = { '1': 1, 3: 3, } - invalid_mappings = { + invalid_inputs = { 5: ['`5` is not a valid choice.'], 'abc': ['`abc` is not a valid choice.'] } + outputs = {} field = fields.ChoiceField( choices=[ (1, 'Poor quality'), @@ -376,35 +459,37 @@ class TestChoiceFieldWithType(ValidAndInvalidValues): ) -class TestChoiceFieldWithListChoices(ValidAndInvalidValues): +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_mappings = { + valid_inputs = { 'poor': 'poor', 'medium': 'medium', 'good': 'good', } - invalid_mappings = { + invalid_inputs = { 'awful': ['`awful` is not a valid choice.'] } + outputs = {} field = fields.ChoiceField(choices=('poor', 'medium', 'good')) -class TestMultipleChoiceField(ValidAndInvalidValues): +class TestMultipleChoiceField(FieldValues): """ Valid and invalid values for `MultipleChoiceField`. """ - valid_mappings = { + valid_inputs = { (): set(), ('aircon',): set(['aircon']), ('aircon', 'manual'): set(['aircon', 'manual']), } - invalid_mappings = { + 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'), -- cgit v1.2.3 From 5586b6581d9d8db05276c08f2c6deffec04ade4f Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 16:02:59 +0100 Subject: Support format=None for date/time fields --- rest_framework/fields.py | 12 +++---- tests/test_fields.py | 85 ++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 88 insertions(+), 9 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index db7ceabb..cbd3334a 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -548,8 +548,8 @@ class DateField(Field): format = api_settings.DATE_FORMAT input_formats = api_settings.DATE_INPUT_FORMATS - def __init__(self, format=None, input_formats=None, *args, **kwargs): - self.format = format if format is not None else self.format + def __init__(self, format=empty, input_formats=None, *args, **kwargs): + self.format = format if format is not empty else self.format self.input_formats = input_formats if input_formats is not None else self.input_formats super(DateField, self).__init__(*args, **kwargs) @@ -604,8 +604,8 @@ class DateTimeField(Field): input_formats = api_settings.DATETIME_INPUT_FORMATS default_timezone = timezone.get_default_timezone() if settings.USE_TZ else None - def __init__(self, format=None, input_formats=None, default_timezone=None, *args, **kwargs): - self.format = format if format is not None else self.format + def __init__(self, format=empty, input_formats=None, default_timezone=None, *args, **kwargs): + self.format = format if format is not empty else self.format self.input_formats = input_formats if input_formats is not None else self.input_formats self.default_timezone = default_timezone if default_timezone is not None else self.default_timezone super(DateTimeField, self).__init__(*args, **kwargs) @@ -670,8 +670,8 @@ class TimeField(Field): format = api_settings.TIME_FORMAT input_formats = api_settings.TIME_INPUT_FORMATS - def __init__(self, format=None, input_formats=None, *args, **kwargs): - self.format = format if format is not None else self.format + def __init__(self, format=empty, input_formats=None, *args, **kwargs): + self.format = format if format is not empty else self.format self.input_formats = input_formats if input_formats is not None else self.input_formats super(TimeField, self).__init__(*args, **kwargs) diff --git a/tests/test_fields.py b/tests/test_fields.py index 0f445d41..b221089c 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -316,7 +316,9 @@ class TestDateField(FieldValues): '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 = {} + outputs = { + datetime.date(2001, 1, 1): '2001-01-01', + } field = fields.DateField() @@ -334,6 +336,30 @@ class TestCustomInputFormatDateField(FieldValues): field = fields.DateField(input_formats=['%d %b %Y']) +class TestCustomOutputFormatDateField(FieldValues): + """ + Values for `DateField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.date(2001, 1, 1): '01 Jan 2001' + } + field = fields.DateField(format='%d %b %Y') + + +class TestNoOutputFormatDateField(FieldValues): + """ + Values for `DateField` with no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.date(2001, 1, 1): datetime.date(2001, 1, 1) + } + field = fields.DateField(format=None) + + class TestDateTimeField(FieldValues): """ Valid and invalid values for `DateTimeField`. @@ -351,7 +377,10 @@ class TestDateTimeField(FieldValues): '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 = {} + outputs = { + datetime.datetime(2001, 1, 1, 13, 00): '2001-01-01T13:00:00', + datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): '2001-01-01T13:00:00Z', + } field = fields.DateTimeField(default_timezone=timezone.UTC()) @@ -369,6 +398,30 @@ class TestCustomInputFormatDateTimeField(FieldValues): field = fields.DateTimeField(default_timezone=timezone.UTC(), input_formats=['%I:%M%p, %d %b %Y']) +class TestCustomOutputFormatDateTimeField(FieldValues): + """ + Values for `DateTimeField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.datetime(2001, 1, 1, 13, 00): '01:00PM, 01 Jan 2001', + } + field = fields.DateTimeField(format='%I:%M%p, %d %b %Y') + + +class TestNoOutputFormatDateTimeField(FieldValues): + """ + Values for `DateTimeField` with no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.datetime(2001, 1, 1, 13, 00): datetime.datetime(2001, 1, 1, 13, 00), + } + field = fields.DateTimeField(format=None) + + class TestNaiveDateTimeField(FieldValues): """ Valid and invalid values for `DateTimeField` with naive datetimes. @@ -394,7 +447,9 @@ class TestTimeField(FieldValues): '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 = {} + outputs = { + datetime.time(13, 00): '13:00:00' + } field = fields.TimeField() @@ -412,6 +467,30 @@ class TestCustomInputFormatTimeField(FieldValues): field = fields.TimeField(input_formats=['%I:%M%p']) +class TestCustomOutputFormatTimeField(FieldValues): + """ + Values for `TimeField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.time(13, 00): '01:00PM' + } + field = fields.TimeField(format='%I:%M%p') + + +class TestNoOutputFormatTimeField(FieldValues): + """ + Values for `TimeField` with a no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.time(13, 00): datetime.time(13, 00) + } + field = fields.TimeField(format=None) + + # Choice types... class TestChoiceField(FieldValues): -- cgit v1.2.3 From e5f0a97595ff9280c7876fc917f6feb27b5ea95d Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 16:45:06 +0100 Subject: More compat fixes --- rest_framework/compat.py | 23 +++++++++++++++++++++++ rest_framework/fields.py | 8 ++++---- tests/test_fields.py | 10 ++++++---- 3 files changed, 33 insertions(+), 8 deletions(-) diff --git a/rest_framework/compat.py b/rest_framework/compat.py index 2b4ddb02..7303c32a 100644 --- a/rest_framework/compat.py +++ b/rest_framework/compat.py @@ -139,6 +139,29 @@ else: self.message = kwargs.pop('message', self.message) super(MaxValueValidator, self).__init__(*args, **kwargs) +# URLValidator only accept `message` in 1.6+ +if django.VERSION >= (1, 6): + from django.core.validators import URLValidator +else: + from django.core.validators import URLValidator as DjangoURLValidator + + class URLValidator(DjangoURLValidator): + def __init__(self, *args, **kwargs): + self.message = kwargs.pop('message', self.message) + super(URLValidator, self).__init__(*args, **kwargs) + + +# EmailValidator requires explicit regex prior to 1.6+ +if django.VERSION >= (1, 6): + from django.core.validators import EmailValidator +else: + from django.core.validators import EmailValidator as DjangoEmailValidator + from django.core.validators import email_re + + class EmailValidator(DjangoEmailValidator): + def __init__(self, *args, **kwargs): + super(EmailValidator, self).__init__(email_re, *args, **kwargs) + # PATCH method is not implemented by Django if 'patch' not in View.http_method_names: diff --git a/rest_framework/fields.py b/rest_framework/fields.py index cbd3334a..12975ae4 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -6,7 +6,7 @@ from django.utils.dateparse import parse_date, parse_datetime, parse_time from django.utils.encoding import is_protected_type from django.utils.translation import ugettext_lazy as _ from rest_framework import ISO_8601 -from rest_framework.compat import smart_text, MinValueValidator, MaxValueValidator +from rest_framework.compat import smart_text, EmailValidator, MinValueValidator, MaxValueValidator, URLValidator from rest_framework.settings import api_settings from rest_framework.utils import html, representation, humanize_datetime import datetime @@ -335,7 +335,7 @@ class EmailField(CharField): def __init__(self, **kwargs): super(EmailField, self).__init__(**kwargs) - validator = validators.EmailValidator(message=self.error_messages['invalid']) + validator = EmailValidator(message=self.error_messages['invalid']) self.validators.append(validator) def to_internal_value(self, data): @@ -381,7 +381,7 @@ class URLField(CharField): def __init__(self, **kwargs): super(URLField, self).__init__(**kwargs) - validator = validators.URLValidator(message=self.error_messages['invalid']) + validator = URLValidator(message=self.error_messages['invalid']) self.validators.append(validator) @@ -525,7 +525,7 @@ class DecimalField(Field): return None if not isinstance(value, decimal.Decimal): - value = decimal.Decimal(value) + value = decimal.Decimal(str(value).strip()) context = decimal.getcontext().copy() context.prec = self.max_digits diff --git a/tests/test_fields.py b/tests/test_fields.py index b221089c..8c50aaba 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -2,6 +2,7 @@ from decimal import Decimal from django.utils import timezone from rest_framework import fields import datetime +import django import pytest @@ -92,7 +93,7 @@ class TestEmailField(FieldValues): ' example@example.com ': 'example@example.com', } invalid_inputs = { - 'example.com': ['Enter a valid email address.'] + 'examplecom': ['Enter a valid email address.'] } outputs = {} field = fields.EmailField() @@ -267,8 +268,8 @@ class TestMinMaxDecimalField(FieldValues): Valid and invalid values for `DecimalField` with min and max limits. """ valid_inputs = { - '10.0': 10.0, - '20.0': 20.0, + '10.0': Decimal('10.0'), + '20.0': Decimal('20.0'), } invalid_inputs = { '9.9': ['Ensure this value is greater than or equal to 10.'], @@ -368,9 +369,10 @@ class TestDateTimeField(FieldValues): '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()), + # Note that 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 = { 'abc': ['Datetime has wrong format. Use one of these formats instead: YYYY-MM-DDThh:mm[:ss[.uuuuuu]][+HH:MM|-HH:MM|Z]'], -- cgit v1.2.3 From b5454dd02290130a7fb0a0e375f3efecc58edc6d Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 16:50:04 +0100 Subject: Tests and tweaks for choice fields --- rest_framework/fields.py | 4 ++-- tests/test_fields.py | 15 +++++++++++---- 2 files changed, 13 insertions(+), 6 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 12975ae4..500018f3 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -750,7 +750,7 @@ class ChoiceField(Field): self.fail('invalid_choice', input=data) def to_representation(self, value): - return value + return self.choice_strings_to_values[str(value)] class MultipleChoiceField(ChoiceField): @@ -769,7 +769,7 @@ class MultipleChoiceField(ChoiceField): ]) def to_representation(self, value): - return value + return [self.choice_strings_to_values[str(item)] for item in value] # File types... diff --git a/tests/test_fields.py b/tests/test_fields.py index 8c50aaba..3343123f 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -505,9 +505,11 @@ class TestChoiceField(FieldValues): 'good': 'good', } invalid_inputs = { - 'awful': ['`awful` is not a valid choice.'] + 'amazing': ['`amazing` is not a valid choice.'] + } + outputs = { + 'good': 'good' } - outputs = {} field = fields.ChoiceField( choices=[ ('poor', 'Poor quality'), @@ -530,7 +532,10 @@ class TestChoiceFieldWithType(FieldValues): 5: ['`5` is not a valid choice.'], 'abc': ['`abc` is not a valid choice.'] } - outputs = {} + outputs = { + '1': 1, + 1: 1 + } field = fields.ChoiceField( choices=[ (1, 'Poor quality'), @@ -553,7 +558,9 @@ class TestChoiceFieldWithListChoices(FieldValues): invalid_inputs = { 'awful': ['`awful` is not a valid choice.'] } - outputs = {} + outputs = { + 'good': 'good' + } field = fields.ChoiceField(choices=('poor', 'medium', 'good')) -- cgit v1.2.3 From 5a95baf2a2258fb5297062ac18582129c05fb320 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 16:52:57 +0100 Subject: Tests & tweaks for ChoiceField --- rest_framework/fields.py | 4 +++- tests/test_fields.py | 4 +++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 500018f3..80eadf1e 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -769,7 +769,9 @@ class MultipleChoiceField(ChoiceField): ]) def to_representation(self, value): - return [self.choice_strings_to_values[str(item)] for item in value] + return set([ + self.choice_strings_to_values[str(item)] for item in value + ]) # File types... diff --git a/tests/test_fields.py b/tests/test_fields.py index 3343123f..3cfc1b88 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -577,7 +577,9 @@ class TestMultipleChoiceField(FieldValues): 'abc': ['Expected a list of items but got type `str`'], ('aircon', 'incorrect'): ['`incorrect` is not a valid choice.'] } - outputs = {} + outputs = [ + (['aircon', 'manual'], set(['aircon', 'manual'])) + ] field = fields.MultipleChoiceField( choices=[ ('aircon', 'AirCon'), -- cgit v1.2.3 From 5d80f7f932bfcc0630ac0fdbf07072a53197b98f Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 22 Sep 2014 17:46:02 +0100 Subject: allow_blank, allow_null --- rest_framework/fields.py | 40 +- tests/test_field_options.py | 55 ++ tests/test_field_values.py | 607 ++++++++++++++++ tests/test_fields.py | 1633 ------------------------------------------- 4 files changed, 678 insertions(+), 1657 deletions(-) create mode 100644 tests/test_field_options.py create mode 100644 tests/test_field_values.py delete mode 100644 tests/test_fields.py diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 80eadf1e..48a3e1ab 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -98,14 +98,15 @@ class Field(object): _creation_counter = 0 default_error_messages = { - 'required': _('This field is required.') + 'required': _('This field is required.'), + 'null': _('This field may not be null.') } default_validators = [] def __init__(self, read_only=False, write_only=False, required=None, default=empty, initial=None, source=None, label=None, help_text=None, style=None, - error_messages=None, validators=[]): + error_messages=None, validators=[], allow_null=False): self._creation_counter = Field._creation_counter Field._creation_counter += 1 @@ -129,6 +130,7 @@ class Field(object): self.help_text = help_text self.style = {} if style is None else style self.validators = validators or self.default_validators[:] + self.allow_null = allow_null # Collect default error message from self and parent classes messages = {} @@ -220,6 +222,11 @@ class Field(object): self.fail('required') return self.get_default() + if data is None: + if not self.allow_null: + self.fail('null') + return None + value = self.to_internal_value(data) self.run_validators(value) return value @@ -315,11 +322,14 @@ class CharField(Field): self.min_length = kwargs.pop('min_length', None) super(CharField, self).__init__(**kwargs) + def run_validation(self, data=empty): + if data == '': + if not self.allow_blank: + self.fail('blank') + return '' + return super(CharField, self).run_validation(data) + def to_internal_value(self, data): - if data == '' and not self.allow_blank: - self.fail('blank') - if data is None: - return None return str(data) def to_representation(self, value): @@ -339,10 +349,6 @@ class EmailField(CharField): self.validators.append(validator) def to_internal_value(self, data): - if data == '' and not self.allow_blank: - self.fail('blank') - if data is None: - return None return str(data).strip() def to_representation(self, value): @@ -437,8 +443,6 @@ class FloatField(Field): self.validators.append(MinValueValidator(min_value, message=message)) def to_internal_value(self, value): - if value is None: - return None try: return float(value) except (TypeError, ValueError): @@ -481,9 +485,6 @@ class DecimalField(Field): than max_digits in the number, and no more than decimal_places digits after the decimal point. """ - if value in (None, ''): - return None - value = smart_text(value).strip() try: value = decimal.Decimal(value) @@ -554,9 +555,6 @@ class DateField(Field): super(DateField, self).__init__(*args, **kwargs) def to_internal_value(self, value): - if value in (None, ''): - return None - if isinstance(value, datetime.datetime): self.fail('datetime') @@ -622,9 +620,6 @@ class DateTimeField(Field): return value def to_internal_value(self, value): - if value in (None, ''): - return None - if isinstance(value, datetime.date) and not isinstance(value, datetime.datetime): self.fail('date') @@ -676,9 +671,6 @@ class TimeField(Field): super(TimeField, self).__init__(*args, **kwargs) def to_internal_value(self, value): - if value in (None, ''): - return None - if isinstance(value, datetime.time): return value diff --git a/tests/test_field_options.py b/tests/test_field_options.py new file mode 100644 index 00000000..444bd424 --- /dev/null +++ b/tests/test_field_options.py @@ -0,0 +1,55 @@ +from rest_framework import fields +import pytest + + +class TestFieldOptions: + def test_required(self): + """ + By default a field must be included in the input. + """ + field = fields.IntegerField() + with pytest.raises(fields.ValidationError) as exc_info: + field.run_validation() + assert exc_info.value.messages == ['This field is required.'] + + def test_not_required(self): + """ + If `required=False` then a field may be omitted from the input. + """ + field = fields.IntegerField(required=False) + with pytest.raises(fields.SkipField): + field.run_validation() + + def test_disallow_null(self): + """ + By default `None` is not a valid input. + """ + field = fields.IntegerField() + with pytest.raises(fields.ValidationError) as exc_info: + field.run_validation(None) + assert exc_info.value.messages == ['This field may not be null.'] + + def test_allow_null(self): + """ + If `allow_null=True` then `None` is a valid input. + """ + field = fields.IntegerField(allow_null=True) + output = field.run_validation(None) + assert output is None + + def test_disallow_blank(self): + """ + By default '' is not a valid input. + """ + field = fields.CharField() + with pytest.raises(fields.ValidationError) as exc_info: + field.run_validation('') + assert exc_info.value.messages == ['This field may not be blank.'] + + def test_allow_blank(self): + """ + If `allow_blank=True` then '' is a valid input. + """ + field = fields.CharField(allow_blank=True) + output = field.run_validation('') + assert output is '' diff --git a/tests/test_field_values.py b/tests/test_field_values.py new file mode 100644 index 00000000..bac50f0b --- /dev/null +++ b/tests/test_field_values.py @@ -0,0 +1,607 @@ +from decimal import Decimal +from django.utils import timezone +from rest_framework import fields +import datetime +import django +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 and invalid values for `BooleanField`. + """ + 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 and invalid values for `CharField`. + """ + 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 and invalid values for `EmailField`. + """ + valid_inputs = { + 'example@example.com': 'example@example.com', + ' example@example.com ': 'example@example.com', + } + invalid_inputs = { + 'examplecom': ['Enter a valid email address.'] + } + outputs = {} + field = fields.EmailField() + + +class TestRegexField(FieldValues): + """ + Valid and invalid values for `RegexField`. + """ + 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 and invalid values for `SlugField`. + """ + 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 and invalid values for `URLField`. + """ + 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': Decimal('10.0'), + '20.0': Decimal('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 = { + datetime.date(2001, 1, 1): '2001-01-01', + } + 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 TestCustomOutputFormatDateField(FieldValues): + """ + Values for `DateField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.date(2001, 1, 1): '01 Jan 2001' + } + field = fields.DateField(format='%d %b %Y') + + +class TestNoOutputFormatDateField(FieldValues): + """ + Values for `DateField` with no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.date(2001, 1, 1): datetime.date(2001, 1, 1) + } + field = fields.DateField(format=None) + + +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()), + 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. + '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 = { + '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 = { + datetime.datetime(2001, 1, 1, 13, 00): '2001-01-01T13:00:00', + datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): '2001-01-01T13:00:00Z', + } + 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 TestCustomOutputFormatDateTimeField(FieldValues): + """ + Values for `DateTimeField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.datetime(2001, 1, 1, 13, 00): '01:00PM, 01 Jan 2001', + } + field = fields.DateTimeField(format='%I:%M%p, %d %b %Y') + + +class TestNoOutputFormatDateTimeField(FieldValues): + """ + Values for `DateTimeField` with no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.datetime(2001, 1, 1, 13, 00): datetime.datetime(2001, 1, 1, 13, 00), + } + field = fields.DateTimeField(format=None) + + +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 = { + datetime.time(13, 00): '13:00:00' + } + 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']) + + +class TestCustomOutputFormatTimeField(FieldValues): + """ + Values for `TimeField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.time(13, 00): '01:00PM' + } + field = fields.TimeField(format='%I:%M%p') + + +class TestNoOutputFormatTimeField(FieldValues): + """ + Values for `TimeField` with a no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.time(13, 00): datetime.time(13, 00) + } + field = fields.TimeField(format=None) + + +# Choice types... + +class TestChoiceField(FieldValues): + """ + Valid and invalid values for `ChoiceField`. + """ + valid_inputs = { + 'poor': 'poor', + 'medium': 'medium', + 'good': 'good', + } + invalid_inputs = { + 'amazing': ['`amazing` is not a valid choice.'] + } + outputs = { + 'good': 'good' + } + 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 = { + '1': 1, + 1: 1 + } + 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 = { + 'good': 'good' + } + 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 = [ + (['aircon', 'manual'], set(['aircon', 'manual'])) + ] + field = fields.MultipleChoiceField( + choices=[ + ('aircon', 'AirCon'), + ('manual', 'Manual drive'), + ('diesel', 'Diesel'), + ] + ) diff --git a/tests/test_fields.py b/tests/test_fields.py deleted file mode 100644 index 3cfc1b88..00000000 --- a/tests/test_fields.py +++ /dev/null @@ -1,1633 +0,0 @@ -from decimal import Decimal -from django.utils import timezone -from rest_framework import fields -import datetime -import django -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 = { - 'examplecom': ['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': Decimal('10.0'), - '20.0': Decimal('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 = { - datetime.date(2001, 1, 1): '2001-01-01', - } - 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 TestCustomOutputFormatDateField(FieldValues): - """ - Values for `DateField` with a custom output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.date(2001, 1, 1): '01 Jan 2001' - } - field = fields.DateField(format='%d %b %Y') - - -class TestNoOutputFormatDateField(FieldValues): - """ - Values for `DateField` with no output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.date(2001, 1, 1): datetime.date(2001, 1, 1) - } - field = fields.DateField(format=None) - - -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()), - 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. - '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 = { - '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 = { - datetime.datetime(2001, 1, 1, 13, 00): '2001-01-01T13:00:00', - datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): '2001-01-01T13:00:00Z', - } - 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 TestCustomOutputFormatDateTimeField(FieldValues): - """ - Values for `DateTimeField` with a custom output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.datetime(2001, 1, 1, 13, 00): '01:00PM, 01 Jan 2001', - } - field = fields.DateTimeField(format='%I:%M%p, %d %b %Y') - - -class TestNoOutputFormatDateTimeField(FieldValues): - """ - Values for `DateTimeField` with no output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.datetime(2001, 1, 1, 13, 00): datetime.datetime(2001, 1, 1, 13, 00), - } - field = fields.DateTimeField(format=None) - - -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 = { - datetime.time(13, 00): '13:00:00' - } - 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']) - - -class TestCustomOutputFormatTimeField(FieldValues): - """ - Values for `TimeField` with a custom output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.time(13, 00): '01:00PM' - } - field = fields.TimeField(format='%I:%M%p') - - -class TestNoOutputFormatTimeField(FieldValues): - """ - Values for `TimeField` with a no output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.time(13, 00): datetime.time(13, 00) - } - field = fields.TimeField(format=None) - - -# Choice types... - -class TestChoiceField(FieldValues): - """ - Valid and invalid values for `ChoiceField`. - """ - valid_inputs = { - 'poor': 'poor', - 'medium': 'medium', - 'good': 'good', - } - invalid_inputs = { - 'amazing': ['`amazing` is not a valid choice.'] - } - outputs = { - 'good': 'good' - } - 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 = { - '1': 1, - 1: 1 - } - 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 = { - 'good': 'good' - } - 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 = [ - (['aircon', 'manual'], set(['aircon', 'manual'])) - ] - 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, ') -- cgit v1.2.3 From b187f53453d3885cd918f5f9f4490bcc8e3e2410 Mon Sep 17 00:00:00 2001 From: Danilo Bargen Date: Mon, 2 Jun 2014 00:41:58 +0200 Subject: Changed return status for CSRF failures to HTTP 403 By default, Django returns "HTTP 403 Forbidden" responses when CSRF validation failed[1]. CSRF is a case of authorization, not of authentication. Therefore `PermissionDenied` should be raised instead of `AuthenticationFailed`. [1] https://docs.djangoproject.com/en/dev/ref/contrib/csrf/#rejected-requests --- rest_framework/authentication.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rest_framework/authentication.py b/rest_framework/authentication.py index f3fec05e..36d74dd9 100644 --- a/rest_framework/authentication.py +++ b/rest_framework/authentication.py @@ -129,7 +129,7 @@ class SessionAuthentication(BaseAuthentication): reason = CSRFCheck().process_view(request, None, (), {}) if reason: # CSRF failed, bail with explicit error message - raise exceptions.AuthenticationFailed('CSRF Failed: %s' % reason) + raise exceptions.PermissionDenied('CSRF Failed: %s' % reason) class TokenAuthentication(BaseAuthentication): -- cgit v1.2.3 From f22d0afc3dfc7478e084d1d6ed6b53f71641dec6 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 23 Sep 2014 14:15:00 +0100 Subject: Tests for field choices --- rest_framework/fields.py | 21 +- rest_framework/serializers.py | 3 + rest_framework/utils/field_mapping.py | 58 +-- tests/test_field_options.py | 55 --- tests/test_field_values.py | 607 ------------------------------ tests/test_fields.py | 674 ++++++++++++++++++++++++++++++++++ tests/test_model_serializer.py | 47 ++- 7 files changed, 756 insertions(+), 709 deletions(-) delete mode 100644 tests/test_field_options.py delete mode 100644 tests/test_field_values.py create mode 100644 tests/test_fields.py diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 48a3e1ab..f5bae734 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -102,6 +102,7 @@ class Field(object): 'null': _('This field may not be null.') } default_validators = [] + default_empty_html = None def __init__(self, read_only=False, write_only=False, required=None, default=empty, initial=None, source=None, @@ -185,6 +186,11 @@ class Field(object): Given the *incoming* primative data, return the value for this field that should be validated and transformed to a native value. """ + if html.is_html_input(dictionary): + # HTML forms will represent empty fields as '', and cannot + # represent None or False values directly. + ret = dictionary.get(self.field_name, '') + return self.default_empty_html if (ret == '') else ret return dictionary.get(self.field_name, empty) def get_attribute(self, instance): @@ -236,9 +242,6 @@ class Field(object): Test the given value against all the validators on the field, and either raise a `ValidationError` or simply return. """ - if value in (None, '', [], (), {}): - return - errors = [] for validator in self.validators: try: @@ -282,16 +285,10 @@ class BooleanField(Field): default_error_messages = { 'invalid': _('`{input}` is not a valid boolean.') } + default_empty_html = False TRUE_VALUES = set(('t', 'T', 'true', 'True', 'TRUE', '1', 1, True)) FALSE_VALUES = set(('f', 'F', 'false', 'False', 'FALSE', '0', 0, 0.0, False)) - def get_value(self, dictionary): - if html.is_html_input(dictionary): - # HTML forms do not send a `False` value on an empty checkbox, - # so we override the default empty value to be False. - return dictionary.get(self.field_name, False) - return dictionary.get(self.field_name, empty) - def to_internal_value(self, data): if data in self.TRUE_VALUES: return True @@ -315,6 +312,7 @@ class CharField(Field): default_error_messages = { 'blank': _('This field may not be blank.') } + default_empty_html = '' def __init__(self, **kwargs): self.allow_blank = kwargs.pop('allow_blank', False) @@ -323,6 +321,9 @@ class CharField(Field): super(CharField, self).__init__(**kwargs) def run_validation(self, data=empty): + # Test for the empty string here so that it does not get validated, + # and so that subclasses do not need to handle it explicitly + # inside the `to_internal_value()` method. if data == '': if not self.allow_blank: self.fail('blank') diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index d9f9c8cb..949f5915 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -411,6 +411,9 @@ class ModelSerializer(Serializer): # `ModelField`, which is used when no other typed field # matched to the model field. kwargs.pop('model_field', None) + if not issubclass(field_cls, CharField): + # `allow_blank` is only valid for textual fields. + kwargs.pop('allow_blank', None) elif field_name in info.relations: # Create forward and reverse relationships. diff --git a/rest_framework/utils/field_mapping.py b/rest_framework/utils/field_mapping.py index be72e444..1c718ccb 100644 --- a/rest_framework/utils/field_mapping.py +++ b/rest_framework/utils/field_mapping.py @@ -49,8 +49,9 @@ def get_field_kwargs(field_name, model_field): kwargs = {} validator_kwarg = model_field.validators - if model_field.null or model_field.blank: - kwargs['required'] = False + # The following will only be used by ModelField classes. + # Gets removed for everything else. + kwargs['model_field'] = model_field if model_field.verbose_name and needs_label(model_field, field_name): kwargs['label'] = capfirst(model_field.verbose_name) @@ -59,23 +60,26 @@ def get_field_kwargs(field_name, model_field): kwargs['help_text'] = model_field.help_text if isinstance(model_field, models.AutoField) or not model_field.editable: + # If this field is read-only, then return early. + # Further keyword arguments are not valid. kwargs['read_only'] = True - # Read only implies that the field is not required. - # We have a cleaner repr on the instance if we don't set it. - kwargs.pop('required', None) + return kwargs if model_field.has_default(): - kwargs['default'] = model_field.get_default() - # Having a default implies that the field is not required. - # We have a cleaner repr on the instance if we don't set it. - kwargs.pop('required', None) + kwargs['required'] = False if model_field.flatchoices: - # If this model field contains choices, then return now, - # any further keyword arguments are not valid. + # If this model field contains choices, then return early. + # Further keyword arguments are not valid. kwargs['choices'] = model_field.flatchoices return kwargs + if model_field.null: + kwargs['allow_null'] = True + + if model_field.blank: + kwargs['allow_blank'] = True + # Ensure that max_length is passed explicitly as a keyword arg, # rather than as a validator. max_length = getattr(model_field, 'max_length', None) @@ -88,7 +92,10 @@ def get_field_kwargs(field_name, model_field): # Ensure that min_length is passed explicitly as a keyword arg, # rather than as a validator. - min_length = getattr(model_field, 'min_length', None) + min_length = next(( + validator.limit_value for validator in validator_kwarg + if isinstance(validator, validators.MinLengthValidator) + ), None) if min_length is not None: kwargs['min_length'] = min_length validator_kwarg = [ @@ -153,20 +160,9 @@ def get_field_kwargs(field_name, model_field): if decimal_places is not None: kwargs['decimal_places'] = decimal_places - if isinstance(model_field, models.BooleanField): - # models.BooleanField has `blank=True`, but *is* actually - # required *unless* a default is provided. - # Also note that Django<1.6 uses `default=False` for - # models.BooleanField, but Django>=1.6 uses `default=None`. - kwargs.pop('required', None) - if validator_kwarg: kwargs['validators'] = validator_kwarg - # The following will only be used by ModelField classes. - # Gets removed for everything else. - kwargs['model_field'] = model_field - return kwargs @@ -188,16 +184,22 @@ def get_relation_kwargs(field_name, relation_info): kwargs.pop('queryset', None) if model_field: - if model_field.null or model_field.blank: - kwargs['required'] = False if model_field.verbose_name and needs_label(model_field, field_name): kwargs['label'] = capfirst(model_field.verbose_name) - if not model_field.editable: - kwargs['read_only'] = True - kwargs.pop('queryset', None) help_text = clean_manytomany_helptext(model_field.help_text) if help_text: kwargs['help_text'] = help_text + if not model_field.editable: + kwargs['read_only'] = True + kwargs.pop('queryset', None) + if kwargs.get('read_only', False): + # If this field is read-only, then return early. + # No further keyword arguments are valid. + return kwargs + if model_field.has_default(): + kwargs['required'] = False + if model_field.null: + kwargs['allow_null'] = True return kwargs diff --git a/tests/test_field_options.py b/tests/test_field_options.py deleted file mode 100644 index 444bd424..00000000 --- a/tests/test_field_options.py +++ /dev/null @@ -1,55 +0,0 @@ -from rest_framework import fields -import pytest - - -class TestFieldOptions: - def test_required(self): - """ - By default a field must be included in the input. - """ - field = fields.IntegerField() - with pytest.raises(fields.ValidationError) as exc_info: - field.run_validation() - assert exc_info.value.messages == ['This field is required.'] - - def test_not_required(self): - """ - If `required=False` then a field may be omitted from the input. - """ - field = fields.IntegerField(required=False) - with pytest.raises(fields.SkipField): - field.run_validation() - - def test_disallow_null(self): - """ - By default `None` is not a valid input. - """ - field = fields.IntegerField() - with pytest.raises(fields.ValidationError) as exc_info: - field.run_validation(None) - assert exc_info.value.messages == ['This field may not be null.'] - - def test_allow_null(self): - """ - If `allow_null=True` then `None` is a valid input. - """ - field = fields.IntegerField(allow_null=True) - output = field.run_validation(None) - assert output is None - - def test_disallow_blank(self): - """ - By default '' is not a valid input. - """ - field = fields.CharField() - with pytest.raises(fields.ValidationError) as exc_info: - field.run_validation('') - assert exc_info.value.messages == ['This field may not be blank.'] - - def test_allow_blank(self): - """ - If `allow_blank=True` then '' is a valid input. - """ - field = fields.CharField(allow_blank=True) - output = field.run_validation('') - assert output is '' diff --git a/tests/test_field_values.py b/tests/test_field_values.py deleted file mode 100644 index bac50f0b..00000000 --- a/tests/test_field_values.py +++ /dev/null @@ -1,607 +0,0 @@ -from decimal import Decimal -from django.utils import timezone -from rest_framework import fields -import datetime -import django -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 and invalid values for `BooleanField`. - """ - 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 and invalid values for `CharField`. - """ - 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 and invalid values for `EmailField`. - """ - valid_inputs = { - 'example@example.com': 'example@example.com', - ' example@example.com ': 'example@example.com', - } - invalid_inputs = { - 'examplecom': ['Enter a valid email address.'] - } - outputs = {} - field = fields.EmailField() - - -class TestRegexField(FieldValues): - """ - Valid and invalid values for `RegexField`. - """ - 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 and invalid values for `SlugField`. - """ - 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 and invalid values for `URLField`. - """ - 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': Decimal('10.0'), - '20.0': Decimal('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 = { - datetime.date(2001, 1, 1): '2001-01-01', - } - 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 TestCustomOutputFormatDateField(FieldValues): - """ - Values for `DateField` with a custom output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.date(2001, 1, 1): '01 Jan 2001' - } - field = fields.DateField(format='%d %b %Y') - - -class TestNoOutputFormatDateField(FieldValues): - """ - Values for `DateField` with no output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.date(2001, 1, 1): datetime.date(2001, 1, 1) - } - field = fields.DateField(format=None) - - -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()), - 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. - '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 = { - '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 = { - datetime.datetime(2001, 1, 1, 13, 00): '2001-01-01T13:00:00', - datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): '2001-01-01T13:00:00Z', - } - 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 TestCustomOutputFormatDateTimeField(FieldValues): - """ - Values for `DateTimeField` with a custom output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.datetime(2001, 1, 1, 13, 00): '01:00PM, 01 Jan 2001', - } - field = fields.DateTimeField(format='%I:%M%p, %d %b %Y') - - -class TestNoOutputFormatDateTimeField(FieldValues): - """ - Values for `DateTimeField` with no output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.datetime(2001, 1, 1, 13, 00): datetime.datetime(2001, 1, 1, 13, 00), - } - field = fields.DateTimeField(format=None) - - -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 = { - datetime.time(13, 00): '13:00:00' - } - 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']) - - -class TestCustomOutputFormatTimeField(FieldValues): - """ - Values for `TimeField` with a custom output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.time(13, 00): '01:00PM' - } - field = fields.TimeField(format='%I:%M%p') - - -class TestNoOutputFormatTimeField(FieldValues): - """ - Values for `TimeField` with a no output format. - """ - valid_inputs = {} - invalid_inputs = {} - outputs = { - datetime.time(13, 00): datetime.time(13, 00) - } - field = fields.TimeField(format=None) - - -# Choice types... - -class TestChoiceField(FieldValues): - """ - Valid and invalid values for `ChoiceField`. - """ - valid_inputs = { - 'poor': 'poor', - 'medium': 'medium', - 'good': 'good', - } - invalid_inputs = { - 'amazing': ['`amazing` is not a valid choice.'] - } - outputs = { - 'good': 'good' - } - 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 = { - '1': 1, - 1: 1 - } - 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 = { - 'good': 'good' - } - 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 = [ - (['aircon', 'manual'], set(['aircon', 'manual'])) - ] - field = fields.MultipleChoiceField( - choices=[ - ('aircon', 'AirCon'), - ('manual', 'Manual drive'), - ('diesel', 'Diesel'), - ] - ) diff --git a/tests/test_fields.py b/tests/test_fields.py new file mode 100644 index 00000000..6bf9aed4 --- /dev/null +++ b/tests/test_fields.py @@ -0,0 +1,674 @@ +from decimal import Decimal +from django.utils import timezone +from rest_framework import fields +import datetime +import django +import pytest + + +# Tests for field keyword arguments and core functionality. +# --------------------------------------------------------- + +class TestFieldOptions: + def test_required(self): + """ + By default a field must be included in the input. + """ + field = fields.IntegerField() + with pytest.raises(fields.ValidationError) as exc_info: + field.run_validation() + assert exc_info.value.messages == ['This field is required.'] + + def test_not_required(self): + """ + If `required=False` then a field may be omitted from the input. + """ + field = fields.IntegerField(required=False) + with pytest.raises(fields.SkipField): + field.run_validation() + + def test_disallow_null(self): + """ + By default `None` is not a valid input. + """ + field = fields.IntegerField() + with pytest.raises(fields.ValidationError) as exc_info: + field.run_validation(None) + assert exc_info.value.messages == ['This field may not be null.'] + + def test_allow_null(self): + """ + If `allow_null=True` then `None` is a valid input. + """ + field = fields.IntegerField(allow_null=True) + output = field.run_validation(None) + assert output is None + + def test_disallow_blank(self): + """ + By default '' is not a valid input. + """ + field = fields.CharField() + with pytest.raises(fields.ValidationError) as exc_info: + field.run_validation('') + assert exc_info.value.messages == ['This field may not be blank.'] + + def test_allow_blank(self): + """ + If `allow_blank=True` then '' is a valid input. + """ + field = fields.CharField(allow_blank=True) + output = field.run_validation('') + assert output is '' + + def test_default(self): + """ + If `default` is set, then omitted values get the default input. + """ + field = fields.IntegerField(default=123) + output = field.run_validation() + assert output is 123 + + +# Tests for field input and output values. +# ---------------------------------------- + +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 and invalid values for `BooleanField`. + """ + 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 and invalid values for `CharField`. + """ + 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 and invalid values for `EmailField`. + """ + valid_inputs = { + 'example@example.com': 'example@example.com', + ' example@example.com ': 'example@example.com', + } + invalid_inputs = { + 'examplecom': ['Enter a valid email address.'] + } + outputs = {} + field = fields.EmailField() + + +class TestRegexField(FieldValues): + """ + Valid and invalid values for `RegexField`. + """ + 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 and invalid values for `SlugField`. + """ + 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 and invalid values for `URLField`. + """ + 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': Decimal('10.0'), + '20.0': Decimal('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 = { + datetime.date(2001, 1, 1): '2001-01-01', + } + 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 TestCustomOutputFormatDateField(FieldValues): + """ + Values for `DateField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.date(2001, 1, 1): '01 Jan 2001' + } + field = fields.DateField(format='%d %b %Y') + + +class TestNoOutputFormatDateField(FieldValues): + """ + Values for `DateField` with no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.date(2001, 1, 1): datetime.date(2001, 1, 1) + } + field = fields.DateField(format=None) + + +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()), + 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. + '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 = { + '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 = { + datetime.datetime(2001, 1, 1, 13, 00): '2001-01-01T13:00:00', + datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): '2001-01-01T13:00:00Z', + } + 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 TestCustomOutputFormatDateTimeField(FieldValues): + """ + Values for `DateTimeField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.datetime(2001, 1, 1, 13, 00): '01:00PM, 01 Jan 2001', + } + field = fields.DateTimeField(format='%I:%M%p, %d %b %Y') + + +class TestNoOutputFormatDateTimeField(FieldValues): + """ + Values for `DateTimeField` with no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.datetime(2001, 1, 1, 13, 00): datetime.datetime(2001, 1, 1, 13, 00), + } + field = fields.DateTimeField(format=None) + + +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 = { + datetime.time(13, 00): '13:00:00' + } + 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']) + + +class TestCustomOutputFormatTimeField(FieldValues): + """ + Values for `TimeField` with a custom output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.time(13, 00): '01:00PM' + } + field = fields.TimeField(format='%I:%M%p') + + +class TestNoOutputFormatTimeField(FieldValues): + """ + Values for `TimeField` with a no output format. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = { + datetime.time(13, 00): datetime.time(13, 00) + } + field = fields.TimeField(format=None) + + +# Choice types... + +class TestChoiceField(FieldValues): + """ + Valid and invalid values for `ChoiceField`. + """ + valid_inputs = { + 'poor': 'poor', + 'medium': 'medium', + 'good': 'good', + } + invalid_inputs = { + 'amazing': ['`amazing` is not a valid choice.'] + } + outputs = { + 'good': 'good' + } + 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 = { + '1': 1, + 1: 1 + } + 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 = { + 'good': 'good' + } + 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 = [ + (['aircon', 'manual'], set(['aircon', 'manual'])) + ] + field = fields.MultipleChoiceField( + choices=[ + ('aircon', 'AirCon'), + ('manual', 'Manual drive'), + ('diesel', 'Diesel'), + ] + ) diff --git a/tests/test_model_serializer.py b/tests/test_model_serializer.py index d9f9efbe..731ed2fb 100644 --- a/tests/test_model_serializer.py +++ b/tests/test_model_serializer.py @@ -6,6 +6,7 @@ These tests deal with ensuring that we correctly map the model fields onto an appropriate set of serializer fields for each case. """ from django.core.exceptions import ImproperlyConfigured +from django.core.validators import MaxValueValidator, MinValueValidator, MinLengthValidator from django.db import models from django.test import TestCase from rest_framework import serializers @@ -15,7 +16,8 @@ def dedent(blocktext): return '\n'.join([line[12:] for line in blocktext.splitlines()[1:-1]]) -# Testing regular field mappings +# Tests for regular field mappings. +# --------------------------------- class CustomField(models.Field): """ @@ -24,9 +26,6 @@ class CustomField(models.Field): pass -COLOR_CHOICES = (('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')) - - class RegularFieldsModel(models.Model): """ A model class for testing regular flat fields. @@ -35,7 +34,6 @@ class RegularFieldsModel(models.Model): big_integer_field = models.BigIntegerField() boolean_field = models.BooleanField(default=False) char_field = models.CharField(max_length=100) - choices_field = models.CharField(max_length=100, choices=COLOR_CHOICES) comma_seperated_integer_field = models.CommaSeparatedIntegerField(max_length=100) date_field = models.DateField() datetime_field = models.DateTimeField() @@ -57,6 +55,19 @@ class RegularFieldsModel(models.Model): return 'method' +COLOR_CHOICES = (('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')) + + +class FieldOptionsModel(models.Model): + value_limit_field = models.IntegerField(validators=[MinValueValidator(1), MaxValueValidator(10)]) + length_limit_field = models.CharField(validators=[MinLengthValidator(3)], max_length=12) + blank_field = models.CharField(blank=True, max_length=10) + null_field = models.IntegerField(null=True) + default_field = models.IntegerField(default=0) + descriptive_field = models.IntegerField(help_text='Some help text', verbose_name='A label') + choices_field = models.CharField(max_length=100, choices=COLOR_CHOICES) + + class TestRegularFieldMappings(TestCase): def test_regular_fields(self): """ @@ -70,9 +81,8 @@ class TestRegularFieldMappings(TestCase): TestSerializer(): auto_field = IntegerField(read_only=True) big_integer_field = IntegerField() - boolean_field = BooleanField(default=False) + boolean_field = BooleanField(required=False) char_field = CharField(max_length=100) - choices_field = ChoiceField(choices=[('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')]) comma_seperated_integer_field = CharField(max_length=100, validators=[]) date_field = DateField() datetime_field = DateTimeField() @@ -80,7 +90,7 @@ class TestRegularFieldMappings(TestCase): email_field = EmailField(max_length=100) float_field = FloatField() integer_field = IntegerField() - null_boolean_field = BooleanField(required=False) + null_boolean_field = BooleanField(allow_null=True) positive_integer_field = IntegerField() positive_small_integer_field = IntegerField() slug_field = SlugField(max_length=100) @@ -92,6 +102,24 @@ class TestRegularFieldMappings(TestCase): """) self.assertEqual(repr(TestSerializer()), expected) + def test_field_options(self): + class TestSerializer(serializers.ModelSerializer): + class Meta: + model = FieldOptionsModel + + expected = dedent(""" + TestSerializer(): + id = IntegerField(label='ID', read_only=True) + value_limit_field = IntegerField(max_value=10, min_value=1) + length_limit_field = CharField(max_length=12, min_length=3) + blank_field = CharField(allow_blank=True, max_length=10) + null_field = IntegerField(allow_null=True) + default_field = IntegerField(required=False) + descriptive_field = IntegerField(help_text='Some help text', label='A label') + choices_field = ChoiceField(choices=[('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')]) + """) + self.assertEqual(repr(TestSerializer()), expected) + def test_method_field(self): """ Properties and methods on the model should be allowed as `Meta.fields` @@ -178,7 +206,8 @@ class TestRegularFieldMappings(TestCase): assert str(excinfo.exception) == expected -# Testing relational field mappings +# Tests for relational field mappings. +# ------------------------------------ class ForeignKeyTargetModel(models.Model): name = models.CharField(max_length=100) -- cgit v1.2.3 From 0404f09a7e69f533038d47ca25caad90c0c2659f Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 23 Sep 2014 14:30:17 +0100 Subject: NullBooleanField --- rest_framework/fields.py | 37 ++++++++++++++++++++++++++++++++++- rest_framework/serializers.py | 2 +- rest_framework/utils/field_mapping.py | 2 +- tests/test_fields.py | 29 ++++++++++++++++++++++++++- tests/test_model_serializer.py | 2 +- 5 files changed, 67 insertions(+), 5 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index f5bae734..f859658a 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -289,6 +289,10 @@ class BooleanField(Field): TRUE_VALUES = set(('t', 'T', 'true', 'True', 'TRUE', '1', 1, True)) FALSE_VALUES = set(('f', 'F', 'false', 'False', 'FALSE', '0', 0, 0.0, False)) + def __init__(self, **kwargs): + assert 'allow_null' not in kwargs, '`allow_null` is not a valid option. Use `NullBooleanField` instead.' + super(BooleanField, self).__init__(**kwargs) + def to_internal_value(self, data): if data in self.TRUE_VALUES: return True @@ -297,7 +301,38 @@ class BooleanField(Field): self.fail('invalid', input=data) def to_representation(self, value): - if value is None: + if value in self.TRUE_VALUES: + return True + elif value in self.FALSE_VALUES: + return False + return bool(value) + + +class NullBooleanField(Field): + default_error_messages = { + 'invalid': _('`{input}` is not a valid boolean.') + } + default_empty_html = None + TRUE_VALUES = set(('t', 'T', 'true', 'True', 'TRUE', '1', 1, True)) + FALSE_VALUES = set(('f', 'F', 'false', 'False', 'FALSE', '0', 0, 0.0, False)) + NULL_VALUES = set(('n', 'N', 'null', 'Null', 'NULL', '', None)) + + def __init__(self, **kwargs): + assert 'allow_null' not in kwargs, '`allow_null` is not a valid option.' + kwargs['allow_null'] = True + super(NullBooleanField, self).__init__(**kwargs) + + def to_internal_value(self, data): + if data in self.TRUE_VALUES: + return True + elif data in self.FALSE_VALUES: + return False + elif data in self.NULL_VALUES: + return None + self.fail('invalid', input=data) + + def to_representation(self, value): + if value in self.NULL_VALUES: return None if value in self.TRUE_VALUES: return True diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 949f5915..d8d72a4c 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -333,7 +333,7 @@ class ModelSerializer(Serializer): models.FloatField: FloatField, models.ImageField: ImageField, models.IntegerField: IntegerField, - models.NullBooleanField: BooleanField, + models.NullBooleanField: NullBooleanField, models.PositiveIntegerField: IntegerField, models.PositiveSmallIntegerField: IntegerField, models.SlugField: SlugField, diff --git a/rest_framework/utils/field_mapping.py b/rest_framework/utils/field_mapping.py index 1c718ccb..c208afdc 100644 --- a/rest_framework/utils/field_mapping.py +++ b/rest_framework/utils/field_mapping.py @@ -74,7 +74,7 @@ def get_field_kwargs(field_name, model_field): kwargs['choices'] = model_field.flatchoices return kwargs - if model_field.null: + if model_field.null and not isinstance(model_field, models.NullBooleanField): kwargs['allow_null'] = True if model_field.blank: diff --git a/tests/test_fields.py b/tests/test_fields.py index 6bf9aed4..91f3f5db 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -124,7 +124,8 @@ class TestBooleanField(FieldValues): False: False, } invalid_inputs = { - 'foo': ['`foo` is not a valid boolean.'] + 'foo': ['`foo` is not a valid boolean.'], + None: ['This field may not be null.'] } outputs = { 'true': True, @@ -140,6 +141,32 @@ class TestBooleanField(FieldValues): field = fields.BooleanField() +class TestNullBooleanField(FieldValues): + """ + Valid and invalid values for `BooleanField`. + """ + valid_inputs = { + 'true': True, + 'false': False, + 'null': None, + True: True, + False: False, + None: None + } + invalid_inputs = { + 'foo': ['`foo` is not a valid boolean.'], + } + outputs = { + 'true': True, + 'false': False, + 'null': None, + True: True, + False: False, + None: None + } + field = fields.NullBooleanField() + + # String types... class TestCharField(FieldValues): diff --git a/tests/test_model_serializer.py b/tests/test_model_serializer.py index 731ed2fb..f7475024 100644 --- a/tests/test_model_serializer.py +++ b/tests/test_model_serializer.py @@ -90,7 +90,7 @@ class TestRegularFieldMappings(TestCase): email_field = EmailField(max_length=100) float_field = FloatField() integer_field = IntegerField() - null_boolean_field = BooleanField(allow_null=True) + null_boolean_field = NullBooleanField() positive_integer_field = IntegerField() positive_small_integer_field = IntegerField() slug_field = SlugField(max_length=100) -- cgit v1.2.3 From da385c9c1f9deeeefd705154a6e6612d6d62f41b Mon Sep 17 00:00:00 2001 From: Collin Anderson Date: Tue, 23 Sep 2014 17:08:38 -0400 Subject: remove patterns and strings from urls #1898 --- docs/api-guide/authentication.md | 7 ++++--- docs/api-guide/format-suffixes.md | 13 +++++++------ docs/index.md | 4 ++-- docs/topics/2.3-announcement.md | 6 +++--- docs/tutorial/1-serialization.md | 13 +++++++------ docs/tutorial/2-requests-and-responses.md | 9 +++++---- docs/tutorial/3-class-based-views.md | 4 ++-- docs/tutorial/4-authentication-and-permissions.md | 4 ++-- docs/tutorial/5-relationships-and-hyperlinked-apis.md | 10 +++++----- docs/tutorial/6-viewsets-and-routers.md | 12 ++++++------ 10 files changed, 43 insertions(+), 39 deletions(-) diff --git a/docs/api-guide/authentication.md b/docs/api-guide/authentication.md index 343466ee..0ec5bad1 100755 --- a/docs/api-guide/authentication.md +++ b/docs/api-guide/authentication.md @@ -190,9 +190,10 @@ If you've already created some users, you can generate tokens for all existing u When using `TokenAuthentication`, you may want to provide a mechanism for clients to obtain a token given the username and password. REST framework provides a built-in view to provide this behavior. To use it, add the `obtain_auth_token` view to your URLconf: - urlpatterns += patterns('', - url(r'^api-token-auth/', 'rest_framework.authtoken.views.obtain_auth_token') - ) + from rest_framework.authtoken import views + urlpatterns += [ + url(r'^api-token-auth/', views.obtain_auth_token) + ] Note that the URL part of the pattern can be whatever you want to use. diff --git a/docs/api-guide/format-suffixes.md b/docs/api-guide/format-suffixes.md index 529738e3..76a3367b 100644 --- a/docs/api-guide/format-suffixes.md +++ b/docs/api-guide/format-suffixes.md @@ -26,12 +26,13 @@ Arguments: Example: from rest_framework.urlpatterns import format_suffix_patterns - - urlpatterns = patterns('blog.views', - url(r'^/$', 'api_root'), - url(r'^comments/$', 'comment_list'), - url(r'^comments/(?P[0-9]+)/$', 'comment_detail') - ) + from blog import views + + urlpatterns = [ + url(r'^/$', views.apt_root), + url(r'^comments/$', views.comment_list), + url(r'^comments/(?P[0-9]+)/$', views.comment_detail) + ] urlpatterns = format_suffix_patterns(urlpatterns, allowed=['json', 'html']) diff --git a/docs/index.md b/docs/index.md index 6dcb962f..e4c971f9 100644 --- a/docs/index.md +++ b/docs/index.md @@ -85,10 +85,10 @@ Add `'rest_framework'` to your `INSTALLED_APPS` setting. If you're intending to use the browsable API you'll probably also want to add REST framework's login and logout views. Add the following to your root `urls.py` file. - urlpatterns = patterns('', + urlpatterns = [ ... url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')) - ) + ] Note that the URL path can be whatever you want, but you must include `'rest_framework.urls'` with the `'rest_framework'` namespace. diff --git a/docs/topics/2.3-announcement.md b/docs/topics/2.3-announcement.md index ba435145..7c800afa 100644 --- a/docs/topics/2.3-announcement.md +++ b/docs/topics/2.3-announcement.md @@ -15,7 +15,7 @@ As an example of just how simple REST framework APIs can now be, here's an API w """ A REST framework API for viewing and editing users and groups. """ - from django.conf.urls.defaults import url, patterns, include + from django.conf.urls.defaults import url, include from django.contrib.auth.models import User, Group from rest_framework import viewsets, routers @@ -36,10 +36,10 @@ As an example of just how simple REST framework APIs can now be, here's an API w # Wire up our API using automatic URL routing. # Additionally, we include login URLs for the browseable API. - urlpatterns = patterns('', + urlpatterns = [ url(r'^', include(router.urls)), url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')) - ) + ] The best place to get started with ViewSets and Routers is to take a look at the [newest section in the tutorial][part-6], which demonstrates their usage. diff --git a/docs/tutorial/1-serialization.md b/docs/tutorial/1-serialization.md index 96214f5b..b0565d91 100644 --- a/docs/tutorial/1-serialization.md +++ b/docs/tutorial/1-serialization.md @@ -64,9 +64,9 @@ We'll also need to add our new `snippets` app and the `rest_framework` app to `I We also need to wire up the root urlconf, in the `tutorial/urls.py` file, to include our snippet app's URLs. - urlpatterns = patterns('', + urlpatterns = [ url(r'^', include('snippets.urls')), - ) + ] Okay, we're ready to roll. @@ -297,11 +297,12 @@ We'll also need a view which corresponds to an individual snippet, and can be us Finally we need to wire these views up. Create the `snippets/urls.py` file: from django.conf.urls import patterns, url + from snippets import views - urlpatterns = patterns('snippets.views', - url(r'^snippets/$', 'snippet_list'), - url(r'^snippets/(?P[0-9]+)/$', 'snippet_detail'), - ) + urlpatterns = [ + url(r'^snippets/$', views.snippet_list), + url(r'^snippets/(?P[0-9]+)/$', views.snippet_detail), + ] It's worth noting that there are a couple of edge cases we're not dealing with properly at the moment. If we send malformed `json`, or if a request is made with a method that the view doesn't handle, then we'll end up with a 500 "server error" response. Still, this'll do for now. diff --git a/docs/tutorial/2-requests-and-responses.md b/docs/tutorial/2-requests-and-responses.md index e70bbbfc..136b0135 100644 --- a/docs/tutorial/2-requests-and-responses.md +++ b/docs/tutorial/2-requests-and-responses.md @@ -110,11 +110,12 @@ Now update the `urls.py` file slightly, to append a set of `format_suffix_patter from django.conf.urls import patterns, url from rest_framework.urlpatterns import format_suffix_patterns + from snippets import views - urlpatterns = patterns('snippets.views', - url(r'^snippets/$', 'snippet_list'), - url(r'^snippets/(?P[0-9]+)$', 'snippet_detail'), - ) + urlpatterns = [ + url(r'^snippets/$', views.snippet_list), + url(r'^snippets/(?P[0-9]+)$', views.snippet_detail), + ] urlpatterns = format_suffix_patterns(urlpatterns) diff --git a/docs/tutorial/3-class-based-views.md b/docs/tutorial/3-class-based-views.md index e04072ca..382f078a 100644 --- a/docs/tutorial/3-class-based-views.md +++ b/docs/tutorial/3-class-based-views.md @@ -68,10 +68,10 @@ We'll also need to refactor our `urls.py` slightly now we're using class based v from rest_framework.urlpatterns import format_suffix_patterns from snippets import views - urlpatterns = patterns('', + urlpatterns = [ url(r'^snippets/$', views.SnippetList.as_view()), url(r'^snippets/(?P[0-9]+)/$', views.SnippetDetail.as_view()), - ) + ] urlpatterns = format_suffix_patterns(urlpatterns) diff --git a/docs/tutorial/4-authentication-and-permissions.md b/docs/tutorial/4-authentication-and-permissions.md index 74ad9a55..9120e254 100644 --- a/docs/tutorial/4-authentication-and-permissions.md +++ b/docs/tutorial/4-authentication-and-permissions.md @@ -137,10 +137,10 @@ Add the following import at the top of the file: And, at the end of the file, add a pattern to include the login and logout views for the browsable API. - urlpatterns += patterns('', + urlpatterns += [ url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')), - ) + ] The `r'^api-auth/'` part of pattern can actually be whatever URL you want to use. The only restriction is that the included urls must use the `'rest_framework'` namespace. diff --git a/docs/tutorial/5-relationships-and-hyperlinked-apis.md b/docs/tutorial/5-relationships-and-hyperlinked-apis.md index 9c61fe3d..36473ce9 100644 --- a/docs/tutorial/5-relationships-and-hyperlinked-apis.md +++ b/docs/tutorial/5-relationships-and-hyperlinked-apis.md @@ -108,8 +108,8 @@ If we're going to have a hyperlinked API, we need to make sure we name our URL p After adding all those names into our URLconf, our final `snippets/urls.py` file should look something like this: # API endpoints - urlpatterns = format_suffix_patterns(patterns('snippets.views', - url(r'^$', 'api_root'), + urlpatterns = format_suffix_patterns([ + url(r'^$', views.api_root), url(r'^snippets/$', views.SnippetList.as_view(), name='snippet-list'), @@ -125,13 +125,13 @@ After adding all those names into our URLconf, our final `snippets/urls.py` file url(r'^users/(?P[0-9]+)/$', views.UserDetail.as_view(), name='user-detail') - )) + ]) # Login and logout views for the browsable API - urlpatterns += patterns('', + urlpatterns += [ url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')), - ) + ] ## Adding pagination diff --git a/docs/tutorial/6-viewsets-and-routers.md b/docs/tutorial/6-viewsets-and-routers.md index b2019520..cf37a260 100644 --- a/docs/tutorial/6-viewsets-and-routers.md +++ b/docs/tutorial/6-viewsets-and-routers.md @@ -87,14 +87,14 @@ Notice how we're creating multiple views from each `ViewSet` class, by binding t Now that we've bound our resources into concrete views, we can register the views with the URL conf as usual. - urlpatterns = format_suffix_patterns(patterns('snippets.views', - url(r'^$', 'api_root'), + urlpatterns = format_suffix_patterns([ + url(r'^$', api_root), url(r'^snippets/$', snippet_list, name='snippet-list'), url(r'^snippets/(?P[0-9]+)/$', snippet_detail, name='snippet-detail'), url(r'^snippets/(?P[0-9]+)/highlight/$', snippet_highlight, name='snippet-highlight'), url(r'^users/$', user_list, name='user-list'), url(r'^users/(?P[0-9]+)/$', user_detail, name='user-detail') - )) + ]) ## Using Routers @@ -102,7 +102,7 @@ Because we're using `ViewSet` classes rather than `View` classes, we actually do Here's our re-wired `urls.py` file. - from django.conf.urls import patterns, url, include + from django.conf.urls import url, include from snippets import views from rest_framework.routers import DefaultRouter @@ -113,10 +113,10 @@ Here's our re-wired `urls.py` file. # The API URLs are now determined automatically by the router. # Additionally, we include the login URLs for the browseable API. - urlpatterns = patterns('', + urlpatterns = [ url(r'^', include(router.urls)), url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')) - ) + ] Registering the viewsets with the router is similar to providing a urlpattern. We include two arguments - the URL prefix for the views, and the viewset itself. -- cgit v1.2.3 From e8c01ecdabe2abda48dd0cf298d4b6c743574449 Mon Sep 17 00:00:00 2001 From: José Padilla Date: Tue, 23 Sep 2014 21:12:58 -0400 Subject: Correctly propagate cloned_request for OPTIONS Update to fix pending changes in #1507--- rest_framework/generics.py | 7 +++++-- tests/test_generics.py | 39 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 44 insertions(+), 2 deletions(-) diff --git a/rest_framework/generics.py b/rest_framework/generics.py index a6f68657..a62da00b 100644 --- a/rest_framework/generics.py +++ b/rest_framework/generics.py @@ -398,10 +398,11 @@ class GenericAPIView(views.APIView): if method not in self.allowed_methods: continue - cloned_request = clone_request(request, method) + original_request = self.request + self.request = clone_request(request, method) try: # Test global permissions - self.check_permissions(cloned_request) + self.check_permissions(self.request) # Test object permissions if method == 'PUT': try: @@ -419,6 +420,8 @@ class GenericAPIView(views.APIView): # appropriate metadata about the fields that should be supplied. serializer = self.get_serializer() actions[method] = serializer.metadata() + finally: + self.request = original_request if actions: ret['actions'] = actions diff --git a/tests/test_generics.py b/tests/test_generics.py index e9f5bebd..dd3bab18 100644 --- a/tests/test_generics.py +++ b/tests/test_generics.py @@ -681,3 +681,42 @@ class TestFilterBackendAppliedToViews(TestCase): response = view(request).render() self.assertContains(response, 'field_b') self.assertNotContains(response, 'field_a') + + def test_options_with_dynamic_serializer(self): + """ + Ensure that OPTIONS returns correct POST json schema: + DynamicSerializer with single field 'field_b' + """ + request = factory.options('/') + view = DynamicSerializerView.as_view() + + with self.assertNumQueries(0): + response = view(request).render() + + expected = { + 'name': 'Dynamic Serializer', + 'description': '', + 'renders': [ + 'text/html', + 'application/json' + ], + 'parses': [ + 'application/json', + 'application/x-www-form-urlencoded', + 'multipart/form-data' + ], + 'actions': { + 'POST': { + 'field_b': { + 'type': u'string', + 'required': True, + 'read_only': False, + 'label': u'field b', + 'max_length': 100 + } + } + } + } + + self.assertEqual(response.status_code, status.HTTP_200_OK) + self.assertEqual(response.data, expected) -- cgit v1.2.3 From 90139b3efc7da7a2c396882b6905291269387ace Mon Sep 17 00:00:00 2001 From: José Padilla Date: Tue, 23 Sep 2014 21:18:56 -0400 Subject: Remove left unicode strings --- tests/test_generics.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/test_generics.py b/tests/test_generics.py index dd3bab18..97116349 100644 --- a/tests/test_generics.py +++ b/tests/test_generics.py @@ -708,10 +708,10 @@ class TestFilterBackendAppliedToViews(TestCase): 'actions': { 'POST': { 'field_b': { - 'type': u'string', + 'type': 'string', 'required': True, 'read_only': False, - 'label': u'field b', + 'label': 'field b', 'max_length': 100 } } -- cgit v1.2.3 From f4b1dcb167be0bbdaae2cc2a92f651536896dc16 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 24 Sep 2014 14:09:49 +0100 Subject: OPTIONS support --- rest_framework/generics.py | 51 +---------- rest_framework/metadata.py | 126 ++++++++++++++++++++++++++ rest_framework/serializers.py | 8 +- rest_framework/settings.py | 2 + rest_framework/utils/field_mapping.py | 20 ++-- rest_framework/views.py | 24 +---- tests/test_metadata.py | 166 ++++++++++++++++++++++++++++++++++ 7 files changed, 316 insertions(+), 81 deletions(-) create mode 100644 rest_framework/metadata.py create mode 100644 tests/test_metadata.py diff --git a/rest_framework/generics.py b/rest_framework/generics.py index eb6b64ef..f49b0a43 100644 --- a/rest_framework/generics.py +++ b/rest_framework/generics.py @@ -4,13 +4,11 @@ Generic views that provide commonly needed behaviour. from __future__ import unicode_literals from django.db.models.query import QuerySet -from django.core.exceptions import PermissionDenied from django.core.paginator import Paginator, InvalidPage from django.http import Http404 from django.shortcuts import get_object_or_404 as _get_object_or_404 from django.utils.translation import ugettext as _ -from rest_framework import views, mixins, exceptions -from rest_framework.request import clone_request +from rest_framework import views, mixins from rest_framework.settings import api_settings @@ -249,53 +247,6 @@ class GenericAPIView(views.APIView): return obj - # The following are placeholder methods, - # and are intended to be overridden. - # - # The are not called by GenericAPIView directly, - # but are used by the mixin methods. - def metadata(self, request): - """ - Return a dictionary of metadata about the view. - Used to return responses for OPTIONS requests. - - We override the default behavior, and add some extra information - about the required request body for POST and PUT operations. - """ - ret = super(GenericAPIView, self).metadata(request) - - actions = {} - for method in ('PUT', 'POST'): - if method not in self.allowed_methods: - continue - - cloned_request = clone_request(request, method) - try: - # Test global permissions - self.check_permissions(cloned_request) - # Test object permissions - if method == 'PUT': - try: - self.get_object() - except Http404: - # Http404 should be acceptable and the serializer - # metadata should be populated. Except this so the - # outer "else" clause of the try-except-else block - # will be executed. - pass - except (exceptions.APIException, PermissionDenied): - pass - else: - # If user has appropriate permissions for the view, include - # appropriate metadata about the fields that should be supplied. - serializer = self.get_serializer() - actions[method] = serializer.metadata() - - if actions: - ret['actions'] = actions - - return ret - # Concrete view classes that provide method handlers # by composing the mixin classes with the base view. diff --git a/rest_framework/metadata.py b/rest_framework/metadata.py new file mode 100644 index 00000000..580259de --- /dev/null +++ b/rest_framework/metadata.py @@ -0,0 +1,126 @@ +""" +The metadata API is used to allow cusomization of how `OPTIONS` requests +are handled. We currently provide a single default implementation that returns +some fairly ad-hoc information about the view. + +Future implementations might use JSON schema or other definations in order +to return this information in a more standardized way. +""" +from __future__ import unicode_literals + +from django.core.exceptions import PermissionDenied +from django.http import Http404 +from django.utils import six +from django.utils.datastructures import SortedDict +from rest_framework import exceptions, serializers +from rest_framework.compat import force_text +from rest_framework.request import clone_request +from rest_framework.utils.field_mapping import ClassLookupDict + + +class BaseMetadata(object): + def determine_metadata(self, request, view): + """ + Return a dictionary of metadata about the view. + Used to return responses for OPTIONS requests. + """ + raise NotImplementedError(".determine_metadata() must be overridden.") + + +class SimpleMetadata(BaseMetadata): + """ + This is the default metadata implementation. + It returns an ad-hoc set of information about the view. + There are not any formalized standards for `OPTIONS` responses + for us to base this on. + """ + label_lookup = ClassLookupDict({ + serializers.Field: 'field', + serializers.BooleanField: 'boolean', + serializers.CharField: 'string', + serializers.URLField: 'url', + serializers.EmailField: 'email', + serializers.RegexField: 'regex', + serializers.SlugField: 'slug', + serializers.IntegerField: 'integer', + serializers.FloatField: 'float', + serializers.DecimalField: 'decimal', + serializers.DateField: 'date', + serializers.DateTimeField: 'datetime', + serializers.TimeField: 'time', + serializers.ChoiceField: 'choice', + serializers.MultipleChoiceField: 'multiple choice', + serializers.FileField: 'file upload', + serializers.ImageField: 'image upload', + }) + + def determine_metadata(self, request, view): + metadata = SortedDict() + metadata['name'] = view.get_view_name() + metadata['description'] = view.get_view_description() + metadata['renders'] = [renderer.media_type for renderer in view.renderer_classes] + metadata['parses'] = [parser.media_type for parser in view.parser_classes] + if hasattr(view, 'get_serializer'): + actions = self.determine_actions(request, view) + if actions: + metadata['actions'] = actions + return metadata + + def determine_actions(self, request, view): + """ + For generic class based views we return information about + the fields that are accepted for 'PUT' and 'POST' methods. + """ + actions = {} + for method in set(['PUT', 'POST']) & set(view.allowed_methods): + view.request = clone_request(request, method) + try: + # Test global permissions + if hasattr(view, 'check_permissions'): + view.check_permissions(view.request) + # Test object permissions + if method == 'PUT' and hasattr(view, 'get_object'): + view.get_object() + except (exceptions.APIException, PermissionDenied, Http404): + pass + else: + # If user has appropriate permissions for the view, include + # appropriate metadata about the fields that should be supplied. + serializer = view.get_serializer() + actions[method] = self.get_serializer_info(serializer) + finally: + view.request = request + + return actions + + def get_serializer_info(self, serializer): + """ + Given an instance of a serializer, return a dictionary of metadata + about its fields. + """ + return SortedDict([ + (field_name, self.get_field_info(field)) + for field_name, field in six.iteritems(serializer.fields) + ]) + + def get_field_info(self, field): + """ + Given an instance of a serializer field, return a dictionary + of metadata about it. + """ + field_info = SortedDict() + field_info['type'] = self.label_lookup[field] + field_info['required'] = getattr(field, 'required', False) + + for attr in ['read_only', 'label', 'help_text', 'min_length', 'max_length']: + value = getattr(field, attr, None) + if value is not None and value != '': + field_info[attr] = force_text(value, strings_only=True) + + if hasattr(field, 'choices'): + field_info['choices'] = [ + {'value': choice_value, 'display_name': choice_name} + for choice_value, choice_name in field.choices.items() + ] + + return field_info diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index d8d72a4c..8902294b 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -21,7 +21,7 @@ from rest_framework.utils import html, model_meta, representation from rest_framework.utils.field_mapping import ( get_url_kwargs, get_field_kwargs, get_relation_kwargs, get_nested_relation_kwargs, - lookup_class + ClassLookupDict ) import copy import inspect @@ -318,7 +318,7 @@ class ListSerializer(BaseSerializer): class ModelSerializer(Serializer): - _field_mapping = { + _field_mapping = ClassLookupDict({ models.AutoField: IntegerField, models.BigIntegerField: IntegerField, models.BooleanField: BooleanField, @@ -341,7 +341,7 @@ class ModelSerializer(Serializer): models.TextField: CharField, models.TimeField: TimeField, models.URLField: URLField, - } + }) _related_class = PrimaryKeyRelatedField def create(self, attrs): @@ -400,7 +400,7 @@ class ModelSerializer(Serializer): elif field_name in info.fields_and_pk: # Create regular model fields. model_field = info.fields_and_pk[field_name] - field_cls = lookup_class(self._field_mapping, model_field) + field_cls = self._field_mapping[model_field] kwargs = get_field_kwargs(field_name, model_field) if 'choices' in kwargs: # Fields with choices get coerced into `ChoiceField` diff --git a/rest_framework/settings.py b/rest_framework/settings.py index 421e146c..d7fb0a43 100644 --- a/rest_framework/settings.py +++ b/rest_framework/settings.py @@ -45,6 +45,7 @@ DEFAULTS = { ), 'DEFAULT_THROTTLE_CLASSES': (), 'DEFAULT_CONTENT_NEGOTIATION_CLASS': 'rest_framework.negotiation.DefaultContentNegotiation', + 'DEFAULT_METADATA_CLASS': 'rest_framework.metadata.SimpleMetadata', # Genric view behavior 'DEFAULT_MODEL_SERIALIZER_CLASS': 'rest_framework.serializers.ModelSerializer', @@ -121,6 +122,7 @@ IMPORT_STRINGS = ( 'DEFAULT_PERMISSION_CLASSES', 'DEFAULT_THROTTLE_CLASSES', 'DEFAULT_CONTENT_NEGOTIATION_CLASS', + 'DEFAULT_METADATA_CLASS', 'DEFAULT_MODEL_SERIALIZER_CLASS', 'DEFAULT_PAGINATION_SERIALIZER_CLASS', 'DEFAULT_FILTER_BACKENDS', diff --git a/rest_framework/utils/field_mapping.py b/rest_framework/utils/field_mapping.py index c208afdc..c3794083 100644 --- a/rest_framework/utils/field_mapping.py +++ b/rest_framework/utils/field_mapping.py @@ -9,17 +9,21 @@ from rest_framework.compat import clean_manytomany_helptext import inspect -def lookup_class(mapping, instance): +class ClassLookupDict(object): """ - Takes a dictionary with classes as keys, and an object. - Traverses the object's inheritance hierarchy in method - resolution order, and returns the first matching value + Takes a dictionary with classes as keys. + Lookups against this object will traverses the object's inheritance + hierarchy in method resolution order, and returns the first matching value from the dictionary or raises a KeyError if nothing matches. """ - for cls in inspect.getmro(instance.__class__): - if cls in mapping: - return mapping[cls] - raise KeyError('Class %s not found in lookup.', cls.__name__) + def __init__(self, mapping): + self.mapping = mapping + + def __getitem__(self, key): + for cls in inspect.getmro(key.__class__): + if cls in self.mapping: + return self.mapping[cls] + raise KeyError('Class %s not found in lookup.', cls.__name__) def needs_label(model_field, field_name): diff --git a/rest_framework/views.py b/rest_framework/views.py index 9f08a4ad..835e223a 100644 --- a/rest_framework/views.py +++ b/rest_framework/views.py @@ -5,7 +5,6 @@ from __future__ import unicode_literals from django.core.exceptions import PermissionDenied, ValidationError, NON_FIELD_ERRORS from django.http import Http404 -from django.utils.datastructures import SortedDict from django.views.decorators.csrf import csrf_exempt from rest_framework import status, exceptions from rest_framework.compat import smart_text, HttpResponseBase, View @@ -99,6 +98,7 @@ class APIView(View): throttle_classes = api_settings.DEFAULT_THROTTLE_CLASSES permission_classes = api_settings.DEFAULT_PERMISSION_CLASSES content_negotiation_class = api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS + metadata_class = api_settings.DEFAULT_METADATA_CLASS # Allow dependancy injection of other settings to make testing easier. settings = api_settings @@ -418,22 +418,8 @@ class APIView(View): def options(self, request, *args, **kwargs): """ Handler method for HTTP 'OPTIONS' request. - We may as well implement this as Django will otherwise provide - a less useful default implementation. """ - return Response(self.metadata(request), status=status.HTTP_200_OK) - - def metadata(self, request): - """ - Return a dictionary of metadata about the view. - Used to return responses for OPTIONS requests. - """ - # By default we can't provide any form-like information, however the - # generic views override this implementation and add additional - # information for POST and PUT methods, based on the serializer. - ret = SortedDict() - ret['name'] = self.get_view_name() - ret['description'] = self.get_view_description() - ret['renders'] = [renderer.media_type for renderer in self.renderer_classes] - ret['parses'] = [parser.media_type for parser in self.parser_classes] - return ret + if self.metadata_class is None: + return self.http_method_not_allowed(request, *args, **kwargs) + data = self.metadata_class().determine_metadata(request, self) + return Response(data, status=status.HTTP_200_OK) diff --git a/tests/test_metadata.py b/tests/test_metadata.py new file mode 100644 index 00000000..0ebea935 --- /dev/null +++ b/tests/test_metadata.py @@ -0,0 +1,166 @@ +from __future__ import unicode_literals + +from rest_framework import exceptions, serializers, views +from rest_framework.request import Request +from rest_framework.test import APIRequestFactory +import pytest + +request = Request(APIRequestFactory().options('/')) + + +class TestMetadata: + def test_metadata(self): + """ + OPTIONS requests to views should return a valid 200 response. + """ + class ExampleView(views.APIView): + """Example view.""" + pass + + response = ExampleView().options(request=request) + expected = { + 'name': 'Example', + 'description': 'Example view.', + 'renders': [ + 'application/json', + 'text/html' + ], + 'parses': [ + 'application/json', + 'application/x-www-form-urlencoded', + 'multipart/form-data' + ] + } + assert response.status_code == 200 + assert response.data == expected + + def test_none_metadata(self): + """ + OPTIONS requests to views where `metadata_class = None` should raise + a MethodNotAllowed exception, which will result in an HTTP 405 response. + """ + class ExampleView(views.APIView): + metadata_class = None + + with pytest.raises(exceptions.MethodNotAllowed): + ExampleView().options(request=request) + + def test_actions(self): + """ + On generic views OPTIONS should return an 'actions' key with metadata + on the fields that may be supplied to PUT and POST requests. + """ + class ExampleSerializer(serializers.Serializer): + choice_field = serializers.ChoiceField(['red', 'green', 'blue']) + integer_field = serializers.IntegerField(max_value=10) + char_field = serializers.CharField(required=False) + + class ExampleView(views.APIView): + """Example view.""" + def post(self, request): + pass + + def get_serializer(self): + return ExampleSerializer() + + response = ExampleView().options(request=request) + expected = { + 'name': 'Example', + 'description': 'Example view.', + 'renders': [ + 'application/json', + 'text/html' + ], + 'parses': [ + 'application/json', + 'application/x-www-form-urlencoded', + 'multipart/form-data' + ], + 'actions': { + 'POST': { + 'choice_field': { + 'type': 'choice', + 'required': True, + 'read_only': False, + 'label': 'Choice field', + 'choices': [ + {'display_name': 'blue', 'value': 'blue'}, + {'display_name': 'green', 'value': 'green'}, + {'display_name': 'red', 'value': 'red'} + ] + }, + 'integer_field': { + 'type': 'integer', + 'required': True, + 'read_only': False, + 'label': 'Integer field' + }, + 'char_field': { + 'type': 'string', + 'required': False, + 'read_only': False, + 'label': 'Char field' + } + } + } + } + assert response.status_code == 200 + assert response.data == expected + + def test_global_permissions(self): + """ + If a user does not have global permissions on an action, then any + metadata associated with it should not be included in OPTION responses. + """ + class ExampleSerializer(serializers.Serializer): + choice_field = serializers.ChoiceField(['red', 'green', 'blue']) + integer_field = serializers.IntegerField(max_value=10) + char_field = serializers.CharField(required=False) + + class ExampleView(views.APIView): + """Example view.""" + def post(self, request): + pass + + def put(self, request): + pass + + def get_serializer(self): + return ExampleSerializer() + + def check_permissions(self, request): + if request.method == 'POST': + raise exceptions.PermissionDenied() + + response = ExampleView().options(request=request) + assert response.status_code == 200 + assert list(response.data['actions'].keys()) == ['PUT'] + + def test_object_permissions(self): + """ + If a user does not have object permissions on an action, then any + metadata associated with it should not be included in OPTION responses. + """ + class ExampleSerializer(serializers.Serializer): + choice_field = serializers.ChoiceField(['red', 'green', 'blue']) + integer_field = serializers.IntegerField(max_value=10) + char_field = serializers.CharField(required=False) + + class ExampleView(views.APIView): + """Example view.""" + def post(self, request): + pass + + def put(self, request): + pass + + def get_serializer(self): + return ExampleSerializer() + + def get_object(self): + if self.request.method == 'PUT': + raise exceptions.PermissionDenied() + + response = ExampleView().options(request=request) + assert response.status_code == 200 + assert list(response.data['actions'].keys()) == ['POST'] -- cgit v1.2.3 From 358445c174629bdd55894c48eaf965bbfd4414b2 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 24 Sep 2014 14:52:34 +0100 Subject: Drop redundant OPTIONS tests --- tests/test_generics.py | 180 ------------------------------------------------- 1 file changed, 180 deletions(-) diff --git a/tests/test_generics.py b/tests/test_generics.py index 51004edf..89f9def0 100644 --- a/tests/test_generics.py +++ b/tests/test_generics.py @@ -23,25 +23,16 @@ class ForeignKeySerializer(serializers.ModelSerializer): class RootView(generics.ListCreateAPIView): - """ - Example description for OPTIONS. - """ queryset = BasicModel.objects.all() serializer_class = BasicSerializer class InstanceView(generics.RetrieveUpdateDestroyAPIView): - """ - Example description for OPTIONS. - """ queryset = BasicModel.objects.exclude(text='filtered out') serializer_class = BasicSerializer class FKInstanceView(generics.RetrieveUpdateDestroyAPIView): - """ - FK: example description for OPTIONS. - """ queryset = ForeignKeySource.objects.all() serializer_class = ForeignKeySerializer @@ -122,47 +113,6 @@ class TestRootView(TestCase): self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED) self.assertEqual(response.data, {"detail": "Method 'DELETE' not allowed."}) - # def test_options_root_view(self): - # """ - # OPTIONS requests to ListCreateAPIView should return metadata - # """ - # request = factory.options('/') - # with self.assertNumQueries(0): - # response = self.view(request).render() - # expected = { - # 'parses': [ - # 'application/json', - # 'application/x-www-form-urlencoded', - # 'multipart/form-data' - # ], - # 'renders': [ - # 'application/json', - # 'text/html' - # ], - # 'name': 'Root', - # 'description': 'Example description for OPTIONS.', - # 'actions': { - # 'POST': { - # 'text': { - # 'max_length': 100, - # 'read_only': False, - # 'required': True, - # 'type': 'string', - # "label": "Text comes here", - # "help_text": "Text description." - # }, - # 'id': { - # 'read_only': True, - # 'required': False, - # 'type': 'integer', - # 'label': 'ID', - # }, - # } - # } - # } - # self.assertEqual(response.status_code, status.HTTP_200_OK) - # self.assertEqual(response.data, expected) - def test_post_cannot_set_id(self): """ POST requests to create a new object should not be able to set the id. @@ -256,89 +206,6 @@ class TestInstanceView(TestCase): ids = [obj.id for obj in self.objects.all()] self.assertEqual(ids, [2, 3]) - # def test_options_instance_view(self): - # """ - # OPTIONS requests to RetrieveUpdateDestroyAPIView should return metadata - # """ - # request = factory.options('/1') - # with self.assertNumQueries(1): - # response = self.view(request, pk=1).render() - # expected = { - # 'parses': [ - # 'application/json', - # 'application/x-www-form-urlencoded', - # 'multipart/form-data' - # ], - # 'renders': [ - # 'application/json', - # 'text/html' - # ], - # 'name': 'Instance', - # 'description': 'Example description for OPTIONS.', - # 'actions': { - # 'PUT': { - # 'text': { - # 'max_length': 100, - # 'read_only': False, - # 'required': True, - # 'type': 'string', - # 'label': 'Text comes here', - # 'help_text': 'Text description.' - # }, - # 'id': { - # 'read_only': True, - # 'required': False, - # 'type': 'integer', - # 'label': 'ID', - # }, - # } - # } - # } - # self.assertEqual(response.status_code, status.HTTP_200_OK) - # self.assertEqual(response.data, expected) - - # def test_options_before_instance_create(self): - # """ - # OPTIONS requests to RetrieveUpdateDestroyAPIView should return metadata - # before the instance has been created - # """ - # request = factory.options('/999') - # with self.assertNumQueries(1): - # response = self.view(request, pk=999).render() - # expected = { - # 'parses': [ - # 'application/json', - # 'application/x-www-form-urlencoded', - # 'multipart/form-data' - # ], - # 'renders': [ - # 'application/json', - # 'text/html' - # ], - # 'name': 'Instance', - # 'description': 'Example description for OPTIONS.', - # 'actions': { - # 'PUT': { - # 'text': { - # 'max_length': 100, - # 'read_only': False, - # 'required': True, - # 'type': 'string', - # 'label': 'Text comes here', - # 'help_text': 'Text description.' - # }, - # 'id': { - # 'read_only': True, - # 'required': False, - # 'type': 'integer', - # 'label': 'ID', - # }, - # } - # } - # } - # self.assertEqual(response.status_code, status.HTTP_200_OK) - # self.assertEqual(response.data, expected) - def test_get_instance_view_incorrect_arg(self): """ GET requests with an incorrect pk type, should raise 404, not 500. @@ -415,53 +282,6 @@ class TestFKInstanceView(TestCase): ] self.view = FKInstanceView.as_view() - # def test_options_root_view(self): - # """ - # OPTIONS requests to ListCreateAPIView should return metadata - # """ - # request = factory.options('/999') - # with self.assertNumQueries(1): - # response = self.view(request, pk=999).render() - # expected = { - # 'name': 'Fk Instance', - # 'description': 'FK: example description for OPTIONS.', - # 'renders': [ - # 'application/json', - # 'text/html' - # ], - # 'parses': [ - # 'application/json', - # 'application/x-www-form-urlencoded', - # 'multipart/form-data' - # ], - # 'actions': { - # 'PUT': { - # 'id': { - # 'type': 'integer', - # 'required': False, - # 'read_only': True, - # 'label': 'ID' - # }, - # 'name': { - # 'type': 'string', - # 'required': True, - # 'read_only': False, - # 'label': 'name', - # 'max_length': 100 - # }, - # 'target': { - # 'type': 'field', - # 'required': True, - # 'read_only': False, - # 'label': 'Target', - # 'help_text': 'Target' - # } - # } - # } - # } - # self.assertEqual(response.status_code, status.HTTP_200_OK) - # self.assertEqual(response.data, expected) - class TestOverriddenGetObject(TestCase): """ -- cgit v1.2.3 From 127c0bd3d68860dd6567d81047257fbc3e70b4b9 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 24 Sep 2014 20:25:59 +0100 Subject: Custom deepcopy on Field classes --- rest_framework/fields.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index f859658a..1f7d964a 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -9,6 +9,7 @@ from rest_framework import ISO_8601 from rest_framework.compat import smart_text, EmailValidator, MinValueValidator, MaxValueValidator, URLValidator from rest_framework.settings import api_settings from rest_framework.utils import html, representation, humanize_datetime +import copy import datetime import decimal import inspect @@ -150,6 +151,11 @@ class Field(object): instance._kwargs = kwargs return instance + def __deepcopy__(self, memo): + args = copy.deepcopy(self._args) + kwargs = copy.deepcopy(self._kwargs) + return self.__class__(*args, **kwargs) + def bind(self, field_name, parent, root): """ Setup the context for the field instance. -- cgit v1.2.3 From fb1546ee50953faae8af505a0c90da00ac08ad92 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 24 Sep 2014 20:53:37 +0100 Subject: Enforce field_name != source --- rest_framework/fields.py | 11 +++++++++++ tests/test_fields.py | 13 ++++++++++++- 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 1f7d964a..9280ea3a 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -160,6 +160,17 @@ class Field(object): """ Setup the context for the field instance. """ + + # In order to enforce a consistent style, we error if a redundant + # 'source' argument has been used. For example: + # my_field = serializer.CharField(source='my_field') + assert self._kwargs.get('source') != field_name, ( + "It is redundant to specify `source='%s'` on field '%s' in " + "serializer '%s', as it is the same the field name. " + "Remove the `source` keyword argument." % + (field_name, self.__class__.__name__, parent.__class__.__name__) + ) + self.field_name = field_name self.parent = parent self.root = root diff --git a/tests/test_fields.py b/tests/test_fields.py index 91f3f5db..c2e03023 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -1,6 +1,6 @@ from decimal import Decimal from django.utils import timezone -from rest_framework import fields +from rest_framework import fields, serializers import datetime import django import pytest @@ -69,6 +69,17 @@ class TestFieldOptions: output = field.run_validation() assert output is 123 + def test_redundant_source(self): + class ExampleSerializer(serializers.Serializer): + example_field = serializers.CharField(source='example_field') + with pytest.raises(AssertionError) as exc_info: + ExampleSerializer() + assert str(exc_info.value) == ( + "It is redundant to specify `source='example_field'` on field " + "'CharField' in serializer 'ExampleSerializer', as it is the " + "same the field name. Remove the `source` keyword argument." + ) + # Tests for field input and output values. # ---------------------------------------- -- cgit v1.2.3 From 1420c76453c37c023a901dd0938d717b7b5e52ca Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 25 Sep 2014 10:49:25 +0100 Subject: Ensure proper sorting of 'choices' attribute on ChoiceField --- rest_framework/fields.py | 9 ++++++--- tests/test_fields.py | 4 ++-- tests/test_metadata.py | 4 ++-- 3 files changed, 10 insertions(+), 7 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 9280ea3a..d1aebbaf 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -2,6 +2,7 @@ from django.conf import settings from django.core import validators from django.core.exceptions import ValidationError from django.utils import timezone +from django.utils.datastructures import SortedDict from django.utils.dateparse import parse_date, parse_datetime, parse_time from django.utils.encoding import is_protected_type from django.utils.translation import ugettext_lazy as _ @@ -166,7 +167,7 @@ class Field(object): # my_field = serializer.CharField(source='my_field') assert self._kwargs.get('source') != field_name, ( "It is redundant to specify `source='%s'` on field '%s' in " - "serializer '%s', as it is the same the field name. " + "serializer '%s', because it is the same as the field name. " "Remove the `source` keyword argument." % (field_name, self.__class__.__name__, parent.__class__.__name__) ) @@ -303,6 +304,7 @@ class BooleanField(Field): 'invalid': _('`{input}` is not a valid boolean.') } default_empty_html = False + initial = False TRUE_VALUES = set(('t', 'T', 'true', 'True', 'TRUE', '1', 1, True)) FALSE_VALUES = set(('f', 'F', 'false', 'False', 'FALSE', '0', 0, 0.0, False)) @@ -365,6 +367,7 @@ class CharField(Field): 'blank': _('This field may not be blank.') } default_empty_html = '' + initial = '' def __init__(self, **kwargs): self.allow_blank = kwargs.pop('allow_blank', False) @@ -775,9 +778,9 @@ class ChoiceField(Field): for item in choices ] if all(pairs): - self.choices = dict([(key, display_value) for key, display_value in choices]) + self.choices = SortedDict([(key, display_value) for key, display_value in choices]) else: - self.choices = dict([(item, item) for item in choices]) + self.choices = SortedDict([(item, item) for item in choices]) # Map the string representation of choices to the underlying value. # Allows us to deal with eg. integer choices while supporting either diff --git a/tests/test_fields.py b/tests/test_fields.py index c2e03023..ebb88d3d 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -76,8 +76,8 @@ class TestFieldOptions: ExampleSerializer() assert str(exc_info.value) == ( "It is redundant to specify `source='example_field'` on field " - "'CharField' in serializer 'ExampleSerializer', as it is the " - "same the field name. Remove the `source` keyword argument." + "'CharField' in serializer 'ExampleSerializer', because it is the " + "same as the field name. Remove the `source` keyword argument." ) diff --git a/tests/test_metadata.py b/tests/test_metadata.py index 0ebea935..5ff59c72 100644 --- a/tests/test_metadata.py +++ b/tests/test_metadata.py @@ -84,9 +84,9 @@ class TestMetadata: 'read_only': False, 'label': 'Choice field', 'choices': [ - {'display_name': 'blue', 'value': 'blue'}, + {'display_name': 'red', 'value': 'red'}, {'display_name': 'green', 'value': 'green'}, - {'display_name': 'red', 'value': 'red'} + {'display_name': 'blue', 'value': 'blue'} ] }, 'integer_field': { -- cgit v1.2.3 From b22c9602fa0f717b688fdb35e4f6f42c189af3f3 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 25 Sep 2014 11:04:18 +0100 Subject: Automatic field binding --- rest_framework/metadata.py | 3 +-- rest_framework/pagination.py | 1 - rest_framework/serializers.py | 30 +++++++++++++++++++++++++----- 3 files changed, 26 insertions(+), 8 deletions(-) diff --git a/rest_framework/metadata.py b/rest_framework/metadata.py index 580259de..af4bc396 100644 --- a/rest_framework/metadata.py +++ b/rest_framework/metadata.py @@ -10,7 +10,6 @@ from __future__ import unicode_literals from django.core.exceptions import PermissionDenied from django.http import Http404 -from django.utils import six from django.utils.datastructures import SortedDict from rest_framework import exceptions, serializers from rest_framework.compat import force_text @@ -100,7 +99,7 @@ class SimpleMetadata(BaseMetadata): """ return SortedDict([ (field_name, self.get_field_info(field)) - for field_name, field in six.iteritems(serializer.fields) + for field_name, field in serializer.fields.items() ]) def get_field_info(self, field): diff --git a/rest_framework/pagination.py b/rest_framework/pagination.py index c5a9270a..fb451285 100644 --- a/rest_framework/pagination.py +++ b/rest_framework/pagination.py @@ -72,7 +72,6 @@ class BasePaginationSerializer(serializers.Serializer): child=object_serializer(), source='object_list' ) - self.fields[results_field].bind(results_field, self, self) class PaginationSerializer(BasePaginationSerializer): diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 8902294b..12e38090 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -149,6 +149,28 @@ class SerializerMetaclass(type): return super(SerializerMetaclass, cls).__new__(cls, name, bases, attrs) +class BindingDict(object): + def __init__(self, serializer): + self.serializer = serializer + self.fields = SortedDict() + + def __setitem__(self, key, field): + self.fields[key] = field + field.bind(field_name=key, parent=self.serializer, root=self.serializer) + + def __getitem__(self, key): + return self.fields[key] + + def __delitem__(self, key): + del self.fields[key] + + def items(self): + return self.fields.items() + + def values(self): + return self.fields.values() + + @six.add_metaclass(SerializerMetaclass) class Serializer(BaseSerializer): def __init__(self, *args, **kwargs): @@ -161,11 +183,9 @@ class Serializer(BaseSerializer): # Every new serializer is created with a clone of the field instances. # This allows users to dynamically modify the fields on a serializer # instance without affecting every other serializer class. - self.fields = self._get_base_fields() - - # Setup all the child fields, to provide them with the current context. - for field_name, field in self.fields.items(): - field.bind(field_name, self, self) + self.fields = BindingDict(self) + for key, value in self._get_base_fields().items(): + self.fields[key] = value def __new__(cls, *args, **kwargs): # We override this method in order to automagically create -- cgit v1.2.3 From 64632da3718f501cb8174243385d38b547c2fefd Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 25 Sep 2014 11:40:32 +0100 Subject: Clean up bind - no longer needs to be called multiple times in nested fields --- rest_framework/fields.py | 21 ++++++++++++++++----- rest_framework/relations.py | 5 ----- rest_framework/serializers.py | 26 +++++++++----------------- tests/test_relations.py | 8 ++++---- 4 files changed, 29 insertions(+), 31 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index d1aebbaf..446732c3 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -109,7 +109,8 @@ class Field(object): def __init__(self, read_only=False, write_only=False, required=None, default=empty, initial=None, source=None, label=None, help_text=None, style=None, - error_messages=None, validators=[], allow_null=False): + error_messages=None, validators=[], allow_null=False, + context=None): self._creation_counter = Field._creation_counter Field._creation_counter += 1 @@ -135,6 +136,11 @@ class Field(object): self.validators = validators or self.default_validators[:] self.allow_null = allow_null + # These are set up by `.bind()` when the field is added to a serializer. + self.field_name = None + self.parent = None + self._context = {} if (context is None) else context + # Collect default error message from self and parent classes messages = {} for cls in reversed(self.__class__.__mro__): @@ -157,7 +163,14 @@ class Field(object): kwargs = copy.deepcopy(self._kwargs) return self.__class__(*args, **kwargs) - def bind(self, field_name, parent, root): + @property + def context(self): + root = self + while root.parent is not None: + root = root.parent + return root._context + + def bind(self, field_name, parent): """ Setup the context for the field instance. """ @@ -174,10 +187,8 @@ class Field(object): self.field_name = field_name self.parent = parent - self.root = root - self.context = parent.context - # `self.label` should deafult to being based on the field name. + # `self.label` should default to being based on the field name. if self.label is None: self.label = field_name.replace('_', ' ').capitalize() diff --git a/rest_framework/relations.py b/rest_framework/relations.py index 5aa1f8bd..b37a6fed 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -243,11 +243,6 @@ class ManyRelation(Field): assert child_relation is not None, '`child_relation` is a required argument.' super(ManyRelation, self).__init__(*args, **kwargs) - def bind(self, field_name, parent, root): - # ManyRelation needs to provide the current context to the child relation. - super(ManyRelation, self).bind(field_name, parent, root) - self.child_relation.bind(field_name, parent, root) - def to_internal_value(self, data): return [ self.child_relation.to_internal_value(item) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 12e38090..04721c7a 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -150,13 +150,20 @@ class SerializerMetaclass(type): class BindingDict(object): + """ + This dict-like object is used to store fields on a serializer. + + This ensures that whenever fields are added to the serializer we call + `field.bind()` so that the `field_name` and `parent` attributes + can be set correctly. + """ def __init__(self, serializer): self.serializer = serializer self.fields = SortedDict() def __setitem__(self, key, field): self.fields[key] = field - field.bind(field_name=key, parent=self.serializer, root=self.serializer) + field.bind(field_name=key, parent=self.serializer) def __getitem__(self, key): return self.fields[key] @@ -174,7 +181,6 @@ class BindingDict(object): @six.add_metaclass(SerializerMetaclass) class Serializer(BaseSerializer): def __init__(self, *args, **kwargs): - self.context = kwargs.pop('context', {}) kwargs.pop('partial', None) kwargs.pop('many', None) @@ -198,13 +204,6 @@ class Serializer(BaseSerializer): def _get_base_fields(self): return copy.deepcopy(self._declared_fields) - def bind(self, field_name, parent, root): - # If the serializer is used as a field then when it becomes bound - # it also needs to bind all its child fields. - super(Serializer, self).bind(field_name, parent, root) - for field_name, field in self.fields.items(): - field.bind(field_name, self, root) - def get_initial(self): return dict([ (field.field_name, field.get_initial()) @@ -290,17 +289,10 @@ class ListSerializer(BaseSerializer): self.child = kwargs.pop('child', copy.deepcopy(self.child)) assert self.child is not None, '`child` is a required argument.' assert not inspect.isclass(self.child), '`child` has not been instantiated.' - self.context = kwargs.pop('context', {}) kwargs.pop('partial', None) super(ListSerializer, self).__init__(*args, **kwargs) - self.child.bind('', self, self) - - def bind(self, field_name, parent, root): - # If the list is used as a field then it needs to provide - # the current context to the child serializer. - super(ListSerializer, self).bind(field_name, parent, root) - self.child.bind(field_name, self, root) + self.child.bind(field_name='', parent=self) def get_value(self, dictionary): # We override the default field access in order to support diff --git a/tests/test_relations.py b/tests/test_relations.py index c29618ce..2d11672b 100644 --- a/tests/test_relations.py +++ b/tests/test_relations.py @@ -51,7 +51,7 @@ class TestHyperlinkedIdentityField(APISimpleTestCase): self.instance = MockObject(pk=1, name='foo') self.field = serializers.HyperlinkedIdentityField(view_name='example') self.field.reverse = mock_reverse - self.field.context = {'request': True} + self.field._context = {'request': True} def test_representation(self): representation = self.field.to_representation(self.instance) @@ -62,7 +62,7 @@ class TestHyperlinkedIdentityField(APISimpleTestCase): assert representation is None def test_representation_with_format(self): - self.field.context['format'] = 'xml' + self.field._context['format'] = 'xml' representation = self.field.to_representation(self.instance) assert representation == 'http://example.org/example/1.xml/' @@ -91,14 +91,14 @@ class TestHyperlinkedIdentityFieldWithFormat(APISimpleTestCase): self.instance = MockObject(pk=1, name='foo') self.field = serializers.HyperlinkedIdentityField(view_name='example', format='json') self.field.reverse = mock_reverse - self.field.context = {'request': True} + self.field._context = {'request': True} def test_representation(self): representation = self.field.to_representation(self.instance) assert representation == 'http://example.org/example/1/' def test_representation_with_format(self): - self.field.context['format'] = 'xml' + self.field._context['format'] = 'xml' representation = self.field.to_representation(self.instance) assert representation == 'http://example.org/example/1.json/' -- cgit v1.2.3 From b47ca158b9ba9733baad080e648d24b0465ec697 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 25 Sep 2014 12:09:12 +0100 Subject: Check for redundant on SerializerMethodField --- rest_framework/fields.py | 29 ++++++++++++++++++++++------- tests/test_fields.py | 30 ++++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 7 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 446732c3..328e93ef 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -178,7 +178,7 @@ class Field(object): # In order to enforce a consistent style, we error if a redundant # 'source' argument has been used. For example: # my_field = serializer.CharField(source='my_field') - assert self._kwargs.get('source') != field_name, ( + assert self.source != field_name, ( "It is redundant to specify `source='%s'` on field '%s' in " "serializer '%s', because it is the same as the field name. " "Remove the `source` keyword argument." % @@ -883,17 +883,32 @@ class SerializerMethodField(Field): def get_extra_info(self, obj): return ... # Calculate some data to return. """ - def __init__(self, method_attr=None, **kwargs): - self.method_attr = method_attr + def __init__(self, method_name=None, **kwargs): + self.method_name = method_name kwargs['source'] = '*' kwargs['read_only'] = True super(SerializerMethodField, self).__init__(**kwargs) + def bind(self, field_name, parent): + # In order to enforce a consistent style, we error if a redundant + # 'method_name' argument has been used. For example: + # my_field = serializer.CharField(source='my_field') + default_method_name = 'get_{field_name}'.format(field_name=field_name) + assert self.method_name != default_method_name, ( + "It is redundant to specify `%s` on SerializerMethodField '%s' in " + "serializer '%s', because it is the same as the default method name. " + "Remove the `method_name` argument." % + (self.method_name, field_name, parent.__class__.__name__) + ) + + # The method name should default to `get_{field_name}`. + if self.method_name is None: + self.method_name = default_method_name + + super(SerializerMethodField, self).bind(field_name, parent) + def to_representation(self, value): - method_attr = self.method_attr - if method_attr is None: - method_attr = 'get_{field_name}'.format(field_name=self.field_name) - method = getattr(self.parent, method_attr) + method = getattr(self.parent, self.method_name) return method(value) diff --git a/tests/test_fields.py b/tests/test_fields.py index ebb88d3d..003b4b8c 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -710,3 +710,33 @@ class TestMultipleChoiceField(FieldValues): ('diesel', 'Diesel'), ] ) + + +# Tests for SerializerMethodField. +# -------------------------------- + +class TestSerializerMethodField: + def test_serializer_method_field(self): + class ExampleSerializer(serializers.Serializer): + example_field = serializers.SerializerMethodField() + + def get_example_field(self, obj): + return 'ran get_example_field(%d)' % obj['example_field'] + + serializer = ExampleSerializer({'example_field': 123}) + assert serializer.data == { + 'example_field': 'ran get_example_field(123)' + } + + def test_redundant_method_name(self): + class ExampleSerializer(serializers.Serializer): + example_field = serializers.SerializerMethodField('get_example_field') + + with pytest.raises(AssertionError) as exc_info: + ExampleSerializer() + assert str(exc_info.value) == ( + "It is redundant to specify `get_example_field` on " + "SerializerMethodField 'example_field' in serializer " + "'ExampleSerializer', because it is the same as the default " + "method name. Remove the `method_name` argument." + ) -- cgit v1.2.3 From 8ee92f8a18c3a31a2a95233f36754203dc60bb18 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 25 Sep 2014 13:10:33 +0100 Subject: Refuse to downcast from datetime to date or time --- rest_framework/fields.py | 118 ++++++++++++++++++++++++++--------------------- tests/test_fields.py | 3 +- 2 files changed, 67 insertions(+), 54 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 328e93ef..d855e6fd 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -608,120 +608,126 @@ class DecimalField(Field): # Date & time fields... -class DateField(Field): +class DateTimeField(Field): default_error_messages = { - 'invalid': _('Date has wrong format. Use one of these formats instead: {format}'), - 'datetime': _('Expected a date but got a datetime.'), + 'invalid': _('Datetime has wrong format. Use one of these formats instead: {format}'), + 'date': _('Expected a datetime but got a date.'), } - format = api_settings.DATE_FORMAT - input_formats = api_settings.DATE_INPUT_FORMATS + format = api_settings.DATETIME_FORMAT + input_formats = api_settings.DATETIME_INPUT_FORMATS + default_timezone = timezone.get_default_timezone() if settings.USE_TZ else None - def __init__(self, format=empty, input_formats=None, *args, **kwargs): + def __init__(self, format=empty, input_formats=None, default_timezone=None, *args, **kwargs): self.format = format if format is not empty else self.format self.input_formats = input_formats if input_formats is not None else self.input_formats - super(DateField, self).__init__(*args, **kwargs) + self.default_timezone = default_timezone if default_timezone is not None else self.default_timezone + super(DateTimeField, self).__init__(*args, **kwargs) + + def enforce_timezone(self, value): + """ + When `self.default_timezone` is `None`, always return naive datetimes. + When `self.default_timezone` is not `None`, always return aware datetimes. + """ + if (self.default_timezone is not None) and not timezone.is_aware(value): + return timezone.make_aware(value, self.default_timezone) + elif (self.default_timezone is None) and timezone.is_aware(value): + return timezone.make_naive(value, timezone.UTC()) + return value def to_internal_value(self, value): - if isinstance(value, datetime.datetime): - self.fail('datetime') + if (isinstance(value, datetime.date) and not isinstance(value, datetime.datetime): + self.fail('date') - if isinstance(value, datetime.date): - return value + if isinstance(value, datetime.datetime): + return self.enforce_timezone(value) for format in self.input_formats: if format.lower() == ISO_8601: try: - parsed = parse_date(value) + parsed = parse_datetime(value) except (ValueError, TypeError): pass else: if parsed is not None: - return parsed + return self.enforce_timezone(parsed) else: try: parsed = datetime.datetime.strptime(value, format) except (ValueError, TypeError): pass else: - return parsed.date() + return self.enforce_timezone(parsed) - humanized_format = humanize_datetime.date_formats(self.input_formats) + humanized_format = humanize_datetime.datetime_formats(self.input_formats) self.fail('invalid', format=humanized_format) def to_representation(self, value): if value is None or self.format is None: return value - if isinstance(value, datetime.datetime): - value = value.date() - if self.format.lower() == ISO_8601: - return value.isoformat() + ret = value.isoformat() + if ret.endswith('+00:00'): + ret = ret[:-6] + 'Z' + return ret return value.strftime(self.format) -class DateTimeField(Field): +class DateField(Field): default_error_messages = { - 'invalid': _('Datetime has wrong format. Use one of these formats instead: {format}'), - 'date': _('Expected a datetime but got a date.'), + 'invalid': _('Date has wrong format. Use one of these formats instead: {format}'), + 'datetime': _('Expected a date but got a datetime.'), } - format = api_settings.DATETIME_FORMAT - input_formats = api_settings.DATETIME_INPUT_FORMATS - default_timezone = timezone.get_default_timezone() if settings.USE_TZ else None + format = api_settings.DATE_FORMAT + input_formats = api_settings.DATE_INPUT_FORMATS - def __init__(self, format=empty, input_formats=None, default_timezone=None, *args, **kwargs): + def __init__(self, format=empty, input_formats=None, *args, **kwargs): self.format = format if format is not empty else self.format self.input_formats = input_formats if input_formats is not None else self.input_formats - self.default_timezone = default_timezone if default_timezone is not None else self.default_timezone - super(DateTimeField, self).__init__(*args, **kwargs) - - def enforce_timezone(self, value): - """ - When `self.default_timezone` is `None`, always return naive datetimes. - When `self.default_timezone` is not `None`, always return aware datetimes. - """ - if (self.default_timezone is not None) and not timezone.is_aware(value): - return timezone.make_aware(value, self.default_timezone) - elif (self.default_timezone is None) and timezone.is_aware(value): - return timezone.make_naive(value, timezone.UTC()) - return value + super(DateField, self).__init__(*args, **kwargs) def to_internal_value(self, value): - if isinstance(value, datetime.date) and not isinstance(value, datetime.datetime): - self.fail('date') - if isinstance(value, datetime.datetime): - return self.enforce_timezone(value) + self.fail('datetime') + + if isinstance(value, datetime.date): + return value for format in self.input_formats: if format.lower() == ISO_8601: try: - parsed = parse_datetime(value) + parsed = parse_date(value) except (ValueError, TypeError): pass else: if parsed is not None: - return self.enforce_timezone(parsed) + return parsed else: try: parsed = datetime.datetime.strptime(value, format) except (ValueError, TypeError): pass else: - return self.enforce_timezone(parsed) + return parsed.date() - humanized_format = humanize_datetime.datetime_formats(self.input_formats) + humanized_format = humanize_datetime.date_formats(self.input_formats) self.fail('invalid', format=humanized_format) def to_representation(self, value): if value is None or self.format is None: return value + # Applying a `DateField` to a datetime value is almost always + # not a sensible thing to do, as it means naively dropping + # any explicit or implicit timezone info. + assert not isinstance(value, datetime.datetime), ( + 'Expected a `date`, but got a `datetime`. Refusing to coerce, ' + 'as this may mean losing timezone information. Use a custom ' + 'read-only field and deal with timezone issues explicitly.' + ) + if self.format.lower() == ISO_8601: - ret = value.isoformat() - if ret.endswith('+00:00'): - ret = ret[:-6] + 'Z' - return ret + return value.isoformat() return value.strftime(self.format) @@ -765,8 +771,14 @@ class TimeField(Field): if value is None or self.format is None: return value - if isinstance(value, datetime.datetime): - value = value.time() + # Applying a `TimeField` to a datetime value is almost always + # not a sensible thing to do, as it means naively dropping + # any explicit or implicit timezone info. + assert not isinstance(value, datetime.datetime), ( + 'Expected a `time`, but got a `datetime`. Refusing to coerce, ' + 'as this may mean losing timezone information. Use a custom ' + 'read-only field and deal with timezone issues explicitly.' + ) if self.format.lower() == ISO_8601: return value.isoformat() diff --git a/tests/test_fields.py b/tests/test_fields.py index 003b4b8c..b29acad8 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -173,7 +173,8 @@ class TestNullBooleanField(FieldValues): 'null': None, True: True, False: False, - None: None + None: None, + 'other': True } field = fields.NullBooleanField() -- cgit v1.2.3 From 3a5335f09f58439f8e3c0bddbed8e4c7eeb32482 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 25 Sep 2014 13:12:02 +0100 Subject: Fix syntax error --- rest_framework/fields.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index d855e6fd..7beccbb7 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -635,7 +635,7 @@ class DateTimeField(Field): return value def to_internal_value(self, value): - if (isinstance(value, datetime.date) and not isinstance(value, datetime.datetime): + if isinstance(value, datetime.date) and not isinstance(value, datetime.datetime): self.fail('date') if isinstance(value, datetime.datetime): -- cgit v1.2.3 From 417fe1b675bd1d42518fb89a6f81547caef5b735 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 25 Sep 2014 13:37:26 +0100 Subject: Partial support --- rest_framework/fields.py | 35 +++++++++++++++++++++++++---------- rest_framework/serializers.py | 6 ++++-- tests/test_serializer.py | 33 ++++++++++++++++++++++++++++++++- 3 files changed, 61 insertions(+), 13 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 7beccbb7..032bfd04 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -109,8 +109,7 @@ class Field(object): def __init__(self, read_only=False, write_only=False, required=None, default=empty, initial=None, source=None, label=None, help_text=None, style=None, - error_messages=None, validators=[], allow_null=False, - context=None): + error_messages=None, validators=[], allow_null=False): self._creation_counter = Field._creation_counter Field._creation_counter += 1 @@ -139,7 +138,6 @@ class Field(object): # These are set up by `.bind()` when the field is added to a serializer. self.field_name = None self.parent = None - self._context = {} if (context is None) else context # Collect default error message from self and parent classes messages = {} @@ -163,13 +161,6 @@ class Field(object): kwargs = copy.deepcopy(self._kwargs) return self.__class__(*args, **kwargs) - @property - def context(self): - root = self - while root.parent is not None: - root = root.parent - return root._context - def bind(self, field_name, parent): """ Setup the context for the field instance. @@ -254,6 +245,8 @@ class Field(object): """ if data is empty: if self.required: + if getattr(self.root, 'partial', False): + raise SkipField() self.fail('required') return self.get_default() @@ -304,7 +297,29 @@ class Field(object): raise AssertionError(msg) raise ValidationError(msg.format(**kwargs)) + @property + def root(self): + """ + Returns the top-level serializer for this field. + """ + root = self + while root.parent is not None: + root = root.parent + return root + + @property + def context(self): + """ + Returns the context as passed to the root serializer on initialization. + """ + return getattr(self.root, '_context', {}) + def __repr__(self): + """ + Fields are represented using their initial calling arguments. + This allows us to create descriptive representations for serializer + instances that show all the declared fields on the serializer. + """ return representation.field_repr(self) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 04721c7a..b6a1898c 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -181,8 +181,9 @@ class BindingDict(object): @six.add_metaclass(SerializerMetaclass) class Serializer(BaseSerializer): def __init__(self, *args, **kwargs): - kwargs.pop('partial', None) kwargs.pop('many', None) + self.partial = kwargs.pop('partial', False) + self._context = kwargs.pop('context', {}) super(Serializer, self).__init__(*args, **kwargs) @@ -289,7 +290,8 @@ class ListSerializer(BaseSerializer): self.child = kwargs.pop('child', copy.deepcopy(self.child)) assert self.child is not None, '`child` is a required argument.' assert not inspect.isclass(self.child), '`child` has not been instantiated.' - kwargs.pop('partial', None) + self.partial = kwargs.pop('partial', False) + self._context = kwargs.pop('context', {}) super(ListSerializer, self).__init__(*args, **kwargs) self.child.bind(field_name='', parent=self) diff --git a/tests/test_serializer.py b/tests/test_serializer.py index b0eb4e27..5646f994 100644 --- a/tests/test_serializer.py +++ b/tests/test_serializer.py @@ -1,3 +1,35 @@ +from rest_framework import serializers + + +# Tests for core functionality. +# ----------------------------- + +class TestSerializer: + def setup(self): + class ExampleSerializer(serializers.Serializer): + char = serializers.CharField() + integer = serializers.IntegerField() + self.Serializer = ExampleSerializer + + def test_valid_serializer(self): + serializer = self.Serializer(data={'char': 'abc', 'integer': 123}) + assert serializer.is_valid() + assert serializer.validated_data == {'char': 'abc', 'integer': 123} + assert serializer.errors == {} + + def test_invalid_serializer(self): + serializer = self.Serializer(data={'char': 'abc'}) + assert not serializer.is_valid() + assert serializer.validated_data == {} + assert serializer.errors == {'integer': ['This field is required.']} + + def test_partial_validation(self): + serializer = self.Serializer(data={'char': 'abc'}, partial=True) + assert serializer.is_valid() + assert serializer.validated_data == {'char': 'abc'} + assert serializer.errors == {} + + # # -*- coding: utf-8 -*- # from __future__ import unicode_literals # from django.db import models @@ -334,7 +366,6 @@ # Check _data attribute is cleared on `save()` # Regression test for #1116 -# — id field is not populated if `data` is accessed prior to `save()` # """ # serializer = ActionItemSerializer(self.actionitem) # self.assertIsNone(serializer.data.get('id', None), 'New instance. `id` should not be set.') -- cgit v1.2.3 From 2859eaf524bca23f27e666d24a0b63ba61698a76 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 10:46:52 +0100 Subject: request.data attribute --- docs/topics/3.0-announcement.md | 344 +++++++++++++++++++++++++++++++++++--- rest_framework/authtoken/views.py | 2 +- rest_framework/fields.py | 51 +++--- rest_framework/filters.py | 6 +- rest_framework/generics.py | 4 +- rest_framework/mixins.py | 6 +- rest_framework/negotiation.py | 4 +- rest_framework/renderers.py | 4 +- rest_framework/request.py | 37 +++- rest_framework/serializers.py | 21 +-- tests/test_fields.py | 140 +++++++++++++++- tests/test_generics.py | 2 +- tests/test_serializer.py | 62 +++++++ 13 files changed, 610 insertions(+), 73 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index cd883cdd..1795611c 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -4,36 +4,65 @@ See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-fr # REST framework 3.0 -**Note incremental nature, discuss upgrading.** +**TODO**: Note incremental nature, discuss upgrading, motivation, features. -## Motivation - -**TODO** +* Serializer reprs. +* Non-magical model serializers. +* Base serializer class. +* Clean logic in views, serializers, fields. --- ## Request objects -#### The `request.data` property. +#### The `.data` and `.query_params` properties. -**TODO** +The usage of `request.DATA` and `request.FILES` is now discouraged in favor of a single `request.data` attribute that contains *all* the parsed data. -#### The parser API. +Having seperate attributes is reasonable for web applications that only ever parse URL encoded or MultiPart requests, but makes less sense for the general-purpose request parsing that REST framework supports. -**TODO** +You may now pass all the request data to a serializer class in a single argument: + + ExampleSerializer(data=request.data) + +Instead of passing the files argument seperately: + + # Don't do this... + ExampleSerializer(data=request.DATA, files=request.FILES) + + +The usage of `request.QUERY_PARAMS` is now discouraged in favor of the lowercased `request.query_params`. ## Serializers #### Single-step object creation. +#### The `.create()` and `.update()` methods. + **TODO**: Drop `.restore_object()`, use `.create()` and `.update()` which should save the instance. -**TODO**: Drop`.object`, use `.validated_data` or get the instance with `.save()`. +#### Use `.validated_data` instead of `.object`. -#### The `BaseSerializer` class. +You must now use the `.validated_data` attribute if you need to inspect the data before saving, rather than using the `.object` attribute, which no longer exists. -**TODO** +For example the following code *is no longer valid*: + + if serializer.is_valid(): + name = serializer.object.name # Inspect validated field data. + logging.info('Creating ticket "%s"' % name) + serializer.object.user = request.user # Include the user when saving. + serializer.save() +Instead of using `.object` to inspect a partially constructed instance, you would now use `.validated_data` to inspect the cleaned incoming values. Also you can't set extra attributes on the instance directly, but instead pass them to the `.save()` method using the `extras` keyword argument. + +The corresponding code would now look like this: + + if serializer.is_valid(): + name = serializer.validated_data['name'] # Inspect validated field data. + logging.info('Creating ticket "%s"' % name) + extras = {'user': request.user} # Include the user when saving. + serializer.save(extras=extras) + #### Always use `fields`, not `exclude`. The `exclude` option is no longer available. You should use the more explicit `fields` option instead. @@ -111,42 +140,287 @@ These fields will be mapped to `serializers.ReadOnlyField()` instances. message = CharField(max_length=1000) expiry_date = ReadOnlyField() +#### The `ListSerializer` class. + +The `ListSerializer` class has now been added, and allows you to create base serializer classes for only accepting multiple inputs. + + class MultipleUserSerializer(ListSerializer): + child = UserSerializer() + +You can also still use the `many=True` argument to serializer classes. It's worth noting that `many=True` argument transparently creates a `ListSerializer` instance, allowing the validation logic for list and non-list data to be cleanly seperated in the REST framework codebase. + +See also the new `ListField` class, which validates input in the same way, but does not include the serializer interfaces of `.is_valid()`, `.data`, `.save()` and so on. + +#### The `BaseSerializer` class. + +REST framework now includes a simple `BaseSerializer` class that can be used to easily support alternative serialization and deserialization styles. + +This class implements the same basic API as the `Serializer` class: + +* `.data` - Returns the outgoing primative representation. +* `.is_valid()` - Deserializes and validates incoming data. +* `.validated_data` - Returns the validated incoming data. +* `.errors` - Returns an errors during validation. +* `.save()` - Persists the validated data into an object instance. + +There are four mathods that can be overriding, depending on what functionality you want the serializer class to support: + +* `.to_representation()` - Override this to support serialization, for read operations. +* `.to_internal_value()` - Override this to support deserialization, for write operations. +* `.create()` and `.update()` - Overide either or both of these to support saving instances. + +##### Read-only serializers. + +To implement a read-only serializer using the `BaseSerializer` class, we just need to override the `.to_representation()` method. Let's take a look at an example using a simple Django model: + + class HighScore(models.Model): + created = models.DateTimeField(auto_now_add=True) + player_name = models.CharField(max_length=10) + score = models.IntegerField() + +It's simple to create a read-only serializer for converting `HighScore` instances into primative data types. + + class HighScoreSerializer(serializers.BaseSerializer): + def to_representation(self, obj): + return { + 'score': obj.score, + 'player_name': obj.player_name + } + +We can now use this class to serialize single `HighScore` instances: + + @api_view(['GET']) + def high_score(request, pk): + instance = HighScore.objects.get(pk=pk) + serializer = HighScoreSerializer(instance) + return Response(serializer.data) + +Or use it to serialize multiple instances: + + @api_view(['GET']) + def all_high_scores(request): + queryset = HighScore.objects.order_by('-score') + serializer = HighScoreSerializer(queryset, many=True) + return Response(serializer.data) + +##### Read-write serializers. + +To create a read-write serializer we first need to implement a `.to_internal_value()` method. This method returns the validated values that will be used to construct the object instance, and may raise a `ValidationError` if the supplied data is in an incorrect format. + +Once you've implemented `.to_internal_value()`, the basic validation API will be available on the serializer, and you will be able to use `.is_valid()`, `.validated_data` and `.errors`. + +If you want to also support `.save()` you'll need to also implement either or both of the `.create()` and `.update()` methods. + +Here's a complete example of our previous `HighScoreSerializer`, that's been updated to support both read and write operations. + + class HighScoreSerializer(serializers.BaseSerializer): + def to_internal_value(self, data): + score = data.get('score') + player_name = data.get('player_name') + + # Perform the data validation. + if not score: + raise ValidationError({ + 'score': 'This field is required.' + }) + if not player_name: + raise ValidationError({ + 'player_name': 'This field is required.' + }) + if len(player_name) > 10: + raise ValidationError({ + 'player_name': 'May not be more than 10 characters.' + }) + + # Return the validated values. This will be available as + # the `.validated_data` property. + return { + 'score': int(score), + 'player_name': player_name + } + + def to_representation(self, obj): + return { + 'score': obj.score, + 'player_name': obj.player_name + } + + def create(self, validated_data): + return HighScore.objects.create(**validated_data) + +#### Creating new base classes with `BaseSerializer`. + +The `BaseSerializer` class is also useful if you want to implement new generic serializer classes for dealing with particular serialization styles or for integrating with different storage backends. + +The following class is an example of a generic serializer that can handle coercing aribitrary objects into primative representations. + + class ObjectSerializer(serializers.BaseSerializer): + """ + A read-only serializer that coerces arbitrary complex objects + into primative representations. + """ + def to_representation(self, obj): + for attribute_name in dir(obj): + attribute = getattr(obj, attribute_name) + if attribute_name('_'): + # Ignore private attributes. + pass + elif hasattr(attribute, '__call__'): + # Ignore methods and other callables. + pass + elif isinstance(attribute, (str, int, bool, float, type(None))): + # Primative types can be passed through unmodified. + output[attribute_name] = attribute + elif isinstance(attribute, list): + # Recursivly deal with items in lists. + output[attribute_name] = [ + self.to_representation(item) for item in attribute + ] + elif isinstance(attribute, dict): + # Recursivly deal with items in dictionarys. + output[attribute_name] = { + str(key): self.to_representation(value) + for key, value in attribute.items() + } + else: + # Force anything else to its string representation. + output[attribute_name] = str(attribute) ## Serializer fields #### The `Field` and `ReadOnly` field classes. -**TODO** +There are some minor tweaks to the field base classes. + +Previously we had these two base classes: + +* `Field` as the base class for read-only fields. A default implementation was included for serializing data. +* `WriteableField` as the base class for read-write fields. + +We now use the following: + +* `Field` is the base class for all fields. It does not include any default implementation for either serializing or deserializing data. +* `ReadOnlyField` is a concrete implementation for read-only fields that simply returns the attribute value without modification. + +#### The `required`, `allow_none`, `allow_blank` and `default` arguments. + +REST framework now has more explict and clear control over validating empty values for fields. + +Previously the meaning of the `required=False` keyword argument was underspecified. In practice it's use meant that a field could either be not included in the input, or it could be included, but be `None`. + +We now have a better seperation, with seperate `required` and `allow_none` arguments. + +The following set of arguments are used to control validation of empty values: + +* `required=False`: The value does not need to be present in the input, and will not be passed to `.create()` or `.update()` if it is not seen. +* `default=`: The value does not need to be present in the input, and a default value will be passed to `.create()` or `.update()` if it is not seen. +* `allow_none=True`: `None` is a valid input. +* `allow_blank=True`: `''` is valid input. For `CharField` and subclasses only. + +Typically you'll want to use `required=False` if the corresponding model field has a default value, and additionally set either `allow_none=True` or `allow_blank=True` if required. + +The `default` argument is there if you need it, but you'll more typically want defaults to be set on model fields, rather than serializer fields. #### Coercing output types. -**TODO** +The previous field implementations did not forcibly coerce returned values into the correct type in many cases. For example, an `IntegerField` would return a string output if the attribute value was a string. We now more strictly coerce to the correct return type, leading to more constrained and expected behavior. -#### The `ListSerializer` class. +#### The `ListField` class. -**TODO** +The `ListField` class has now been added. This field validates list input. It takes a `child` keyword argument which is used to specify the field used to validate each item in the list. For example: + + scores = ListField(child=IntegerField(min_value=0, max_value=100)) + +You can also use a declarative style to create new subclasses of `ListField`, like this: + + class ScoresField(ListField): + child = IntegerField(min_value=0, max_value=100) + +We can now use the `ScoresField` class inside another serializer: + + scores = ScoresField() + +See also the new `ListSerializer` class, which validates input in the same way, but also includes the serializer interfaces of `.is_valid()`, `.data`, `.save()` and so on. + +#### The `ChoiceField` class may now accept a flat list. + +The `ChoiceField` class may now accept a list of choices in addition to the existing style of using a list of pairs of `(name, display_value)`. The following is now valid: + + color = ChoiceField(choices=['red', 'green', 'blue']) #### The `MultipleChoiceField` class. -**TODO** +The `MultipleChoiceField` class has been added. This field acts like `ChoiceField`, but returns a set, which may include none, one or many of the valid choices. #### Changes to the custom field API. -**TODO** `to_representation`, `to_internal_value`. +The `from_native(self, value)` and `to_native(self, data)` method names have been replaced with the more obviously named `to_representation(self, value)` and `to_internal_value(self, data)`. -#### Explicit `querysets` required on relational fields. +The `field_from_native()` and `field_to_native()` methods are removed. -**TODO** +#### Explicit `queryset` required on relational fields. + +Previously relational fields that were explicitly declared on a serializer class could omit the queryset argument if (and only if) they were declared on a `ModelSerializer`. + +This code *would be valid* in `2.4.3`: + + class AccountSerializer(serializers.ModelSerializer): + organisations = serializers.SlugRelatedField(slug_field='name') + + class Meta: + model = Account + +However this code *would not be valid* in `2.4.3`: + + # Missing `queryset` + class AccountSerializer(serializers.Serializer): + organisations = serializers.SlugRelatedField(slug_field='name') + + def restore_object(self, attrs, instance=None): + # ... + +The queryset argument is now always required for writable relational fields. +This removes some magic and makes it easier and more obvious to move between implict `ModelSerializer` classes and explicit `Serializer` classes. + + class AccountSerializer(serializers.ModelSerializer): + organisations = serializers.SlugRelatedField( + slug_field='name', + queryset=Organisation.objects.all() + ) + + class Meta: + model = Account + +The `queryset` argument is only ever required for writable fields, and is not required or valid for fields with `read_only=True`. #### Optional argument to `SerializerMethodField`. -**TODO** +The argument to `SerializerMethodField` is now optional, and defaults to `get_`. For example the following is valid: + + class AccountSerializer(serializers.Serializer): + # `method_name='get_billing_details'` by default. + billing_details = serializers.SerializerMethodField() + + def get_billing_details(self, account): + return calculate_billing(account) + +In order to ensure a consistent code style an assertion error will be raised if you include a redundant method name argument that matches the default method name. For example, the following code *will raise an error*: + + billing_details = serializers.SerializerMethodField('get_billing_details') + +#### Enforcing consistent `source` usage. + +I've see several codebases that unneccessarily include the `source` argument, setting it to the same value as the field name. This usage is redundant and confusing, making it less obvious that `source` is usually not required. + +The following usage will *now raise an error*: + + email = serializers.EmailField(source='email') ## Generic views #### Simplification of view logic. -**TODO** +The view logic for the default method handlers has been significantly simplified, due to the new serializers API. #### Removal of pre/post save hooks. @@ -169,6 +443,20 @@ I would personally recommend that developers treat view instances as immutable o #### PUT as create. +Allowing `PUT` as create operations is problematic, as it neccessarily exposes information about the existence or non-existance of objects. It's also not obvious that transparently allowing re-creating of previously deleted instances is neccessarily a better default behavior than simply returning `404` responses. + +Both styles "`PUT` as 404" and "`PUT` as create" can be valid in different circumstances, but we've now opted for the 404 behavior as the default, due to it being simpler and more obvious. + +If you need to restore the previous behavior you can include the `AllowPUTAsCreateMixin` class in your view. This class can be imported from `rest_framework.mixins`. + +#### Customizing error responses. + +The generic views now raise `ValidationError` for invalid data. This exception is then dealt with by the exception handler, rather than the view returning a `400 Bad Request` response directly. + +This change means that you can now easily cusomize the style of error responses across your entire API, without having to modify any of the generic views. + +## The metadata API + **TODO** ## API style @@ -241,3 +529,17 @@ Or modify it on an individual serializer field, using the `corece_to_string` key ) The default JSON renderer will return float objects for uncoerced `Decimal` instances. This allows you to easily switch between string or float representations for decimals depending on your API design needs. + +## What's coming next. + +3.0 is an incremental release, and there are several upcoming features that will build on the baseline improvements that it makes. + +The 3.1 release is planned to address improvements in the following components: + +* Request parsing, mediatypes & the implementation of the browsable API. +* Introduction of a new pagination API. +* Better support for API versioning. + +The 3.2 release is planned to introduce an alternative admin-style interface to the browsable API. + +You can follow development on the GitHub site, where we use [milestones to indicate planning timescales](https://github.com/tomchristie/django-rest-framework/milestones). diff --git a/rest_framework/authtoken/views.py b/rest_framework/authtoken/views.py index 94e6f061..103abb27 100644 --- a/rest_framework/authtoken/views.py +++ b/rest_framework/authtoken/views.py @@ -16,7 +16,7 @@ class ObtainAuthToken(APIView): model = Token def post(self, request): - serializer = self.serializer_class(data=request.DATA) + serializer = self.serializer_class(data=request.data) if serializer.is_valid(): user = serializer.validated_data['user'] token, created = Token.objects.get_or_create(user=user) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 032bfd04..ec07a413 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -56,7 +56,7 @@ def get_attribute(instance, attrs): except AttributeError as exc: try: return instance[attr] - except (KeyError, TypeError): + except (KeyError, TypeError, AttributeError): raise exc return instance @@ -90,6 +90,7 @@ NOT_READ_ONLY_WRITE_ONLY = 'May not set both `read_only` and `write_only`' NOT_READ_ONLY_REQUIRED = 'May not set both `read_only` and `required`' NOT_READ_ONLY_DEFAULT = 'May not set both `read_only` and `default`' NOT_REQUIRED_DEFAULT = 'May not set both `required` and `default`' +USE_READONLYFIELD = 'Field(read_only=True) should be ReadOnlyField' MISSING_ERROR_MESSAGE = ( 'ValidationError raised by `{class_name}`, but error key `{key}` does ' 'not exist in the `error_messages` dictionary.' @@ -105,9 +106,10 @@ class Field(object): } default_validators = [] default_empty_html = None + initial = None def __init__(self, read_only=False, write_only=False, - required=None, default=empty, initial=None, source=None, + required=None, default=empty, initial=empty, source=None, label=None, help_text=None, style=None, error_messages=None, validators=[], allow_null=False): self._creation_counter = Field._creation_counter @@ -122,13 +124,14 @@ class Field(object): assert not (read_only and required), NOT_READ_ONLY_REQUIRED assert not (read_only and default is not empty), NOT_READ_ONLY_DEFAULT assert not (required and default is not empty), NOT_REQUIRED_DEFAULT + assert not (read_only and self.__class__ == Field), USE_READONLYFIELD self.read_only = read_only self.write_only = write_only self.required = required self.default = default self.source = source - self.initial = initial + self.initial = self.initial if (initial is empty) else initial self.label = label self.help_text = help_text self.style = {} if style is None else style @@ -146,24 +149,10 @@ class Field(object): messages.update(error_messages or {}) self.error_messages = messages - def __new__(cls, *args, **kwargs): - """ - When a field is instantiated, we store the arguments that were used, - so that we can present a helpful representation of the object. - """ - instance = super(Field, cls).__new__(cls) - instance._args = args - instance._kwargs = kwargs - return instance - - def __deepcopy__(self, memo): - args = copy.deepcopy(self._args) - kwargs = copy.deepcopy(self._kwargs) - return self.__class__(*args, **kwargs) - def bind(self, field_name, parent): """ - Setup the context for the field instance. + Initializes the field name and parent for the field instance. + Called when a field is added to the parent serializer instance. """ # In order to enforce a consistent style, we error if a redundant @@ -244,9 +233,9 @@ class Field(object): validated data. """ if data is empty: + if getattr(self.root, 'partial', False): + raise SkipField() if self.required: - if getattr(self.root, 'partial', False): - raise SkipField() self.fail('required') return self.get_default() @@ -314,6 +303,25 @@ class Field(object): """ return getattr(self.root, '_context', {}) + def __new__(cls, *args, **kwargs): + """ + When a field is instantiated, we store the arguments that were used, + so that we can present a helpful representation of the object. + """ + instance = super(Field, cls).__new__(cls) + instance._args = args + instance._kwargs = kwargs + return instance + + def __deepcopy__(self, memo): + """ + When cloning fields we instantiate using the arguments it was + originally created with, rather than copying the complete state. + """ + args = copy.deepcopy(self._args) + kwargs = copy.deepcopy(self._kwargs) + return self.__class__(*args, **kwargs) + def __repr__(self): """ Fields are represented using their initial calling arguments. @@ -358,6 +366,7 @@ class NullBooleanField(Field): 'invalid': _('`{input}` is not a valid boolean.') } default_empty_html = None + initial = None TRUE_VALUES = set(('t', 'T', 'true', 'True', 'TRUE', '1', 1, True)) FALSE_VALUES = set(('f', 'F', 'false', 'False', 'FALSE', '0', 0, 0.0, False)) NULL_VALUES = set(('n', 'N', 'null', 'Null', 'NULL', '', None)) diff --git a/rest_framework/filters.py b/rest_framework/filters.py index c580f935..085dfe65 100644 --- a/rest_framework/filters.py +++ b/rest_framework/filters.py @@ -64,7 +64,7 @@ class DjangoFilterBackend(BaseFilterBackend): filter_class = self.get_filter_class(view, queryset) if filter_class: - return filter_class(request.QUERY_PARAMS, queryset=queryset).qs + return filter_class(request.query_params, queryset=queryset).qs return queryset @@ -78,7 +78,7 @@ class SearchFilter(BaseFilterBackend): Search terms are set by a ?search=... query parameter, and may be comma and/or whitespace delimited. """ - params = request.QUERY_PARAMS.get(self.search_param, '') + params = request.query_params.get(self.search_param, '') return params.replace(',', ' ').split() def construct_search(self, field_name): @@ -121,7 +121,7 @@ class OrderingFilter(BaseFilterBackend): the `ordering_param` value on the OrderingFilter or by specifying an `ORDERING_PARAM` value in the API settings. """ - params = request.QUERY_PARAMS.get(self.ordering_param) + params = request.query_params.get(self.ordering_param) if params: return [param.strip() for param in params.split(',')] diff --git a/rest_framework/generics.py b/rest_framework/generics.py index f49b0a43..cf903dab 100644 --- a/rest_framework/generics.py +++ b/rest_framework/generics.py @@ -112,7 +112,7 @@ class GenericAPIView(views.APIView): paginator = self.paginator_class(queryset, page_size) page_kwarg = self.kwargs.get(self.page_kwarg) - page_query_param = self.request.QUERY_PARAMS.get(self.page_kwarg) + page_query_param = self.request.query_params.get(self.page_kwarg) page = page_kwarg or page_query_param or 1 try: page_number = paginator.validate_number(page) @@ -166,7 +166,7 @@ class GenericAPIView(views.APIView): if self.paginate_by_param: try: return strict_positive_int( - self.request.QUERY_PARAMS[self.paginate_by_param], + self.request.query_params[self.paginate_by_param], cutoff=self.max_paginate_by ) except (KeyError, ValueError): diff --git a/rest_framework/mixins.py b/rest_framework/mixins.py index 14a6b44b..04b7a763 100644 --- a/rest_framework/mixins.py +++ b/rest_framework/mixins.py @@ -18,7 +18,7 @@ class CreateModelMixin(object): Create a model instance. """ def create(self, request, *args, **kwargs): - serializer = self.get_serializer(data=request.DATA) + serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) serializer.save() headers = self.get_success_headers(serializer.data) @@ -62,7 +62,7 @@ class UpdateModelMixin(object): def update(self, request, *args, **kwargs): partial = kwargs.pop('partial', False) instance = self.get_object() - serializer = self.get_serializer(instance, data=request.DATA, partial=partial) + serializer = self.get_serializer(instance, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data) @@ -95,7 +95,7 @@ class AllowPUTAsCreateMixin(object): def update(self, request, *args, **kwargs): partial = kwargs.pop('partial', False) instance = self.get_object_or_none() - serializer = self.get_serializer(instance, data=request.DATA, partial=partial) + serializer = self.get_serializer(instance, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) if instance is None: diff --git a/rest_framework/negotiation.py b/rest_framework/negotiation.py index ca7b5397..1838130a 100644 --- a/rest_framework/negotiation.py +++ b/rest_framework/negotiation.py @@ -38,7 +38,7 @@ class DefaultContentNegotiation(BaseContentNegotiation): """ # Allow URL style format override. eg. "?format=json format_query_param = self.settings.URL_FORMAT_OVERRIDE - format = format_suffix or request.QUERY_PARAMS.get(format_query_param) + format = format_suffix or request.query_params.get(format_query_param) if format: renderers = self.filter_renderers(renderers, format) @@ -87,5 +87,5 @@ class DefaultContentNegotiation(BaseContentNegotiation): Allows URL style accept override. eg. "?accept=application/json" """ header = request.META.get('HTTP_ACCEPT', '*/*') - header = request.QUERY_PARAMS.get(self.settings.URL_ACCEPT_OVERRIDE, header) + header = request.query_params.get(self.settings.URL_ACCEPT_OVERRIDE, header) return [token.strip() for token in header.split(',')] diff --git a/rest_framework/renderers.py b/rest_framework/renderers.py index 3bf03e62..225f9fe8 100644 --- a/rest_framework/renderers.py +++ b/rest_framework/renderers.py @@ -120,7 +120,7 @@ class JSONPRenderer(JSONRenderer): Determine the name of the callback to wrap around the json output. """ request = renderer_context.get('request', None) - params = request and request.QUERY_PARAMS or {} + params = request and request.query_params or {} return params.get(self.callback_parameter, self.default_callback) def render(self, data, accepted_media_type=None, renderer_context=None): @@ -426,7 +426,7 @@ class BrowsableAPIRenderer(BaseRenderer): """ if request.method == method: try: - data = request.DATA + data = request.data # files = request.FILES except ParseError: data = None diff --git a/rest_framework/request.py b/rest_framework/request.py index 27532661..d80baa70 100644 --- a/rest_framework/request.py +++ b/rest_framework/request.py @@ -4,7 +4,7 @@ The Request class is used as a wrapper around the standard request object. The wrapped request then offers a richer API, in particular : - content automatically parsed according to `Content-Type` header, - and available as `request.DATA` + and available as `request.data` - full support of PUT method, including support for file uploads - form overloading of HTTP method, content type and content """ @@ -13,6 +13,7 @@ from django.conf import settings from django.http import QueryDict from django.http.multipartparser import parse_header from django.utils.datastructures import MultiValueDict +from django.utils.datastructures import MergeDict as DjangoMergeDict from rest_framework import HTTP_HEADER_ENCODING from rest_framework import exceptions from rest_framework.compat import BytesIO @@ -58,6 +59,15 @@ class override_method(object): self.view.action = self.action +class MergeDict(DjangoMergeDict, dict): + """ + Using this as a workaround until the parsers API is properly + addressed in 3.1. + """ + def __init__(self, *dicts): + self.dicts = dicts + + class Empty(object): """ Placeholder for unset attributes. @@ -82,6 +92,7 @@ def clone_request(request, method): parser_context=request.parser_context) ret._data = request._data ret._files = request._files + ret._full_data = request._full_data ret._content_type = request._content_type ret._stream = request._stream ret._method = method @@ -133,6 +144,7 @@ class Request(object): self.parser_context = parser_context self._data = Empty self._files = Empty + self._full_data = Empty self._method = Empty self._content_type = Empty self._stream = Empty @@ -186,12 +198,25 @@ class Request(object): return self._stream @property - def QUERY_PARAMS(self): + def query_params(self): """ More semantically correct name for request.GET. """ return self._request.GET + @property + def QUERY_PARAMS(self): + """ + Synonym for `.query_params`, for backwards compatibility. + """ + return self._request.GET + + @property + def data(self): + if not _hasattr(self, '_full_data'): + self._load_data_and_files() + return self._full_data + @property def DATA(self): """ @@ -272,6 +297,10 @@ class Request(object): if not _hasattr(self, '_data'): self._data, self._files = self._parse() + if self._files: + self._full_data = MergeDict(self._data, self._files) + else: + self._full_data = self._data def _load_method_and_content_type(self): """ @@ -333,6 +362,7 @@ class Request(object): # At this point we're committed to parsing the request as form data. self._data = self._request.POST self._files = self._request.FILES + self._full_data = MergeDict(self._data, self._files) # Method overloading - change the method and remove the param from the content. if ( @@ -350,7 +380,7 @@ class Request(object): ): self._content_type = self._data[self._CONTENTTYPE_PARAM] self._stream = BytesIO(self._data[self._CONTENT_PARAM].encode(self.parser_context['encoding'])) - self._data, self._files = (Empty, Empty) + self._data, self._files, self._full_data = (Empty, Empty, Empty) def _parse(self): """ @@ -380,6 +410,7 @@ class Request(object): # logging the request or similar. self._data = QueryDict('', encoding=self._request._encoding) self._files = MultiValueDict() + self._full_data = self._data raise # Parser classes may return the raw data, or a diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index b6a1898c..a2b878ec 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -57,21 +57,24 @@ class BaseSerializer(Field): def to_representation(self, instance): raise NotImplementedError('`to_representation()` must be implemented.') - def update(self, instance, attrs): + def update(self, instance, validated_data): raise NotImplementedError('`update()` must be implemented.') - def create(self, attrs): + def create(self, validated_data): raise NotImplementedError('`create()` must be implemented.') def save(self, extras=None): - attrs = self.validated_data + validated_data = self.validated_data if extras is not None: - attrs = dict(list(attrs.items()) + list(extras.items())) + validated_data = dict( + list(validated_data.items()) + + list(extras.items()) + ) if self.instance is not None: - self.update(self.instance, attrs) + self.update(self.instance, validated_data) else: - self.instance = self.create(attrs) + self.instance = self.create(validated_data) return self.instance @@ -321,12 +324,6 @@ class ListSerializer(BaseSerializer): def create(self, attrs_list): return [self.child.create(attrs) for attrs in attrs_list] - def save(self): - if self.instance is not None: - self.update(self.instance, self.validated_data) - self.instance = self.create(self.validated_data) - return self.instance - def __repr__(self): return representation.list_repr(self, indent=1) 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 -- cgit v1.2.3 From 43e80c74b225e17edfe8a90da893823bf50b946f Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 11:56:29 +0100 Subject: Release notes --- docs/topics/3.0-announcement.md | 79 +++++++++++++++++++++++++++++++++++++---- rest_framework/serializers.py | 3 ++ 2 files changed, 75 insertions(+), 7 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 1795611c..35d725ff 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -4,12 +4,25 @@ See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-fr # REST framework 3.0 -**TODO**: Note incremental nature, discuss upgrading, motivation, features. +The 3.0 release of Django REST framework is the result of almost four years of iteration and refinement. It comprehensively addresses some of the previous remaining design issues in serializers, fields and the generic views. -* Serializer reprs. -* Non-magical model serializers. -* Base serializer class. -* Clean logic in views, serializers, fields. +This release is incremental in nature. There *are* some breaking API changes, and upgrading *will* require you to read the release notes carefully, but the migration path should otherwise be relatively straightforward. + +The difference in quality of the REST framework API and implementation should make writing, maintaining and debugging your application far easier. + +## New features + +Notable features of this new release include: + +* Printable representations on serializers that allow you to inspect exactly what fields are present on the instance. +* Simple model serializers that are vastly easier to understand and debug, and that make it easy to switch between the implicit `ModelSerializer` class and the explicit `Serializer` class. +* A new `BaseSerializer` class, making it easier to write serializers for alternative storage backends, or to completely customize your serialization and validation logic. +* A cleaner fields API plus new `ListField` and `MultipleChoiceField` classes. +* Super simple default implementations for the generic views. +* Support for overriding how validation errors are handled by your API. +* A metadata API that allows you to customize how `OPTIONS` requests are handled by your API. + +Below is an in-depth guide to the API changes and migration notes for 3.0. --- @@ -37,9 +50,59 @@ The usage of `request.QUERY_PARAMS` is now discouraged in favor of the lowercase #### Single-step object creation. +Previously the serializers used a two-step object creation, as follows: + +1. Validating the data would create an object instance. This instance would be available as `serializer.object`. +2. Calling `serializer.save()` would then save the object instance to the database. + +This style is in line with how the `ModelForm` class works in Django, but is problematic for a number of reasons: + +* Some data, such as many-to-many relationships, cannot be added to the object instance until after it has been save. This type of data needed to be hidden in some undocumentated state on the object instance, or kept as state on the serializer instance so that it could be used when `.save()` is called. +* Instantiating model instances directly means that you cannot use model manager classes for instance creation, eg `ExampleModel.objects.create(...)`. Manager classes are an excellent layer at which to enforce business logic and application-level data constraints. +* The two step process makes it unclear where to put deserialization logic. For example, should extra attributes such as the current user get added to the instance during object creation or during object save? + +We now use single-step object creation, like so: + +1. Validating the data makes the cleaned data available as `serializer.validated_data`. +2. Calling `serializer.save()` then saves and returns the new object instance. + +The resulting API changes are further detailed below. + #### The `.create()` and `.update()` methods. -**TODO**: Drop `.restore_object()`, use `.create()` and `.update()` which should save the instance. +The `.restore_object()` method is now replaced with two seperate methods, `.create()` and `.update()`. + +When using the `.create()` and `.update()` methods you should both create *and save* the object instance. This is in contrast to the previous `.restore_object()` behavior that would instantiate the object but not save it. + +The following example from the tutorial previously used `restore_object()` to handle both creating and updating object instances. + + def restore_object(self, attrs, instance=None): + if instance: + # Update existing instance + instance.title = attrs.get('title', instance.title) + instance.code = attrs.get('code', instance.code) + instance.linenos = attrs.get('linenos', instance.linenos) + instance.language = attrs.get('language', instance.language) + instance.style = attrs.get('style', instance.style) + return instance + + # Create new instance + return Snippet(**attrs) + +This would now be split out into two seperate methods. + + def update(self, instance, validated_attrs) + instance.title = validated_attrs.get('title', instance.title) + instance.code = validated_attrs.get('code', instance.code) + instance.linenos = validated_attrs.get('linenos', instance.linenos) + instance.language = validated_attrs.get('language', instance.language) + instance.style = validated_attrs.get('style', instance.style) + instance.save() + + def create(self, validated_attrs): + return Snippet.objects.create(**validated_attrs) + +Note that the `.create` method should return the newly created object instance. #### Use `.validated_data` instead of `.object`. @@ -457,7 +520,9 @@ This change means that you can now easily cusomize the style of error responses ## The metadata API -**TODO** +Behavior for dealing with `OPTIONS` requests was previously built directly into the class based views. This has now been properly seperated out into a Metadata API that allows the same pluggable style as other API policies in REST framework. + +This makes it far easier to use a different style for `OPTIONS` responses throughout your API, and makes it possible to create third-party metadata policies. ## API style diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index a2b878ec..86bed773 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -75,6 +75,9 @@ class BaseSerializer(Field): self.update(self.instance, validated_data) else: self.instance = self.create(validated_data) + assert self.instance is not None, ( + '`create()` did not return an object instance.' + ) return self.instance -- cgit v1.2.3 From e8af73d144d73a55aecde6a1fda8516f15f027c1 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 12:17:20 +0100 Subject: Release notes --- docs/topics/3.0-announcement.md | 35 +++++++++++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 35d725ff..144d3550 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -125,14 +125,41 @@ The corresponding code would now look like this: logging.info('Creating ticket "%s"' % name) extras = {'user': request.user} # Include the user when saving. serializer.save(extras=extras) - + +#### Printable serializer reprensentations. + +Serializer instances now support a printable representation that allows you to inspect the fields present on the instance. + +For instance, given the following example model: + + class LocationRating(models.Model): + location = models.CharField(max_length=100) + rating = models.IntegerField() + created_by = models.ForeignKey(User) + +Let's create a simple `ModelSerializer` class c. + + class LocationRatingSerializer(serializer.ModelSerializer): + class Meta: + model = LocationRating + +We can now inspect its representation in the Django shell, using `python manage.py shell`... + + >>> serializer = LocationRatingSerializer() + >>> print(serializer) # Or use `print serializer` in Python 2.x + LocationRatingSerializer(): + id = IntegerField(label='ID', read_only=True) + location = CharField(max_length=100) + rating = IntegerField() + created_by = PrimaryKeyRelatedField(queryset=User.objects.all()) + #### Always use `fields`, not `exclude`. -The `exclude` option is no longer available. You should use the more explicit `fields` option instead. +The `exclude` option on `ModelSerializer` is no longer available. You should use the more explicit `fields` option instead. #### The `extra_kwargs` option. -The `read_only_fields` and `write_only_fields` options have been removed and replaced with a more generic `extra_kwargs`. +The `read_only_fields` and `write_only_fields` options on `ModelSerializer` have been removed and replaced with a more generic `extra_kwargs`. class MySerializer(serializer.ModelSerializer): class Meta: @@ -177,7 +204,7 @@ Alternatively, specify the field explicitly on the serializer class: #### Fields for model methods and properties. -You can now specify field names in the `fields` option that refer to model methods or properties. For example, suppose you have the following model: +With `ModelSerilizer` you can now specify field names in the `fields` option that refer to model methods or properties. For example, suppose you have the following model: class Invitation(models.Model): created = models.DateTimeField() -- cgit v1.2.3 From 90311357add780433c79e97346ed85f1f4224877 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 12:18:27 +0100 Subject: Release notes --- docs/topics/3.0-announcement.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 144d3550..daacbba0 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -137,13 +137,13 @@ For instance, given the following example model: rating = models.IntegerField() created_by = models.ForeignKey(User) -Let's create a simple `ModelSerializer` class c. +Let's create a simple `ModelSerializer` class corresponding to the `LocationRating` model. class LocationRatingSerializer(serializer.ModelSerializer): class Meta: model = LocationRating -We can now inspect its representation in the Django shell, using `python manage.py shell`... +We can now inspect the serializer representation in the Django shell, using `python manage.py shell`... >>> serializer = LocationRatingSerializer() >>> print(serializer) # Or use `print serializer` in Python 2.x -- cgit v1.2.3 From fde934d33c8692bab5e0e7b6009d358101a25dd7 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 12:21:05 +0100 Subject: Release notes --- docs/topics/3.0-announcement.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index daacbba0..a4e4db14 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -21,6 +21,7 @@ Notable features of this new release include: * Super simple default implementations for the generic views. * Support for overriding how validation errors are handled by your API. * A metadata API that allows you to customize how `OPTIONS` requests are handled by your API. +* A more compact JSON output with unicode style encoding turned on by default. Below is an in-depth guide to the API changes and migration notes for 3.0. -- cgit v1.2.3 From 8b8623c5f84d443d26804cac52a793a3037a1dd0 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 12:48:20 +0100 Subject: Allow many, partial and context in BaseSerializer --- docs/topics/3.0-announcement.md | 7 +++++ rest_framework/serializers.py | 28 +++++++++----------- tests/test_serializer.py | 58 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 77 insertions(+), 16 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index a4e4db14..faba2d35 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -2,6 +2,13 @@ See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-framework/pull/1800) for more details. +Most notable outstanding issues still to resolved on the `version-3.0` branch. + +* `FileField` and `ImageField` support. +* Forms support for serializers and in the browsable API. +* Enforcing uniqueness on `unique=True` and `unique_together` fields. +* Optimisations for serialializing primary keys. + # REST framework 3.0 The 3.0 release of Django REST framework is the result of almost four years of iteration and refinement. It comprehensively addresses some of the previous remaining design issues in serializers, fields and the generic views. diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 86bed773..245ec26f 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -47,9 +47,20 @@ class BaseSerializer(Field): """ def __init__(self, instance=None, data=None, **kwargs): - super(BaseSerializer, self).__init__(**kwargs) self.instance = instance self._initial_data = data + self.partial = kwargs.pop('partial', False) + self._context = kwargs.pop('context', {}) + kwargs.pop('many', None) + super(BaseSerializer, self).__init__(**kwargs) + + def __new__(cls, *args, **kwargs): + # We override this method in order to automagically create + # `ListSerializer` classes instead when `many=True` is set. + if kwargs.pop('many', False): + kwargs['child'] = cls() + return ListSerializer(*args, **kwargs) + return super(BaseSerializer, cls).__new__(cls, *args, **kwargs) def to_internal_value(self, data): raise NotImplementedError('`to_internal_value()` must be implemented.') @@ -187,10 +198,6 @@ class BindingDict(object): @six.add_metaclass(SerializerMetaclass) class Serializer(BaseSerializer): def __init__(self, *args, **kwargs): - kwargs.pop('many', None) - self.partial = kwargs.pop('partial', False) - self._context = kwargs.pop('context', {}) - super(Serializer, self).__init__(*args, **kwargs) # Every new serializer is created with a clone of the field instances. @@ -200,14 +207,6 @@ class Serializer(BaseSerializer): for key, value in self._get_base_fields().items(): self.fields[key] = value - def __new__(cls, *args, **kwargs): - # We override this method in order to automagically create - # `ListSerializer` classes instead when `many=True` is set. - if kwargs.pop('many', False): - kwargs['child'] = cls() - return ListSerializer(*args, **kwargs) - return super(Serializer, cls).__new__(cls, *args, **kwargs) - def _get_base_fields(self): return copy.deepcopy(self._declared_fields) @@ -296,9 +295,6 @@ class ListSerializer(BaseSerializer): self.child = kwargs.pop('child', copy.deepcopy(self.child)) assert self.child is not None, '`child` is a required argument.' assert not inspect.isclass(self.child), '`child` has not been instantiated.' - self.partial = kwargs.pop('partial', False) - self._context = kwargs.pop('context', {}) - super(ListSerializer, self).__init__(*args, **kwargs) self.child.bind(field_name='', parent=self) diff --git a/tests/test_serializer.py b/tests/test_serializer.py index 256a12e6..4df1b736 100644 --- a/tests/test_serializer.py +++ b/tests/test_serializer.py @@ -43,6 +43,64 @@ class TestSerializer: serializer.data +class TestBaseSerializer: + def setup(self): + class ExampleSerializer(serializers.BaseSerializer): + def to_representation(self, obj): + return { + 'id': obj['id'], + 'email': obj['name'] + '@' + obj['domain'] + } + + def to_internal_value(self, data): + name, domain = str(data['email']).split('@') + return { + 'id': int(data['id']), + 'name': name, + 'domain': domain, + } + + self.Serializer = ExampleSerializer + + def test_serialize_instance(self): + instance = {'id': 1, 'name': 'tom', 'domain': 'example.com'} + serializer = self.Serializer(instance) + assert serializer.data == {'id': 1, 'email': 'tom@example.com'} + + def test_serialize_list(self): + instances = [ + {'id': 1, 'name': 'tom', 'domain': 'example.com'}, + {'id': 2, 'name': 'ann', 'domain': 'example.com'}, + ] + serializer = self.Serializer(instances, many=True) + assert serializer.data == [ + {'id': 1, 'email': 'tom@example.com'}, + {'id': 2, 'email': 'ann@example.com'} + ] + + def test_validate_data(self): + data = {'id': 1, 'email': 'tom@example.com'} + serializer = self.Serializer(data=data) + assert serializer.is_valid() + assert serializer.validated_data == { + 'id': 1, + 'name': 'tom', + 'domain': 'example.com' + } + + def test_validate_list(self): + data = [ + {'id': 1, 'email': 'tom@example.com'}, + {'id': 2, 'email': 'ann@example.com'}, + ] + serializer = self.Serializer(data=data, many=True) + assert serializer.is_valid() + assert serializer.validated_data == [ + {'id': 1, 'name': 'tom', 'domain': 'example.com'}, + {'id': 2, 'name': 'ann', 'domain': 'example.com'} + ] + + class TestStarredSource: """ Tests for `source='*'` argument, which is used for nested representations. -- cgit v1.2.3 From 802913d5e4d40ee17054415bded02981055b651d Mon Sep 17 00:00:00 2001 From: Anton D. Kachalov Date: Fri, 26 Sep 2014 16:07:46 +0400 Subject: [templates/rest_framework/base.html] Separate `object-form' and `generic-content-form' IDs for POST and PUT forms Signed-off-by: Anton D. Kachalov --- rest_framework/templates/rest_framework/base.html | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/rest_framework/templates/rest_framework/base.html b/rest_framework/templates/rest_framework/base.html index a84ccf26..3628daa0 100644 --- a/rest_framework/templates/rest_framework/base.html +++ b/rest_framework/templates/rest_framework/base.html @@ -142,16 +142,16 @@ {% if post_form %} {% endif %}
{% if post_form %} -
+
{% with form=post_form %}
@@ -166,7 +166,7 @@ {% endwith %}
{% endif %} -
+
{% with form=raw_data_post_form %}
@@ -188,16 +188,16 @@ {% if put_form %} {% endif %}
{% if put_form %} -
+
@@ -211,7 +211,7 @@
{% endif %} -
+
{% with form=raw_data_put_or_patch_form %}
-- cgit v1.2.3 From 2e87de01430d7fec83f00948e60c8d61b317053b Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 13:08:20 +0100 Subject: Added ListField --- rest_framework/fields.py | 38 ++++++++++++++++++++++++++++++++++++++ rest_framework/serializers.py | 6 ++++-- tests/test_fields.py | 19 +++++++++++++++++++ 3 files changed, 61 insertions(+), 2 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index ec07a413..cf42d36c 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -881,6 +881,44 @@ class ImageField(Field): # Advanced field types... +class ListField(Field): + child = None + initial = [] + default_error_messages = { + 'not_a_list': _('Expected a list of items but got type `{input_type}`') + } + + def __init__(self, *args, **kwargs): + self.child = kwargs.pop('child', copy.deepcopy(self.child)) + assert self.child is not None, '`child` is a required argument.' + assert not inspect.isclass(self.child), '`child` has not been instantiated.' + super(ListField, self).__init__(*args, **kwargs) + self.child.bind(field_name='', parent=self) + + def get_value(self, dictionary): + # We override the default field access in order to support + # lists in HTML forms. + if html.is_html_input(dictionary): + return html.parse_html_list(dictionary, prefix=self.field_name) + return dictionary.get(self.field_name, empty) + + def to_internal_value(self, data): + """ + List of dicts of native values <- List of dicts of primitive datatypes. + """ + if html.is_html_input(data): + data = html.parse_html_list(data) + if isinstance(data, type('')) or not hasattr(data, '__iter__'): + self.fail('not_a_list', input_type=type(data).__name__) + return [self.child.run_validation(item) for item in data] + + def to_representation(self, data): + """ + List of object instances -> List of dicts of primitive datatypes. + """ + return [self.child.to_representation(item) for item in data] + + class ReadOnlyField(Field): """ A read-only field that simply returns the field value. diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 245ec26f..fa2e8fb1 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -287,6 +287,9 @@ class Serializer(BaseSerializer): return representation.serializer_repr(self, indent=1) +# There's some replication of `ListField` here, +# but that's probably better than obfuscating the call hierarchy. + class ListSerializer(BaseSerializer): child = None initial = [] @@ -301,7 +304,7 @@ class ListSerializer(BaseSerializer): def get_value(self, dictionary): # We override the default field access in order to support # lists in HTML forms. - if is_html_input(dictionary): + if html.is_html_input(dictionary): return html.parse_html_list(dictionary, prefix=self.field_name) return dictionary.get(self.field_name, empty) @@ -311,7 +314,6 @@ class ListSerializer(BaseSerializer): """ if html.is_html_input(data): data = html.parse_html_list(data) - return [self.child.run_validation(item) for item in data] def to_representation(self, data): diff --git a/tests/test_fields.py b/tests/test_fields.py index 1539a210..68112748 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -849,6 +849,25 @@ class TestMultipleChoiceField(FieldValues): ) +class TestListField(FieldValues): + """ + Values for `ListField`. + """ + valid_inputs = [ + ([1, 2, 3], [1, 2, 3]), + (['1', '2', '3'], [1, 2, 3]) + ] + invalid_inputs = [ + ('not a list', ['Expected a list of items but got type `str`']), + ([1, 2, 'error'], ['A valid integer is required.']) + ] + outputs = [ + ([1, 2, 3], [1, 2, 3]), + (['1', '2', '3'], [1, 2, 3]) + ] + field = fields.ListField(child=fields.IntegerField()) + + # Tests for SerializerMethodField. # -------------------------------- -- cgit v1.2.3 From 0eb6a4de8a3293c3b326fadccf7aa0be67c2f5b5 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 13:10:58 +0100 Subject: Release notes --- docs/topics/3.0-announcement.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index faba2d35..9769e884 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -8,6 +8,7 @@ Most notable outstanding issues still to resolved on the `version-3.0` branch. * Forms support for serializers and in the browsable API. * Enforcing uniqueness on `unique=True` and `unique_together` fields. * Optimisations for serialializing primary keys. +* Refine style of validation errors in some cases, such as validation errors in `ListField`. # REST framework 3.0 -- cgit v1.2.3 From 24f7db2fc156b0af7749a5cc17c1df3f5522bf88 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 13:12:10 +0100 Subject: Release notes --- docs/topics/3.0-announcement.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 9769e884..a48d22ea 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -2,13 +2,15 @@ See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-framework/pull/1800) for more details. -Most notable outstanding issues still to resolved on the `version-3.0` branch. +The most notable outstanding issues still to resolved on the `version-3.0` branch are as follows: * `FileField` and `ImageField` support. * Forms support for serializers and in the browsable API. * Enforcing uniqueness on `unique=True` and `unique_together` fields. * Optimisations for serialializing primary keys. * Refine style of validation errors in some cases, such as validation errors in `ListField`. +* `.validate()` method on fields. +* `.transform_()` method on serializers. # REST framework 3.0 -- cgit v1.2.3 From 33ccf40b76ddae790c34c294a133219e68efb946 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 13:14:08 +0100 Subject: Update version number --- rest_framework/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rest_framework/__init__.py b/rest_framework/__init__.py index 7f724c18..261c9c98 100644 --- a/rest_framework/__init__.py +++ b/rest_framework/__init__.py @@ -8,7 +8,7 @@ ______ _____ _____ _____ __ """ __title__ = 'Django REST framework' -__version__ = '2.4.3' +__version__ = '3.0.0' __author__ = 'Tom Christie' __license__ = 'BSD 2-Clause' __copyright__ = 'Copyright 2011-2014 Tom Christie' -- cgit v1.2.3 From ee79b453974f3dc8ead83bff86784366d59a4fb1 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 13:19:32 +0100 Subject: Prepend some pre-release notes --- docs/topics/3.0-announcement.md | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index a48d22ea..21052ca0 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -1,6 +1,10 @@ -**THIS DOCUMENT IS CURRENTLY A WORK IN PROGRESS** +## Pre-release notes: -See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-framework/pull/1800) for more details. +The 3.0 release is now ready for some tentative testing and upgrades for super keen early adopters. You can install the development version directly from GitHub like so: + + pip install https://github.com/tomchristie/django-rest-framework/archive/version-3.0.zip + +See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-framework/pull/1800) for more details on remaining work. The most notable outstanding issues still to resolved on the `version-3.0` branch are as follows: @@ -12,6 +16,12 @@ The most notable outstanding issues still to resolved on the `version-3.0` branc * `.validate()` method on fields. * `.transform_()` method on serializers. +**Your feedback on the upgrade process and 3.0 changes is hugely important!** + +Please do get in touch via twitter, IRC, a GitHub ticket, or the discussion group. + +--- + # REST framework 3.0 The 3.0 release of Django REST framework is the result of almost four years of iteration and refinement. It comprehensively addresses some of the previous remaining design issues in serializers, fields and the generic views. -- cgit v1.2.3 From 8be4496586519f84b839b07efc74148a3559349e Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 13:59:37 +0100 Subject: Drop erronous print statements --- tests/test_fields.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/test_fields.py b/tests/test_fields.py index 68112748..342ae192 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -78,8 +78,6 @@ class TestSource: 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'} -- cgit v1.2.3 From 609014460861fdfe82054551790d6439292dde7b Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 14:32:44 +0100 Subject: Simplify serialization slightly --- rest_framework/fields.py | 11 +++++++---- rest_framework/serializers.py | 3 +-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index cf42d36c..4c49aaba 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -202,12 +202,15 @@ class Field(object): return self.default_empty_html if (ret == '') else ret return dictionary.get(self.field_name, empty) - def get_attribute(self, instance): + def get_field_representation(self, instance): """ - Given the *outgoing* object instance, return the value for this field - that should be returned as a primative value. + Given the outgoing object instance, return the primative value + that should be used for this field. """ - return get_attribute(instance, self.source_attrs) + attribute = get_attribute(instance, self.source_attrs) + if attribute is None: + return None + return self.to_representation(attribute) def get_default(self): """ diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index fa2e8fb1..080b958d 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -268,8 +268,7 @@ class Serializer(BaseSerializer): fields = [field for field in self.fields.values() if not field.write_only] for field in fields: - native_value = field.get_attribute(instance) - ret[field.field_name] = field.to_representation(native_value) + ret[field.field_name] = field.get_field_representation(instance) return ret -- cgit v1.2.3 From dee3f78cb688b1bee892ef78d6eec23ccf67a80e Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 17:06:20 +0100 Subject: FileField and ImageField --- requirements-test.txt | 1 - rest_framework/compat.py | 9 ----- rest_framework/fields.py | 82 +++++++++++++++++++++++++++++++--------- rest_framework/settings.py | 3 +- tests/test_fields.py | 93 ++++++++++++++++++++++++++++++++++++++++++++-- tox.ini | 16 -------- 6 files changed, 156 insertions(+), 48 deletions(-) diff --git a/requirements-test.txt b/requirements-test.txt index d6ee5c6f..06c8849a 100644 --- a/requirements-test.txt +++ b/requirements-test.txt @@ -13,4 +13,3 @@ django-filter>=0.5.4 django-oauth-plus>=2.2.1 oauth2>=1.5.211 django-oauth2-provider>=0.2.4 -Pillow==2.3.0 diff --git a/rest_framework/compat.py b/rest_framework/compat.py index 7303c32a..89af9b48 100644 --- a/rest_framework/compat.py +++ b/rest_framework/compat.py @@ -84,15 +84,6 @@ except ImportError: from collections import UserDict from collections import MutableMapping as DictMixin -# Try to import PIL in either of the two ways it can end up installed. -try: - from PIL import Image -except ImportError: - try: - import Image - except ImportError: - Image = None - def get_model_name(model_cls): try: diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 4c49aaba..f4b53279 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -1,3 +1,4 @@ +from django import forms from django.conf import settings from django.core import validators from django.core.exceptions import ValidationError @@ -427,8 +428,6 @@ class CharField(Field): return str(data) def to_representation(self, value): - if value is None: - return None return str(value) @@ -446,8 +445,6 @@ class EmailField(CharField): return str(data).strip() def to_representation(self, value): - if value is None: - return None return str(value).strip() @@ -513,8 +510,6 @@ class IntegerField(Field): return data def to_representation(self, value): - if value is None: - return None return int(value) @@ -543,8 +538,6 @@ class FloatField(Field): self.fail('invalid') def to_representation(self, value): - if value is None: - return None return float(value) @@ -616,9 +609,6 @@ class DecimalField(Field): return value def to_representation(self, value): - if value in (None, ''): - return None - if not isinstance(value, decimal.Decimal): value = decimal.Decimal(str(value).strip()) @@ -689,7 +679,7 @@ class DateTimeField(Field): self.fail('invalid', format=humanized_format) def to_representation(self, value): - if value is None or self.format is None: + if self.format is None: return value if self.format.lower() == ISO_8601: @@ -741,7 +731,7 @@ class DateField(Field): self.fail('invalid', format=humanized_format) def to_representation(self, value): - if value is None or self.format is None: + if self.format is None: return value # Applying a `DateField` to a datetime value is almost always @@ -795,7 +785,7 @@ class TimeField(Field): self.fail('invalid', format=humanized_format) def to_representation(self, value): - if value is None or self.format is None: + if self.format is None: return value # Applying a `TimeField` to a datetime value is almost always @@ -875,14 +865,68 @@ class MultipleChoiceField(ChoiceField): # File types... class FileField(Field): - pass # TODO + default_error_messages = { + 'required': _("No file was submitted."), + 'invalid': _("The submitted data was not a file. Check the encoding type on the form."), + 'no_name': _("No filename could be determined."), + 'empty': _("The submitted file is empty."), + 'max_length': _('Ensure this filename has at most {max_length} characters (it has {length}).'), + } + use_url = api_settings.UPLOADED_FILES_USE_URL + def __init__(self, *args, **kwargs): + self.max_length = kwargs.pop('max_length', None) + self.allow_empty_file = kwargs.pop('allow_empty_file', False) + self.use_url = kwargs.pop('use_url', self.use_url) + super(FileField, self).__init__(*args, **kwargs) -class ImageField(Field): - pass # TODO + def to_internal_value(self, data): + try: + # `UploadedFile` objects should have name and size attributes. + file_name = data.name + file_size = data.size + except AttributeError: + self.fail('invalid') + if not file_name: + self.fail('no_name') + if not self.allow_empty_file and not file_size: + self.fail('empty') + if self.max_length and len(file_name) > self.max_length: + self.fail('max_length', max_length=self.max_length, length=len(file_name)) -# Advanced field types... + return data + + def to_representation(self, value): + if self.use_url: + return settings.MEDIA_URL + value.url + return value.name + + +class ImageField(FileField): + default_error_messages = { + 'invalid_image': _( + 'Upload a valid image. The file you uploaded was either not an ' + 'image or a corrupted image.' + ), + } + + def __init__(self, *args, **kwargs): + self._DjangoImageField = kwargs.pop('_DjangoImageField', forms.ImageField) + super(ImageField, self).__init__(*args, **kwargs) + + def to_internal_value(self, data): + # Image validation is a bit grungy, so we'll just outright + # defer to Django's implementation so we don't need to + # consider it, or treat PIL as a test dependancy. + file_object = super(ImageField, self).to_internal_value(data) + django_field = self._DjangoImageField() + django_field.error_messages = self.error_messages + django_field.to_python(file_object) + return file_object + + +# Composite field types... class ListField(Field): child = None @@ -922,6 +966,8 @@ class ListField(Field): return [self.child.to_representation(item) for item in data] +# Miscellaneous field types... + class ReadOnlyField(Field): """ A read-only field that simply returns the field value. diff --git a/rest_framework/settings.py b/rest_framework/settings.py index d7fb0a43..1e8c27fc 100644 --- a/rest_framework/settings.py +++ b/rest_framework/settings.py @@ -110,7 +110,8 @@ DEFAULTS = { # Encoding 'UNICODE_JSON': True, 'COMPACT_JSON': True, - 'COERCE_DECIMAL_TO_STRING': True + 'COERCE_DECIMAL_TO_STRING': True, + 'UPLOADED_FILES_USE_URL': True } diff --git a/tests/test_fields.py b/tests/test_fields.py index 342ae192..aa8c3a68 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -1,4 +1,5 @@ from decimal import Decimal +from django.core.exceptions import ValidationError from django.utils import timezone from rest_framework import fields, serializers import datetime @@ -516,7 +517,7 @@ class TestDecimalField(FieldValues): Decimal('1.0'): '1.0', Decimal('0.0'): '0.0', Decimal('1.09'): '1.1', - Decimal('0.04'): '0.0', + Decimal('0.04'): '0.0' } field = fields.DecimalField(max_digits=3, decimal_places=1) @@ -576,7 +577,7 @@ class TestDateField(FieldValues): datetime.datetime(2001, 1, 1, 12, 00): ['Expected a date but got a datetime.'], } outputs = { - datetime.date(2001, 1, 1): '2001-01-01', + datetime.date(2001, 1, 1): '2001-01-01' } field = fields.DateField() @@ -639,7 +640,7 @@ class TestDateTimeField(FieldValues): } outputs = { datetime.datetime(2001, 1, 1, 13, 00): '2001-01-01T13:00:00', - datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): '2001-01-01T13:00:00Z', + datetime.datetime(2001, 1, 1, 13, 00, tzinfo=timezone.UTC()): '2001-01-01T13:00:00Z' } field = fields.DateTimeField(default_timezone=timezone.UTC()) @@ -847,6 +848,92 @@ class TestMultipleChoiceField(FieldValues): ) +# File fields... + +class MockFile: + def __init__(self, name='', size=0, url=''): + self.name = name + self.size = size + self.url = url + + def __eq__(self, other): + return ( + isinstance(other, MockFile) and + self.name == other.name and + self.size == other.size and + self.url == other.url + ) + + +class TestFileField(FieldValues): + """ + Values for `FileField`. + """ + valid_inputs = [ + (MockFile(name='example', size=10), MockFile(name='example', size=10)) + ] + invalid_inputs = [ + ('invalid', ['The submitted data was not a file. Check the encoding type on the form.']), + (MockFile(name='example.txt', size=0), ['The submitted file is empty.']), + (MockFile(name='', size=10), ['No filename could be determined.']), + (MockFile(name='x' * 100, size=10), ['Ensure this filename has at most 10 characters (it has 100).']) + ] + outputs = [ + (MockFile(name='example.txt', url='/example.txt'), '/example.txt') + ] + field = fields.FileField(max_length=10) + + +class TestFieldFieldWithName(FieldValues): + """ + Values for `FileField` with a filename output instead of URLs. + """ + valid_inputs = {} + invalid_inputs = {} + outputs = [ + (MockFile(name='example.txt', url='/example.txt'), 'example.txt') + ] + field = fields.FileField(use_url=False) + + +# Stub out mock Django `forms.ImageField` class so we don't *actually* +# call into it's regular validation, or require PIL for testing. +class FailImageValidation(object): + def to_python(self, value): + raise ValidationError(self.error_messages['invalid_image']) + + +class PassImageValidation(object): + def to_python(self, value): + return value + + +class TestInvalidImageField(FieldValues): + """ + Values for an invalid `ImageField`. + """ + valid_inputs = {} + invalid_inputs = [ + (MockFile(name='example.txt', size=10), ['Upload a valid image. The file you uploaded was either not an image or a corrupted image.']) + ] + outputs = {} + field = fields.ImageField(_DjangoImageField=FailImageValidation) + + +class TestValidImageField(FieldValues): + """ + Values for an valid `ImageField`. + """ + valid_inputs = [ + (MockFile(name='example.txt', size=10), MockFile(name='example.txt', size=10)) + ] + invalid_inputs = {} + outputs = {} + field = fields.ImageField(_DjangoImageField=PassImageValidation) + + +# Composite fields... + class TestListField(FieldValues): """ Values for `ListField`. diff --git a/tox.ini b/tox.ini index d40a7079..5b9a0ffe 100644 --- a/tox.ini +++ b/tox.ini @@ -21,7 +21,6 @@ basepython = python3.4 deps = Django==1.7 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py3.3-django1.7] @@ -29,7 +28,6 @@ basepython = python3.3 deps = Django==1.7 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py3.2-django1.7] @@ -37,7 +35,6 @@ basepython = python3.2 deps = Django==1.7 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py2.7-django1.7] @@ -49,7 +46,6 @@ deps = Django==1.7 # oauth2==1.5.211 # django-oauth2-provider==0.2.4 django-guardian==1.2.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py3.4-django1.6] @@ -57,7 +53,6 @@ basepython = python3.4 deps = Django==1.6.3 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py3.3-django1.6] @@ -65,7 +60,6 @@ basepython = python3.3 deps = Django==1.6.3 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py3.2-django1.6] @@ -73,7 +67,6 @@ basepython = python3.2 deps = Django==1.6.3 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py2.7-django1.6] @@ -85,7 +78,6 @@ deps = Django==1.6.3 oauth2==1.5.211 django-oauth2-provider==0.2.4 django-guardian==1.2.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py2.6-django1.6] @@ -97,7 +89,6 @@ deps = Django==1.6.3 oauth2==1.5.211 django-oauth2-provider==0.2.4 django-guardian==1.2.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py3.4-django1.5] @@ -105,7 +96,6 @@ basepython = python3.4 deps = django==1.5.6 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py3.3-django1.5] @@ -113,7 +103,6 @@ basepython = python3.3 deps = django==1.5.6 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py3.2-django1.5] @@ -121,7 +110,6 @@ basepython = python3.2 deps = django==1.5.6 django-filter==0.7 defusedxml==0.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py2.7-django1.5] @@ -133,7 +121,6 @@ deps = django==1.5.6 oauth2==1.5.211 django-oauth2-provider==0.2.3 django-guardian==1.2.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py2.6-django1.5] @@ -145,7 +132,6 @@ deps = django==1.5.6 oauth2==1.5.211 django-oauth2-provider==0.2.3 django-guardian==1.2.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py2.7-django1.4] @@ -157,7 +143,6 @@ deps = django==1.4.11 oauth2==1.5.211 django-oauth2-provider==0.2.3 django-guardian==1.2.3 - Pillow==2.3.0 pytest-django==2.6.1 [testenv:py2.6-django1.4] @@ -169,5 +154,4 @@ deps = django==1.4.11 oauth2==1.5.211 django-oauth2-provider==0.2.3 django-guardian==1.2.3 - Pillow==2.3.0 pytest-django==2.6.1 -- cgit v1.2.3 From ce04d59a53df45715c4805831406b2105c9594a8 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 26 Sep 2014 17:07:47 +0100 Subject: Update release notes --- docs/topics/3.0-announcement.md | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 21052ca0..24f4ed4c 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -8,7 +8,6 @@ See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-fr The most notable outstanding issues still to resolved on the `version-3.0` branch are as follows: -* `FileField` and `ImageField` support. * Forms support for serializers and in the browsable API. * Enforcing uniqueness on `unique=True` and `unique_together` fields. * Optimisations for serialializing primary keys. -- cgit v1.2.3 From 43fd5a873051c99600386c1fdc9fa368edeb6eda Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 09:24:03 +0100 Subject: Uniqueness validation --- rest_framework/fields.py | 4 +++ rest_framework/utils/field_mapping.py | 5 +++ rest_framework/validators.py | 57 +++++++++++++++++++++++++++++++++++ tests/test_validators.py | 35 +++++++++++++++++++++ 4 files changed, 101 insertions(+) create mode 100644 rest_framework/validators.py create mode 100644 tests/test_validators.py diff --git a/rest_framework/fields.py b/rest_framework/fields.py index f4b53279..231f693c 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -150,6 +150,10 @@ class Field(object): messages.update(error_messages or {}) self.error_messages = messages + for validator in validators: + if getattr(validator, 'requires_context', False): + validator.serializer_field = self + def bind(self, field_name, parent): """ Initializes the field name and parent for the field instance. diff --git a/rest_framework/utils/field_mapping.py b/rest_framework/utils/field_mapping.py index c3794083..cf9d910a 100644 --- a/rest_framework/utils/field_mapping.py +++ b/rest_framework/utils/field_mapping.py @@ -6,6 +6,7 @@ from django.core import validators from django.db import models from django.utils.text import capfirst from rest_framework.compat import clean_manytomany_helptext +from rest_framework.validators import UniqueValidator import inspect @@ -156,6 +157,10 @@ def get_field_kwargs(field_name, model_field): if validator is not validators.validate_slug ] + if getattr(model_field, 'unique', False): + validator = UniqueValidator(queryset=model_field.model._default_manager) + validator_kwarg.append(validator) + max_digits = getattr(model_field, 'max_digits', None) if max_digits is not None: kwargs['max_digits'] = max_digits diff --git a/rest_framework/validators.py b/rest_framework/validators.py new file mode 100644 index 00000000..f5fbeb3c --- /dev/null +++ b/rest_framework/validators.py @@ -0,0 +1,57 @@ +from django.core.exceptions import ValidationError + + +class UniqueValidator: + # Validators with `requires_context` will have the field instance + # passed to them when the field is instantiated. + requires_context = True + + def __init__(self, queryset): + self.queryset = queryset + self.serializer_field = None + + def get_queryset(self): + return self.queryset.all() + + def __call__(self, value): + field = self.serializer_field + + # Determine the model field name that the serializer field corresponds to. + field_name = field.source_attrs[0] if field.source_attrs else field.field_name + + # Determine the existing instance, if this is an update operation. + instance = getattr(field.parent, 'instance', None) + + # Ensure uniqueness. + filter_kwargs = {field_name: value} + queryset = self.get_queryset().filter(**filter_kwargs) + if instance: + queryset = queryset.exclude(pk=instance.pk) + if queryset.exists(): + raise ValidationError('This field must be unique.') + + +class UniqueTogetherValidator: + requires_context = True + + def __init__(self, queryset, fields): + self.queryset = queryset + self.fields = fields + self.serializer_field = None + + def __call__(self, value): + serializer = self.serializer_field + + # Determine the existing instance, if this is an update operation. + instance = getattr(serializer, 'instance', None) + + # Ensure uniqueness. + filter_kwargs = dict([ + (field_name, value[field_name]) for field_name in self.fields + ]) + queryset = self.get_queryset().filter(**filter_kwargs) + if instance: + queryset = queryset.exclude(pk=instance.pk) + if queryset.exists(): + field_names = ' and '.join(self.fields) + raise ValidationError('The fields %s must make a unique set.' % field_names) diff --git a/tests/test_validators.py b/tests/test_validators.py new file mode 100644 index 00000000..a1366a1a --- /dev/null +++ b/tests/test_validators.py @@ -0,0 +1,35 @@ +from django.db import models +from django.test import TestCase +from rest_framework import serializers + + +class ExampleModel(models.Model): + username = models.CharField(unique=True, max_length=100) + + +class ExampleSerializer(serializers.ModelSerializer): + class Meta: + model = ExampleModel + + +class TestUniquenessValidation(TestCase): + def setUp(self): + self.instance = ExampleModel.objects.create(username='existing') + + def test_is_not_unique(self): + data = {'username': 'existing'} + serializer = ExampleSerializer(data=data) + assert not serializer.is_valid() + assert serializer.errors == {'username': ['This field must be unique.']} + + def test_is_unique(self): + data = {'username': 'other'} + serializer = ExampleSerializer(data=data) + assert serializer.is_valid() + assert serializer.validated_data == {'username': 'other'} + + def test_updated_instance_excluded(self): + data = {'username': 'existing'} + serializer = ExampleSerializer(self.instance, data=data) + assert serializer.is_valid() + assert serializer.validated_data == {'username': 'existing'} -- cgit v1.2.3 From 9805a085fb115785f272489dc24b51ba6f8e6329 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 11:23:02 +0100 Subject: UniqueTogetherValidator --- rest_framework/serializers.py | 80 +++++++++++++++++++++++--- rest_framework/validators.py | 38 ++++++++++--- tests/test_validators.py | 129 +++++++++++++++++++++++++++++++++++++++--- 3 files changed, 223 insertions(+), 24 deletions(-) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 080b958d..09ad376a 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -23,6 +23,7 @@ from rest_framework.utils.field_mapping import ( get_relation_kwargs, get_nested_relation_kwargs, ClassLookupDict ) +from rest_framework.validators import UniqueTogetherValidator import copy import inspect @@ -95,7 +96,7 @@ class BaseSerializer(Field): def is_valid(self, raise_exception=False): if not hasattr(self, '_validated_data'): try: - self._validated_data = self.to_internal_value(self._initial_data) + self._validated_data = self.run_validation(self._initial_data) except ValidationError as exc: self._validated_data = {} self._errors = exc.message_dict @@ -223,15 +224,43 @@ class Serializer(BaseSerializer): return html.parse_html_dict(dictionary, prefix=self.field_name) return dictionary.get(self.field_name, empty) - def to_internal_value(self, data): + def run_validation(self, data=empty): """ - Dict of native values <- Dict of primitive datatypes. + We override the default `run_validation`, because the validation + performed by validators and the `.validate()` method should + be coerced into an error dictionary with a 'non_fields_error' key. """ + if data is empty: + if getattr(self.root, 'partial', False): + raise SkipField() + if self.required: + self.fail('required') + return self.get_default() + + if data is None: + if not self.allow_null: + self.fail('null') + return None + if not isinstance(data, dict): raise ValidationError({ api_settings.NON_FIELD_ERRORS_KEY: ['Invalid data'] }) + value = self.to_internal_value(data) + try: + self.run_validators(value) + self.validate(value) + except ValidationError as exc: + raise ValidationError({ + api_settings.NON_FIELD_ERRORS_KEY: exc.messages + }) + return value + + def to_internal_value(self, data): + """ + Dict of native values <- Dict of primitive datatypes. + """ ret = {} errors = {} fields = [field for field in self.fields.values() if not field.read_only] @@ -253,12 +282,7 @@ class Serializer(BaseSerializer): if errors: raise ValidationError(errors) - try: - return self.validate(ret) - except ValidationError as exc: - raise ValidationError({ - api_settings.NON_FIELD_ERRORS_KEY: exc.messages - }) + return ret def to_representation(self, instance): """ @@ -355,6 +379,14 @@ class ModelSerializer(Serializer): }) _related_class = PrimaryKeyRelatedField + def __init__(self, *args, **kwargs): + super(ModelSerializer, self).__init__(*args, **kwargs) + if 'validators' not in kwargs: + validators = self.get_unique_together_validators() + if validators: + self.validators.extend(validators) + self._kwargs['validators'] = validators + def create(self, attrs): ModelClass = self.Meta.model @@ -381,6 +413,36 @@ class ModelSerializer(Serializer): setattr(obj, attr, value) obj.save() + def get_unique_together_validators(self): + field_names = set([ + field.source for field in self.fields.values() + if (field.source != '*') and ('.' not in field.source) + ]) + + validators = [] + model_class = self.Meta.model + + for unique_together in model_class._meta.unique_together: + if field_names.issuperset(set(unique_together)): + validator = UniqueTogetherValidator( + queryset=model_class._default_manager, + fields=unique_together + ) + validator.serializer_field = self + validators.append(validator) + + for parent_class in model_class._meta.parents.keys(): + for unique_together in parent_class._meta.unique_together: + if field_names.issuperset(set(unique_together)): + validator = UniqueTogetherValidator( + queryset=parent_class._default_manager, + fields=unique_together + ) + validator.serializer_field = self + validators.append(validator) + + return validators + def _get_base_fields(self): declared_fields = copy.deepcopy(self._declared_fields) diff --git a/rest_framework/validators.py b/rest_framework/validators.py index f5fbeb3c..20de4b42 100644 --- a/rest_framework/validators.py +++ b/rest_framework/validators.py @@ -1,18 +1,26 @@ +""" +We perform uniqueness checks explicitly on the serializer class, rather +the using Django's `.full_clean()`. + +This gives us better seperation of concerns, allows us to use single-step +object creation, and makes it possible to switch between using the implicit +`ModelSerializer` class and an equivelent explicit `Serializer` class. +""" from django.core.exceptions import ValidationError +from django.utils.translation import ugettext_lazy as _ +from rest_framework.utils.representation import smart_repr class UniqueValidator: # Validators with `requires_context` will have the field instance # passed to them when the field is instantiated. requires_context = True + message = _('This field must be unique.') def __init__(self, queryset): self.queryset = queryset self.serializer_field = None - def get_queryset(self): - return self.queryset.all() - def __call__(self, value): field = self.serializer_field @@ -24,15 +32,22 @@ class UniqueValidator: # Ensure uniqueness. filter_kwargs = {field_name: value} - queryset = self.get_queryset().filter(**filter_kwargs) + queryset = self.queryset.filter(**filter_kwargs) if instance: queryset = queryset.exclude(pk=instance.pk) if queryset.exists(): - raise ValidationError('This field must be unique.') + raise ValidationError(self.message) + + def __repr__(self): + return '<%s(queryset=%s)>' % ( + self.__class__.__name__, + smart_repr(self.queryset) + ) class UniqueTogetherValidator: requires_context = True + message = _('The fields {field_names} must make a unique set.') def __init__(self, queryset, fields): self.queryset = queryset @@ -49,9 +64,16 @@ class UniqueTogetherValidator: filter_kwargs = dict([ (field_name, value[field_name]) for field_name in self.fields ]) - queryset = self.get_queryset().filter(**filter_kwargs) + queryset = self.queryset.filter(**filter_kwargs) if instance: queryset = queryset.exclude(pk=instance.pk) if queryset.exists(): - field_names = ' and '.join(self.fields) - raise ValidationError('The fields %s must make a unique set.' % field_names) + field_names = ', '.join(self.fields) + raise ValidationError(self.message.format(field_names=field_names)) + + def __repr__(self): + return '<%s(queryset=%s, fields=%s)>' % ( + self.__class__.__name__, + smart_repr(self.queryset), + smart_repr(self.fields) + ) diff --git a/tests/test_validators.py b/tests/test_validators.py index a1366a1a..c35ecb51 100644 --- a/tests/test_validators.py +++ b/tests/test_validators.py @@ -3,33 +3,148 @@ from django.test import TestCase from rest_framework import serializers -class ExampleModel(models.Model): +def dedent(blocktext): + return '\n'.join([line[12:] for line in blocktext.splitlines()[1:-1]]) + + +# Tests for `UniqueValidator` +# --------------------------- + +class UniquenessModel(models.Model): username = models.CharField(unique=True, max_length=100) -class ExampleSerializer(serializers.ModelSerializer): +class UniquenessSerializer(serializers.ModelSerializer): class Meta: - model = ExampleModel + model = UniquenessModel class TestUniquenessValidation(TestCase): def setUp(self): - self.instance = ExampleModel.objects.create(username='existing') + self.instance = UniquenessModel.objects.create(username='existing') + + def test_repr(self): + serializer = UniquenessSerializer() + expected = dedent(""" + UniquenessSerializer(): + id = IntegerField(label='ID', read_only=True) + username = CharField(max_length=100, validators=[]) + """) + assert repr(serializer) == expected def test_is_not_unique(self): data = {'username': 'existing'} - serializer = ExampleSerializer(data=data) + serializer = UniquenessSerializer(data=data) assert not serializer.is_valid() assert serializer.errors == {'username': ['This field must be unique.']} def test_is_unique(self): data = {'username': 'other'} - serializer = ExampleSerializer(data=data) + serializer = UniquenessSerializer(data=data) assert serializer.is_valid() assert serializer.validated_data == {'username': 'other'} def test_updated_instance_excluded(self): data = {'username': 'existing'} - serializer = ExampleSerializer(self.instance, data=data) + serializer = UniquenessSerializer(self.instance, data=data) assert serializer.is_valid() assert serializer.validated_data == {'username': 'existing'} + + +# Tests for `UniqueTogetherValidator` +# ----------------------------------- + +class UniquenessTogetherModel(models.Model): + race_name = models.CharField(max_length=100) + position = models.IntegerField() + + class Meta: + unique_together = ('race_name', 'position') + + +class UniquenessTogetherSerializer(serializers.ModelSerializer): + class Meta: + model = UniquenessTogetherModel + + +class TestUniquenessTogetherValidation(TestCase): + def setUp(self): + self.instance = UniquenessTogetherModel.objects.create( + race_name='example', + position=1 + ) + UniquenessTogetherModel.objects.create( + race_name='example', + position=2 + ) + UniquenessTogetherModel.objects.create( + race_name='other', + position=1 + ) + + def test_repr(self): + serializer = UniquenessTogetherSerializer() + expected = dedent(""" + UniquenessTogetherSerializer(validators=[]): + id = IntegerField(label='ID', read_only=True) + race_name = CharField(max_length=100) + position = IntegerField() + """) + assert repr(serializer) == expected + + def test_is_not_unique_together(self): + """ + Failing unique together validation should result in non field errors. + """ + data = {'race_name': 'example', 'position': 2} + serializer = UniquenessTogetherSerializer(data=data) + print serializer.validators + assert not serializer.is_valid() + assert serializer.errors == { + 'non_field_errors': [ + 'The fields race_name, position must make a unique set.' + ] + } + + def test_is_unique_together(self): + """ + In a unique together validation, one field may be non-unique + so long as the set as a whole is unique. + """ + data = {'race_name': 'other', 'position': 2} + serializer = UniquenessTogetherSerializer(data=data) + assert serializer.is_valid() + assert serializer.validated_data == { + 'race_name': 'other', + 'position': 2 + } + + def test_updated_instance_excluded_from_unique_together(self): + """ + When performing an update, the existing instance does not count + as a match against uniqueness. + """ + data = {'race_name': 'example', 'position': 1} + serializer = UniquenessTogetherSerializer(self.instance, data=data) + assert serializer.is_valid() + assert serializer.validated_data == { + 'race_name': 'example', + 'position': 1 + } + + def test_ignore_exlcuded_fields(self): + """ + When model fields are not included in a serializer, then uniqueness + validtors should not be added for that field. + """ + class ExcludedFieldSerializer(serializers.ModelSerializer): + class Meta: + model = UniquenessTogetherModel + fields = ('id', 'race_name',) + serializer = ExcludedFieldSerializer() + expected = dedent(""" + ExcludedFieldSerializer(): + id = IntegerField(label='ID', read_only=True) + race_name = CharField(max_length=100) + """) + assert repr(serializer) == expected -- cgit v1.2.3 From d2d412993f537952fd7809ded3e981f85ec318e9 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 11:24:21 +0100 Subject: .validate() on serializer fields --- rest_framework/fields.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 231f693c..fee6080a 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -254,6 +254,7 @@ class Field(object): value = self.to_internal_value(data) self.run_validators(value) + self.validate(value) return value def run_validators(self, value): @@ -270,6 +271,9 @@ class Field(object): if errors: raise ValidationError(errors) + def validate(self, value): + pass + def to_internal_value(self, data): """ Transform the *incoming* primative data into a native value. -- cgit v1.2.3 From 4798df52df5d59cc570043e3eb7e26f7ce57b54f Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 12:57:05 +0100 Subject: Update release notes --- docs/topics/3.0-announcement.md | 44 ++++++++++++++++++++++++++++++++++++----- tests/test_validators.py | 1 - 2 files changed, 39 insertions(+), 6 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 24f4ed4c..92062552 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -146,7 +146,41 @@ The corresponding code would now look like this: extras = {'user': request.user} # Include the user when saving. serializer.save(extras=extras) -#### Printable serializer reprensentations. +#### Limitations of ModelSerializer validation. + +This change also means that we no longer use the `.full_clean()` method on model instances, but instead perform all validation explicitly on the serializer. This gives a cleaner seperation, and ensures that there's no automatic validation behavior on `ModelSerializer` classes that can't also be easily replicated on regular `Serializer` classes. + +This change comes with the following limitations: + +* The model `.clean()` method will not be called as part of serializer validation. Use the serializer `.validate()` method to perform a final validation step on incoming data where required. +* The `.unique_for_date`, `.unique_for_month` and `.unique_for_year` options on model fields are not automatically validated. Again, you'll need to handle these explicitly on the serializer if required. + +#### Writable nested serialization. + +REST framework 2.x attempted to automatically support writable nested serialization, but the behavior was complex and non-obvious. Attempting to automatically handle these case is problematic: + +* There can be complex dependancies involved in order of saving multiple related model instances. +* It's unclear what behavior the user should expect when related models are passed `None` data. +* It's unclear how the user should expect to-many relationships to handle updates, creations and deletions of multiple records. + +Using the `depth` option on `ModelSerializer` will now create **read-only nested serializers** by default. To use writable nested serialization you'll want to declare a nested field on the serializer class, and write the `create()` and/or `update()` methods explicitly. + + class UserSerializer(serializers.ModelSerializer): + profile = ProfileSerializer() + + class Meta: + model = User + fields = ('username', 'email', 'profile') + + def create(self, validated_data): + profile_data = validated_data.pop['profile'] + user = User.objects.create(**validated_data) + profile = Profile.objects.create(user=user, **profile_data) + return user + +The single-step object creation makes this far simpler and more obvious than the previous `.restore_object()` behavior. + +#### Printable serializer representations. Serializer instances now support a printable representation that allows you to inspect the fields present on the instance. @@ -279,7 +313,7 @@ There are four mathods that can be overriding, depending on what functionality y * `.to_internal_value()` - Override this to support deserialization, for write operations. * `.create()` and `.update()` - Overide either or both of these to support saving instances. -##### Read-only serializers. +##### Read-only `BaseSerializer` classes. To implement a read-only serializer using the `BaseSerializer` class, we just need to override the `.to_representation()` method. Let's take a look at an example using a simple Django model: @@ -313,7 +347,7 @@ Or use it to serialize multiple instances: serializer = HighScoreSerializer(queryset, many=True) return Response(serializer.data) -##### Read-write serializers. +##### Read-write `BaseSerializer` classes. To create a read-write serializer we first need to implement a `.to_internal_value()` method. This method returns the validated values that will be used to construct the object instance, and may raise a `ValidationError` if the supplied data is in an incorrect format. @@ -358,9 +392,9 @@ Here's a complete example of our previous `HighScoreSerializer`, that's been upd def create(self, validated_data): return HighScore.objects.create(**validated_data) -#### Creating new base classes with `BaseSerializer`. +#### Creating new generic serializers with `BaseSerializer`. -The `BaseSerializer` class is also useful if you want to implement new generic serializer classes for dealing with particular serialization styles or for integrating with different storage backends. +The `BaseSerializer` class is also useful if you want to implement new generic serializer classes for dealing with particular serialization styles, or for integrating with alternative storage backends. The following class is an example of a generic serializer that can handle coercing aribitrary objects into primative representations. diff --git a/tests/test_validators.py b/tests/test_validators.py index c35ecb51..ac04d2b4 100644 --- a/tests/test_validators.py +++ b/tests/test_validators.py @@ -98,7 +98,6 @@ class TestUniquenessTogetherValidation(TestCase): """ data = {'race_name': 'example', 'position': 2} serializer = UniquenessTogetherSerializer(data=data) - print serializer.validators assert not serializer.is_valid() assert serializer.errors == { 'non_field_errors': [ -- cgit v1.2.3 From 657d1de032bfa392609d53751e89366b972cd678 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 14:12:09 +0100 Subject: Latest release notes --- docs/topics/3.0-announcement.md | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 92062552..584c4979 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -560,6 +560,35 @@ The following usage will *now raise an error*: email = serializers.EmailField(source='email') +#### The `UniqueValidator` and `UniqueTogetherValidator` classes. + +REST framework now provides two new validators that allow you to ensure field uniqueness, while still using a completely explicit `Serializer` class instead of using `ModelSerializer`. + +The `UniqueValidator` should be applied to a serializer field, and takes a single `queryset` argument. + + from rest_framework import serializers + from rest_framework.validators import UniqueValidator + + class OrganizationSerializer(serializers.Serializer): + url = serializers.HyperlinkedIdentityField(view_name='organisation_detail') + created = serializers.DateTimeField(read_only=True) + name = serializers.CharField( + max_length=100, + validators=UniqueValidator(queryset=Organisation.objects.all()) + ) + +The `UniqueTogetherValidator` should be applied to a serializer, and takes a `queryset` argument and a `fields` argument which should be a list or tuple of field names. + + class RaceResultSerializer(serializers.Serializer): + category = serializers.ChoiceField(['5k', '10k']) + position = serializers.IntegerField() + name = serializers.CharField(max_length=100) + + default_validators = [UniqueTogetherValidator( + queryset=RaceResult.objects.all(), + fields=('category', 'position') + )] + ## Generic views #### Simplification of view logic. @@ -633,6 +662,16 @@ The `COMPACT_JSON` setting has been added, and can be used to revert this behavi 'COMPACT_JSON': False } +#### File fields as URLs + +The `FileField` and `ImageField` classes are now represented as URLs by default. You should ensure you set Django's standard `MEDIA_URL` setting appropriately. + +You can revert this behavior, and display filenames as the representation, using the `UPLOADED_FILES_USE_URL` settings key: + + REST_FRAMEWORK = { + 'UPLOADED_FILES_USE_URL': False + } + #### Throttle headers using `Retry-After`. The custom `X-Throttle-Wait-Second` header has now been dropped in favor of the standard `Retry-After` header. You can revert this behavior if needed by writing a custom exception handler for your application. -- cgit v1.2.3 From d1b2c8ac7faec65483cbddf4f1718ca4f5805246 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 14:12:26 +0100 Subject: Absolute URLs for file fields --- rest_framework/fields.py | 12 +++++++----- rest_framework/serializers.py | 2 -- tests/test_fields.py | 17 +++++++++++++++++ 3 files changed, 24 insertions(+), 7 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index fee6080a..f7ea3b0c 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -150,10 +150,6 @@ class Field(object): messages.update(error_messages or {}) self.error_messages = messages - for validator in validators: - if getattr(validator, 'requires_context', False): - validator.serializer_field = self - def bind(self, field_name, parent): """ Initializes the field name and parent for the field instance. @@ -264,6 +260,8 @@ class Field(object): """ errors = [] for validator in self.validators: + if getattr(validator, 'requires_context', False): + validator.serializer_field = self try: validator(value) except ValidationError as exc: @@ -907,7 +905,11 @@ class FileField(Field): def to_representation(self, value): if self.use_url: - return settings.MEDIA_URL + value.url + url = settings.MEDIA_URL + value.url + request = self.context.get('request', None) + if request is not None: + return request.build_absolute_uri(url) + return url return value.name diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 09ad376a..0faa5671 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -428,7 +428,6 @@ class ModelSerializer(Serializer): queryset=model_class._default_manager, fields=unique_together ) - validator.serializer_field = self validators.append(validator) for parent_class in model_class._meta.parents.keys(): @@ -438,7 +437,6 @@ class ModelSerializer(Serializer): queryset=parent_class._default_manager, fields=unique_together ) - validator.serializer_field = self validators.append(validator) return validators diff --git a/tests/test_fields.py b/tests/test_fields.py index aa8c3a68..bbd9f93d 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -953,6 +953,23 @@ class TestListField(FieldValues): field = fields.ListField(child=fields.IntegerField()) +# Tests for FieldField. +# --------------------- + +class MockRequest: + def build_absolute_uri(self, value): + return 'http://example.com' + value + + +class TestFileFieldContext: + def test_fully_qualified_when_request_in_context(self): + field = fields.FileField(max_length=10) + field._context = {'request': MockRequest()} + obj = MockFile(name='example.txt', url='/example.txt') + value = field.to_representation(obj) + assert value == 'http://example.com/example.txt' + + # Tests for SerializerMethodField. # -------------------------------- -- cgit v1.2.3 From 5734b6e20241c4d0d1441535657c5ef25302b225 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 16:56:50 +0100 Subject: Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 63513f75..428fb8e9 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ There is a live example API for testing purposes, [available here][sandbox]. # Requirements -* Python (2.6.5+, 2.7, 3.2, 3.3) +* Python (2.6.5+, 2.7, 3.2, 3.3, 3.4) * Django (1.4.2+, 1.5, 1.6, 1.7) # Installation -- cgit v1.2.3 From a8622adcd9f940131b63e91d53d2c49fcb89ee6a Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 16:57:40 +0100 Subject: Update index.md --- docs/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/index.md b/docs/index.md index e4c971f9..b18b71d2 100644 --- a/docs/index.md +++ b/docs/index.md @@ -49,7 +49,7 @@ Some reasons you might want to use REST framework: REST framework requires the following: -* Python (2.6.5+, 2.7, 3.2, 3.3) +* Python (2.6.5+, 2.7, 3.2, 3.3, 3.4) * Django (1.4.2+, 1.5, 1.6, 1.7) The following packages are optional: -- cgit v1.2.3 From 83a5ea8db27b9452a5539f1e0574f493392a91ad Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 29 Sep 2014 21:17:13 +0100 Subject: Update release notes --- docs/topics/3.0-announcement.md | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 584c4979..12ab5a0d 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -664,14 +664,26 @@ The `COMPACT_JSON` setting has been added, and can be used to revert this behavi #### File fields as URLs -The `FileField` and `ImageField` classes are now represented as URLs by default. You should ensure you set Django's standard `MEDIA_URL` setting appropriately. +The `FileField` and `ImageField` classes are now represented as URLs by default. You should ensure you set Django's [standard `MEDIA_URL` setting](https://docs.djangoproject.com/en/dev/ref/settings/#std:setting-MEDIA_URL) appropriately, and ensure your application [serves the uploaded files](https://docs.djangoproject.com/en/dev/howto/static-files/#serving-uploaded-files-in-development). -You can revert this behavior, and display filenames as the representation, using the `UPLOADED_FILES_USE_URL` settings key: +You can revert this behavior, and display filenames in the representation by using the `UPLOADED_FILES_USE_URL` settings key: REST_FRAMEWORK = { 'UPLOADED_FILES_USE_URL': False } +You can also modify serializer fields individually, using the `use_url` argument: + + uploaded_file = serializers.FileField(user_url=False) + +Also note that you should pass the `request` object to the serializer as context when instantiating it, so that a fully qualified URL can be returned. Returned URLs will then be of the form `https://example.com/url_path/filename.txt`. For example: + + context = {'request': request} + serializer = ExampleSerializer(instance, context=context) + return Response(serializer.data) + +If the request is omitted from the context, the returned URLs will be of the form `/url_path/filename.txt`. + #### Throttle headers using `Retry-After`. The custom `X-Throttle-Wait-Second` header has now been dropped in favor of the standard `Retry-After` header. You can revert this behavior if needed by writing a custom exception handler for your application. -- cgit v1.2.3 From da4900a353bd1136aa96cb5444b34f7beefa8e85 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 30 Sep 2014 11:10:13 +0100 Subject: Update 3.0-announcement.md --- docs/topics/3.0-announcement.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 12ab5a0d..1c7e016e 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -9,10 +9,8 @@ See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-fr The most notable outstanding issues still to resolved on the `version-3.0` branch are as follows: * Forms support for serializers and in the browsable API. -* Enforcing uniqueness on `unique=True` and `unique_together` fields. * Optimisations for serialializing primary keys. * Refine style of validation errors in some cases, such as validation errors in `ListField`. -* `.validate()` method on fields. * `.transform_()` method on serializers. **Your feedback on the upgrade process and 3.0 changes is hugely important!** -- cgit v1.2.3 From 770d63fb046917f9fe1f08449f07bf13f1adfa4f Mon Sep 17 00:00:00 2001 From: Omer Katz Date: Wed, 1 Oct 2014 13:12:33 +0300 Subject: Fixed documentation typo. --- docs/topics/3.0-announcement.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 1c7e016e..d2505a1b 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -75,7 +75,7 @@ Previously the serializers used a two-step object creation, as follows: This style is in line with how the `ModelForm` class works in Django, but is problematic for a number of reasons: -* Some data, such as many-to-many relationships, cannot be added to the object instance until after it has been save. This type of data needed to be hidden in some undocumentated state on the object instance, or kept as state on the serializer instance so that it could be used when `.save()` is called. +* Some data, such as many-to-many relationships, cannot be added to the object instance until after it has been saved. This type of data needed to be hidden in some undocumentated state on the object instance, or kept as state on the serializer instance so that it could be used when `.save()` is called. * Instantiating model instances directly means that you cannot use model manager classes for instance creation, eg `ExampleModel.objects.create(...)`. Manager classes are an excellent layer at which to enforce business logic and application-level data constraints. * The two step process makes it unclear where to put deserialization logic. For example, should extra attributes such as the current user get added to the instance during object creation or during object save? -- cgit v1.2.3 From 381771731f48c75e7d5951e353049cceec386512 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 1 Oct 2014 13:09:14 +0100 Subject: Use six.text_type instead of str everywhere --- rest_framework/compat.py | 9 +++++---- rest_framework/fields.py | 22 +++++++++++----------- rest_framework/filters.py | 3 ++- rest_framework/generics.py | 5 +++-- rest_framework/parsers.py | 3 ++- rest_framework/relations.py | 3 ++- rest_framework/reverse.py | 3 ++- rest_framework/utils/encoders.py | 6 +++--- 8 files changed, 30 insertions(+), 24 deletions(-) diff --git a/rest_framework/compat.py b/rest_framework/compat.py index 89af9b48..3993cee6 100644 --- a/rest_framework/compat.py +++ b/rest_framework/compat.py @@ -5,11 +5,12 @@ versions of django/python, and compatibility wrappers around optional packages. # flake8: noqa from __future__ import unicode_literals -import django -import inspect + from django.core.exceptions import ImproperlyConfigured from django.conf import settings from django.utils import six +import django +import inspect # Handle django.utils.encoding rename in 1.5 onwards. @@ -177,12 +178,12 @@ class RequestFactory(DjangoRequestFactory): r = { 'PATH_INFO': self._get_path(parsed), 'QUERY_STRING': force_text(parsed[4]), - 'REQUEST_METHOD': str(method), + 'REQUEST_METHOD': six.text_type(method), } if data: r.update({ 'CONTENT_LENGTH': len(data), - 'CONTENT_TYPE': str(content_type), + 'CONTENT_TYPE': six.text_type(content_type), 'wsgi.input': FakePayload(data), }) elif django.VERSION <= (1, 4): diff --git a/rest_framework/fields.py b/rest_framework/fields.py index f7ea3b0c..f3ff2233 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -2,7 +2,7 @@ from django import forms from django.conf import settings from django.core import validators from django.core.exceptions import ValidationError -from django.utils import timezone +from django.utils import six, timezone from django.utils.datastructures import SortedDict from django.utils.dateparse import parse_date, parse_datetime, parse_time from django.utils.encoding import is_protected_type @@ -431,10 +431,10 @@ class CharField(Field): return super(CharField, self).run_validation(data) def to_internal_value(self, data): - return str(data) + return six.text_type(data) def to_representation(self, value): - return str(value) + return six.text_type(value) class EmailField(CharField): @@ -448,10 +448,10 @@ class EmailField(CharField): self.validators.append(validator) def to_internal_value(self, data): - return str(data).strip() + return six.text_type(data).strip() def to_representation(self, value): - return str(value).strip() + return six.text_type(value).strip() class RegexField(CharField): @@ -510,7 +510,7 @@ class IntegerField(Field): def to_internal_value(self, data): try: - data = int(str(data)) + data = int(six.text_type(data)) except (ValueError, TypeError): self.fail('invalid') return data @@ -616,7 +616,7 @@ class DecimalField(Field): def to_representation(self, value): if not isinstance(value, decimal.Decimal): - value = decimal.Decimal(str(value).strip()) + value = decimal.Decimal(six.text_type(value).strip()) context = decimal.getcontext().copy() context.prec = self.max_digits @@ -832,19 +832,19 @@ class ChoiceField(Field): # Allows us to deal with eg. integer choices while supporting either # integer or string input, but still get the correct datatype out. self.choice_strings_to_values = dict([ - (str(key), key) for key in self.choices.keys() + (six.text_type(key), key) for key in self.choices.keys() ]) super(ChoiceField, self).__init__(**kwargs) def to_internal_value(self, data): try: - return self.choice_strings_to_values[str(data)] + return self.choice_strings_to_values[six.text_type(data)] except KeyError: self.fail('invalid_choice', input=data) def to_representation(self, value): - return self.choice_strings_to_values[str(value)] + return self.choice_strings_to_values[six.text_type(value)] class MultipleChoiceField(ChoiceField): @@ -864,7 +864,7 @@ class MultipleChoiceField(ChoiceField): def to_representation(self, value): return set([ - self.choice_strings_to_values[str(item)] for item in value + self.choice_strings_to_values[six.text_type(item)] for item in value ]) diff --git a/rest_framework/filters.py b/rest_framework/filters.py index 085dfe65..4c485668 100644 --- a/rest_framework/filters.py +++ b/rest_framework/filters.py @@ -3,6 +3,7 @@ Provides generic filtering backends that can be used to filter the results returned by list views. """ from __future__ import unicode_literals + from django.core.exceptions import ImproperlyConfigured from django.db import models from django.utils import six @@ -97,7 +98,7 @@ class SearchFilter(BaseFilterBackend): if not search_fields: return queryset - orm_lookups = [self.construct_search(str(search_field)) + orm_lookups = [self.construct_search(six.text_type(search_field)) for search_field in search_fields] for search_term in self.get_search_terms(request): diff --git a/rest_framework/generics.py b/rest_framework/generics.py index cf903dab..3d6cf168 100644 --- a/rest_framework/generics.py +++ b/rest_framework/generics.py @@ -3,10 +3,11 @@ Generic views that provide commonly needed behaviour. """ from __future__ import unicode_literals -from django.db.models.query import QuerySet from django.core.paginator import Paginator, InvalidPage +from django.db.models.query import QuerySet from django.http import Http404 from django.shortcuts import get_object_or_404 as _get_object_or_404 +from django.utils import six from django.utils.translation import ugettext as _ from rest_framework import views, mixins from rest_framework.settings import api_settings @@ -127,7 +128,7 @@ class GenericAPIView(views.APIView): error_format = _('Invalid page (%(page_number)s): %(message)s') raise Http404(error_format % { 'page_number': page_number, - 'message': str(exc) + 'message': six.text_type(exc) }) return page diff --git a/rest_framework/parsers.py b/rest_framework/parsers.py index fa02ecf1..ccb82f03 100644 --- a/rest_framework/parsers.py +++ b/rest_framework/parsers.py @@ -5,6 +5,7 @@ They give us a generic way of being able to handle various media types on the request, such as form content or json encoded data. """ from __future__ import unicode_literals + from django.conf import settings from django.core.files.uploadhandler import StopFutureHandlers from django.http import QueryDict @@ -132,7 +133,7 @@ class MultiPartParser(BaseParser): data, files = parser.parse() return DataAndFiles(data, files) except MultiPartParserError as exc: - raise ParseError('Multipart form parse error - %s' % str(exc)) + raise ParseError('Multipart form parse error - %s' % six.text_type(exc)) class XMLParser(BaseParser): diff --git a/rest_framework/relations.py b/rest_framework/relations.py index b37a6fed..b5effc6c 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -4,6 +4,7 @@ from rest_framework.reverse import reverse from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch, Resolver404 from django.db.models.query import QuerySet +from django.utils import six from django.utils.translation import ugettext_lazy as _ @@ -49,7 +50,7 @@ class StringRelatedField(Field): super(StringRelatedField, self).__init__(**kwargs) def to_representation(self, value): - return str(value) + return six.text_type(value) class PrimaryKeyRelatedField(RelatedField): diff --git a/rest_framework/reverse.py b/rest_framework/reverse.py index a51b07f5..a74e8aa2 100644 --- a/rest_framework/reverse.py +++ b/rest_framework/reverse.py @@ -3,6 +3,7 @@ Provide reverse functions that return fully qualified URLs """ from __future__ import unicode_literals from django.core.urlresolvers import reverse as django_reverse +from django.utils import six from django.utils.functional import lazy @@ -20,4 +21,4 @@ def reverse(viewname, args=None, kwargs=None, request=None, format=None, **extra return url -reverse_lazy = lazy(reverse, str) +reverse_lazy = lazy(reverse, six.text_type) diff --git a/rest_framework/utils/encoders.py b/rest_framework/utils/encoders.py index 174b08b8..7c4179a1 100644 --- a/rest_framework/utils/encoders.py +++ b/rest_framework/utils/encoders.py @@ -2,8 +2,8 @@ Helper classes for parsers. """ from __future__ import unicode_literals -from django.utils import timezone from django.db.models.query import QuerySet +from django.utils import six, timezone from django.utils.datastructures import SortedDict from django.utils.functional import Promise from rest_framework.compat import force_text @@ -40,7 +40,7 @@ class JSONEncoder(json.JSONEncoder): representation = representation[:12] return representation elif isinstance(obj, datetime.timedelta): - return str(obj.total_seconds()) + return six.text_type(obj.total_seconds()) elif isinstance(obj, decimal.Decimal): # Serializers will coerce decimals to strings by default. return float(obj) @@ -72,7 +72,7 @@ else: than the usual behaviour of sorting the keys. """ def represent_decimal(self, data): - return self.represent_scalar('tag:yaml.org,2002:str', str(data)) + return self.represent_scalar('tag:yaml.org,2002:str', six.text_type(data)) def represent_mapping(self, tag, mapping, flow_style=None): value = [] -- cgit v1.2.3 From c630a12e26f29145784523dd1b01ab0b3576f42c Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 1 Oct 2014 13:24:47 +0100 Subject: Deal with lazy strings in serializer reprs --- rest_framework/utils/representation.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/rest_framework/utils/representation.py b/rest_framework/utils/representation.py index e64fdd22..180b51f8 100644 --- a/rest_framework/utils/representation.py +++ b/rest_framework/utils/representation.py @@ -3,6 +3,8 @@ Helper functions for creating user-friendly representations of serializer classes and serializer fields. """ from django.db import models +from django.utils.functional import Promise +from rest_framework.compat import force_text import re @@ -19,6 +21,9 @@ def smart_repr(value): if isinstance(value, models.Manager): return manager_repr(value) + if isinstance(value, Promise) and value._delegate_text: + value = force_text(value) + value = repr(value) # Representations like u'help text' -- cgit v1.2.3 From c171fa21ac62538331755524057d2435f33ec8a5 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 1 Oct 2014 19:44:46 +0100 Subject: First pass at HTML form rendering --- rest_framework/renderers.py | 47 ++++++++++++++++++++-- rest_framework/serializers.py | 2 + .../templates/rest_framework/fields/attrs.html | 1 + .../rest_framework/fields/horizontal/checkbox.html | 10 +++++ .../rest_framework/fields/horizontal/fieldset.html | 10 +++++ .../rest_framework/fields/horizontal/input.html | 7 ++++ .../rest_framework/fields/horizontal/label.html | 1 + .../rest_framework/fields/horizontal/select.html | 10 +++++ .../fields/horizontal/select_checkbox.html | 22 ++++++++++ .../fields/horizontal/select_multiple.html | 10 +++++ .../fields/horizontal/select_radio.html | 22 ++++++++++ .../rest_framework/fields/horizontal/textarea.html | 7 ++++ .../rest_framework/fields/inline/checkbox.html | 6 +++ .../rest_framework/fields/inline/fieldset.html | 3 ++ .../rest_framework/fields/inline/input.html | 4 ++ .../rest_framework/fields/inline/label.html | 1 + .../rest_framework/fields/inline/select.html | 8 ++++ .../fields/inline/select_checkbox.html | 11 +++++ .../fields/inline/select_multiple.html | 8 ++++ .../rest_framework/fields/inline/select_radio.html | 11 +++++ .../rest_framework/fields/inline/textarea.html | 4 ++ .../rest_framework/fields/vertical/checkbox.html | 6 +++ .../rest_framework/fields/vertical/fieldset.html | 6 +++ .../rest_framework/fields/vertical/input.html | 5 +++ .../rest_framework/fields/vertical/label.html | 1 + .../rest_framework/fields/vertical/select.html | 8 ++++ .../fields/vertical/select_checkbox.html | 22 ++++++++++ .../fields/vertical/select_multiple.html | 8 ++++ .../fields/vertical/select_radio.html | 22 ++++++++++ .../rest_framework/fields/vertical/textarea.html | 5 +++ rest_framework/templates/rest_framework/form.html | 40 ++++++++++++------ rest_framework/templatetags/rest_framework.py | 8 ++++ rest_framework/utils/field_mapping.py | 3 ++ tests/test_model_serializer.py | 2 +- 34 files changed, 325 insertions(+), 16 deletions(-) create mode 100644 rest_framework/templates/rest_framework/fields/attrs.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/checkbox.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/fieldset.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/input.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/label.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/select.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/select_radio.html create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/textarea.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/checkbox.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/fieldset.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/input.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/label.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/select.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/select_checkbox.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/select_multiple.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/select_radio.html create mode 100644 rest_framework/templates/rest_framework/fields/inline/textarea.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/checkbox.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/fieldset.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/input.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/label.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/select.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/select_multiple.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/select_radio.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/textarea.html diff --git a/rest_framework/renderers.py b/rest_framework/renderers.py index 225f9fe8..6483a47c 100644 --- a/rest_framework/renderers.py +++ b/rest_framework/renderers.py @@ -13,17 +13,18 @@ import django from django import forms from django.core.exceptions import ImproperlyConfigured from django.http.multipartparser import parse_header -from django.template import RequestContext, loader, Template +from django.template import Context, RequestContext, loader, Template from django.test.client import encode_multipart from django.utils import six from django.utils.xmlutils import SimplerXMLGenerator +from rest_framework import exceptions, serializers, status, VERSION from rest_framework.compat import StringIO, smart_text, yaml from rest_framework.exceptions import ParseError from rest_framework.settings import api_settings from rest_framework.request import is_form_media_type, override_method from rest_framework.utils import encoders from rest_framework.utils.breadcrumbs import get_breadcrumbs -from rest_framework import exceptions, status, VERSION +from rest_framework.utils.field_mapping import ClassLookupDict def zero_as_none(value): @@ -341,6 +342,42 @@ class HTMLFormRenderer(BaseRenderer): template = 'rest_framework/form.html' charset = 'utf-8' + field_templates = ClassLookupDict({ + serializers.Field: { + 'default': 'input.html' + }, + serializers.BooleanField: { + 'default': 'checkbox.html' + }, + serializers.CharField: { + 'default': 'input.html', + 'textarea': 'textarea.html' + }, + serializers.ChoiceField: { + 'default': 'select.html', + 'radio': 'select_radio.html' + }, + serializers.MultipleChoiceField: { + 'default': 'select_multiple.html', + 'checkbox': 'select_checkbox.html' + } + }) + + def render_field(self, field, value, errors, layout=None): + layout = layout or 'vertical' + style_type = field.style.get('type', 'default') + if style_type == 'textarea' and layout == 'inline': + style_type = 'default' + base = self.field_templates[field][style_type] + template_name = 'rest_framework/fields/' + layout + '/' + base + template = loader.get_template(template_name) + context = Context({ + 'field': field, + 'value': value, + 'errors': errors + }) + return template.render(context) + def render(self, data, accepted_media_type=None, renderer_context=None): """ Render serializer data and return an HTML form, as a string. @@ -349,7 +386,11 @@ class HTMLFormRenderer(BaseRenderer): request = renderer_context['request'] template = loader.get_template(self.template) - context = RequestContext(request, {'form': data}) + context = RequestContext(request, { + 'form': data, + 'layout': getattr(getattr(data, 'Meta', None), 'layout', 'vertical'), + 'renderer': self + }) return template.render(context) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 0faa5671..5da81247 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -302,6 +302,8 @@ class Serializer(BaseSerializer): def __iter__(self): errors = self.errors if hasattr(self, '_errors') else {} for field in self.fields.values(): + if field.read_only: + continue value = self.data.get(field.field_name) if self.data else None error = errors.get(field.field_name) yield FieldResult(field, value, error) diff --git a/rest_framework/templates/rest_framework/fields/attrs.html b/rest_framework/templates/rest_framework/fields/attrs.html new file mode 100644 index 00000000..b5a4dbcf --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/attrs.html @@ -0,0 +1 @@ +name="{{ field.field_name }}" {% if field.style.placeholder %}placeholder="{{ field.style.placeholder }}"{% endif %} {% if field.style.rows %}rows="{{ field.style.rows }}"{% endif %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html b/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html new file mode 100644 index 00000000..dce4a5cf --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html @@ -0,0 +1,10 @@ +
+
+
+ +
+
+
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html b/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html new file mode 100644 index 00000000..86417633 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html @@ -0,0 +1,10 @@ +
+ {% if field.label %} +
+ {{ field.label }} +
+ {% endif %} + {% for field_item in value.field_items.values() %} + {{ renderer.render_field(field_item, layout=layout) }} + {% endfor %} +
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/input.html b/rest_framework/templates/rest_framework/fields/horizontal/input.html new file mode 100644 index 00000000..310154bb --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/input.html @@ -0,0 +1,7 @@ +
+ {% include "rest_framework/fields/horizontal/label.html" %} +
+ + {% if field.help_text %}

{{ field.help_text }}

{% endif %} +
+
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/label.html b/rest_framework/templates/rest_framework/fields/horizontal/label.html new file mode 100644 index 00000000..bf21f78c --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/label.html @@ -0,0 +1 @@ +{% if field.label %}{% endif %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select.html b/rest_framework/templates/rest_framework/fields/horizontal/select.html new file mode 100644 index 00000000..3f8cab0a --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/select.html @@ -0,0 +1,10 @@ +
+ {% include "rest_framework/fields/horizontal/label.html" %} +
+ +
+
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html b/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html new file mode 100644 index 00000000..659eede8 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html @@ -0,0 +1,22 @@ +
+ {% include "rest_framework/fields/horizontal/label.html" %} +
+ {% if field.style.inline %} + {% for key, text in field.choices.items %} + + {% endfor %} + {% else %} + {% for key, text in field.choices.items %} +
+ +
+ {% endfor %} + {% endif %} +
+
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html b/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html new file mode 100644 index 00000000..da25eb2b --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html @@ -0,0 +1,10 @@ +
+ {% include "rest_framework/fields/horizontal/label.html" %} +
+ +
+
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html b/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html new file mode 100644 index 00000000..188f05e2 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html @@ -0,0 +1,22 @@ +
+ {% include "rest_framework/fields/horizontal/label.html" %} +
+ {% if field.style.inline %} + {% for key, text in field.choices.items %} + + {% endfor %} + {% else %} + {% for key, text in field.choices.items %} +
+ +
+ {% endfor %} + {% endif %} +
+
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/textarea.html b/rest_framework/templates/rest_framework/fields/horizontal/textarea.html new file mode 100644 index 00000000..e99266f3 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/textarea.html @@ -0,0 +1,7 @@ +
+ {% include "rest_framework/fields/horizontal/label.html" %} +
+ + {% if field.help_text %}

{{ field.help_text }}

{% endif %} +
+
diff --git a/rest_framework/templates/rest_framework/fields/inline/checkbox.html b/rest_framework/templates/rest_framework/fields/inline/checkbox.html new file mode 100644 index 00000000..01d30aae --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/checkbox.html @@ -0,0 +1,6 @@ +
+ +
diff --git a/rest_framework/templates/rest_framework/fields/inline/fieldset.html b/rest_framework/templates/rest_framework/fields/inline/fieldset.html new file mode 100644 index 00000000..d22982fd --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/fieldset.html @@ -0,0 +1,3 @@ +{% for field_item in value.field_items.values() %} + {{ renderer.render_field(field_item, layout=layout) }} +{% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/inline/input.html b/rest_framework/templates/rest_framework/fields/inline/input.html new file mode 100644 index 00000000..aefd1672 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/input.html @@ -0,0 +1,4 @@ +
+ {% include "rest_framework/fields/inline/label.html" %} + +
diff --git a/rest_framework/templates/rest_framework/fields/inline/label.html b/rest_framework/templates/rest_framework/fields/inline/label.html new file mode 100644 index 00000000..7d546a57 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/label.html @@ -0,0 +1 @@ +{% if field.label %}{% endif %} diff --git a/rest_framework/templates/rest_framework/fields/inline/select.html b/rest_framework/templates/rest_framework/fields/inline/select.html new file mode 100644 index 00000000..cb9a7013 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/select.html @@ -0,0 +1,8 @@ +
+ {% include "rest_framework/fields/inline/label.html" %} + +
diff --git a/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html b/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html new file mode 100644 index 00000000..424df93e --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html @@ -0,0 +1,11 @@ +
+ {% include "rest_framework/fields/inline/label.html" %} + {% for key, text in field.choices.items %} +
+ +
+ {% endfor %} +
diff --git a/rest_framework/templates/rest_framework/fields/inline/select_multiple.html b/rest_framework/templates/rest_framework/fields/inline/select_multiple.html new file mode 100644 index 00000000..6fdfd672 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/select_multiple.html @@ -0,0 +1,8 @@ +
+ {% include "rest_framework/fields/inline/label.html" %} + +
diff --git a/rest_framework/templates/rest_framework/fields/inline/select_radio.html b/rest_framework/templates/rest_framework/fields/inline/select_radio.html new file mode 100644 index 00000000..ddabc9e9 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/select_radio.html @@ -0,0 +1,11 @@ +
+ {% include "rest_framework/fields/inline/label.html" %} + {% for key, text in field.choices.items %} +
+ +
+ {% endfor %} +
diff --git a/rest_framework/templates/rest_framework/fields/inline/textarea.html b/rest_framework/templates/rest_framework/fields/inline/textarea.html new file mode 100644 index 00000000..31366809 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/inline/textarea.html @@ -0,0 +1,4 @@ +
+ {% include "rest_framework/fields/inline/label.html" %} + +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/checkbox.html b/rest_framework/templates/rest_framework/fields/vertical/checkbox.html new file mode 100644 index 00000000..01d30aae --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/checkbox.html @@ -0,0 +1,6 @@ +
+ +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/fieldset.html b/rest_framework/templates/rest_framework/fields/vertical/fieldset.html new file mode 100644 index 00000000..cad32df9 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/fieldset.html @@ -0,0 +1,6 @@ +
+ {% if field.label %}{{ field.label }}{% endif %} + {% for field_item in value.field_items.values() %} + {{ renderer.render_field(field_item, layout=layout) }} + {% endfor %} +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/input.html b/rest_framework/templates/rest_framework/fields/vertical/input.html new file mode 100644 index 00000000..c25407d1 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/input.html @@ -0,0 +1,5 @@ +
+ {% include "rest_framework/fields/vertical/label.html" %} + + {% if field.help_text %}

{{ field.help_text }}

{% endif %} +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/label.html b/rest_framework/templates/rest_framework/fields/vertical/label.html new file mode 100644 index 00000000..651939b2 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/label.html @@ -0,0 +1 @@ +{% if field.label %}{% endif %} diff --git a/rest_framework/templates/rest_framework/fields/vertical/select.html b/rest_framework/templates/rest_framework/fields/vertical/select.html new file mode 100644 index 00000000..44679d8a --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/select.html @@ -0,0 +1,8 @@ +
+ {% include "rest_framework/fields/vertical/label.html" %} + +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html b/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html new file mode 100644 index 00000000..e60574c0 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html @@ -0,0 +1,22 @@ +
+ {% include "rest_framework/fields/vertical/label.html" %} + {% if field.style.inline %} +
+ {% for key, text in field.choices.items %} + + {% endfor %} +
+ {% else %} + {% for key, text in field.choices.items %} +
+ +
+ {% endfor %} + {% endif %} +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html b/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html new file mode 100644 index 00000000..f0fa418b --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html @@ -0,0 +1,8 @@ +
+ {% include "rest_framework/fields/vertical/label.html" %} + +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_radio.html b/rest_framework/templates/rest_framework/fields/vertical/select_radio.html new file mode 100644 index 00000000..4ffe38ea --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/select_radio.html @@ -0,0 +1,22 @@ +
+ {% include "rest_framework/fields/vertical/label.html" %} + {% if field.style.inline %} +
+ {% for key, text in field.choices.items %} + + {% endfor %} +
+ {% else %} + {% for key, text in field.choices.items %} +
+ +
+ {% endfor %} + {% endif %} +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/textarea.html b/rest_framework/templates/rest_framework/fields/vertical/textarea.html new file mode 100644 index 00000000..33cb27c7 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/textarea.html @@ -0,0 +1,5 @@ +
+ {% include "rest_framework/fields/vertical/label.html" %} + + {% if field.help_text %}

{{ field.help_text }}

{% endif %} +
diff --git a/rest_framework/templates/rest_framework/form.html b/rest_framework/templates/rest_framework/form.html index b1e148df..64b1b0bc 100644 --- a/rest_framework/templates/rest_framework/form.html +++ b/rest_framework/templates/rest_framework/form.html @@ -1,15 +1,31 @@ + + + + + +
+ +

User update

+
+ {% load rest_framework %} -{% csrf_token %} -{{ form.non_field_errors }} -{% for field in form.fields.values %} - {% if not field.read_only %} -
- {{ field.label_tag|add_class:"control-label" }} -
- {{ field.widget_html }} - {% if field.help_text %}{{ field.help_text }}{% endif %} - {% for error in field.errors %}{{ error }}{% endfor %} + + {% csrf_token %} + {% for field, value, errors in form %} + {% render_field field value errors layout=layout renderer=renderer %} + {% endfor %} + + {% if layout == "horizontal" %} +
+
+ +
-
+ {% else %} + {% endif %} -{% endfor %} + + +
+
+ diff --git a/rest_framework/templatetags/rest_framework.py b/rest_framework/templatetags/rest_framework.py index 864d64dd..88ff9d4e 100644 --- a/rest_framework/templatetags/rest_framework.py +++ b/rest_framework/templatetags/rest_framework.py @@ -31,6 +31,14 @@ class_re = re.compile(r'(?<=class=["\'])(.*)(?=["\'])') # And the template tags themselves... +# @register.simple_tag +# def render_field(field, value, errors, renderer): +# return renderer.render_field(field, value, errors) +@register.simple_tag +def render_field(field, value, errors, layout=None, renderer=None): + return renderer.render_field(field, value, errors, layout) + + @register.simple_tag def optional_login(request): """ diff --git a/rest_framework/utils/field_mapping.py b/rest_framework/utils/field_mapping.py index cf9d910a..b4d33e39 100644 --- a/rest_framework/utils/field_mapping.py +++ b/rest_framework/utils/field_mapping.py @@ -79,6 +79,9 @@ def get_field_kwargs(field_name, model_field): kwargs['choices'] = model_field.flatchoices return kwargs + if isinstance(model_field, models.TextField): + kwargs['style'] = {'type': 'textarea'} + if model_field.null and not isinstance(model_field, models.NullBooleanField): kwargs['allow_null'] = True diff --git a/tests/test_model_serializer.py b/tests/test_model_serializer.py index f7475024..2edf0be5 100644 --- a/tests/test_model_serializer.py +++ b/tests/test_model_serializer.py @@ -95,7 +95,7 @@ class TestRegularFieldMappings(TestCase): positive_small_integer_field = IntegerField() slug_field = SlugField(max_length=100) small_integer_field = IntegerField() - text_field = CharField() + text_field = CharField(style={'type': 'textarea'}) time_field = TimeField() url_field = URLField(max_length=100) custom_field = ModelField(model_field=) -- cgit v1.2.3 From ffc6aa3abcb0f823b43b63db1666913565e6f934 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 1 Oct 2014 21:35:27 +0100 Subject: More forms support --- rest_framework/relations.py | 20 +++++++++++++++++ rest_framework/renderers.py | 25 ++++++++++++++++++++-- .../fields/vertical/select_multiple.html | 2 +- rest_framework/templates/rest_framework/form.html | 2 +- 4 files changed, 45 insertions(+), 4 deletions(-) diff --git a/rest_framework/relations.py b/rest_framework/relations.py index b5effc6c..8c135672 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -38,6 +38,16 @@ class RelatedField(Field): queryset = queryset.all() return queryset + @property + def choices(self): + return dict([ + ( + str(self.to_representation(item)), + str(item) + ) + for item in self.queryset.all() + ]) + class StringRelatedField(Field): """ @@ -255,3 +265,13 @@ class ManyRelation(Field): self.child_relation.to_representation(value) for value in obj.all() ] + + @property + def choices(self): + return dict([ + ( + str(self.child_relation.to_representation(item)), + str(item) + ) + for item in self.child_relation.queryset.all() + ]) diff --git a/rest_framework/renderers.py b/rest_framework/renderers.py index 6483a47c..297c60d8 100644 --- a/rest_framework/renderers.py +++ b/rest_framework/renderers.py @@ -360,22 +360,43 @@ class HTMLFormRenderer(BaseRenderer): serializers.MultipleChoiceField: { 'default': 'select_multiple.html', 'checkbox': 'select_checkbox.html' + }, + serializers.ManyRelation: { + 'default': 'select_multiple.html', + 'checkbox': 'select_checkbox.html' } }) + input_type = ClassLookupDict({ + serializers.Field: 'text', + serializers.EmailField: 'email', + serializers.URLField: 'url', + serializers.IntegerField: 'number', + serializers.DateTimeField: 'datetime-local', + serializers.DateField: 'date', + serializers.TimeField: 'time', + }) + def render_field(self, field, value, errors, layout=None): layout = layout or 'vertical' style_type = field.style.get('type', 'default') if style_type == 'textarea' and layout == 'inline': style_type = 'default' + + input_type = self.input_type[field] + if input_type == 'datetime-local': + value = value.rstrip('Z') + base = self.field_templates[field][style_type] template_name = 'rest_framework/fields/' + layout + '/' + base template = loader.get_template(template_name) context = Context({ 'field': field, 'value': value, - 'errors': errors + 'errors': errors, + 'input_type': input_type }) + return template.render(context) def render(self, data, accepted_media_type=None, renderer_context=None): @@ -388,7 +409,7 @@ class HTMLFormRenderer(BaseRenderer): template = loader.get_template(self.template) context = RequestContext(request, { 'form': data, - 'layout': getattr(getattr(data, 'Meta', None), 'layout', 'vertical'), + 'layout': getattr(getattr(data, 'Meta', None), 'layout', 'horizontal'), 'renderer': self }) return template.render(context) diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html b/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html index f0fa418b..00b25b4b 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html @@ -1,7 +1,7 @@
{% include "rest_framework/fields/vertical/label.html" %} diff --git a/rest_framework/templates/rest_framework/form.html b/rest_framework/templates/rest_framework/form.html index 64b1b0bc..658aa293 100644 --- a/rest_framework/templates/rest_framework/form.html +++ b/rest_framework/templates/rest_framework/form.html @@ -9,7 +9,7 @@
{% load rest_framework %} -
+ {% csrf_token %} {% for field, value, errors in form %} {% render_field field value errors layout=layout renderer=renderer %} -- cgit v1.2.3 From 79e91dff92443ab1f301638ac280bd3231a2ca15 Mon Sep 17 00:00:00 2001 From: Omer Katz Date: Thu, 2 Oct 2014 16:44:20 +0300 Subject: The encoder now returns tuples instead of lists. Tuples take a little less memory which is significant when serializing a lot of objects. --- rest_framework/utils/encoders.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rest_framework/utils/encoders.py b/rest_framework/utils/encoders.py index 7c4179a1..486186c9 100644 --- a/rest_framework/utils/encoders.py +++ b/rest_framework/utils/encoders.py @@ -45,7 +45,7 @@ class JSONEncoder(json.JSONEncoder): # Serializers will coerce decimals to strings by default. return float(obj) elif isinstance(obj, QuerySet): - return list(obj) + return tuple(obj) elif hasattr(obj, 'tolist'): # Numpy arrays and array scalars. return obj.tolist() @@ -55,7 +55,7 @@ class JSONEncoder(json.JSONEncoder): except: pass elif hasattr(obj, '__iter__'): - return [item for item in obj] + return tuple(item for item in obj) return super(JSONEncoder, self).default(obj) -- cgit v1.2.3 From df7b6fcf58417fd95e49655eb140b387899b1ceb Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 2 Oct 2014 16:24:24 +0100 Subject: First pass on incorperating the form rendering into the browsable API --- rest_framework/fields.py | 8 +- rest_framework/relations.py | 4 +- rest_framework/renderers.py | 62 +++++----- rest_framework/serializers.py | 129 +++++++++++++++------ .../static/rest_framework/css/bootstrap-tweaks.css | 18 ++- rest_framework/templates/rest_framework/base.html | 56 ++++----- .../rest_framework/fields/horizontal/checkbox.html | 2 +- .../rest_framework/fields/horizontal/fieldset.html | 2 +- .../rest_framework/fields/horizontal/input.html | 2 +- .../rest_framework/fields/horizontal/select.html | 2 +- .../fields/horizontal/select_checkbox.html | 4 +- .../fields/horizontal/select_multiple.html | 2 +- .../fields/horizontal/select_radio.html | 4 +- .../rest_framework/fields/horizontal/textarea.html | 2 +- .../rest_framework/fields/inline/checkbox.html | 2 +- .../rest_framework/fields/inline/fieldset.html | 2 +- .../rest_framework/fields/inline/input.html | 2 +- .../rest_framework/fields/inline/select.html | 2 +- .../fields/inline/select_checkbox.html | 2 +- .../fields/inline/select_multiple.html | 2 +- .../rest_framework/fields/inline/select_radio.html | 2 +- .../rest_framework/fields/inline/textarea.html | 2 +- .../rest_framework/fields/vertical/fieldset.html | 2 +- .../rest_framework/fields/vertical/input.html | 2 +- .../rest_framework/fields/vertical/select.html | 2 +- .../fields/vertical/select_checkbox.html | 4 +- .../fields/vertical/select_multiple.html | 2 +- .../fields/vertical/select_radio.html | 4 +- .../rest_framework/fields/vertical/textarea.html | 2 +- rest_framework/templates/rest_framework/form.html | 14 ++- rest_framework/templatetags/rest_framework.py | 7 +- rest_framework/utils/field_mapping.py | 9 +- 32 files changed, 217 insertions(+), 144 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index f3ff2233..c794963e 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -689,10 +689,10 @@ class DateTimeField(Field): return value if self.format.lower() == ISO_8601: - ret = value.isoformat() - if ret.endswith('+00:00'): - ret = ret[:-6] + 'Z' - return ret + value = value.isoformat() + if value.endswith('+00:00'): + value = value[:-6] + 'Z' + return value return value.strftime(self.format) diff --git a/rest_framework/relations.py b/rest_framework/relations.py index 8c135672..988b9ede 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -127,7 +127,7 @@ class HyperlinkedRelatedField(RelatedField): attributes are not configured to correctly match the URL conf. """ # Unsaved objects will not yet have a valid URL. - if obj.pk is None: + if obj.pk: return None lookup_value = getattr(obj, self.lookup_field) @@ -248,11 +248,13 @@ class ManyRelation(Field): You shouldn't need to be using this class directly yourself. """ + initial = [] def __init__(self, child_relation=None, *args, **kwargs): self.child_relation = child_relation assert child_relation is not None, '`child_relation` is a required argument.' super(ManyRelation, self).__init__(*args, **kwargs) + self.child_relation.bind(field_name='', parent=self) def to_internal_value(self, data): return [ diff --git a/rest_framework/renderers.py b/rest_framework/renderers.py index 297c60d8..931dd434 100644 --- a/rest_framework/renderers.py +++ b/rest_framework/renderers.py @@ -377,23 +377,21 @@ class HTMLFormRenderer(BaseRenderer): serializers.TimeField: 'time', }) - def render_field(self, field, value, errors, layout=None): + def render_field(self, field, layout=None): layout = layout or 'vertical' style_type = field.style.get('type', 'default') if style_type == 'textarea' and layout == 'inline': style_type = 'default' input_type = self.input_type[field] - if input_type == 'datetime-local': - value = value.rstrip('Z') + if input_type == 'datetime-local' and isinstance(field.value, six.text_type): + field.value = field.value.rstrip('Z') base = self.field_templates[field][style_type] template_name = 'rest_framework/fields/' + layout + '/' + base template = loader.get_template(template_name) context = Context({ 'field': field, - 'value': value, - 'errors': errors, 'input_type': input_type }) @@ -408,7 +406,7 @@ class HTMLFormRenderer(BaseRenderer): template = loader.get_template(self.template) context = RequestContext(request, { - 'form': data, + 'form': data.serializer, 'layout': getattr(getattr(data, 'Meta', None), 'layout', 'horizontal'), 'renderer': self }) @@ -479,27 +477,29 @@ class BrowsableAPIRenderer(BaseRenderer): return False # Doesn't have permissions return True - def get_rendered_html_form(self, view, method, request): + def get_rendered_html_form(self, data, view, method, request): """ Return a string representing a rendered HTML form, possibly bound to either the input or output data. In the absence of the View having an associated form then return None. """ + serializer = getattr(data, 'serializer', None) + if serializer and not getattr(serializer, 'many', False): + instance = getattr(serializer, 'instance', None) + else: + instance = None + if request.method == method: try: data = request.data - # files = request.FILES except ParseError: data = None - # files = None else: data = None - # files = None with override_method(view, request, method) as request: - obj = getattr(view, 'object', None) - if not self.show_form_for_method(view, method, request, obj): + if not self.show_form_for_method(view, method, request, instance): return if method in ('DELETE', 'OPTIONS'): @@ -511,19 +511,24 @@ class BrowsableAPIRenderer(BaseRenderer): ): return - serializer = view.get_serializer(instance=obj, data=data) - serializer.is_valid() - data = serializer.data - + serializer = view.get_serializer(instance=instance, data=data) + if data is not None: + serializer.is_valid() form_renderer = self.form_renderer_class() - return form_renderer.render(data, self.accepted_media_type, self.renderer_context) + return form_renderer.render(serializer.data, self.accepted_media_type, self.renderer_context) - def get_raw_data_form(self, view, method, request): + def get_raw_data_form(self, data, view, method, request): """ Returns a form that allows for arbitrary content types to be tunneled via standard HTML forms. (Which are typically application/x-www-form-urlencoded) """ + serializer = getattr(data, 'serializer', None) + if serializer and not getattr(serializer, 'many', False): + instance = getattr(serializer, 'instance', None) + else: + instance = None + with override_method(view, request, method) as request: # If we're not using content overloading there's no point in # supplying a generic form, as the view won't treat the form's @@ -533,8 +538,7 @@ class BrowsableAPIRenderer(BaseRenderer): return None # Check permissions - obj = getattr(view, 'object', None) - if not self.show_form_for_method(view, method, request, obj): + if not self.show_form_for_method(view, method, request, instance): return # If possible, serialize the initial content for the generic form @@ -545,8 +549,8 @@ class BrowsableAPIRenderer(BaseRenderer): # corresponding renderer that can be used to render the data. # Get a read-only version of the serializer - serializer = view.get_serializer(instance=obj) - if obj is None: + serializer = view.get_serializer(instance=instance) + if instance is None: for name, field in serializer.fields.items(): if getattr(field, 'read_only', None): del serializer.fields[name] @@ -606,9 +610,9 @@ class BrowsableAPIRenderer(BaseRenderer): renderer = self.get_default_renderer(view) - raw_data_post_form = self.get_raw_data_form(view, 'POST', request) - raw_data_put_form = self.get_raw_data_form(view, 'PUT', request) - raw_data_patch_form = self.get_raw_data_form(view, 'PATCH', request) + raw_data_post_form = self.get_raw_data_form(data, view, 'POST', request) + raw_data_put_form = self.get_raw_data_form(data, view, 'PUT', request) + raw_data_patch_form = self.get_raw_data_form(data, view, 'PATCH', request) raw_data_put_or_patch_form = raw_data_put_form or raw_data_patch_form response_headers = dict(response.items()) @@ -632,10 +636,10 @@ class BrowsableAPIRenderer(BaseRenderer): 'available_formats': [renderer_cls.format for renderer_cls in view.renderer_classes], 'response_headers': response_headers, - # 'put_form': self.get_rendered_html_form(view, 'PUT', request), - # 'post_form': self.get_rendered_html_form(view, 'POST', request), - # 'delete_form': self.get_rendered_html_form(view, 'DELETE', request), - # 'options_form': self.get_rendered_html_form(view, 'OPTIONS', request), + 'put_form': self.get_rendered_html_form(data, view, 'PUT', request), + 'post_form': self.get_rendered_html_form(data, view, 'POST', request), + 'delete_form': self.get_rendered_html_form(data, view, 'DELETE', request), + 'options_form': self.get_rendered_html_form(data, view, 'OPTIONS', request), 'raw_data_put_form': raw_data_put_form, 'raw_data_post_form': raw_data_post_form, diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 5da81247..0f24ed40 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -14,7 +14,6 @@ from django.core.exceptions import ImproperlyConfigured, ValidationError from django.db import models from django.utils import six from django.utils.datastructures import SortedDict -from collections import namedtuple from rest_framework.fields import empty, set_value, Field, SkipField from rest_framework.settings import api_settings from rest_framework.utils import html, model_meta, representation @@ -38,8 +37,8 @@ from rest_framework.relations import * # NOQA from rest_framework.fields import * # NOQA -FieldResult = namedtuple('FieldResult', ['field', 'value', 'error']) - +# BaseSerializer +# -------------- class BaseSerializer(Field): """ @@ -113,11 +112,6 @@ class BaseSerializer(Field): if not hasattr(self, '_data'): if self.instance is not None: self._data = self.to_representation(self.instance) - elif self._initial_data is not None: - self._data = dict([ - (field_name, field.get_value(self._initial_data)) - for field_name, field in self.fields.items() - ]) else: self._data = self.get_initial() return self._data @@ -137,34 +131,48 @@ class BaseSerializer(Field): return self._validated_data -class SerializerMetaclass(type): +# Serializer & ListSerializer classes +# ----------------------------------- + +class ReturnDict(SortedDict): """ - This metaclass sets a dictionary named `base_fields` on the class. + Return object from `serialier.data` for the `Serializer` class. + Includes a backlink to the serializer instance for renderers + to use if they need richer field information. + """ + def __init__(self, *args, **kwargs): + self.serializer = kwargs.pop('serializer') + super(ReturnDict, self).__init__(*args, **kwargs) - Any instances of `Field` included as attributes on either the class - or on any of its superclasses will be include in the - `base_fields` dictionary. + +class ReturnList(list): + """ + Return object from `serialier.data` for the `SerializerList` class. + Includes a backlink to the serializer instance for renderers + to use if they need richer field information. """ + def __init__(self, *args, **kwargs): + self.serializer = kwargs.pop('serializer') + super(ReturnList, self).__init__(*args, **kwargs) - @classmethod - def _get_declared_fields(cls, bases, attrs): - fields = [(field_name, attrs.pop(field_name)) - for field_name, obj in list(attrs.items()) - if isinstance(obj, Field)] - fields.sort(key=lambda x: x[1]._creation_counter) - # If this class is subclassing another Serializer, add that Serializer's - # fields. Note that we loop over the bases in *reverse*. This is necessary - # in order to maintain the correct order of fields. - for base in bases[::-1]: - if hasattr(base, '_declared_fields'): - fields = list(base._declared_fields.items()) + fields +class BoundField(object): + """ + A field object that also includes `.value` and `.error` properties. + Returned when iterating over a serializer instance, + providing an API similar to Django forms and form fields. + """ + def __init__(self, field, value, errors): + self._field = field + self.value = value + self.errors = errors - return SortedDict(fields) + def __getattr__(self, attr_name): + return getattr(self._field, attr_name) - def __new__(cls, name, bases, attrs): - attrs['_declared_fields'] = cls._get_declared_fields(bases, attrs) - return super(SerializerMetaclass, cls).__new__(cls, name, bases, attrs) + @property + def _proxy_class(self): + return self._field.__class__ class BindingDict(object): @@ -196,6 +204,36 @@ class BindingDict(object): return self.fields.values() +class SerializerMetaclass(type): + """ + This metaclass sets a dictionary named `base_fields` on the class. + + Any instances of `Field` included as attributes on either the class + or on any of its superclasses will be include in the + `base_fields` dictionary. + """ + + @classmethod + def _get_declared_fields(cls, bases, attrs): + fields = [(field_name, attrs.pop(field_name)) + for field_name, obj in list(attrs.items()) + if isinstance(obj, Field)] + fields.sort(key=lambda x: x[1]._creation_counter) + + # If this class is subclassing another Serializer, add that Serializer's + # fields. Note that we loop over the bases in *reverse*. This is necessary + # in order to maintain the correct order of fields. + for base in bases[::-1]: + if hasattr(base, '_declared_fields'): + fields = list(base._declared_fields.items()) + fields + + return SortedDict(fields) + + def __new__(cls, name, bases, attrs): + attrs['_declared_fields'] = cls._get_declared_fields(bases, attrs) + return super(SerializerMetaclass, cls).__new__(cls, name, bases, attrs) + + @six.add_metaclass(SerializerMetaclass) class Serializer(BaseSerializer): def __init__(self, *args, **kwargs): @@ -212,10 +250,18 @@ class Serializer(BaseSerializer): return copy.deepcopy(self._declared_fields) def get_initial(self): - return dict([ + if self._initial_data is not None: + return ReturnDict([ + (field_name, field.get_value(self._initial_data)) + for field_name, field in self.fields.items() + ], serializer=self) + #return self.to_representation(self._initial_data) + + return ReturnDict([ (field.field_name, field.get_initial()) for field in self.fields.values() - ]) + if not field.write_only + ], serializer=self) def get_value(self, dictionary): # We override the default field access in order to support @@ -288,7 +334,7 @@ class Serializer(BaseSerializer): """ Object instance -> Dict of primitive datatypes. """ - ret = SortedDict() + ret = ReturnDict(serializer=self) fields = [field for field in self.fields.values() if not field.write_only] for field in fields: @@ -302,11 +348,9 @@ class Serializer(BaseSerializer): def __iter__(self): errors = self.errors if hasattr(self, '_errors') else {} for field in self.fields.values(): - if field.read_only: - continue value = self.data.get(field.field_name) if self.data else None error = errors.get(field.field_name) - yield FieldResult(field, value, error) + yield BoundField(field, value, error) def __repr__(self): return representation.serializer_repr(self, indent=1) @@ -317,7 +361,7 @@ class Serializer(BaseSerializer): class ListSerializer(BaseSerializer): child = None - initial = [] + many = True def __init__(self, *args, **kwargs): self.child = kwargs.pop('child', copy.deepcopy(self.child)) @@ -326,6 +370,11 @@ class ListSerializer(BaseSerializer): super(ListSerializer, self).__init__(*args, **kwargs) self.child.bind(field_name='', parent=self) + def get_initial(self): + if self._initial_data is not None: + return self.to_representation(self._initial_data) + return ReturnList(serializer=self) + def get_value(self, dictionary): # We override the default field access in order to support # lists in HTML forms. @@ -345,7 +394,10 @@ class ListSerializer(BaseSerializer): """ List of object instances -> List of dicts of primitive datatypes. """ - return [self.child.to_representation(item) for item in data] + return ReturnList( + [self.child.to_representation(item) for item in data], + serializer=self + ) def create(self, attrs_list): return [self.child.create(attrs) for attrs in attrs_list] @@ -354,6 +406,9 @@ class ListSerializer(BaseSerializer): return representation.list_repr(self, indent=1) +# ModelSerializer & HyperlinkedModelSerializer +# -------------------------------------------- + class ModelSerializer(Serializer): _field_mapping = ClassLookupDict({ models.AutoField: IntegerField, diff --git a/rest_framework/static/rest_framework/css/bootstrap-tweaks.css b/rest_framework/static/rest_framework/css/bootstrap-tweaks.css index 6fa1e6cb..84389b1d 100644 --- a/rest_framework/static/rest_framework/css/bootstrap-tweaks.css +++ b/rest_framework/static/rest_framework/css/bootstrap-tweaks.css @@ -10,6 +10,12 @@ a single block in the template. background: transparent; border-top-color: transparent; padding-top: 0; + text-align: right; +} + +#generic-content-form textarea { + font-family:Consolas,Monaco,Lucida Console,Liberation Mono,DejaVu Sans Mono,Bitstream Vera Sans Mono,Courier New, monospace; + font-size: 80%; } .navbar-inverse .brand a { @@ -29,7 +35,7 @@ a single block in the template. z-index: 3; } -.navbar .navbar-inner { +.navbar { background: #2C2C2C; color: white; border: none; @@ -37,7 +43,7 @@ a single block in the template. border-radius: 0px; } -.navbar .navbar-inner .nav li, .navbar .navbar-inner .nav li a, .navbar .navbar-inner .brand:hover { +.navbar .nav li, .navbar .nav li a, .navbar .brand:hover { color: white; } @@ -45,11 +51,11 @@ a single block in the template. background: #2C2C2C; } -.navbar .navbar-inner .dropdown-menu li a, .navbar .navbar-inner .dropdown-menu li { +.navbar .dropdown-menu li a, .navbar .dropdown-menu li { color: #A30000; } -.navbar .navbar-inner .dropdown-menu li a:hover { +.navbar .dropdown-menu li a:hover { background: #EEEEEE; color: #C20000; } @@ -61,10 +67,10 @@ html { background: none; } -body, .navbar .navbar-inner .container-fluid { +/*body, .navbar .container-fluid { max-width: 1150px; margin: 0 auto; -} +}*/ body { background: url("../img/grid.png") repeat-x; diff --git a/rest_framework/templates/rest_framework/base.html b/rest_framework/templates/rest_framework/base.html index a84ccf26..2e03dd98 100644 --- a/rest_framework/templates/rest_framework/base.html +++ b/rest_framework/templates/rest_framework/base.html @@ -15,7 +15,8 @@ {% block style %} {% block bootstrap_theme %} - + + {% endblock %} @@ -26,44 +27,42 @@ {% block body %} - +
{% block navbar %} -
-
-
- - {% block branding %} - - Django REST framework {{ version }} - - {% endblock %} - -
    - {% block userlinks %} - {% if user.is_authenticated %} - {% optional_logout request user %} - {% else %} - {% optional_login request %} - {% endif %} - {% endblock %} -
-
+
+
+ + {% block branding %} + + Django REST framework {{ version }} + + {% endblock %} + +
    + {% block userlinks %} + {% if user.is_authenticated %} + {% optional_logout request user %} + {% else %} + {% optional_login request %} + {% endif %} + {% endblock %} +
{% endblock %} +
{% block breadcrumbs %}
    {% for breadcrumb_name, breadcrumb_url in breadcrumblist %} -
  • - - {{ breadcrumb_name }} - - {% if not forloop.last %}›{% endif %} -
    • + {% if forloop.last %} +
  • {{ breadcrumb_name }}
    • + {% else %} +
  • {{ breadcrumb_name }}
    • + {% endif %} {% endfor %}
{% endblock %} @@ -238,6 +237,7 @@ {% endif %}
+
{% block footer %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html b/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html index dce4a5cf..dd3c3cef 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html @@ -2,7 +2,7 @@
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html b/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html index 86417633..843a56b2 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html @@ -4,7 +4,7 @@ {{ field.label }}
{% endif %} - {% for field_item in value.field_items.values() %} + {% for field_item in field.value.field_items.values() %} {{ renderer.render_field(field_item, layout=layout) }} {% endfor %}
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/input.html b/rest_framework/templates/rest_framework/fields/horizontal/input.html index 310154bb..6f1a504b 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/input.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/input.html @@ -1,7 +1,7 @@
{% include "rest_framework/fields/horizontal/label.html" %}
- + {% if field.help_text %}

{{ field.help_text }}

{% endif %}
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select.html b/rest_framework/templates/rest_framework/fields/horizontal/select.html index 3f8cab0a..7367d726 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select.html @@ -3,7 +3,7 @@
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html b/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html index 659eede8..381cda2c 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html @@ -4,7 +4,7 @@ {% if field.style.inline %} {% for key, text in field.choices.items %} {% endfor %} @@ -12,7 +12,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html b/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html index da25eb2b..29ba8661 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html @@ -3,7 +3,7 @@
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html b/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html index 188f05e2..20aab8b2 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html @@ -4,7 +4,7 @@ {% if field.style.inline %} {% for key, text in field.choices.items %} {% endfor %} @@ -12,7 +12,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/textarea.html b/rest_framework/templates/rest_framework/fields/horizontal/textarea.html index e99266f3..3d016195 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/textarea.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/textarea.html @@ -1,7 +1,7 @@
{% include "rest_framework/fields/horizontal/label.html" %}
- + {% if field.help_text %}

{{ field.help_text }}

{% endif %}
diff --git a/rest_framework/templates/rest_framework/fields/inline/checkbox.html b/rest_framework/templates/rest_framework/fields/inline/checkbox.html index 01d30aae..289bbb4d 100644 --- a/rest_framework/templates/rest_framework/fields/inline/checkbox.html +++ b/rest_framework/templates/rest_framework/fields/inline/checkbox.html @@ -1,6 +1,6 @@
diff --git a/rest_framework/templates/rest_framework/fields/inline/fieldset.html b/rest_framework/templates/rest_framework/fields/inline/fieldset.html index d22982fd..380d4627 100644 --- a/rest_framework/templates/rest_framework/fields/inline/fieldset.html +++ b/rest_framework/templates/rest_framework/fields/inline/fieldset.html @@ -1,3 +1,3 @@ -{% for field_item in value.field_items.values() %} +{% for field_item in field.value.field_items.values() %} {{ renderer.render_field(field_item, layout=layout) }} {% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/inline/input.html b/rest_framework/templates/rest_framework/fields/inline/input.html index aefd1672..e4a92ccd 100644 --- a/rest_framework/templates/rest_framework/fields/inline/input.html +++ b/rest_framework/templates/rest_framework/fields/inline/input.html @@ -1,4 +1,4 @@
{% include "rest_framework/fields/inline/label.html" %} - +
diff --git a/rest_framework/templates/rest_framework/fields/inline/select.html b/rest_framework/templates/rest_framework/fields/inline/select.html index cb9a7013..9f361c4a 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select.html +++ b/rest_framework/templates/rest_framework/fields/inline/select.html @@ -2,7 +2,7 @@ {% include "rest_framework/fields/inline/label.html" %}
diff --git a/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html b/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html index 424df93e..0f33fb69 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html +++ b/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html @@ -3,7 +3,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/inline/select_multiple.html b/rest_framework/templates/rest_framework/fields/inline/select_multiple.html index 6fdfd672..7c9e5168 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select_multiple.html +++ b/rest_framework/templates/rest_framework/fields/inline/select_multiple.html @@ -2,7 +2,7 @@ {% include "rest_framework/fields/inline/label.html" %}
diff --git a/rest_framework/templates/rest_framework/fields/inline/select_radio.html b/rest_framework/templates/rest_framework/fields/inline/select_radio.html index ddabc9e9..177c0eeb 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select_radio.html +++ b/rest_framework/templates/rest_framework/fields/inline/select_radio.html @@ -3,7 +3,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/inline/textarea.html b/rest_framework/templates/rest_framework/fields/inline/textarea.html index 31366809..8259487b 100644 --- a/rest_framework/templates/rest_framework/fields/inline/textarea.html +++ b/rest_framework/templates/rest_framework/fields/inline/textarea.html @@ -1,4 +1,4 @@
{% include "rest_framework/fields/inline/label.html" %} - +
diff --git a/rest_framework/templates/rest_framework/fields/vertical/fieldset.html b/rest_framework/templates/rest_framework/fields/vertical/fieldset.html index cad32df9..8708916b 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/fieldset.html +++ b/rest_framework/templates/rest_framework/fields/vertical/fieldset.html @@ -1,6 +1,6 @@
{% if field.label %}{{ field.label }}{% endif %} - {% for field_item in value.field_items.values() %} + {% for field_item in field.value.field_items.values() %} {{ renderer.render_field(field_item, layout=layout) }} {% endfor %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/input.html b/rest_framework/templates/rest_framework/fields/vertical/input.html index c25407d1..3ee2716a 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/input.html +++ b/rest_framework/templates/rest_framework/fields/vertical/input.html @@ -1,5 +1,5 @@
{% include "rest_framework/fields/vertical/label.html" %} - + {% if field.help_text %}

{{ field.help_text }}

{% endif %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select.html b/rest_framework/templates/rest_framework/fields/vertical/select.html index 44679d8a..dcc9a3cd 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select.html @@ -2,7 +2,7 @@ {% include "rest_framework/fields/vertical/label.html" %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html b/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html index e60574c0..1fbe6a94 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html @@ -4,7 +4,7 @@
{% for key, text in field.choices.items %} {% endfor %} @@ -13,7 +13,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html b/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html index 00b25b4b..2cc40d99 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html @@ -2,7 +2,7 @@ {% include "rest_framework/fields/vertical/label.html" %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_radio.html b/rest_framework/templates/rest_framework/fields/vertical/select_radio.html index 4ffe38ea..470bcb0b 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select_radio.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select_radio.html @@ -4,7 +4,7 @@
{% for key, text in field.choices.items %} {% endfor %} @@ -13,7 +13,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/textarea.html b/rest_framework/templates/rest_framework/fields/vertical/textarea.html index 33cb27c7..406cfa77 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/textarea.html +++ b/rest_framework/templates/rest_framework/fields/vertical/textarea.html @@ -1,5 +1,5 @@
{% include "rest_framework/fields/vertical/label.html" %} - + {% if field.help_text %}

{{ field.help_text }}

{% endif %}
diff --git a/rest_framework/templates/rest_framework/form.html b/rest_framework/templates/rest_framework/form.html index 658aa293..162c5633 100644 --- a/rest_framework/templates/rest_framework/form.html +++ b/rest_framework/templates/rest_framework/form.html @@ -1,4 +1,4 @@ - + {% load rest_framework %} {% csrf_token %} - {% for field, value, errors in form %} - {% render_field field value errors layout=layout renderer=renderer %} + {% for field in form %} + {% if not field.read_only %} + {% render_field field layout=layout renderer=renderer %} + {% endif %} {% endfor %} {% if layout == "horizontal" %} @@ -25,7 +27,7 @@ {% endif %} - + diff --git a/rest_framework/templatetags/rest_framework.py b/rest_framework/templatetags/rest_framework.py index 88ff9d4e..49a4c338 100644 --- a/rest_framework/templatetags/rest_framework.py +++ b/rest_framework/templatetags/rest_framework.py @@ -31,12 +31,9 @@ class_re = re.compile(r'(?<=class=["\'])(.*)(?=["\'])') # And the template tags themselves... -# @register.simple_tag -# def render_field(field, value, errors, renderer): -# return renderer.render_field(field, value, errors) @register.simple_tag -def render_field(field, value, errors, layout=None, renderer=None): - return renderer.render_field(field, value, errors, layout) +def render_field(field, layout=None, renderer=None): + return renderer.render_field(field, layout) @register.simple_tag diff --git a/rest_framework/utils/field_mapping.py b/rest_framework/utils/field_mapping.py index b4d33e39..30fae370 100644 --- a/rest_framework/utils/field_mapping.py +++ b/rest_framework/utils/field_mapping.py @@ -21,7 +21,14 @@ class ClassLookupDict(object): self.mapping = mapping def __getitem__(self, key): - for cls in inspect.getmro(key.__class__): + if hasattr(key, '_proxy_class'): + # Deal with proxy classes. Ie. BoundField behaves as if it + # is a Field instance when using ClassLookupDict. + base_class = key._proxy_class + else: + base_class = key.__class__ + + for cls in inspect.getmro(base_class): if cls in self.mapping: return self.mapping[cls] raise KeyError('Class %s not found in lookup.', cls.__name__) -- cgit v1.2.3 From fec7c4b45812d22423e73ec3ab801857a55d7340 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 2 Oct 2014 18:13:15 +0100 Subject: Browsable API tweaks --- rest_framework/fields.py | 5 ++--- rest_framework/relations.py | 1 + rest_framework/serializers.py | 1 + rest_framework/static/rest_framework/css/bootstrap-tweaks.css | 2 +- rest_framework/static/rest_framework/css/default.css | 3 +-- 5 files changed, 6 insertions(+), 6 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index c794963e..3f22660c 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -106,7 +106,7 @@ class Field(object): 'null': _('This field may not be null.') } default_validators = [] - default_empty_html = None + default_empty_html = empty initial = None def __init__(self, read_only=False, write_only=False, @@ -375,7 +375,6 @@ class NullBooleanField(Field): default_error_messages = { 'invalid': _('`{input}` is not a valid boolean.') } - default_empty_html = None initial = None TRUE_VALUES = set(('t', 'T', 'true', 'True', 'TRUE', '1', 1, True)) FALSE_VALUES = set(('f', 'F', 'false', 'False', 'FALSE', '0', 0, 0.0, False)) @@ -411,7 +410,6 @@ class CharField(Field): default_error_messages = { 'blank': _('This field may not be blank.') } - default_empty_html = '' initial = '' def __init__(self, **kwargs): @@ -852,6 +850,7 @@ class MultipleChoiceField(ChoiceField): 'invalid_choice': _('`{input}` is not a valid choice.'), 'not_a_list': _('Expected a list of items but got type `{input_type}`') } + default_empty_html = [] def to_internal_value(self, data): if isinstance(data, type('')) or not hasattr(data, '__iter__'): diff --git a/rest_framework/relations.py b/rest_framework/relations.py index 988b9ede..4f971917 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -249,6 +249,7 @@ class ManyRelation(Field): You shouldn't need to be using this class directly yourself. """ initial = [] + default_empty_html = [] def __init__(self, child_relation=None, *args, **kwargs): self.child_relation = child_relation diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 0f24ed40..21cb7ea2 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -254,6 +254,7 @@ class Serializer(BaseSerializer): return ReturnDict([ (field_name, field.get_value(self._initial_data)) for field_name, field in self.fields.items() + if field.get_value(self._initial_data) is not empty ], serializer=self) #return self.to_representation(self._initial_data) diff --git a/rest_framework/static/rest_framework/css/bootstrap-tweaks.css b/rest_framework/static/rest_framework/css/bootstrap-tweaks.css index 84389b1d..6a37cae2 100644 --- a/rest_framework/static/rest_framework/css/bootstrap-tweaks.css +++ b/rest_framework/static/rest_framework/css/bootstrap-tweaks.css @@ -173,7 +173,7 @@ footer a:hover { .page-header { border-bottom: none; padding-bottom: 0px; - margin-bottom: 20px; + margin: 0; } /* custom general page styles */ diff --git a/rest_framework/static/rest_framework/css/default.css b/rest_framework/static/rest_framework/css/default.css index 461cdfe5..82c6033b 100644 --- a/rest_framework/static/rest_framework/css/default.css +++ b/rest_framework/static/rest_framework/css/default.css @@ -33,7 +33,7 @@ h2, h3 { } ul.breadcrumb { - margin: 80px 0 0 0; + margin: 70px 0 0 0; } form select, form input, form textarea { @@ -67,5 +67,4 @@ pre { .page-header { border-bottom: none; padding-bottom: 0px; - margin-bottom: 20px; } -- cgit v1.2.3 From dfab9af294972720f59890967cd9ae1a6c0796b6 Mon Sep 17 00:00:00 2001 From: Craig de Stigter Date: Fri, 3 Oct 2014 08:41:18 +1300 Subject: Minor: fix spelling and grammar, mostly in 3.0 announcement --- CONTRIBUTING.md | 2 +- docs/api-guide/fields.md | 2 +- docs/api-guide/renderers.md | 2 +- docs/topics/2.4-announcement.md | 2 +- docs/topics/3.0-announcement.md | 42 +++++++++++++++--------------- docs/topics/contributing.md | 2 +- docs/topics/release-notes.md | 2 +- docs/topics/writable-nested-serializers.md | 2 +- rest_framework/compat.py | 2 +- rest_framework/fields.py | 12 ++++----- rest_framework/relations.py | 2 +- rest_framework/validators.py | 2 +- rest_framework/views.py | 2 +- tests/test_model_serializer.py | 4 +-- tests/test_relations.py | 12 ++++----- 15 files changed, 46 insertions(+), 46 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index a6dd05a0..1b199534 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -75,7 +75,7 @@ You can also use the excellent [`tox`][tox] testing tool to run the tests agains It's a good idea to make pull requests early on. A pull request represents the start of a discussion, and doesn't necessarily need to be the final, finished submission. -It's also always best to make a new branch before starting work on a pull request. This means that you'll be able to later switch back to working on another seperate issue without interfering with an ongoing pull requests. +It's also always best to make a new branch before starting work on a pull request. This means that you'll be able to later switch back to working on another separate issue without interfering with an ongoing pull requests. It's also useful to remember that if you have an outstanding pull request then pushing new commits to your GitHub repo will also automatically update the pull requests. diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md index f0778318..292a51d8 100644 --- a/docs/api-guide/fields.md +++ b/docs/api-guide/fields.md @@ -286,7 +286,7 @@ For example, to validate numbers up to 999 with a resolution of 2 decimal places serializers.DecimalField(max_digits=5, decimal_places=2) -And to validate numbers up to anything lesss than one billion with a resolution of 10 decimal places: +And to validate numbers up to anything less than one billion with a resolution of 10 decimal places: serializers.DecimalField(max_digits=19, decimal_places=10) diff --git a/docs/api-guide/renderers.md b/docs/api-guide/renderers.md index 2e1c892f..db7436c2 100644 --- a/docs/api-guide/renderers.md +++ b/docs/api-guide/renderers.md @@ -74,7 +74,7 @@ If your API includes views that can serve both regular webpages and API response Renders the request data into `JSON`, using utf-8 encoding. -Note that the default style is to include unicode characters, and render the response using a compact style with no uneccessary whitespace: +Note that the default style is to include unicode characters, and render the response using a compact style with no unnecessary whitespace: {"unicode black star":"★","value":999} diff --git a/docs/topics/2.4-announcement.md b/docs/topics/2.4-announcement.md index 09294b91..d8aa5b10 100644 --- a/docs/topics/2.4-announcement.md +++ b/docs/topics/2.4-announcement.md @@ -23,7 +23,7 @@ The documentation has previously stated that usage of the more explicit style is Doing so will mean that there are cases of API code where you'll now need to include a serializer class where you previously were just using the `.model` shortcut. However we firmly believe that it is the right trade-off to make. -Removing the shortcut takes away an unneccessary layer of abstraction, and makes your codebase more explicit without any significant extra complexity. It also results in better consistency, as there's now only one way to set the serializer class and queryset attributes for the view, instead of two. +Removing the shortcut takes away an unnecessary layer of abstraction, and makes your codebase more explicit without any significant extra complexity. It also results in better consistency, as there's now only one way to set the serializer class and queryset attributes for the view, instead of two. The `DEFAULT_MODEL_SERIALIZER_CLASS` API setting is now also deprecated. diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index d2505a1b..5242be57 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -6,10 +6,10 @@ The 3.0 release is now ready for some tentative testing and upgrades for super k See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-framework/pull/1800) for more details on remaining work. -The most notable outstanding issues still to resolved on the `version-3.0` branch are as follows: +The most notable outstanding issues still to be resolved on the `version-3.0` branch are as follows: * Forms support for serializers and in the browsable API. -* Optimisations for serialializing primary keys. +* Optimisations for serializing primary keys. * Refine style of validation errors in some cases, such as validation errors in `ListField`. * `.transform_()` method on serializers. @@ -50,13 +50,13 @@ Below is an in-depth guide to the API changes and migration notes for 3.0. The usage of `request.DATA` and `request.FILES` is now discouraged in favor of a single `request.data` attribute that contains *all* the parsed data. -Having seperate attributes is reasonable for web applications that only ever parse URL encoded or MultiPart requests, but makes less sense for the general-purpose request parsing that REST framework supports. +Having separate attributes is reasonable for web applications that only ever parse URL encoded or MultiPart requests, but makes less sense for the general-purpose request parsing that REST framework supports. You may now pass all the request data to a serializer class in a single argument: ExampleSerializer(data=request.data) -Instead of passing the files argument seperately: +Instead of passing the files argument separately: # Don't do this... ExampleSerializer(data=request.DATA, files=request.FILES) @@ -75,7 +75,7 @@ Previously the serializers used a two-step object creation, as follows: This style is in line with how the `ModelForm` class works in Django, but is problematic for a number of reasons: -* Some data, such as many-to-many relationships, cannot be added to the object instance until after it has been saved. This type of data needed to be hidden in some undocumentated state on the object instance, or kept as state on the serializer instance so that it could be used when `.save()` is called. +* Some data, such as many-to-many relationships, cannot be added to the object instance until after it has been saved. This type of data needed to be hidden in some undocumented state on the object instance, or kept as state on the serializer instance so that it could be used when `.save()` is called. * Instantiating model instances directly means that you cannot use model manager classes for instance creation, eg `ExampleModel.objects.create(...)`. Manager classes are an excellent layer at which to enforce business logic and application-level data constraints. * The two step process makes it unclear where to put deserialization logic. For example, should extra attributes such as the current user get added to the instance during object creation or during object save? @@ -88,7 +88,7 @@ The resulting API changes are further detailed below. #### The `.create()` and `.update()` methods. -The `.restore_object()` method is now replaced with two seperate methods, `.create()` and `.update()`. +The `.restore_object()` method is now replaced with two separate methods, `.create()` and `.update()`. When using the `.create()` and `.update()` methods you should both create *and save* the object instance. This is in contrast to the previous `.restore_object()` behavior that would instantiate the object but not save it. @@ -107,7 +107,7 @@ The following example from the tutorial previously used `restore_object()` to ha # Create new instance return Snippet(**attrs) -This would now be split out into two seperate methods. +This would now be split out into two separate methods. def update(self, instance, validated_attrs) instance.title = validated_attrs.get('title', instance.title) @@ -146,7 +146,7 @@ The corresponding code would now look like this: #### Limitations of ModelSerializer validation. -This change also means that we no longer use the `.full_clean()` method on model instances, but instead perform all validation explicitly on the serializer. This gives a cleaner seperation, and ensures that there's no automatic validation behavior on `ModelSerializer` classes that can't also be easily replicated on regular `Serializer` classes. +This change also means that we no longer use the `.full_clean()` method on model instances, but instead perform all validation explicitly on the serializer. This gives a cleaner separation, and ensures that there's no automatic validation behavior on `ModelSerializer` classes that can't also be easily replicated on regular `Serializer` classes. This change comes with the following limitations: @@ -157,7 +157,7 @@ This change comes with the following limitations: REST framework 2.x attempted to automatically support writable nested serialization, but the behavior was complex and non-obvious. Attempting to automatically handle these case is problematic: -* There can be complex dependancies involved in order of saving multiple related model instances. +* There can be complex dependencies involved in order of saving multiple related model instances. * It's unclear what behavior the user should expect when related models are passed `None` data. * It's unclear how the user should expect to-many relationships to handle updates, creations and deletions of multiple records. @@ -289,7 +289,7 @@ The `ListSerializer` class has now been added, and allows you to create base ser class MultipleUserSerializer(ListSerializer): child = UserSerializer() -You can also still use the `many=True` argument to serializer classes. It's worth noting that `many=True` argument transparently creates a `ListSerializer` instance, allowing the validation logic for list and non-list data to be cleanly seperated in the REST framework codebase. +You can also still use the `many=True` argument to serializer classes. It's worth noting that `many=True` argument transparently creates a `ListSerializer` instance, allowing the validation logic for list and non-list data to be cleanly separated in the REST framework codebase. See also the new `ListField` class, which validates input in the same way, but does not include the serializer interfaces of `.is_valid()`, `.data`, `.save()` and so on. @@ -299,7 +299,7 @@ REST framework now includes a simple `BaseSerializer` class that can be used to This class implements the same basic API as the `Serializer` class: -* `.data` - Returns the outgoing primative representation. +* `.data` - Returns the outgoing primitive representation. * `.is_valid()` - Deserializes and validates incoming data. * `.validated_data` - Returns the validated incoming data. * `.errors` - Returns an errors during validation. @@ -320,7 +320,7 @@ To implement a read-only serializer using the `BaseSerializer` class, we just ne player_name = models.CharField(max_length=10) score = models.IntegerField() -It's simple to create a read-only serializer for converting `HighScore` instances into primative data types. +It's simple to create a read-only serializer for converting `HighScore` instances into primitive data types. class HighScoreSerializer(serializers.BaseSerializer): def to_representation(self, obj): @@ -394,12 +394,12 @@ Here's a complete example of our previous `HighScoreSerializer`, that's been upd The `BaseSerializer` class is also useful if you want to implement new generic serializer classes for dealing with particular serialization styles, or for integrating with alternative storage backends. -The following class is an example of a generic serializer that can handle coercing aribitrary objects into primative representations. +The following class is an example of a generic serializer that can handle coercing aribitrary objects into primitive representations. class ObjectSerializer(serializers.BaseSerializer): """ A read-only serializer that coerces arbitrary complex objects - into primative representations. + into primitive representations. """ def to_representation(self, obj): for attribute_name in dir(obj): @@ -411,7 +411,7 @@ The following class is an example of a generic serializer that can handle coerci # Ignore methods and other callables. pass elif isinstance(attribute, (str, int, bool, float, type(None))): - # Primative types can be passed through unmodified. + # primitive types can be passed through unmodified. output[attribute_name] = attribute elif isinstance(attribute, list): # Recursivly deal with items in lists. @@ -437,7 +437,7 @@ There are some minor tweaks to the field base classes. Previously we had these two base classes: * `Field` as the base class for read-only fields. A default implementation was included for serializing data. -* `WriteableField` as the base class for read-write fields. +* `WritableField` as the base class for read-write fields. We now use the following: @@ -448,9 +448,9 @@ We now use the following: REST framework now has more explict and clear control over validating empty values for fields. -Previously the meaning of the `required=False` keyword argument was underspecified. In practice it's use meant that a field could either be not included in the input, or it could be included, but be `None`. +Previously the meaning of the `required=False` keyword argument was underspecified. In practice its use meant that a field could either be not included in the input, or it could be included, but be `None`. -We now have a better seperation, with seperate `required` and `allow_none` arguments. +We now have a better separation, with separate `required` and `allow_none` arguments. The following set of arguments are used to control validation of empty values: @@ -552,7 +552,7 @@ In order to ensure a consistent code style an assertion error will be raised if #### Enforcing consistent `source` usage. -I've see several codebases that unneccessarily include the `source` argument, setting it to the same value as the field name. This usage is redundant and confusing, making it less obvious that `source` is usually not required. +I've see several codebases that unnecessarily include the `source` argument, setting it to the same value as the field name. This usage is redundant and confusing, making it less obvious that `source` is usually not required. The following usage will *now raise an error*: @@ -614,7 +614,7 @@ I would personally recommend that developers treat view instances as immutable o #### PUT as create. -Allowing `PUT` as create operations is problematic, as it neccessarily exposes information about the existence or non-existance of objects. It's also not obvious that transparently allowing re-creating of previously deleted instances is neccessarily a better default behavior than simply returning `404` responses. +Allowing `PUT` as create operations is problematic, as it necessarily exposes information about the existence or non-existance of objects. It's also not obvious that transparently allowing re-creating of previously deleted instances is necessarily a better default behavior than simply returning `404` responses. Both styles "`PUT` as 404" and "`PUT` as create" can be valid in different circumstances, but we've now opted for the 404 behavior as the default, due to it being simpler and more obvious. @@ -628,7 +628,7 @@ This change means that you can now easily cusomize the style of error responses ## The metadata API -Behavior for dealing with `OPTIONS` requests was previously built directly into the class based views. This has now been properly seperated out into a Metadata API that allows the same pluggable style as other API policies in REST framework. +Behavior for dealing with `OPTIONS` requests was previously built directly into the class based views. This has now been properly separated out into a Metadata API that allows the same pluggable style as other API policies in REST framework. This makes it far easier to use a different style for `OPTIONS` responses throughout your API, and makes it possible to create third-party metadata policies. diff --git a/docs/topics/contributing.md b/docs/topics/contributing.md index 3400bc8f..50b8ded1 100644 --- a/docs/topics/contributing.md +++ b/docs/topics/contributing.md @@ -109,7 +109,7 @@ You can also use the excellent [tox][tox] testing tool to run the tests against It's a good idea to make pull requests early on. A pull request represents the start of a discussion, and doesn't necessarily need to be the final, finished submission. -It's also always best to make a new branch before starting work on a pull request. This means that you'll be able to later switch back to working on another seperate issue without interfering with an ongoing pull requests. +It's also always best to make a new branch before starting work on a pull request. This means that you'll be able to later switch back to working on another separate issue without interfering with an ongoing pull requests. It's also useful to remember that if you have an outstanding pull request then pushing new commits to your GitHub repo will also automatically update the pull requests. diff --git a/docs/topics/release-notes.md b/docs/topics/release-notes.md index 16589f3b..4fa3d627 100644 --- a/docs/topics/release-notes.md +++ b/docs/topics/release-notes.md @@ -149,7 +149,7 @@ You can determine your currently installed version using `pip freeze`: * Added `write_only_fields` option to `ModelSerializer` classes. * JSON renderer now deals with objects that implement a dict-like interface. * Fix compatiblity with newer versions of `django-oauth-plus`. -* Bugfix: Refine behavior that calls model manager `all()` across nested serializer relationships, preventing erronous behavior with some non-ORM objects, and preventing unneccessary queryset re-evaluations. +* Bugfix: Refine behavior that calls model manager `all()` across nested serializer relationships, preventing erronous behavior with some non-ORM objects, and preventing unnecessary queryset re-evaluations. * Bugfix: Allow defaults on BooleanFields to be properly honored when values are not supplied. * Bugfix: Prevent double-escaping of non-latin1 URL query params when appending `format=json` params. diff --git a/docs/topics/writable-nested-serializers.md b/docs/topics/writable-nested-serializers.md index 66ea7815..abc6a82f 100644 --- a/docs/topics/writable-nested-serializers.md +++ b/docs/topics/writable-nested-serializers.md @@ -6,7 +6,7 @@ Although flat data structures serve to properly delineate between the individual entities in your service, there are cases where it may be more appropriate or convenient to use nested data structures. -Nested data structures are easy enough to work with if they're read-only - simply nest your serializer classes and you're good to go. However, there are a few more subtleties to using writable nested serializers, due to the dependancies between the various model instances, and the need to save or delete multiple instances in a single action. +Nested data structures are easy enough to work with if they're read-only - simply nest your serializer classes and you're good to go. However, there are a few more subtleties to using writable nested serializers, due to the dependencies between the various model instances, and the need to save or delete multiple instances in a single action. ## One-to-many data structures diff --git a/rest_framework/compat.py b/rest_framework/compat.py index 3993cee6..e4e69580 100644 --- a/rest_framework/compat.py +++ b/rest_framework/compat.py @@ -131,7 +131,7 @@ else: self.message = kwargs.pop('message', self.message) super(MaxValueValidator, self).__init__(*args, **kwargs) -# URLValidator only accept `message` in 1.6+ +# URLValidator only accepts `message` in 1.6+ if django.VERSION >= (1, 6): from django.core.validators import URLValidator else: diff --git a/rest_framework/fields.py b/rest_framework/fields.py index f3ff2233..bba8ccae 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -186,14 +186,14 @@ class Field(object): def get_initial(self): """ - Return a value to use when the field is being returned as a primative + Return a value to use when the field is being returned as a primitive value, without any object instance. """ return self.initial def get_value(self, dictionary): """ - Given the *incoming* primative data, return the value for this field + Given the *incoming* primitive data, return the value for this field that should be validated and transformed to a native value. """ if html.is_html_input(dictionary): @@ -205,7 +205,7 @@ class Field(object): def get_field_representation(self, instance): """ - Given the outgoing object instance, return the primative value + Given the outgoing object instance, return the primitive value that should be used for this field. """ attribute = get_attribute(instance, self.source_attrs) @@ -274,13 +274,13 @@ class Field(object): def to_internal_value(self, data): """ - Transform the *incoming* primative data into a native value. + Transform the *incoming* primitive data into a native value. """ raise NotImplementedError('to_internal_value() must be implemented.') def to_representation(self, value): """ - Transform the *outgoing* native value into primative data. + Transform the *outgoing* native value into primitive data. """ raise NotImplementedError('to_representation() must be implemented.') @@ -928,7 +928,7 @@ class ImageField(FileField): def to_internal_value(self, data): # Image validation is a bit grungy, so we'll just outright # defer to Django's implementation so we don't need to - # consider it, or treat PIL as a test dependancy. + # consider it, or treat PIL as a test dependency. file_object = super(ImageField, self).to_internal_value(data) django_field = self._DjangoImageField() django_field.error_messages = self.error_messages diff --git a/rest_framework/relations.py b/rest_framework/relations.py index 8c135672..8141de13 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -100,7 +100,7 @@ class HyperlinkedRelatedField(RelatedField): self.lookup_url_kwarg = kwargs.pop('lookup_url_kwarg', self.lookup_field) self.format = kwargs.pop('format', None) - # We include these simply for dependancy injection in tests. + # We include these simply for dependency injection in tests. # We can't add them as class attributes or they would expect an # implict `self` argument to be passed. self.reverse = reverse diff --git a/rest_framework/validators.py b/rest_framework/validators.py index 20de4b42..5bb69ad8 100644 --- a/rest_framework/validators.py +++ b/rest_framework/validators.py @@ -2,7 +2,7 @@ We perform uniqueness checks explicitly on the serializer class, rather the using Django's `.full_clean()`. -This gives us better seperation of concerns, allows us to use single-step +This gives us better separation of concerns, allows us to use single-step object creation, and makes it possible to switch between using the implicit `ModelSerializer` class and an equivelent explicit `Serializer` class. """ diff --git a/rest_framework/views.py b/rest_framework/views.py index 835e223a..979229eb 100644 --- a/rest_framework/views.py +++ b/rest_framework/views.py @@ -100,7 +100,7 @@ class APIView(View): content_negotiation_class = api_settings.DEFAULT_CONTENT_NEGOTIATION_CLASS metadata_class = api_settings.DEFAULT_METADATA_CLASS - # Allow dependancy injection of other settings to make testing easier. + # Allow dependency injection of other settings to make testing easier. settings = api_settings @classmethod diff --git a/tests/test_model_serializer.py b/tests/test_model_serializer.py index 2edf0be5..bb74cd2e 100644 --- a/tests/test_model_serializer.py +++ b/tests/test_model_serializer.py @@ -34,7 +34,7 @@ class RegularFieldsModel(models.Model): big_integer_field = models.BigIntegerField() boolean_field = models.BooleanField(default=False) char_field = models.CharField(max_length=100) - comma_seperated_integer_field = models.CommaSeparatedIntegerField(max_length=100) + comma_separated_integer_field = models.CommaSeparatedIntegerField(max_length=100) date_field = models.DateField() datetime_field = models.DateTimeField() decimal_field = models.DecimalField(max_digits=3, decimal_places=1) @@ -83,7 +83,7 @@ class TestRegularFieldMappings(TestCase): big_integer_field = IntegerField() boolean_field = BooleanField(required=False) char_field = CharField(max_length=100) - comma_seperated_integer_field = CharField(max_length=100, validators=[]) + comma_separated_integer_field = CharField(max_length=100, validators=[]) date_field = DateField() datetime_field = DateTimeField() decimal_field = DecimalField(decimal_places=1, max_digits=3) diff --git a/tests/test_relations.py b/tests/test_relations.py index 2d11672b..66784195 100644 --- a/tests/test_relations.py +++ b/tests/test_relations.py @@ -161,18 +161,18 @@ class TestSlugRelatedField(APISimpleTestCase): # https://github.com/tomchristie/django-rest-framework/issues/446 # """ # field = serializers.PrimaryKeyRelatedField(queryset=NullModel.objects.all()) -# self.assertRaises(serializers.ValidationError, field.to_primative, '') -# self.assertRaises(serializers.ValidationError, field.to_primative, []) +# self.assertRaises(serializers.ValidationError, field.to_primitive, '') +# self.assertRaises(serializers.ValidationError, field.to_primitive, []) # def test_hyperlinked_related_field_with_empty_string(self): # field = serializers.HyperlinkedRelatedField(queryset=NullModel.objects.all(), view_name='') -# self.assertRaises(serializers.ValidationError, field.to_primative, '') -# self.assertRaises(serializers.ValidationError, field.to_primative, []) +# self.assertRaises(serializers.ValidationError, field.to_primitive, '') +# self.assertRaises(serializers.ValidationError, field.to_primitive, []) # def test_slug_related_field_with_empty_string(self): # field = serializers.SlugRelatedField(queryset=NullModel.objects.all(), slug_field='pk') -# self.assertRaises(serializers.ValidationError, field.to_primative, '') -# self.assertRaises(serializers.ValidationError, field.to_primative, []) +# self.assertRaises(serializers.ValidationError, field.to_primitive, '') +# self.assertRaises(serializers.ValidationError, field.to_primitive, []) # class TestManyRelatedMixin(TestCase): -- cgit v1.2.3 From 857a8486b1534f89bd482de86d39ff717b6618eb Mon Sep 17 00:00:00 2001 From: Craig de Stigter Date: Fri, 3 Oct 2014 09:00:33 +1300 Subject: More spelling tweaks --- docs/topics/3.0-announcement.md | 6 +++--- rest_framework/filters.py | 2 +- rest_framework/mixins.py | 2 +- rest_framework/relations.py | 2 +- tests/test_response.py | 4 ++-- 5 files changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 5242be57..fcae79e1 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -411,7 +411,7 @@ The following class is an example of a generic serializer that can handle coerci # Ignore methods and other callables. pass elif isinstance(attribute, (str, int, bool, float, type(None))): - # primitive types can be passed through unmodified. + # Primitive types can be passed through unmodified. output[attribute_name] = attribute elif isinstance(attribute, list): # Recursivly deal with items in lists. @@ -446,7 +446,7 @@ We now use the following: #### The `required`, `allow_none`, `allow_blank` and `default` arguments. -REST framework now has more explict and clear control over validating empty values for fields. +REST framework now has more explicit and clear control over validating empty values for fields. Previously the meaning of the `required=False` keyword argument was underspecified. In practice its use meant that a field could either be not included in the input, or it could be included, but be `None`. @@ -522,7 +522,7 @@ However this code *would not be valid* in `2.4.3`: # ... The queryset argument is now always required for writable relational fields. -This removes some magic and makes it easier and more obvious to move between implict `ModelSerializer` classes and explicit `Serializer` classes. +This removes some magic and makes it easier and more obvious to move between implicit `ModelSerializer` classes and explicit `Serializer` classes. class AccountSerializer(serializers.ModelSerializer): organisations = serializers.SlugRelatedField( diff --git a/rest_framework/filters.py b/rest_framework/filters.py index 4c485668..d188a2d1 100644 --- a/rest_framework/filters.py +++ b/rest_framework/filters.py @@ -148,7 +148,7 @@ class OrderingFilter(BaseFilterBackend): if not getattr(field, 'write_only', False) ] elif valid_fields == '__all__': - # View explictly allows filtering on any model field + # View explicitly allows filtering on any model field valid_fields = [field.name for field in queryset.model._meta.fields] valid_fields += queryset.query.aggregates.keys() diff --git a/rest_framework/mixins.py b/rest_framework/mixins.py index 04b7a763..de334b4b 100644 --- a/rest_framework/mixins.py +++ b/rest_framework/mixins.py @@ -83,7 +83,7 @@ class DestroyModelMixin(object): # The AllowPUTAsCreateMixin was previously the default behaviour -# for PUT requests. This has now been removed and must be *explictly* +# for PUT requests. This has now been removed and must be *explicitly* # included if it is the behavior that you want. # For more info see: ... diff --git a/rest_framework/relations.py b/rest_framework/relations.py index 8141de13..dc9781e7 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -102,7 +102,7 @@ class HyperlinkedRelatedField(RelatedField): # We include these simply for dependency injection in tests. # We can't add them as class attributes or they would expect an - # implict `self` argument to be passed. + # implicit `self` argument to be passed. self.reverse = reverse self.resolve = resolve diff --git a/tests/test_response.py b/tests/test_response.py index 84c39c1a..f233ae33 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -262,9 +262,9 @@ class Issue807Tests(TestCase): expected = "{0}; charset={1}".format(RendererC.media_type, RendererC.charset) self.assertEqual(expected, resp['Content-Type']) - def test_content_type_set_explictly_on_response(self): + def test_content_type_set_explicitly_on_response(self): """ - The content type may be set explictly on the response. + The content type may be set explicitly on the response. """ headers = {"HTTP_ACCEPT": RendererC.media_type} resp = self.client.get('/setbyview', **headers) -- cgit v1.2.3 From 765b0b33bf1fa9b7c6b45d3877d10a05d4e9f6ea Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 3 Oct 2014 13:12:23 +0100 Subject: Revert accidental stupidity --- rest_framework/relations.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rest_framework/relations.py b/rest_framework/relations.py index 4f971917..f9b5ff0d 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -127,7 +127,7 @@ class HyperlinkedRelatedField(RelatedField): attributes are not configured to correctly match the URL conf. """ # Unsaved objects will not yet have a valid URL. - if obj.pk: + if obj.pk is None: return None lookup_value = getattr(obj, self.lookup_field) -- cgit v1.2.3 From e6c5ebdda6d0f169f21498909e2d390c460138a9 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 3 Oct 2014 13:14:17 +0100 Subject: Fix indentation --- rest_framework/serializers.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 21cb7ea2..c3a0815e 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -252,10 +252,10 @@ class Serializer(BaseSerializer): def get_initial(self): if self._initial_data is not None: return ReturnDict([ - (field_name, field.get_value(self._initial_data)) - for field_name, field in self.fields.items() - if field.get_value(self._initial_data) is not empty - ], serializer=self) + (field_name, field.get_value(self._initial_data)) + for field_name, field in self.fields.items() + if field.get_value(self._initial_data) is not empty + ], serializer=self) #return self.to_representation(self._initial_data) return ReturnDict([ -- cgit v1.2.3 From 3a3e2bf57d5443dc0b058d5beb3111f87c418947 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 3 Oct 2014 13:42:06 +0100 Subject: Serializer.save() takes keyword arguments, not 'extras' argument --- docs/topics/3.0-announcement.md | 21 ++++++++++----------- rest_framework/mixins.py | 4 ++-- rest_framework/serializers.py | 7 +++---- 3 files changed, 15 insertions(+), 17 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index fcae79e1..4a781503 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -109,16 +109,16 @@ The following example from the tutorial previously used `restore_object()` to ha This would now be split out into two separate methods. - def update(self, instance, validated_attrs) - instance.title = validated_attrs.get('title', instance.title) - instance.code = validated_attrs.get('code', instance.code) - instance.linenos = validated_attrs.get('linenos', instance.linenos) - instance.language = validated_attrs.get('language', instance.language) - instance.style = validated_attrs.get('style', instance.style) + def update(self, instance, validated_data) + instance.title = validated_data.get('title', instance.title) + instance.code = validated_data.get('code', instance.code) + instance.linenos = validated_data.get('linenos', instance.linenos) + instance.language = validated_data.get('language', instance.language) + instance.style = validated_data.get('style', instance.style) instance.save() - def create(self, validated_attrs): - return Snippet.objects.create(**validated_attrs) + def create(self, validated_data): + return Snippet.objects.create(**validated_data) Note that the `.create` method should return the newly created object instance. @@ -134,15 +134,14 @@ For example the following code *is no longer valid*: serializer.object.user = request.user # Include the user when saving. serializer.save() -Instead of using `.object` to inspect a partially constructed instance, you would now use `.validated_data` to inspect the cleaned incoming values. Also you can't set extra attributes on the instance directly, but instead pass them to the `.save()` method using the `extras` keyword argument. +Instead of using `.object` to inspect a partially constructed instance, you would now use `.validated_data` to inspect the cleaned incoming values. Also you can't set extra attributes on the instance directly, but instead pass them to the `.save()` method as keyword arguments. The corresponding code would now look like this: if serializer.is_valid(): name = serializer.validated_data['name'] # Inspect validated field data. logging.info('Creating ticket "%s"' % name) - extras = {'user': request.user} # Include the user when saving. - serializer.save(extras=extras) + serializer.save(user=request.user) # Include the user when saving. #### Limitations of ModelSerializer validation. diff --git a/rest_framework/mixins.py b/rest_framework/mixins.py index de334b4b..bc4ce22f 100644 --- a/rest_framework/mixins.py +++ b/rest_framework/mixins.py @@ -101,8 +101,8 @@ class AllowPUTAsCreateMixin(object): if instance is None: lookup_url_kwarg = self.lookup_url_kwarg or self.lookup_field lookup_value = self.kwargs[lookup_url_kwarg] - extras = {self.lookup_field: lookup_value} - serializer.save(extras=extras) + extra_kwargs = {self.lookup_field: lookup_value} + serializer.save(**extra_kwargs) return Response(serializer.data, status=status.HTTP_201_CREATED) serializer.save() diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index c3a0815e..ed024f87 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -74,12 +74,12 @@ class BaseSerializer(Field): def create(self, validated_data): raise NotImplementedError('`create()` must be implemented.') - def save(self, extras=None): + def save(self, **kwargs): validated_data = self.validated_data - if extras is not None: + if kwargs: validated_data = dict( list(validated_data.items()) + - list(extras.items()) + list(kwargs.items()) ) if self.instance is not None: @@ -256,7 +256,6 @@ class Serializer(BaseSerializer): for field_name, field in self.fields.items() if field.get_value(self._initial_data) is not empty ], serializer=self) - #return self.to_representation(self._initial_data) return ReturnDict([ (field.field_name, field.get_initial()) -- cgit v1.2.3 From 0803716ed034389a09305b7f037cb05d9ff5c57d Mon Sep 17 00:00:00 2001 From: Kevin London Date: Sat, 4 Oct 2014 17:34:27 -0700 Subject: Update links in 2.4-announcement.md The links to Django Rest Framework pages were 404ing because the URLs include a slash.--- docs/topics/2.4-announcement.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/topics/2.4-announcement.md b/docs/topics/2.4-announcement.md index 09294b91..8e4f3bb2 100644 --- a/docs/topics/2.4-announcement.md +++ b/docs/topics/2.4-announcement.md @@ -164,8 +164,8 @@ Once again, many thanks to all the generous [backers and sponsors][kickstarter-s [lts-releases]: https://docs.djangoproject.com/en/dev/internals/release-process/#long-term-support-lts-releases [2-4-release-notes]: release-notes#240 -[view-name-and-description-settings]: ../api-guide/settings/#view-names-and-descriptions -[client-ip-identification]: ../api-guide/throttling/#how-clients-are-identified +[view-name-and-description-settings]: ../api-guide/settings#view-names-and-descriptions +[client-ip-identification]: ../api-guide/throttling#how-clients-are-identified [2-3-announcement]: 2.3-announcement [github-labels]: https://github.com/tomchristie/django-rest-framework/issues [github-milestones]: https://github.com/tomchristie/django-rest-framework/milestones -- cgit v1.2.3 From 2dfe75c23a041493bc83514d8e9e9268b79072d9 Mon Sep 17 00:00:00 2001 From: Jones Chi Date: Fri, 3 Oct 2014 14:42:49 +0800 Subject: Fix follow does not work on APIClient Handle follow just like Django's Client. --- rest_framework/test.py | 46 ++++++++++++++++++++++++++++++++++++++++++++++ tests/test_testing.py | 47 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 93 insertions(+) diff --git a/rest_framework/test.py b/rest_framework/test.py index 9b40353a..74d2c868 100644 --- a/rest_framework/test.py +++ b/rest_framework/test.py @@ -156,6 +156,52 @@ class APIClient(APIRequestFactory, DjangoClient): kwargs.update(self._credentials) return super(APIClient, self).request(**kwargs) + def get(self, path, data=None, follow=False, **extra): + response = super(APIClient, self).get(path, data=data, **extra) + if follow: + response = self._handle_redirects(response, **extra) + return response + + def post(self, path, data=None, format=None, content_type=None, + follow=False, **extra): + response = super(APIClient, self).post( + path, data=data, format=format, content_type=content_type, **extra) + if follow: + response = self._handle_redirects(response, **extra) + return response + + def put(self, path, data=None, format=None, content_type=None, + follow=False, **extra): + response = super(APIClient, self).put( + path, data=data, format=format, content_type=content_type, **extra) + if follow: + response = self._handle_redirects(response, **extra) + return response + + def patch(self, path, data=None, format=None, content_type=None, + follow=False, **extra): + response = super(APIClient, self).patch( + path, data=data, format=format, content_type=content_type, **extra) + if follow: + response = self._handle_redirects(response, **extra) + return response + + def delete(self, path, data=None, format=None, content_type=None, + follow=False, **extra): + response = super(APIClient, self).delete( + path, data=data, format=format, content_type=content_type, **extra) + if follow: + response = self._handle_redirects(response, **extra) + return response + + def options(self, path, data=None, format=None, content_type=None, + follow=False, **extra): + response = super(APIClient, self).options( + path, data=data, format=format, content_type=content_type, **extra) + if follow: + response = self._handle_redirects(response, **extra) + return response + def logout(self): self._credentials = {} return super(APIClient, self).logout() diff --git a/tests/test_testing.py b/tests/test_testing.py index 9c472026..9fd5966e 100644 --- a/tests/test_testing.py +++ b/tests/test_testing.py @@ -5,6 +5,7 @@ from django.conf.urls import patterns, url from io import BytesIO from django.contrib.auth.models import User +from django.shortcuts import redirect from django.test import TestCase from rest_framework.decorators import api_view from rest_framework.response import Response @@ -28,10 +29,16 @@ def session_view(request): }) +@api_view(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']) +def redirect_view(request): + return redirect('/view/') + + urlpatterns = patterns( '', url(r'^view/$', view), url(r'^session-view/$', session_view), + url(r'^redirect-view/$', redirect_view), ) @@ -111,6 +118,46 @@ class TestAPITestClient(TestCase): response = self.client.get('/view/') self.assertEqual(response.data['auth'], b'') + def test_follow_redirect(self): + """ + Follow redirect by setting follow argument. + """ + response = self.client.get('/redirect-view/') + self.assertEqual(response.status_code, 302) + response = self.client.get('/redirect-view/', follow=True) + self.assertIsNotNone(response.redirect_chain) + self.assertEqual(response.status_code, 200) + + response = self.client.post('/redirect-view/') + self.assertEqual(response.status_code, 302) + response = self.client.post('/redirect-view/', follow=True) + self.assertIsNotNone(response.redirect_chain) + self.assertEqual(response.status_code, 200) + + response = self.client.put('/redirect-view/') + self.assertEqual(response.status_code, 302) + response = self.client.put('/redirect-view/', follow=True) + self.assertIsNotNone(response.redirect_chain) + self.assertEqual(response.status_code, 200) + + response = self.client.patch('/redirect-view/') + self.assertEqual(response.status_code, 302) + response = self.client.patch('/redirect-view/', follow=True) + self.assertIsNotNone(response.redirect_chain) + self.assertEqual(response.status_code, 200) + + response = self.client.delete('/redirect-view/') + self.assertEqual(response.status_code, 302) + response = self.client.delete('/redirect-view/', follow=True) + self.assertIsNotNone(response.redirect_chain) + self.assertEqual(response.status_code, 200) + + response = self.client.options('/redirect-view/') + self.assertEqual(response.status_code, 302) + response = self.client.options('/redirect-view/', follow=True) + self.assertIsNotNone(response.redirect_chain) + self.assertEqual(response.status_code, 200) + class TestAPIRequestFactory(TestCase): def test_csrf_exempt_by_default(self): -- cgit v1.2.3 From 6bfed6f8525a49fc50df7143ac2d492528b8f2ac Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 7 Oct 2014 17:04:53 +0100 Subject: Enforce uniqueness validation for relational fields --- rest_framework/fields.py | 2 ++ rest_framework/utils/field_mapping.py | 3 +++ tests/test_model_serializer.py | 4 ++-- 3 files changed, 7 insertions(+), 2 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 0963d4bf..9d577c53 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -224,6 +224,8 @@ class Field(object): """ if self.default is empty: raise SkipField() + if is_simple_callable(self.default): + return self.default() return self.default def run_validation(self, data=empty): diff --git a/rest_framework/utils/field_mapping.py b/rest_framework/utils/field_mapping.py index 30fae370..fd6da699 100644 --- a/rest_framework/utils/field_mapping.py +++ b/rest_framework/utils/field_mapping.py @@ -219,6 +219,9 @@ def get_relation_kwargs(field_name, relation_info): kwargs['required'] = False if model_field.null: kwargs['allow_null'] = True + if getattr(model_field, 'unique', False): + validator = UniqueValidator(queryset=model_field.model._default_manager) + kwargs['validators'] = [validator] return kwargs diff --git a/tests/test_model_serializer.py b/tests/test_model_serializer.py index bb74cd2e..18170bc0 100644 --- a/tests/test_model_serializer.py +++ b/tests/test_model_serializer.py @@ -248,7 +248,7 @@ class TestRelationalFieldMappings(TestCase): TestSerializer(): id = IntegerField(label='ID', read_only=True) foreign_key = PrimaryKeyRelatedField(queryset=ForeignKeyTargetModel.objects.all()) - one_to_one = PrimaryKeyRelatedField(queryset=OneToOneTargetModel.objects.all()) + one_to_one = PrimaryKeyRelatedField(queryset=OneToOneTargetModel.objects.all(), validators=[]) many_to_many = PrimaryKeyRelatedField(many=True, queryset=ManyToManyTargetModel.objects.all()) through = PrimaryKeyRelatedField(many=True, read_only=True) """) @@ -287,7 +287,7 @@ class TestRelationalFieldMappings(TestCase): TestSerializer(): url = HyperlinkedIdentityField(view_name='relationalmodel-detail') foreign_key = HyperlinkedRelatedField(queryset=ForeignKeyTargetModel.objects.all(), view_name='foreignkeytargetmodel-detail') - one_to_one = HyperlinkedRelatedField(queryset=OneToOneTargetModel.objects.all(), view_name='onetoonetargetmodel-detail') + one_to_one = HyperlinkedRelatedField(queryset=OneToOneTargetModel.objects.all(), validators=[], view_name='onetoonetargetmodel-detail') many_to_many = HyperlinkedRelatedField(many=True, queryset=ManyToManyTargetModel.objects.all(), view_name='manytomanytargetmodel-detail') through = HyperlinkedRelatedField(many=True, read_only=True, view_name='throughtargetmodel-detail') """) -- cgit v1.2.3 From 3fa4a1898aee0dabee951f81f790bb2da042ec81 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 7 Oct 2014 17:21:12 +0100 Subject: Reintroduce save hooks --- rest_framework/mixins.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/rest_framework/mixins.py b/rest_framework/mixins.py index bc4ce22f..03ebb034 100644 --- a/rest_framework/mixins.py +++ b/rest_framework/mixins.py @@ -20,10 +20,13 @@ class CreateModelMixin(object): def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) - serializer.save() + self.create_valid(serializer) headers = self.get_success_headers(serializer.data) return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers) + def create_valid(self, serializer): + serializer.save() + def get_success_headers(self, data): try: return {'Location': data[api_settings.URL_FIELD_NAME]} @@ -64,9 +67,12 @@ class UpdateModelMixin(object): instance = self.get_object() serializer = self.get_serializer(instance, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) - serializer.save() + self.update_valid(serializer) return Response(serializer.data) + def update_valid(self, serializer): + serializer.save() + def partial_update(self, request, *args, **kwargs): kwargs['partial'] = True return self.update(request, *args, **kwargs) -- cgit v1.2.3 From 311d315a739f4d1d02e87a09de0bbf9e7b0cee46 Mon Sep 17 00:00:00 2001 From: Xavier Ordoquy Date: Wed, 8 Oct 2014 08:33:28 +0200 Subject: Reverted 59d0a0387d907260ef8f91bbbca618831abd75a3 and fixed the tests --- rest_framework/response.py | 4 ---- tests/test_renderers.py | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/rest_framework/response.py b/rest_framework/response.py index 0a7d313f..d6ca1aad 100644 --- a/rest_framework/response.py +++ b/rest_framework/response.py @@ -5,7 +5,6 @@ it is initialized with unrendered data, instead of a pre-rendered string. The appropriate renderer is called during Django's template response rendering. """ from __future__ import unicode_literals -import django from django.core.handlers.wsgi import STATUS_CODE_TEXT from django.template.response import SimpleTemplateResponse from django.utils import six @@ -16,9 +15,6 @@ class Response(SimpleTemplateResponse): An HttpResponse that allows its data to be rendered into arbitrary media types. """ - # TODO: remove that once Django 1.3 isn't supported - if django.VERSION >= (1, 4): - rendering_attrs = SimpleTemplateResponse.rendering_attrs + ['_closable_objects'] def __init__(self, data=None, status=None, template_name=None, headers=None, diff --git a/tests/test_renderers.py b/tests/test_renderers.py index 91244e26..b922ec29 100644 --- a/tests/test_renderers.py +++ b/tests/test_renderers.py @@ -643,7 +643,7 @@ class CacheRenderTest(TestCase): """ method = getattr(self.client, http_method) resp = method(url) - del resp.client, resp.request + del resp.client, resp.request, resp._closable_objects try: del resp.wsgi_request except AttributeError: -- cgit v1.2.3 From 093febb91299e332c810de6a6b6aba57c2b16a91 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 11:04:08 +0100 Subject: Tests for relational fields --- rest_framework/fields.py | 9 +- tests/test_relations_hyperlink.py | 903 +++++++++++++++++++------------------- tests/test_relations_pk.py | 886 +++++++++++++++++++------------------ tests/test_relations_slug.py | 525 +++++++++++----------- 4 files changed, 1168 insertions(+), 1155 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 9d577c53..5fb0ec8d 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -1,7 +1,7 @@ from django import forms from django.conf import settings from django.core import validators -from django.core.exceptions import ValidationError +from django.core.exceptions import ObjectDoesNotExist, ValidationError from django.utils import six, timezone from django.utils.datastructures import SortedDict from django.utils.dateparse import parse_date, parse_datetime, parse_time @@ -54,6 +54,8 @@ def get_attribute(instance, attrs): for attr in attrs: try: instance = getattr(instance, attr) + except ObjectDoesNotExist: + return None except AttributeError as exc: try: return instance[attr] @@ -108,6 +110,7 @@ class Field(object): default_validators = [] default_empty_html = empty initial = None + coerce_blank_to_null = True def __init__(self, read_only=False, write_only=False, required=None, default=empty, initial=empty, source=None, @@ -245,6 +248,9 @@ class Field(object): self.fail('required') return self.get_default() + if data == '' and self.coerce_blank_to_null: + data = None + if data is None: if not self.allow_null: self.fail('null') @@ -413,6 +419,7 @@ class CharField(Field): 'blank': _('This field may not be blank.') } initial = '' + coerce_blank_to_null = False def __init__(self, **kwargs): self.allow_blank = kwargs.pop('allow_blank', False) diff --git a/tests/test_relations_hyperlink.py b/tests/test_relations_hyperlink.py index 315d1abf..0337f359 100644 --- a/tests/test_relations_hyperlink.py +++ b/tests/test_relations_hyperlink.py @@ -1,459 +1,460 @@ -# from __future__ import unicode_literals -# from django.conf.urls import patterns, url -# from django.test import TestCase -# from rest_framework import serializers -# from rest_framework.test import APIRequestFactory -# from tests.models import ( -# BlogPost, -# ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, -# NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource -# ) - -# factory = APIRequestFactory() -# request = factory.get('/') # Just to ensure we have a request in the serializer context - - -# def dummy_view(request, pk): -# pass - -# urlpatterns = patterns( -# '', -# url(r'^dummyurl/(?P[0-9]+)/$', dummy_view, name='dummy-url'), -# url(r'^manytomanysource/(?P[0-9]+)/$', dummy_view, name='manytomanysource-detail'), -# url(r'^manytomanytarget/(?P[0-9]+)/$', dummy_view, name='manytomanytarget-detail'), -# url(r'^foreignkeysource/(?P[0-9]+)/$', dummy_view, name='foreignkeysource-detail'), -# url(r'^foreignkeytarget/(?P[0-9]+)/$', dummy_view, name='foreignkeytarget-detail'), -# url(r'^nullableforeignkeysource/(?P[0-9]+)/$', dummy_view, name='nullableforeignkeysource-detail'), -# url(r'^onetoonetarget/(?P[0-9]+)/$', dummy_view, name='onetoonetarget-detail'), -# url(r'^nullableonetoonesource/(?P[0-9]+)/$', dummy_view, name='nullableonetoonesource-detail'), -# ) - - -# # ManyToMany -# class ManyToManyTargetSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = ManyToManyTarget -# fields = ('url', 'name', 'sources') - - -# class ManyToManySourceSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = ManyToManySource -# fields = ('url', 'name', 'targets') - - -# # ForeignKey -# class ForeignKeyTargetSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = ForeignKeyTarget -# fields = ('url', 'name', 'sources') - - -# class ForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = ForeignKeySource -# fields = ('url', 'name', 'target') - - -# # Nullable ForeignKey -# class NullableForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = NullableForeignKeySource -# fields = ('url', 'name', 'target') - - -# # Nullable OneToOne -# class NullableOneToOneTargetSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = OneToOneTarget -# fields = ('url', 'name', 'nullable_source') - - -# # TODO: Add test that .data cannot be accessed prior to .is_valid - -# class HyperlinkedManyToManyTests(TestCase): -# urls = 'tests.test_relations_hyperlink' - -# def setUp(self): -# for idx in range(1, 4): -# target = ManyToManyTarget(name='target-%d' % idx) -# target.save() -# source = ManyToManySource(name='source-%d' % idx) -# source.save() -# for target in ManyToManyTarget.objects.all(): -# source.targets.add(target) - -# def test_many_to_many_retrieve(self): -# queryset = ManyToManySource.objects.all() -# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, -# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, -# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_many_to_many_retrieve(self): -# queryset = ManyToManyTarget.objects.all() -# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, -# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, -# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_many_to_many_update(self): -# data = {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} -# instance = ManyToManySource.objects.get(pk=1) -# serializer = ManyToManySourceSerializer(instance, data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# serializer.save() -# self.assertEqual(serializer.data, data) - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = ManyToManySource.objects.all() -# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, -# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, -# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_many_to_many_update(self): -# data = {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']} -# instance = ManyToManyTarget.objects.get(pk=1) -# serializer = ManyToManyTargetSerializer(instance, data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# serializer.save() -# self.assertEqual(serializer.data, data) - -# # Ensure target 1 is updated, and everything else is as expected -# queryset = ManyToManyTarget.objects.all() -# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']}, -# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, -# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} - -# ] -# self.assertEqual(serializer.data, expected) - -# def test_many_to_many_create(self): -# data = {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} -# serializer = ManyToManySourceSerializer(data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is added, and everything else is as expected -# queryset = ManyToManySource.objects.all() -# serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, -# {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, -# {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, -# {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_many_to_many_create(self): -# data = {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} -# serializer = ManyToManyTargetSerializer(data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-4') - -# # Ensure target 4 is added, and everything else is as expected -# queryset = ManyToManyTarget.objects.all() -# serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, -# {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, -# {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}, -# {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} -# ] -# self.assertEqual(serializer.data, expected) - - -# class HyperlinkedForeignKeyTests(TestCase): -# urls = 'tests.test_relations_hyperlink' - -# def setUp(self): -# target = ForeignKeyTarget(name='target-1') -# target.save() -# new_target = ForeignKeyTarget(name='target-2') -# new_target.save() -# for idx in range(1, 4): -# source = ForeignKeySource(name='source-%d' % idx, target=target) -# source.save() - -# def test_foreign_key_retrieve(self): -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_foreign_key_retrieve(self): -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, -# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update(self): -# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'}, -# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_incorrect_type(self): -# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 2} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected url string, received int.']}) - -# def test_reverse_foreign_key_update(self): -# data = {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} -# instance = ForeignKeyTarget.objects.get(pk=2) -# serializer = ForeignKeyTargetSerializer(instance, data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# # We shouldn't have saved anything to the db yet since save -# # hasn't been called. -# queryset = ForeignKeyTarget.objects.all() -# new_serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, -# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, -# ] -# self.assertEqual(new_serializer.data, expected) - -# serializer.save() -# self.assertEqual(serializer.data, data) - -# # Ensure target 2 is update, and everything else is as expected -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, -# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create(self): -# data = {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'} -# serializer = ForeignKeySourceSerializer(data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_foreign_key_create(self): -# data = {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} -# serializer = ForeignKeyTargetSerializer(data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-3') - -# # Ensure target 4 is added, and everything else is as expected -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, -# {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, -# {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_invalid_null(self): -# data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': None} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'target': ['This field is required.']}) - - -# class HyperlinkedNullableForeignKeyTests(TestCase): -# urls = 'tests.test_relations_hyperlink' - -# def setUp(self): -# target = ForeignKeyTarget(name='target-1') -# target.save() -# for idx in range(1, 4): -# if idx == 3: -# target = None -# source = NullableForeignKeySource(name='source-%d' % idx, target=target) -# source.save() - -# def test_foreign_key_retrieve_with_null(self): -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create_with_valid_null(self): -# data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} -# serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is created, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, -# {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create_with_valid_emptystring(self): -# """ -# The emptystring should be interpreted as null in the context -# of relationships. -# """ -# data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': ''} -# expected_data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} -# serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, expected_data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is created, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, -# {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_valid_null(self): -# data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} -# instance = NullableForeignKeySource.objects.get(pk=1) -# serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, -# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_valid_emptystring(self): -# """ -# The emptystring should be interpreted as null in the context -# of relationships. -# """ -# data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': ''} -# expected_data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} -# instance = NullableForeignKeySource.objects.get(pk=1) -# serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, expected_data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, -# {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, -# {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, -# ] -# self.assertEqual(serializer.data, expected) +from __future__ import unicode_literals +from django.conf.urls import patterns, url +from django.test import TestCase +from rest_framework import serializers +from rest_framework.test import APIRequestFactory +from tests.models import ( + ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, + NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource +) + +factory = APIRequestFactory() +request = factory.get('/') # Just to ensure we have a request in the serializer context + + +dummy_view = lambda request, pk: None + +urlpatterns = patterns( + '', + url(r'^dummyurl/(?P[0-9]+)/$', dummy_view, name='dummy-url'), + url(r'^manytomanysource/(?P[0-9]+)/$', dummy_view, name='manytomanysource-detail'), + url(r'^manytomanytarget/(?P[0-9]+)/$', dummy_view, name='manytomanytarget-detail'), + url(r'^foreignkeysource/(?P[0-9]+)/$', dummy_view, name='foreignkeysource-detail'), + url(r'^foreignkeytarget/(?P[0-9]+)/$', dummy_view, name='foreignkeytarget-detail'), + url(r'^nullableforeignkeysource/(?P[0-9]+)/$', dummy_view, name='nullableforeignkeysource-detail'), + url(r'^onetoonetarget/(?P[0-9]+)/$', dummy_view, name='onetoonetarget-detail'), + url(r'^nullableonetoonesource/(?P[0-9]+)/$', dummy_view, name='nullableonetoonesource-detail'), +) + + +# ManyToMany +class ManyToManyTargetSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = ManyToManyTarget + fields = ('url', 'name', 'sources') + + +class ManyToManySourceSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = ManyToManySource + fields = ('url', 'name', 'targets') + + +# ForeignKey +class ForeignKeyTargetSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = ForeignKeyTarget + fields = ('url', 'name', 'sources') + + +class ForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = ForeignKeySource + fields = ('url', 'name', 'target') + + +# Nullable ForeignKey +class NullableForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = NullableForeignKeySource + fields = ('url', 'name', 'target') + + +# Nullable OneToOne +class NullableOneToOneTargetSerializer(serializers.HyperlinkedModelSerializer): + class Meta: + model = OneToOneTarget + fields = ('url', 'name', 'nullable_source') + + +# TODO: Add test that .data cannot be accessed prior to .is_valid + +class HyperlinkedManyToManyTests(TestCase): + urls = 'tests.test_relations_hyperlink' + + def setUp(self): + for idx in range(1, 4): + target = ManyToManyTarget(name='target-%d' % idx) + target.save() + source = ManyToManySource(name='source-%d' % idx) + source.save() + for target in ManyToManyTarget.objects.all(): + source.targets.add(target) + + def test_many_to_many_retrieve(self): + queryset = ManyToManySource.objects.all() + serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, + {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, + {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_many_to_many_retrieve(self): + queryset = ManyToManyTarget.objects.all() + serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, + {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, + {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} + ] + self.assertEqual(serializer.data, expected) + + def test_many_to_many_update(self): + data = {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} + instance = ManyToManySource.objects.get(pk=1) + serializer = ManyToManySourceSerializer(instance, data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = ManyToManySource.objects.all() + serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, + {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, + {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']} + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_many_to_many_update(self): + data = {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']} + instance = ManyToManyTarget.objects.get(pk=1) + serializer = ManyToManyTargetSerializer(instance, data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure target 1 is updated, and everything else is as expected + queryset = ManyToManyTarget.objects.all() + serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/']}, + {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, + {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']} + + ] + self.assertEqual(serializer.data, expected) + + def test_many_to_many_create(self): + data = {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} + serializer = ManyToManySourceSerializer(data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is added, and everything else is as expected + queryset = ManyToManySource.objects.all() + serializer = ManyToManySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/manytomanysource/1/', 'name': 'source-1', 'targets': ['http://testserver/manytomanytarget/1/']}, + {'url': 'http://testserver/manytomanysource/2/', 'name': 'source-2', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/']}, + {'url': 'http://testserver/manytomanysource/3/', 'name': 'source-3', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/2/', 'http://testserver/manytomanytarget/3/']}, + {'url': 'http://testserver/manytomanysource/4/', 'name': 'source-4', 'targets': ['http://testserver/manytomanytarget/1/', 'http://testserver/manytomanytarget/3/']} + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_many_to_many_create(self): + data = {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} + serializer = ManyToManyTargetSerializer(data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'target-4') + + # Ensure target 4 is added, and everything else is as expected + queryset = ManyToManyTarget.objects.all() + serializer = ManyToManyTargetSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/manytomanytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, + {'url': 'http://testserver/manytomanytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/manytomanysource/2/', 'http://testserver/manytomanysource/3/']}, + {'url': 'http://testserver/manytomanytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/manytomanysource/3/']}, + {'url': 'http://testserver/manytomanytarget/4/', 'name': 'target-4', 'sources': ['http://testserver/manytomanysource/1/', 'http://testserver/manytomanysource/3/']} + ] + self.assertEqual(serializer.data, expected) + + +class HyperlinkedForeignKeyTests(TestCase): + urls = 'tests.test_relations_hyperlink' + + def setUp(self): + target = ForeignKeyTarget(name='target-1') + target.save() + new_target = ForeignKeyTarget(name='target-2') + new_target.save() + for idx in range(1, 4): + source = ForeignKeySource(name='source-%d' % idx, target=target) + source.save() + + def test_foreign_key_retrieve(self): + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_foreign_key_retrieve(self): + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, + {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update(self): + data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/2/'}, + {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_incorrect_type(self): + data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 2} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) + self.assertFalse(serializer.is_valid()) + self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected URL string, received int.']}) + + def test_reverse_foreign_key_update(self): + data = {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} + instance = ForeignKeyTarget.objects.get(pk=2) + serializer = ForeignKeyTargetSerializer(instance, data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + # We shouldn't have saved anything to the db yet since save + # hasn't been called. + queryset = ForeignKeyTarget.objects.all() + new_serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/2/', 'http://testserver/foreignkeysource/3/']}, + {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, + ] + self.assertEqual(new_serializer.data, expected) + + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure target 2 is update, and everything else is as expected + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, + {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create(self): + data = {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'} + serializer = ForeignKeySourceSerializer(data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 1 is updated, and everything else is as expected + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/foreignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/foreignkeysource/3/', 'name': 'source-3', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/foreignkeysource/4/', 'name': 'source-4', 'target': 'http://testserver/foreignkeytarget/2/'}, + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_foreign_key_create(self): + data = {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']} + serializer = ForeignKeyTargetSerializer(data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'target-3') + + # Ensure target 4 is added, and everything else is as expected + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/foreignkeytarget/1/', 'name': 'target-1', 'sources': ['http://testserver/foreignkeysource/2/']}, + {'url': 'http://testserver/foreignkeytarget/2/', 'name': 'target-2', 'sources': []}, + {'url': 'http://testserver/foreignkeytarget/3/', 'name': 'target-3', 'sources': ['http://testserver/foreignkeysource/1/', 'http://testserver/foreignkeysource/3/']}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_invalid_null(self): + data = {'url': 'http://testserver/foreignkeysource/1/', 'name': 'source-1', 'target': None} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data, context={'request': request}) + self.assertFalse(serializer.is_valid()) + self.assertEqual(serializer.errors, {'target': ['This field may not be null.']}) + + +class HyperlinkedNullableForeignKeyTests(TestCase): + urls = 'tests.test_relations_hyperlink' + + def setUp(self): + target = ForeignKeyTarget(name='target-1') + target.save() + for idx in range(1, 4): + if idx == 3: + target = None + source = NullableForeignKeySource(name='source-%d' % idx, target=target) + source.save() + + def test_foreign_key_retrieve_with_null(self): + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create_with_valid_null(self): + data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} + serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is created, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, + {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create_with_valid_emptystring(self): + """ + The emptystring should be interpreted as null in the context + of relationships. + """ + data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': ''} + expected_data = {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} + serializer = NullableForeignKeySourceSerializer(data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, expected_data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is created, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, + {'url': 'http://testserver/nullableforeignkeysource/4/', 'name': 'source-4', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_valid_null(self): + data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} + instance = NullableForeignKeySource.objects.get(pk=1) + serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, + {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_valid_emptystring(self): + """ + The emptystring should be interpreted as null in the context + of relationships. + """ + data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': ''} + expected_data = {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None} + instance = NullableForeignKeySource.objects.get(pk=1) + serializer = NullableForeignKeySourceSerializer(instance, data=data, context={'request': request}) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, expected_data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/nullableforeignkeysource/1/', 'name': 'source-1', 'target': None}, + {'url': 'http://testserver/nullableforeignkeysource/2/', 'name': 'source-2', 'target': 'http://testserver/foreignkeytarget/1/'}, + {'url': 'http://testserver/nullableforeignkeysource/3/', 'name': 'source-3', 'target': None}, + ] + self.assertEqual(serializer.data, expected) # # reverse foreign keys MUST be read_only # # In the general case they do not provide .remove() or .clear() # # and cannot be arbitrarily set. -# # def test_reverse_foreign_key_update(self): -# # data = {'id': 1, 'name': 'target-1', 'sources': [1]} -# # instance = ForeignKeyTarget.objects.get(pk=1) -# # serializer = ForeignKeyTargetSerializer(instance, data=data) -# # self.assertTrue(serializer.is_valid()) -# # self.assertEqual(serializer.data, data) -# # serializer.save() - -# # # Ensure target 1 is updated, and everything else is as expected -# # queryset = ForeignKeyTarget.objects.all() -# # serializer = ForeignKeyTargetSerializer(queryset, many=True) -# # expected = [ -# # {'id': 1, 'name': 'target-1', 'sources': [1]}, -# # {'id': 2, 'name': 'target-2', 'sources': []}, -# # ] -# # self.assertEqual(serializer.data, expected) - - -# class HyperlinkedNullableOneToOneTests(TestCase): -# urls = 'tests.test_relations_hyperlink' - -# def setUp(self): -# target = OneToOneTarget(name='target-1') -# target.save() -# new_target = OneToOneTarget(name='target-2') -# new_target.save() -# source = NullableOneToOneSource(name='source-1', target=target) -# source.save() - -# def test_reverse_foreign_key_retrieve_with_null(self): -# queryset = OneToOneTarget.objects.all() -# serializer = NullableOneToOneTargetSerializer(queryset, many=True, context={'request': request}) -# expected = [ -# {'url': 'http://testserver/onetoonetarget/1/', 'name': 'target-1', 'nullable_source': 'http://testserver/nullableonetoonesource/1/'}, -# {'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None}, -# ] -# self.assertEqual(serializer.data, expected) + # def test_reverse_foreign_key_update(self): + # data = {'id': 1, 'name': 'target-1', 'sources': [1]} + # instance = ForeignKeyTarget.objects.get(pk=1) + # serializer = ForeignKeyTargetSerializer(instance, data=data) + # print serializer.is_valid() + # print serializer.errors + # print serializer + # self.assertTrue(serializer.is_valid()) + # serializer.save() + # self.assertEqual(serializer.data, data) + + # # Ensure target 1 is updated, and everything else is as expected + # queryset = ForeignKeyTarget.objects.all() + # serializer = ForeignKeyTargetSerializer(queryset, many=True) + # expected = [ + # {'id': 1, 'name': 'target-1', 'sources': [1]}, + # {'id': 2, 'name': 'target-2', 'sources': []}, + # ] + # self.assertEqual(serializer.data, expected) + + +class HyperlinkedNullableOneToOneTests(TestCase): + urls = 'tests.test_relations_hyperlink' + + def setUp(self): + target = OneToOneTarget(name='target-1') + target.save() + new_target = OneToOneTarget(name='target-2') + new_target.save() + source = NullableOneToOneSource(name='source-1', target=target) + source.save() + + def test_reverse_foreign_key_retrieve_with_null(self): + queryset = OneToOneTarget.objects.all() + serializer = NullableOneToOneTargetSerializer(queryset, many=True, context={'request': request}) + expected = [ + {'url': 'http://testserver/onetoonetarget/1/', 'name': 'target-1', 'nullable_source': 'http://testserver/nullableonetoonesource/1/'}, + {'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None}, + ] + self.assertEqual(serializer.data, expected) # # Regression tests for #694 (`source` attribute on related fields) diff --git a/tests/test_relations_pk.py b/tests/test_relations_pk.py index 031a79b3..da3c5786 100644 --- a/tests/test_relations_pk.py +++ b/tests/test_relations_pk.py @@ -1,446 +1,443 @@ -# from __future__ import unicode_literals -# from django.db import models -# from django.test import TestCase -# from django.utils import six -# from rest_framework import serializers -# from tests.models import ( -# BlogPost, ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, -# NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource, -# ) - - -# # ManyToMany -# class ManyToManyTargetSerializer(serializers.ModelSerializer): -# class Meta: -# model = ManyToManyTarget -# fields = ('id', 'name', 'sources') - - -# class ManyToManySourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = ManyToManySource -# fields = ('id', 'name', 'targets') - - -# # ForeignKey -# class ForeignKeyTargetSerializer(serializers.ModelSerializer): -# class Meta: -# model = ForeignKeyTarget -# fields = ('id', 'name', 'sources') - - -# class ForeignKeySourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = ForeignKeySource -# fields = ('id', 'name', 'target') - - -# # Nullable ForeignKey -# class NullableForeignKeySourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = NullableForeignKeySource -# fields = ('id', 'name', 'target') - - -# # Nullable OneToOne -# class NullableOneToOneTargetSerializer(serializers.ModelSerializer): -# class Meta: -# model = OneToOneTarget -# fields = ('id', 'name', 'nullable_source') - - -# # TODO: Add test that .data cannot be accessed prior to .is_valid - -# class PKManyToManyTests(TestCase): -# def setUp(self): -# for idx in range(1, 4): -# target = ManyToManyTarget(name='target-%d' % idx) -# target.save() -# source = ManyToManySource(name='source-%d' % idx) -# source.save() -# for target in ManyToManyTarget.objects.all(): -# source.targets.add(target) - -# def test_many_to_many_retrieve(self): -# queryset = ManyToManySource.objects.all() -# serializer = ManyToManySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'targets': [1]}, -# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, -# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_many_to_many_retrieve(self): -# queryset = ManyToManyTarget.objects.all() -# serializer = ManyToManyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, -# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, -# {'id': 3, 'name': 'target-3', 'sources': [3]} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_many_to_many_update(self): -# data = {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]} -# instance = ManyToManySource.objects.get(pk=1) -# serializer = ManyToManySourceSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# serializer.save() -# self.assertEqual(serializer.data, data) - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = ManyToManySource.objects.all() -# serializer = ManyToManySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]}, -# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, -# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_many_to_many_update(self): -# data = {'id': 1, 'name': 'target-1', 'sources': [1]} -# instance = ManyToManyTarget.objects.get(pk=1) -# serializer = ManyToManyTargetSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# serializer.save() -# self.assertEqual(serializer.data, data) - -# # Ensure target 1 is updated, and everything else is as expected -# queryset = ManyToManyTarget.objects.all() -# serializer = ManyToManyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [1]}, -# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, -# {'id': 3, 'name': 'target-3', 'sources': [3]} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_many_to_many_create(self): -# data = {'id': 4, 'name': 'source-4', 'targets': [1, 3]} -# serializer = ManyToManySourceSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is added, and everything else is as expected -# queryset = ManyToManySource.objects.all() -# serializer = ManyToManySourceSerializer(queryset, many=True) -# self.assertFalse(serializer.fields['targets'].read_only) -# expected = [ -# {'id': 1, 'name': 'source-1', 'targets': [1]}, -# {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, -# {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}, -# {'id': 4, 'name': 'source-4', 'targets': [1, 3]}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_many_to_many_create(self): -# data = {'id': 4, 'name': 'target-4', 'sources': [1, 3]} -# serializer = ManyToManyTargetSerializer(data=data) -# self.assertFalse(serializer.fields['sources'].read_only) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-4') - -# # Ensure target 4 is added, and everything else is as expected -# queryset = ManyToManyTarget.objects.all() -# serializer = ManyToManyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, -# {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, -# {'id': 3, 'name': 'target-3', 'sources': [3]}, -# {'id': 4, 'name': 'target-4', 'sources': [1, 3]} -# ] -# self.assertEqual(serializer.data, expected) - - -# class PKForeignKeyTests(TestCase): -# def setUp(self): -# target = ForeignKeyTarget(name='target-1') -# target.save() -# new_target = ForeignKeyTarget(name='target-2') -# new_target.save() -# for idx in range(1, 4): -# source = ForeignKeySource(name='source-%d' % idx, target=target) -# source.save() - -# def test_foreign_key_retrieve(self): -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 1}, -# {'id': 2, 'name': 'source-2', 'target': 1}, -# {'id': 3, 'name': 'source-3', 'target': 1} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_foreign_key_retrieve(self): -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, -# {'id': 2, 'name': 'target-2', 'sources': []}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update(self): -# data = {'id': 1, 'name': 'source-1', 'target': 2} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 2}, -# {'id': 2, 'name': 'source-2', 'target': 1}, -# {'id': 3, 'name': 'source-3', 'target': 1} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_incorrect_type(self): -# data = {'id': 1, 'name': 'source-1', 'target': 'foo'} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected pk value, received %s.' % six.text_type.__name__]}) - -# def test_reverse_foreign_key_update(self): -# data = {'id': 2, 'name': 'target-2', 'sources': [1, 3]} -# instance = ForeignKeyTarget.objects.get(pk=2) -# serializer = ForeignKeyTargetSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# # We shouldn't have saved anything to the db yet since save -# # hasn't been called. -# queryset = ForeignKeyTarget.objects.all() -# new_serializer = ForeignKeyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, -# {'id': 2, 'name': 'target-2', 'sources': []}, -# ] -# self.assertEqual(new_serializer.data, expected) - -# serializer.save() -# self.assertEqual(serializer.data, data) - -# # Ensure target 2 is update, and everything else is as expected -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [2]}, -# {'id': 2, 'name': 'target-2', 'sources': [1, 3]}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create(self): -# data = {'id': 4, 'name': 'source-4', 'target': 2} -# serializer = ForeignKeySourceSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is added, and everything else is as expected -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 1}, -# {'id': 2, 'name': 'source-2', 'target': 1}, -# {'id': 3, 'name': 'source-3', 'target': 1}, -# {'id': 4, 'name': 'source-4', 'target': 2}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_foreign_key_create(self): -# data = {'id': 3, 'name': 'target-3', 'sources': [1, 3]} -# serializer = ForeignKeyTargetSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-3') - -# # Ensure target 3 is added, and everything else is as expected -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [2]}, -# {'id': 2, 'name': 'target-2', 'sources': []}, -# {'id': 3, 'name': 'target-3', 'sources': [1, 3]}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_invalid_null(self): -# data = {'id': 1, 'name': 'source-1', 'target': None} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'target': ['This field is required.']}) - -# def test_foreign_key_with_empty(self): -# """ -# Regression test for #1072 - -# https://github.com/tomchristie/django-rest-framework/issues/1072 -# """ -# serializer = NullableForeignKeySourceSerializer() -# self.assertEqual(serializer.data['target'], None) - - -# class PKNullableForeignKeyTests(TestCase): -# def setUp(self): -# target = ForeignKeyTarget(name='target-1') -# target.save() -# for idx in range(1, 4): -# if idx == 3: -# target = None -# source = NullableForeignKeySource(name='source-%d' % idx, target=target) -# source.save() - -# def test_foreign_key_retrieve_with_null(self): -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 1}, -# {'id': 2, 'name': 'source-2', 'target': 1}, -# {'id': 3, 'name': 'source-3', 'target': None}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create_with_valid_null(self): -# data = {'id': 4, 'name': 'source-4', 'target': None} -# serializer = NullableForeignKeySourceSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is created, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 1}, -# {'id': 2, 'name': 'source-2', 'target': 1}, -# {'id': 3, 'name': 'source-3', 'target': None}, -# {'id': 4, 'name': 'source-4', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create_with_valid_emptystring(self): -# """ -# The emptystring should be interpreted as null in the context -# of relationships. -# """ -# data = {'id': 4, 'name': 'source-4', 'target': ''} -# expected_data = {'id': 4, 'name': 'source-4', 'target': None} -# serializer = NullableForeignKeySourceSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, expected_data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is created, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 1}, -# {'id': 2, 'name': 'source-2', 'target': 1}, -# {'id': 3, 'name': 'source-3', 'target': None}, -# {'id': 4, 'name': 'source-4', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_valid_null(self): -# data = {'id': 1, 'name': 'source-1', 'target': None} -# instance = NullableForeignKeySource.objects.get(pk=1) -# serializer = NullableForeignKeySourceSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': None}, -# {'id': 2, 'name': 'source-2', 'target': 1}, -# {'id': 3, 'name': 'source-3', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_valid_emptystring(self): -# """ -# The emptystring should be interpreted as null in the context -# of relationships. -# """ -# data = {'id': 1, 'name': 'source-1', 'target': ''} -# expected_data = {'id': 1, 'name': 'source-1', 'target': None} -# instance = NullableForeignKeySource.objects.get(pk=1) -# serializer = NullableForeignKeySourceSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, expected_data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': None}, -# {'id': 2, 'name': 'source-2', 'target': 1}, -# {'id': 3, 'name': 'source-3', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# # reverse foreign keys MUST be read_only -# # In the general case they do not provide .remove() or .clear() -# # and cannot be arbitrarily set. - -# # def test_reverse_foreign_key_update(self): -# # data = {'id': 1, 'name': 'target-1', 'sources': [1]} -# # instance = ForeignKeyTarget.objects.get(pk=1) -# # serializer = ForeignKeyTargetSerializer(instance, data=data) -# # self.assertTrue(serializer.is_valid()) -# # self.assertEqual(serializer.data, data) -# # serializer.save() - -# # # Ensure target 1 is updated, and everything else is as expected -# # queryset = ForeignKeyTarget.objects.all() -# # serializer = ForeignKeyTargetSerializer(queryset, many=True) -# # expected = [ -# # {'id': 1, 'name': 'target-1', 'sources': [1]}, -# # {'id': 2, 'name': 'target-2', 'sources': []}, -# # ] -# # self.assertEqual(serializer.data, expected) - - -# class PKNullableOneToOneTests(TestCase): -# def setUp(self): -# target = OneToOneTarget(name='target-1') -# target.save() -# new_target = OneToOneTarget(name='target-2') -# new_target.save() -# source = NullableOneToOneSource(name='source-1', target=new_target) -# source.save() - -# def test_reverse_foreign_key_retrieve_with_null(self): -# queryset = OneToOneTarget.objects.all() -# serializer = NullableOneToOneTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'nullable_source': None}, -# {'id': 2, 'name': 'target-2', 'nullable_source': 1}, -# ] -# self.assertEqual(serializer.data, expected) - - -# # The below models and tests ensure that serializer fields corresponding -# # to a ManyToManyField field with a user-specified ``through`` model are -# # set to read only +from __future__ import unicode_literals +from django.test import TestCase +from django.utils import six +from rest_framework import serializers +from tests.models import ( + ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, + NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource, +) + + +# ManyToMany +class ManyToManyTargetSerializer(serializers.ModelSerializer): + class Meta: + model = ManyToManyTarget + fields = ('id', 'name', 'sources') + + +class ManyToManySourceSerializer(serializers.ModelSerializer): + class Meta: + model = ManyToManySource + fields = ('id', 'name', 'targets') + + +# ForeignKey +class ForeignKeyTargetSerializer(serializers.ModelSerializer): + class Meta: + model = ForeignKeyTarget + fields = ('id', 'name', 'sources') + + +class ForeignKeySourceSerializer(serializers.ModelSerializer): + class Meta: + model = ForeignKeySource + fields = ('id', 'name', 'target') + + +# Nullable ForeignKey +class NullableForeignKeySourceSerializer(serializers.ModelSerializer): + class Meta: + model = NullableForeignKeySource + fields = ('id', 'name', 'target') + + +# Nullable OneToOne +class NullableOneToOneTargetSerializer(serializers.ModelSerializer): + class Meta: + model = OneToOneTarget + fields = ('id', 'name', 'nullable_source') + + +# TODO: Add test that .data cannot be accessed prior to .is_valid + +class PKManyToManyTests(TestCase): + def setUp(self): + for idx in range(1, 4): + target = ManyToManyTarget(name='target-%d' % idx) + target.save() + source = ManyToManySource(name='source-%d' % idx) + source.save() + for target in ManyToManyTarget.objects.all(): + source.targets.add(target) + + def test_many_to_many_retrieve(self): + queryset = ManyToManySource.objects.all() + serializer = ManyToManySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'targets': [1]}, + {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, + {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_many_to_many_retrieve(self): + queryset = ManyToManyTarget.objects.all() + serializer = ManyToManyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, + {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, + {'id': 3, 'name': 'target-3', 'sources': [3]} + ] + self.assertEqual(serializer.data, expected) + + def test_many_to_many_update(self): + data = {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]} + instance = ManyToManySource.objects.get(pk=1) + serializer = ManyToManySourceSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = ManyToManySource.objects.all() + serializer = ManyToManySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'targets': [1, 2, 3]}, + {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, + {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]} + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_many_to_many_update(self): + data = {'id': 1, 'name': 'target-1', 'sources': [1]} + instance = ManyToManyTarget.objects.get(pk=1) + serializer = ManyToManyTargetSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure target 1 is updated, and everything else is as expected + queryset = ManyToManyTarget.objects.all() + serializer = ManyToManyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': [1]}, + {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, + {'id': 3, 'name': 'target-3', 'sources': [3]} + ] + self.assertEqual(serializer.data, expected) + + def test_many_to_many_create(self): + data = {'id': 4, 'name': 'source-4', 'targets': [1, 3]} + serializer = ManyToManySourceSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is added, and everything else is as expected + queryset = ManyToManySource.objects.all() + serializer = ManyToManySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'targets': [1]}, + {'id': 2, 'name': 'source-2', 'targets': [1, 2]}, + {'id': 3, 'name': 'source-3', 'targets': [1, 2, 3]}, + {'id': 4, 'name': 'source-4', 'targets': [1, 3]}, + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_many_to_many_create(self): + data = {'id': 4, 'name': 'target-4', 'sources': [1, 3]} + serializer = ManyToManyTargetSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'target-4') + + # Ensure target 4 is added, and everything else is as expected + queryset = ManyToManyTarget.objects.all() + serializer = ManyToManyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, + {'id': 2, 'name': 'target-2', 'sources': [2, 3]}, + {'id': 3, 'name': 'target-3', 'sources': [3]}, + {'id': 4, 'name': 'target-4', 'sources': [1, 3]} + ] + self.assertEqual(serializer.data, expected) + + +class PKForeignKeyTests(TestCase): + def setUp(self): + target = ForeignKeyTarget(name='target-1') + target.save() + new_target = ForeignKeyTarget(name='target-2') + new_target.save() + for idx in range(1, 4): + source = ForeignKeySource(name='source-%d' % idx, target=target) + source.save() + + def test_foreign_key_retrieve(self): + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 1}, + {'id': 2, 'name': 'source-2', 'target': 1}, + {'id': 3, 'name': 'source-3', 'target': 1} + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_foreign_key_retrieve(self): + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, + {'id': 2, 'name': 'target-2', 'sources': []}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update(self): + data = {'id': 1, 'name': 'source-1', 'target': 2} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 2}, + {'id': 2, 'name': 'source-2', 'target': 1}, + {'id': 3, 'name': 'source-3', 'target': 1} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_incorrect_type(self): + data = {'id': 1, 'name': 'source-1', 'target': 'foo'} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data) + self.assertFalse(serializer.is_valid()) + self.assertEqual(serializer.errors, {'target': ['Incorrect type. Expected pk value, received %s.' % six.text_type.__name__]}) + + def test_reverse_foreign_key_update(self): + data = {'id': 2, 'name': 'target-2', 'sources': [1, 3]} + instance = ForeignKeyTarget.objects.get(pk=2) + serializer = ForeignKeyTargetSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + # We shouldn't have saved anything to the db yet since save + # hasn't been called. + queryset = ForeignKeyTarget.objects.all() + new_serializer = ForeignKeyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': [1, 2, 3]}, + {'id': 2, 'name': 'target-2', 'sources': []}, + ] + self.assertEqual(new_serializer.data, expected) + + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure target 2 is update, and everything else is as expected + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': [2]}, + {'id': 2, 'name': 'target-2', 'sources': [1, 3]}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create(self): + data = {'id': 4, 'name': 'source-4', 'target': 2} + serializer = ForeignKeySourceSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is added, and everything else is as expected + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 1}, + {'id': 2, 'name': 'source-2', 'target': 1}, + {'id': 3, 'name': 'source-3', 'target': 1}, + {'id': 4, 'name': 'source-4', 'target': 2}, + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_foreign_key_create(self): + data = {'id': 3, 'name': 'target-3', 'sources': [1, 3]} + serializer = ForeignKeyTargetSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'target-3') + + # Ensure target 3 is added, and everything else is as expected + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': [2]}, + {'id': 2, 'name': 'target-2', 'sources': []}, + {'id': 3, 'name': 'target-3', 'sources': [1, 3]}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_invalid_null(self): + data = {'id': 1, 'name': 'source-1', 'target': None} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data) + self.assertFalse(serializer.is_valid()) + self.assertEqual(serializer.errors, {'target': ['This field may not be null.']}) + + def test_foreign_key_with_empty(self): + """ + Regression test for #1072 + + https://github.com/tomchristie/django-rest-framework/issues/1072 + """ + serializer = NullableForeignKeySourceSerializer() + self.assertEqual(serializer.data['target'], None) + + +class PKNullableForeignKeyTests(TestCase): + def setUp(self): + target = ForeignKeyTarget(name='target-1') + target.save() + for idx in range(1, 4): + if idx == 3: + target = None + source = NullableForeignKeySource(name='source-%d' % idx, target=target) + source.save() + + def test_foreign_key_retrieve_with_null(self): + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 1}, + {'id': 2, 'name': 'source-2', 'target': 1}, + {'id': 3, 'name': 'source-3', 'target': None}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create_with_valid_null(self): + data = {'id': 4, 'name': 'source-4', 'target': None} + serializer = NullableForeignKeySourceSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is created, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 1}, + {'id': 2, 'name': 'source-2', 'target': 1}, + {'id': 3, 'name': 'source-3', 'target': None}, + {'id': 4, 'name': 'source-4', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create_with_valid_emptystring(self): + """ + The emptystring should be interpreted as null in the context + of relationships. + """ + data = {'id': 4, 'name': 'source-4', 'target': ''} + expected_data = {'id': 4, 'name': 'source-4', 'target': None} + serializer = NullableForeignKeySourceSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, expected_data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is created, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 1}, + {'id': 2, 'name': 'source-2', 'target': 1}, + {'id': 3, 'name': 'source-3', 'target': None}, + {'id': 4, 'name': 'source-4', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_valid_null(self): + data = {'id': 1, 'name': 'source-1', 'target': None} + instance = NullableForeignKeySource.objects.get(pk=1) + serializer = NullableForeignKeySourceSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': None}, + {'id': 2, 'name': 'source-2', 'target': 1}, + {'id': 3, 'name': 'source-3', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_valid_emptystring(self): + """ + The emptystring should be interpreted as null in the context + of relationships. + """ + data = {'id': 1, 'name': 'source-1', 'target': ''} + expected_data = {'id': 1, 'name': 'source-1', 'target': None} + instance = NullableForeignKeySource.objects.get(pk=1) + serializer = NullableForeignKeySourceSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, expected_data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': None}, + {'id': 2, 'name': 'source-2', 'target': 1}, + {'id': 3, 'name': 'source-3', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + # reverse foreign keys MUST be read_only + # In the general case they do not provide .remove() or .clear() + # and cannot be arbitrarily set. + + # def test_reverse_foreign_key_update(self): + # data = {'id': 1, 'name': 'target-1', 'sources': [1]} + # instance = ForeignKeyTarget.objects.get(pk=1) + # serializer = ForeignKeyTargetSerializer(instance, data=data) + # self.assertTrue(serializer.is_valid()) + # self.assertEqual(serializer.data, data) + # serializer.save() + + # # Ensure target 1 is updated, and everything else is as expected + # queryset = ForeignKeyTarget.objects.all() + # serializer = ForeignKeyTargetSerializer(queryset, many=True) + # expected = [ + # {'id': 1, 'name': 'target-1', 'sources': [1]}, + # {'id': 2, 'name': 'target-2', 'sources': []}, + # ] + # self.assertEqual(serializer.data, expected) + + +class PKNullableOneToOneTests(TestCase): + def setUp(self): + target = OneToOneTarget(name='target-1') + target.save() + new_target = OneToOneTarget(name='target-2') + new_target.save() + source = NullableOneToOneSource(name='source-1', target=new_target) + source.save() + + def test_reverse_foreign_key_retrieve_with_null(self): + queryset = OneToOneTarget.objects.all() + serializer = NullableOneToOneTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'nullable_source': None}, + {'id': 2, 'name': 'target-2', 'nullable_source': 1}, + ] + self.assertEqual(serializer.data, expected) + + +# The below models and tests ensure that serializer fields corresponding +# to a ManyToManyField field with a user-specified ``through`` model are +# set to read only # class ManyToManyThroughTarget(models.Model): @@ -481,7 +478,6 @@ # def test_many_to_many_create(self): # data = {'id': 2, 'name': 'source-2', 'targets': [self.target.pk]} # serializer = ManyToManyThroughSourceSerializer(data=data) -# self.assertTrue(serializer.fields['targets'].read_only) # self.assertTrue(serializer.is_valid()) # obj = serializer.save() # self.assertEqual(obj.name, 'source-2') @@ -490,9 +486,7 @@ # def test_many_to_many_reverse_create(self): # data = {'id': 2, 'name': 'target-2', 'sources': [self.source.pk]} # serializer = ManyToManyThroughTargetSerializer(data=data) -# self.assertTrue(serializer.fields['sources'].read_only) # self.assertTrue(serializer.is_valid()) -# serializer.save() # obj = serializer.save() # self.assertEqual(obj.name, 'target-2') # self.assertEqual(obj.sources.count(), 0) diff --git a/tests/test_relations_slug.py b/tests/test_relations_slug.py index f7a59a95..7bac9046 100644 --- a/tests/test_relations_slug.py +++ b/tests/test_relations_slug.py @@ -1,257 +1,268 @@ -# from django.test import TestCase -# from rest_framework import serializers -# from tests.models import NullableForeignKeySource, ForeignKeySource, ForeignKeyTarget - - -# class ForeignKeyTargetSerializer(serializers.ModelSerializer): -# sources = serializers.SlugRelatedField(many=True, slug_field='name') - -# class Meta: -# model = ForeignKeyTarget - - -# class ForeignKeySourceSerializer(serializers.ModelSerializer): -# target = serializers.SlugRelatedField(slug_field='name') - -# class Meta: -# model = ForeignKeySource - - -# class NullableForeignKeySourceSerializer(serializers.ModelSerializer): -# target = serializers.SlugRelatedField(slug_field='name', required=False) - -# class Meta: -# model = NullableForeignKeySource - - -# # TODO: M2M Tests, FKTests (Non-nullable), One2One -# class SlugForeignKeyTests(TestCase): -# def setUp(self): -# target = ForeignKeyTarget(name='target-1') -# target.save() -# new_target = ForeignKeyTarget(name='target-2') -# new_target.save() -# for idx in range(1, 4): -# source = ForeignKeySource(name='source-%d' % idx, target=target) -# source.save() - -# def test_foreign_key_retrieve(self): -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, -# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, -# {'id': 3, 'name': 'source-3', 'target': 'target-1'} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_foreign_key_retrieve(self): -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, -# {'id': 2, 'name': 'target-2', 'sources': []}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update(self): -# data = {'id': 1, 'name': 'source-1', 'target': 'target-2'} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 'target-2'}, -# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, -# {'id': 3, 'name': 'source-3', 'target': 'target-1'} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_incorrect_type(self): -# data = {'id': 1, 'name': 'source-1', 'target': 123} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'target': ['Object with name=123 does not exist.']}) - -# def test_reverse_foreign_key_update(self): -# data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']} -# instance = ForeignKeyTarget.objects.get(pk=2) -# serializer = ForeignKeyTargetSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# # We shouldn't have saved anything to the db yet since save -# # hasn't been called. -# queryset = ForeignKeyTarget.objects.all() -# new_serializer = ForeignKeyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, -# {'id': 2, 'name': 'target-2', 'sources': []}, -# ] -# self.assertEqual(new_serializer.data, expected) - -# serializer.save() -# self.assertEqual(serializer.data, data) - -# # Ensure target 2 is update, and everything else is as expected -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, -# {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create(self): -# data = {'id': 4, 'name': 'source-4', 'target': 'target-2'} -# serializer = ForeignKeySourceSerializer(data=data) -# serializer.is_valid() -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is added, and everything else is as expected -# queryset = ForeignKeySource.objects.all() -# serializer = ForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, -# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, -# {'id': 3, 'name': 'source-3', 'target': 'target-1'}, -# {'id': 4, 'name': 'source-4', 'target': 'target-2'}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_reverse_foreign_key_create(self): -# data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']} -# serializer = ForeignKeyTargetSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-3') - -# # Ensure target 3 is added, and everything else is as expected -# queryset = ForeignKeyTarget.objects.all() -# serializer = ForeignKeyTargetSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, -# {'id': 2, 'name': 'target-2', 'sources': []}, -# {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_invalid_null(self): -# data = {'id': 1, 'name': 'source-1', 'target': None} -# instance = ForeignKeySource.objects.get(pk=1) -# serializer = ForeignKeySourceSerializer(instance, data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'target': ['This field is required.']}) - - -# class SlugNullableForeignKeyTests(TestCase): -# def setUp(self): -# target = ForeignKeyTarget(name='target-1') -# target.save() -# for idx in range(1, 4): -# if idx == 3: -# target = None -# source = NullableForeignKeySource(name='source-%d' % idx, target=target) -# source.save() - -# def test_foreign_key_retrieve_with_null(self): -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, -# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, -# {'id': 3, 'name': 'source-3', 'target': None}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create_with_valid_null(self): -# data = {'id': 4, 'name': 'source-4', 'target': None} -# serializer = NullableForeignKeySourceSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is created, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, -# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, -# {'id': 3, 'name': 'source-3', 'target': None}, -# {'id': 4, 'name': 'source-4', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_create_with_valid_emptystring(self): -# """ -# The emptystring should be interpreted as null in the context -# of relationships. -# """ -# data = {'id': 4, 'name': 'source-4', 'target': ''} -# expected_data = {'id': 4, 'name': 'source-4', 'target': None} -# serializer = NullableForeignKeySourceSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, expected_data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure source 4 is created, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': 'target-1'}, -# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, -# {'id': 3, 'name': 'source-3', 'target': None}, -# {'id': 4, 'name': 'source-4', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_valid_null(self): -# data = {'id': 1, 'name': 'source-1', 'target': None} -# instance = NullableForeignKeySource.objects.get(pk=1) -# serializer = NullableForeignKeySourceSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': None}, -# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, -# {'id': 3, 'name': 'source-3', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_foreign_key_update_with_valid_emptystring(self): -# """ -# The emptystring should be interpreted as null in the context -# of relationships. -# """ -# data = {'id': 1, 'name': 'source-1', 'target': ''} -# expected_data = {'id': 1, 'name': 'source-1', 'target': None} -# instance = NullableForeignKeySource.objects.get(pk=1) -# serializer = NullableForeignKeySourceSerializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, expected_data) -# serializer.save() - -# # Ensure source 1 is updated, and everything else is as expected -# queryset = NullableForeignKeySource.objects.all() -# serializer = NullableForeignKeySourceSerializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': None}, -# {'id': 2, 'name': 'source-2', 'target': 'target-1'}, -# {'id': 3, 'name': 'source-3', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) +from django.test import TestCase +from rest_framework import serializers +from tests.models import NullableForeignKeySource, ForeignKeySource, ForeignKeyTarget + + +class ForeignKeyTargetSerializer(serializers.ModelSerializer): + sources = serializers.SlugRelatedField( + slug_field='name', + queryset=ForeignKeySource.objects.all(), + many=True + ) + + class Meta: + model = ForeignKeyTarget + + +class ForeignKeySourceSerializer(serializers.ModelSerializer): + target = serializers.SlugRelatedField( + slug_field='name', + queryset=ForeignKeyTarget.objects.all() + ) + + class Meta: + model = ForeignKeySource + + +class NullableForeignKeySourceSerializer(serializers.ModelSerializer): + target = serializers.SlugRelatedField( + slug_field='name', + queryset=ForeignKeyTarget.objects.all(), + allow_null=True + ) + + class Meta: + model = NullableForeignKeySource + + +# TODO: M2M Tests, FKTests (Non-nullable), One2One +class SlugForeignKeyTests(TestCase): + def setUp(self): + target = ForeignKeyTarget(name='target-1') + target.save() + new_target = ForeignKeyTarget(name='target-2') + new_target.save() + for idx in range(1, 4): + source = ForeignKeySource(name='source-%d' % idx, target=target) + source.save() + + def test_foreign_key_retrieve(self): + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 'target-1'}, + {'id': 2, 'name': 'source-2', 'target': 'target-1'}, + {'id': 3, 'name': 'source-3', 'target': 'target-1'} + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_foreign_key_retrieve(self): + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, + {'id': 2, 'name': 'target-2', 'sources': []}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update(self): + data = {'id': 1, 'name': 'source-1', 'target': 'target-2'} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 'target-2'}, + {'id': 2, 'name': 'source-2', 'target': 'target-1'}, + {'id': 3, 'name': 'source-3', 'target': 'target-1'} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_incorrect_type(self): + data = {'id': 1, 'name': 'source-1', 'target': 123} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data) + self.assertFalse(serializer.is_valid()) + self.assertEqual(serializer.errors, {'target': ['Object with name=123 does not exist.']}) + + def test_reverse_foreign_key_update(self): + data = {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']} + instance = ForeignKeyTarget.objects.get(pk=2) + serializer = ForeignKeyTargetSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + # We shouldn't have saved anything to the db yet since save + # hasn't been called. + queryset = ForeignKeyTarget.objects.all() + new_serializer = ForeignKeyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': ['source-1', 'source-2', 'source-3']}, + {'id': 2, 'name': 'target-2', 'sources': []}, + ] + self.assertEqual(new_serializer.data, expected) + + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure target 2 is update, and everything else is as expected + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, + {'id': 2, 'name': 'target-2', 'sources': ['source-1', 'source-3']}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create(self): + data = {'id': 4, 'name': 'source-4', 'target': 'target-2'} + serializer = ForeignKeySourceSerializer(data=data) + serializer.is_valid() + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is added, and everything else is as expected + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 'target-1'}, + {'id': 2, 'name': 'source-2', 'target': 'target-1'}, + {'id': 3, 'name': 'source-3', 'target': 'target-1'}, + {'id': 4, 'name': 'source-4', 'target': 'target-2'}, + ] + self.assertEqual(serializer.data, expected) + + def test_reverse_foreign_key_create(self): + data = {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']} + serializer = ForeignKeyTargetSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'target-3') + + # Ensure target 3 is added, and everything else is as expected + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'target-1', 'sources': ['source-2']}, + {'id': 2, 'name': 'target-2', 'sources': []}, + {'id': 3, 'name': 'target-3', 'sources': ['source-1', 'source-3']}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_invalid_null(self): + data = {'id': 1, 'name': 'source-1', 'target': None} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(instance, data=data) + self.assertFalse(serializer.is_valid()) + self.assertEqual(serializer.errors, {'target': ['This field may not be null.']}) + + +class SlugNullableForeignKeyTests(TestCase): + def setUp(self): + target = ForeignKeyTarget(name='target-1') + target.save() + for idx in range(1, 4): + if idx == 3: + target = None + source = NullableForeignKeySource(name='source-%d' % idx, target=target) + source.save() + + def test_foreign_key_retrieve_with_null(self): + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 'target-1'}, + {'id': 2, 'name': 'source-2', 'target': 'target-1'}, + {'id': 3, 'name': 'source-3', 'target': None}, + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create_with_valid_null(self): + data = {'id': 4, 'name': 'source-4', 'target': None} + serializer = NullableForeignKeySourceSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is created, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 'target-1'}, + {'id': 2, 'name': 'source-2', 'target': 'target-1'}, + {'id': 3, 'name': 'source-3', 'target': None}, + {'id': 4, 'name': 'source-4', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_create_with_valid_emptystring(self): + """ + The emptystring should be interpreted as null in the context + of relationships. + """ + data = {'id': 4, 'name': 'source-4', 'target': ''} + expected_data = {'id': 4, 'name': 'source-4', 'target': None} + serializer = NullableForeignKeySourceSerializer(data=data) + self.assertTrue(serializer.is_valid()) + obj = serializer.save() + self.assertEqual(serializer.data, expected_data) + self.assertEqual(obj.name, 'source-4') + + # Ensure source 4 is created, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': 'target-1'}, + {'id': 2, 'name': 'source-2', 'target': 'target-1'}, + {'id': 3, 'name': 'source-3', 'target': None}, + {'id': 4, 'name': 'source-4', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_valid_null(self): + data = {'id': 1, 'name': 'source-1', 'target': None} + instance = NullableForeignKeySource.objects.get(pk=1) + serializer = NullableForeignKeySourceSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': None}, + {'id': 2, 'name': 'source-2', 'target': 'target-1'}, + {'id': 3, 'name': 'source-3', 'target': None} + ] + self.assertEqual(serializer.data, expected) + + def test_foreign_key_update_with_valid_emptystring(self): + """ + The emptystring should be interpreted as null in the context + of relationships. + """ + data = {'id': 1, 'name': 'source-1', 'target': ''} + expected_data = {'id': 1, 'name': 'source-1', 'target': None} + instance = NullableForeignKeySource.objects.get(pk=1) + serializer = NullableForeignKeySourceSerializer(instance, data=data) + self.assertTrue(serializer.is_valid()) + serializer.save() + self.assertEqual(serializer.data, expected_data) + + # Ensure source 1 is updated, and everything else is as expected + queryset = NullableForeignKeySource.objects.all() + serializer = NullableForeignKeySourceSerializer(queryset, many=True) + expected = [ + {'id': 1, 'name': 'source-1', 'target': None}, + {'id': 2, 'name': 'source-2', 'target': 'target-1'}, + {'id': 3, 'name': 'source-3', 'target': None} + ] + self.assertEqual(serializer.data, expected) -- cgit v1.2.3 From 6b09e5f2bba9167404ec329fa12c7f0215ca51ac Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 11:22:10 +0100 Subject: Tests for generic relationships --- rest_framework/relations.py | 2 +- rest_framework/serializers.py | 10 +- tests/test_genericrelations.py | 255 +++++++++++++++++------------------------ 3 files changed, 110 insertions(+), 157 deletions(-) diff --git a/rest_framework/relations.py b/rest_framework/relations.py index e5bdf60c..df5025b8 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -49,7 +49,7 @@ class RelatedField(Field): ]) -class StringRelatedField(Field): +class StringRelatedField(RelatedField): """ A read only field that represents its targets using their plain string representation. diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index ed024f87..3d868a9e 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -520,11 +520,6 @@ class ModelSerializer(Serializer): ret[field_name] = declared_fields[field_name] continue - elif field_name == api_settings.URL_FIELD_NAME: - # Create the URL field. - field_cls = HyperlinkedIdentityField - kwargs = get_url_kwargs(model) - elif field_name in info.fields_and_pk: # Create regular model fields. model_field = info.fields_and_pk[field_name] @@ -561,6 +556,11 @@ class ModelSerializer(Serializer): field_cls = ReadOnlyField kwargs = {} + elif field_name == api_settings.URL_FIELD_NAME: + # Create the URL field. + field_cls = HyperlinkedIdentityField + kwargs = get_url_kwargs(model) + else: raise ImproperlyConfigured( 'Field name `%s` is not valid for model `%s`.' % diff --git a/tests/test_genericrelations.py b/tests/test_genericrelations.py index a87ea3fd..380ad91d 100644 --- a/tests/test_genericrelations.py +++ b/tests/test_genericrelations.py @@ -1,151 +1,104 @@ -# from __future__ import unicode_literals -# from django.contrib.contenttypes.models import ContentType -# from django.contrib.contenttypes.generic import GenericRelation, GenericForeignKey -# from django.db import models -# from django.test import TestCase -# from rest_framework import serializers -# from rest_framework.compat import python_2_unicode_compatible - - -# @python_2_unicode_compatible -# class Tag(models.Model): -# """ -# Tags have a descriptive slug, and are attached to an arbitrary object. -# """ -# tag = models.SlugField() -# content_type = models.ForeignKey(ContentType) -# object_id = models.PositiveIntegerField() -# tagged_item = GenericForeignKey('content_type', 'object_id') - -# def __str__(self): -# return self.tag - - -# @python_2_unicode_compatible -# class Bookmark(models.Model): -# """ -# A URL bookmark that may have multiple tags attached. -# """ -# url = models.URLField() -# tags = GenericRelation(Tag) - -# def __str__(self): -# return 'Bookmark: %s' % self.url - - -# @python_2_unicode_compatible -# class Note(models.Model): -# """ -# A textual note that may have multiple tags attached. -# """ -# text = models.TextField() -# tags = GenericRelation(Tag) - -# def __str__(self): -# return 'Note: %s' % self.text - - -# class TestGenericRelations(TestCase): -# def setUp(self): -# self.bookmark = Bookmark.objects.create(url='https://www.djangoproject.com/') -# Tag.objects.create(tagged_item=self.bookmark, tag='django') -# Tag.objects.create(tagged_item=self.bookmark, tag='python') -# self.note = Note.objects.create(text='Remember the milk') -# Tag.objects.create(tagged_item=self.note, tag='reminder') - -# def test_generic_relation(self): -# """ -# Test a relationship that spans a GenericRelation field. -# IE. A reverse generic relationship. -# """ - -# class BookmarkSerializer(serializers.ModelSerializer): -# tags = serializers.RelatedField(many=True) - -# class Meta: -# model = Bookmark -# exclude = ('id',) - -# serializer = BookmarkSerializer(self.bookmark) -# expected = { -# 'tags': ['django', 'python'], -# 'url': 'https://www.djangoproject.com/' -# } -# self.assertEqual(serializer.data, expected) - -# def test_generic_nested_relation(self): -# """ -# Test saving a GenericRelation field via a nested serializer. -# """ - -# class TagSerializer(serializers.ModelSerializer): -# class Meta: -# model = Tag -# exclude = ('content_type', 'object_id') - -# class BookmarkSerializer(serializers.ModelSerializer): -# tags = TagSerializer(many=True) - -# class Meta: -# model = Bookmark -# exclude = ('id',) - -# data = { -# 'url': 'https://docs.djangoproject.com/', -# 'tags': [ -# {'tag': 'contenttypes'}, -# {'tag': 'genericrelations'}, -# ] -# } -# serializer = BookmarkSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# serializer.save() -# self.assertEqual(serializer.object.tags.count(), 2) - -# def test_generic_fk(self): -# """ -# Test a relationship that spans a GenericForeignKey field. -# IE. A forward generic relationship. -# """ - -# class TagSerializer(serializers.ModelSerializer): -# tagged_item = serializers.RelatedField() - -# class Meta: -# model = Tag -# exclude = ('id', 'content_type', 'object_id') - -# serializer = TagSerializer(Tag.objects.all(), many=True) -# expected = [ -# { -# 'tag': 'django', -# 'tagged_item': 'Bookmark: https://www.djangoproject.com/' -# }, -# { -# 'tag': 'python', -# 'tagged_item': 'Bookmark: https://www.djangoproject.com/' -# }, -# { -# 'tag': 'reminder', -# 'tagged_item': 'Note: Remember the milk' -# } -# ] -# self.assertEqual(serializer.data, expected) - -# def test_restore_object_generic_fk(self): -# """ -# Ensure an object with a generic foreign key can be restored. -# """ - -# class TagSerializer(serializers.ModelSerializer): -# class Meta: -# model = Tag -# exclude = ('content_type', 'object_id') - -# serializer = TagSerializer() - -# bookmark = Bookmark(url='http://example.com') -# attrs = {'tagged_item': bookmark, 'tag': 'example'} - -# tag = serializer.restore_object(attrs) -# self.assertEqual(tag.tagged_item, bookmark) +from __future__ import unicode_literals +from django.contrib.contenttypes.models import ContentType +from django.contrib.contenttypes.generic import GenericRelation, GenericForeignKey +from django.db import models +from django.test import TestCase +from rest_framework import serializers +from rest_framework.compat import python_2_unicode_compatible + + +@python_2_unicode_compatible +class Tag(models.Model): + """ + Tags have a descriptive slug, and are attached to an arbitrary object. + """ + tag = models.SlugField() + content_type = models.ForeignKey(ContentType) + object_id = models.PositiveIntegerField() + tagged_item = GenericForeignKey('content_type', 'object_id') + + def __str__(self): + return self.tag + + +@python_2_unicode_compatible +class Bookmark(models.Model): + """ + A URL bookmark that may have multiple tags attached. + """ + url = models.URLField() + tags = GenericRelation(Tag) + + def __str__(self): + return 'Bookmark: %s' % self.url + + +@python_2_unicode_compatible +class Note(models.Model): + """ + A textual note that may have multiple tags attached. + """ + text = models.TextField() + tags = GenericRelation(Tag) + + def __str__(self): + return 'Note: %s' % self.text + + +class TestGenericRelations(TestCase): + def setUp(self): + self.bookmark = Bookmark.objects.create(url='https://www.djangoproject.com/') + Tag.objects.create(tagged_item=self.bookmark, tag='django') + Tag.objects.create(tagged_item=self.bookmark, tag='python') + self.note = Note.objects.create(text='Remember the milk') + Tag.objects.create(tagged_item=self.note, tag='reminder') + + def test_generic_relation(self): + """ + Test a relationship that spans a GenericRelation field. + IE. A reverse generic relationship. + """ + + class BookmarkSerializer(serializers.ModelSerializer): + tags = serializers.StringRelatedField(many=True) + + class Meta: + model = Bookmark + fields = ('tags', 'url') + + serializer = BookmarkSerializer(self.bookmark) + expected = { + 'tags': ['django', 'python'], + 'url': 'https://www.djangoproject.com/' + } + self.assertEqual(serializer.data, expected) + + def test_generic_fk(self): + """ + Test a relationship that spans a GenericForeignKey field. + IE. A forward generic relationship. + """ + + class TagSerializer(serializers.ModelSerializer): + tagged_item = serializers.StringRelatedField() + + class Meta: + model = Tag + fields = ('tag', 'tagged_item') + + serializer = TagSerializer(Tag.objects.all(), many=True) + expected = [ + { + 'tag': 'django', + 'tagged_item': 'Bookmark: https://www.djangoproject.com/' + }, + { + 'tag': 'python', + 'tagged_item': 'Bookmark: https://www.djangoproject.com/' + }, + { + 'tag': 'reminder', + 'tagged_item': 'Note: Remember the milk' + } + ] + self.assertEqual(serializer.data, expected) -- cgit v1.2.3 From af0f01c5b6597fe2f146268f7632f7e3954d17c2 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 11:23:40 +0100 Subject: Move generic relation tests --- tests/test_genericrelations.py | 104 ---------------------------------------- tests/test_relations_generic.py | 104 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 104 insertions(+), 104 deletions(-) delete mode 100644 tests/test_genericrelations.py create mode 100644 tests/test_relations_generic.py diff --git a/tests/test_genericrelations.py b/tests/test_genericrelations.py deleted file mode 100644 index 380ad91d..00000000 --- a/tests/test_genericrelations.py +++ /dev/null @@ -1,104 +0,0 @@ -from __future__ import unicode_literals -from django.contrib.contenttypes.models import ContentType -from django.contrib.contenttypes.generic import GenericRelation, GenericForeignKey -from django.db import models -from django.test import TestCase -from rest_framework import serializers -from rest_framework.compat import python_2_unicode_compatible - - -@python_2_unicode_compatible -class Tag(models.Model): - """ - Tags have a descriptive slug, and are attached to an arbitrary object. - """ - tag = models.SlugField() - content_type = models.ForeignKey(ContentType) - object_id = models.PositiveIntegerField() - tagged_item = GenericForeignKey('content_type', 'object_id') - - def __str__(self): - return self.tag - - -@python_2_unicode_compatible -class Bookmark(models.Model): - """ - A URL bookmark that may have multiple tags attached. - """ - url = models.URLField() - tags = GenericRelation(Tag) - - def __str__(self): - return 'Bookmark: %s' % self.url - - -@python_2_unicode_compatible -class Note(models.Model): - """ - A textual note that may have multiple tags attached. - """ - text = models.TextField() - tags = GenericRelation(Tag) - - def __str__(self): - return 'Note: %s' % self.text - - -class TestGenericRelations(TestCase): - def setUp(self): - self.bookmark = Bookmark.objects.create(url='https://www.djangoproject.com/') - Tag.objects.create(tagged_item=self.bookmark, tag='django') - Tag.objects.create(tagged_item=self.bookmark, tag='python') - self.note = Note.objects.create(text='Remember the milk') - Tag.objects.create(tagged_item=self.note, tag='reminder') - - def test_generic_relation(self): - """ - Test a relationship that spans a GenericRelation field. - IE. A reverse generic relationship. - """ - - class BookmarkSerializer(serializers.ModelSerializer): - tags = serializers.StringRelatedField(many=True) - - class Meta: - model = Bookmark - fields = ('tags', 'url') - - serializer = BookmarkSerializer(self.bookmark) - expected = { - 'tags': ['django', 'python'], - 'url': 'https://www.djangoproject.com/' - } - self.assertEqual(serializer.data, expected) - - def test_generic_fk(self): - """ - Test a relationship that spans a GenericForeignKey field. - IE. A forward generic relationship. - """ - - class TagSerializer(serializers.ModelSerializer): - tagged_item = serializers.StringRelatedField() - - class Meta: - model = Tag - fields = ('tag', 'tagged_item') - - serializer = TagSerializer(Tag.objects.all(), many=True) - expected = [ - { - 'tag': 'django', - 'tagged_item': 'Bookmark: https://www.djangoproject.com/' - }, - { - 'tag': 'python', - 'tagged_item': 'Bookmark: https://www.djangoproject.com/' - }, - { - 'tag': 'reminder', - 'tagged_item': 'Note: Remember the milk' - } - ] - self.assertEqual(serializer.data, expected) diff --git a/tests/test_relations_generic.py b/tests/test_relations_generic.py new file mode 100644 index 00000000..380ad91d --- /dev/null +++ b/tests/test_relations_generic.py @@ -0,0 +1,104 @@ +from __future__ import unicode_literals +from django.contrib.contenttypes.models import ContentType +from django.contrib.contenttypes.generic import GenericRelation, GenericForeignKey +from django.db import models +from django.test import TestCase +from rest_framework import serializers +from rest_framework.compat import python_2_unicode_compatible + + +@python_2_unicode_compatible +class Tag(models.Model): + """ + Tags have a descriptive slug, and are attached to an arbitrary object. + """ + tag = models.SlugField() + content_type = models.ForeignKey(ContentType) + object_id = models.PositiveIntegerField() + tagged_item = GenericForeignKey('content_type', 'object_id') + + def __str__(self): + return self.tag + + +@python_2_unicode_compatible +class Bookmark(models.Model): + """ + A URL bookmark that may have multiple tags attached. + """ + url = models.URLField() + tags = GenericRelation(Tag) + + def __str__(self): + return 'Bookmark: %s' % self.url + + +@python_2_unicode_compatible +class Note(models.Model): + """ + A textual note that may have multiple tags attached. + """ + text = models.TextField() + tags = GenericRelation(Tag) + + def __str__(self): + return 'Note: %s' % self.text + + +class TestGenericRelations(TestCase): + def setUp(self): + self.bookmark = Bookmark.objects.create(url='https://www.djangoproject.com/') + Tag.objects.create(tagged_item=self.bookmark, tag='django') + Tag.objects.create(tagged_item=self.bookmark, tag='python') + self.note = Note.objects.create(text='Remember the milk') + Tag.objects.create(tagged_item=self.note, tag='reminder') + + def test_generic_relation(self): + """ + Test a relationship that spans a GenericRelation field. + IE. A reverse generic relationship. + """ + + class BookmarkSerializer(serializers.ModelSerializer): + tags = serializers.StringRelatedField(many=True) + + class Meta: + model = Bookmark + fields = ('tags', 'url') + + serializer = BookmarkSerializer(self.bookmark) + expected = { + 'tags': ['django', 'python'], + 'url': 'https://www.djangoproject.com/' + } + self.assertEqual(serializer.data, expected) + + def test_generic_fk(self): + """ + Test a relationship that spans a GenericForeignKey field. + IE. A forward generic relationship. + """ + + class TagSerializer(serializers.ModelSerializer): + tagged_item = serializers.StringRelatedField() + + class Meta: + model = Tag + fields = ('tag', 'tagged_item') + + serializer = TagSerializer(Tag.objects.all(), many=True) + expected = [ + { + 'tag': 'django', + 'tagged_item': 'Bookmark: https://www.djangoproject.com/' + }, + { + 'tag': 'python', + 'tagged_item': 'Bookmark: https://www.djangoproject.com/' + }, + { + 'tag': 'reminder', + 'tagged_item': 'Note: Remember the milk' + } + ] + self.assertEqual(serializer.data, expected) -- cgit v1.2.3 From 0cbb57b40fdb073c7ca09c9d1078926260c646db Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 12:17:30 +0100 Subject: Tweak pre/post save hooks. Return instance in .update(). --- docs/topics/3.0-announcement.md | 26 ++++++++++++++++++-------- rest_framework/mixins.py | 13 ++++++++----- rest_framework/serializers.py | 24 ++++++++++++++---------- 3 files changed, 40 insertions(+), 23 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 4a781503..89817ea5 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -116,11 +116,12 @@ This would now be split out into two separate methods. instance.language = validated_data.get('language', instance.language) instance.style = validated_data.get('style', instance.style) instance.save() + return instance def create(self, validated_data): return Snippet.objects.create(**validated_data) -Note that the `.create` method should return the newly created object instance. +Note that these methods should return the newly created object instance. #### Use `.validated_data` instead of `.object`. @@ -592,18 +593,27 @@ The `UniqueTogetherValidator` should be applied to a serializer, and takes a `qu The view logic for the default method handlers has been significantly simplified, due to the new serializers API. -#### Removal of pre/post save hooks. +#### Changes to pre/post save hooks. -The following method hooks no longer exist on the new, simplified, generic views: `pre_save`, `post_save`, `pre_delete`, `post_delete`. +The `pre_save` and `post_save` hooks no longer exist, but are replaced with `perform_create(self, serializer)` and `perform_update(self, serializer)`. -If you do need custom behavior, you might choose to instead override the `.save()` method on your serializer class. For example: +These method should save the object instance by calling `serializer.save()`, adding in any explicit additional arguments as required. They may also perform any custom pre-save or post-save behavior. - def save(self, *args, **kwargs): - instance = super(MySerializer).save(*args, **kwarg) +For example: + + def perform_create(self, serializer): + # Include the owner attribute directly, rather than from request data. + instance = serializer.save(owner=self.request.user) + # Perform a custom post-save action. send_email(instance.to_email, instance.message) - return instance -Alternatively write your view logic exlpicitly, or tie your pre/post save behavior into the model class or model manager. +The `pre_delete` and `post_delete` hooks no longer exist, and are replaced with `.perform_destroy(self, instance)`, which should delete the instance and perform any custom actions. + + def perform_destroy(self, instance): + # Perform a custom pre-delete action. + send_deletion_alert(user=instance.created_by, deleted=instance) + # Delete the object instance. + instance.delete() #### Removal of view attributes. diff --git a/rest_framework/mixins.py b/rest_framework/mixins.py index 03ebb034..4c62debb 100644 --- a/rest_framework/mixins.py +++ b/rest_framework/mixins.py @@ -20,11 +20,11 @@ class CreateModelMixin(object): def create(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.data) serializer.is_valid(raise_exception=True) - self.create_valid(serializer) + self.perform_create(serializer) headers = self.get_success_headers(serializer.data) return Response(serializer.data, status=status.HTTP_201_CREATED, headers=headers) - def create_valid(self, serializer): + def perform_create(self, serializer): serializer.save() def get_success_headers(self, data): @@ -67,10 +67,10 @@ class UpdateModelMixin(object): instance = self.get_object() serializer = self.get_serializer(instance, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) - self.update_valid(serializer) + self.preform_update(serializer) return Response(serializer.data) - def update_valid(self, serializer): + def preform_update(self, serializer): serializer.save() def partial_update(self, request, *args, **kwargs): @@ -84,9 +84,12 @@ class DestroyModelMixin(object): """ def destroy(self, request, *args, **kwargs): instance = self.get_object() - instance.delete() + self.perform_destroy(instance) return Response(status=status.HTTP_204_NO_CONTENT) + def perform_destroy(self, instance): + instance.delete() + # The AllowPUTAsCreateMixin was previously the default behaviour # for PUT requests. This has now been removed and must be *explicitly* diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 3d868a9e..e7cd50d6 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -83,7 +83,10 @@ class BaseSerializer(Field): ) if self.instance is not None: - self.update(self.instance, validated_data) + self.instance = self.update(self.instance, validated_data) + assert self.instance is not None, ( + '`update()` did not return an object instance.' + ) else: self.instance = self.create(validated_data) assert self.instance is not None, ( @@ -444,19 +447,19 @@ class ModelSerializer(Serializer): self.validators.extend(validators) self._kwargs['validators'] = validators - def create(self, attrs): + def create(self, validated_attrs): ModelClass = self.Meta.model - # Remove many-to-many relationships from attrs. + # Remove many-to-many relationships from validated_attrs. # They are not valid arguments to the default `.create()` method, # as they require that the instance has already been saved. info = model_meta.get_field_info(ModelClass) many_to_many = {} for field_name, relation_info in info.relations.items(): - if relation_info.to_many and (field_name in attrs): - many_to_many[field_name] = attrs.pop(field_name) + if relation_info.to_many and (field_name in validated_attrs): + many_to_many[field_name] = validated_attrs.pop(field_name) - instance = ModelClass.objects.create(**attrs) + instance = ModelClass.objects.create(**validated_attrs) # Save many-to-many relationships after the instance is created. if many_to_many: @@ -465,10 +468,11 @@ class ModelSerializer(Serializer): return instance - def update(self, obj, attrs): - for attr, value in attrs.items(): - setattr(obj, attr, value) - obj.save() + def update(self, instance, validated_attrs): + for attr, value in validated_attrs.items(): + setattr(instance, attr, value) + instance.save() + return instance def get_unique_together_validators(self): field_names = set([ -- cgit v1.2.3 From 28f3b314f12cbff33c55602c2c5f5f5cce956171 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 12:36:28 +0100 Subject: .validate() returning validated data. transform_ hooks. --- rest_framework/serializers.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index e7cd50d6..8513428c 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -299,7 +299,8 @@ class Serializer(BaseSerializer): value = self.to_internal_value(data) try: self.run_validators(value) - self.validate(value) + value = self.validate(value) + assert value is not None, '.validate() should return the validated data' except ValidationError as exc: raise ValidationError({ api_settings.NON_FIELD_ERRORS_KEY: exc.messages @@ -341,7 +342,12 @@ class Serializer(BaseSerializer): fields = [field for field in self.fields.values() if not field.write_only] for field in fields: - ret[field.field_name] = field.get_field_representation(instance) + value = field.get_field_representation(instance) + transform_method = getattr(self, 'transform_' + field.field_name, None) + if transform_method is not None: + value = transform_method(value) + + ret[field.field_name] = value return ret -- cgit v1.2.3 From 14ae52a24e93063f77c6010269bf9cd3316627fe Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 16:09:37 +0100 Subject: More gradual deprecation --- docs/topics/3.0-announcement.md | 26 +++++++------ rest_framework/request.py | 16 ++++++++ rest_framework/serializers.py | 71 ++++++++++++++++++++++++++++++++++- rest_framework/utils/field_mapping.py | 22 +++++------ rest_framework/utils/model_meta.py | 4 +- 5 files changed, 113 insertions(+), 26 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 89817ea5..6520f2bd 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -8,10 +8,9 @@ See the [Version 3.0 GitHub issue](https://github.com/tomchristie/django-rest-fr The most notable outstanding issues still to be resolved on the `version-3.0` branch are as follows: -* Forms support for serializers and in the browsable API. +* Finish forms support for serializers and in the browsable API. * Optimisations for serializing primary keys. * Refine style of validation errors in some cases, such as validation errors in `ListField`. -* `.transform_()` method on serializers. **Your feedback on the upgrade process and 3.0 changes is hugely important!** @@ -48,12 +47,13 @@ Below is an in-depth guide to the API changes and migration notes for 3.0. #### The `.data` and `.query_params` properties. -The usage of `request.DATA` and `request.FILES` is now discouraged in favor of a single `request.data` attribute that contains *all* the parsed data. +The usage of `request.DATA` and `request.FILES` is now pending deprecation in favor of a single `request.data` attribute that contains *all* the parsed data. -Having separate attributes is reasonable for web applications that only ever parse URL encoded or MultiPart requests, but makes less sense for the general-purpose request parsing that REST framework supports. +Having separate attributes is reasonable for web applications that only ever parse url-encoded or multipart requests, but makes less sense for the general-purpose request parsing that REST framework supports. You may now pass all the request data to a serializer class in a single argument: + # Do this... ExampleSerializer(data=request.data) Instead of passing the files argument separately: @@ -62,7 +62,7 @@ Instead of passing the files argument separately: ExampleSerializer(data=request.DATA, files=request.FILES) -The usage of `request.QUERY_PARAMS` is now discouraged in favor of the lowercased `request.query_params`. +The usage of `request.QUERY_PARAMS` is now pending deprecation in favor of the lowercased `request.query_params`. ## Serializers @@ -73,7 +73,7 @@ Previously the serializers used a two-step object creation, as follows: 1. Validating the data would create an object instance. This instance would be available as `serializer.object`. 2. Calling `serializer.save()` would then save the object instance to the database. -This style is in line with how the `ModelForm` class works in Django, but is problematic for a number of reasons: +This style is in-line with how the `ModelForm` class works in Django, but is problematic for a number of reasons: * Some data, such as many-to-many relationships, cannot be added to the object instance until after it has been saved. This type of data needed to be hidden in some undocumented state on the object instance, or kept as state on the serializer instance so that it could be used when `.save()` is called. * Instantiating model instances directly means that you cannot use model manager classes for instance creation, eg `ExampleModel.objects.create(...)`. Manager classes are an excellent layer at which to enforce business logic and application-level data constraints. @@ -109,7 +109,7 @@ The following example from the tutorial previously used `restore_object()` to ha This would now be split out into two separate methods. - def update(self, instance, validated_data) + def update(self, instance, validated_data): instance.title = validated_data.get('title', instance.title) instance.code = validated_data.get('code', instance.code) instance.linenos = validated_data.get('linenos', instance.linenos) @@ -211,28 +211,30 @@ The `exclude` option on `ModelSerializer` is no longer available. You should use #### The `extra_kwargs` option. -The `read_only_fields` and `write_only_fields` options on `ModelSerializer` have been removed and replaced with a more generic `extra_kwargs`. +The `write_only_fields` option on `ModelSerializer` has been moved to `PendingDeprecation` and replaced with a more generic `extra_kwargs`. class MySerializer(serializer.ModelSerializer): class Meta: model = MyModel fields = ('id', 'email', 'notes', 'is_admin') extra_kwargs = { - 'is_admin': {'read_only': True} + 'is_admin': {'write_only': True} } Alternatively, specify the field explicitly on the serializer class: class MySerializer(serializer.ModelSerializer): - is_admin = serializers.BooleanField(read_only=True) + is_admin = serializers.BooleanField(write_only=True) class Meta: model = MyModel fields = ('id', 'email', 'notes', 'is_admin') +The `read_only_fields` option remains as a convenient shortcut for the more common case. + #### Changes to `HyperlinkedModelSerializer`. -The `view_name` and `lookup_field` options have been removed. They are no longer required, as you can use the `extra_kwargs` argument instead: +The `view_name` and `lookup_field` options have been moved to `PendingDeprecation`. They are no longer required, as you can use the `extra_kwargs` argument instead: class MySerializer(serializer.HyperlinkedModelSerializer): class Meta: @@ -633,7 +635,7 @@ If you need to restore the previous behavior you can include the `AllowPUTAsCrea The generic views now raise `ValidationError` for invalid data. This exception is then dealt with by the exception handler, rather than the view returning a `400 Bad Request` response directly. -This change means that you can now easily cusomize the style of error responses across your entire API, without having to modify any of the generic views. +This change means that you can now easily customize the style of error responses across your entire API, without having to modify any of the generic views. ## The metadata API diff --git a/rest_framework/request.py b/rest_framework/request.py index d80baa70..d4352742 100644 --- a/rest_framework/request.py +++ b/rest_framework/request.py @@ -18,6 +18,7 @@ from rest_framework import HTTP_HEADER_ENCODING from rest_framework import exceptions from rest_framework.compat import BytesIO from rest_framework.settings import api_settings +import warnings def is_form_media_type(media_type): @@ -209,6 +210,11 @@ class Request(object): """ Synonym for `.query_params`, for backwards compatibility. """ + warnings.warn( + "`request.QUERY_PARAMS` is pending deprecation. Use `request.query_params` instead.", + PendingDeprecationWarning, + stacklevel=1 + ) return self._request.GET @property @@ -225,6 +231,11 @@ class Request(object): Similar to usual behaviour of `request.POST`, except that it handles arbitrary parsers, and also works on methods other than POST (eg PUT). """ + warnings.warn( + "`request.DATA` is pending deprecation. Use `request.data` instead.", + PendingDeprecationWarning, + stacklevel=1 + ) if not _hasattr(self, '_data'): self._load_data_and_files() return self._data @@ -237,6 +248,11 @@ class Request(object): Similar to usual behaviour of `request.FILES`, except that it handles arbitrary parsers, and also works on methods other than POST (eg PUT). """ + warnings.warn( + "`request.FILES` is pending deprecation. Use `request.data` instead.", + PendingDeprecationWarning, + stacklevel=1 + ) if not _hasattr(self, '_files'): self._load_data_and_files() return self._files diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 8513428c..9fcbcba7 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -25,6 +25,7 @@ from rest_framework.utils.field_mapping import ( from rest_framework.validators import UniqueTogetherValidator import copy import inspect +import warnings # Note: We do the following so that users of the framework can use this style: # @@ -517,12 +518,24 @@ class ModelSerializer(Serializer): depth = getattr(self.Meta, 'depth', 0) extra_kwargs = getattr(self.Meta, 'extra_kwargs', {}) + extra_kwargs = self._include_additional_options(extra_kwargs) + # Retrieve metadata about fields & relationships on the model class. info = model_meta.get_field_info(model) # Use the default set of fields if none is supplied explicitly. if fields is None: fields = self._get_default_field_names(declared_fields, info) + exclude = getattr(self.Meta, 'exclude', None) + if exclude is not None: + warnings.warn( + "The `Meta.exclude` option is pending deprecation. " + "Use the explicit `Meta.fields` instead.", + PendingDeprecationWarning, + stacklevel=3 + ) + for field_name in exclude: + fields.remove(field_name) for field_name in fields: if field_name in declared_fields: @@ -589,13 +602,69 @@ class ModelSerializer(Serializer): ) # Populate any kwargs defined in `Meta.extra_kwargs` - kwargs.update(extra_kwargs.get(field_name, {})) + extras = extra_kwargs.get(field_name, {}) + if extras.get('read_only', False): + for attr in [ + 'required', 'default', 'allow_blank', 'allow_null', + 'min_length', 'max_length', 'min_value', 'max_value', + 'validators' + ]: + kwargs.pop(attr, None) + kwargs.update(extras) # Create the serializer field. ret[field_name] = field_cls(**kwargs) return ret + def _include_additional_options(self, extra_kwargs): + read_only_fields = getattr(self.Meta, 'read_only_fields', None) + if read_only_fields is not None: + for field_name in read_only_fields: + kwargs = extra_kwargs.get(field_name, {}) + kwargs['read_only'] = True + extra_kwargs[field_name] = kwargs + + # These are all pending deprecation. + write_only_fields = getattr(self.Meta, 'write_only_fields', None) + if write_only_fields is not None: + warnings.warn( + "The `Meta.write_only_fields` option is pending deprecation. " + "Use `Meta.extra_kwargs={: {'write_only': True}}` instead.", + PendingDeprecationWarning, + stacklevel=3 + ) + for field_name in write_only_fields: + kwargs = extra_kwargs.get(field_name, {}) + kwargs['write_only'] = True + extra_kwargs[field_name] = kwargs + + view_name = getattr(self.Meta, 'view_name', None) + if view_name is not None: + warnings.warn( + "The `Meta.view_name` option is pending deprecation. " + "Use `Meta.extra_kwargs={'url': {'view_name': ...}}` instead.", + PendingDeprecationWarning, + stacklevel=3 + ) + kwargs = extra_kwargs.get(field_name, {}) + kwargs['view_name'] = view_name + extra_kwargs[api_settings.URL_FIELD_NAME] = kwargs + + lookup_field = getattr(self.Meta, 'lookup_field', None) + if lookup_field is not None: + warnings.warn( + "The `Meta.lookup_field` option is pending deprecation. " + "Use `Meta.extra_kwargs={'url': {'lookup_field': ...}}` instead.", + PendingDeprecationWarning, + stacklevel=3 + ) + kwargs = extra_kwargs.get(field_name, {}) + kwargs['lookup_field'] = lookup_field + extra_kwargs[api_settings.URL_FIELD_NAME] = kwargs + + return extra_kwargs + def _get_default_field_names(self, declared_fields, model_info): return ( [model_info.pk.name] + diff --git a/rest_framework/utils/field_mapping.py b/rest_framework/utils/field_mapping.py index fd6da699..6db37146 100644 --- a/rest_framework/utils/field_mapping.py +++ b/rest_framework/utils/field_mapping.py @@ -71,6 +71,17 @@ def get_field_kwargs(field_name, model_field): if model_field.help_text: kwargs['help_text'] = model_field.help_text + max_digits = getattr(model_field, 'max_digits', None) + if max_digits is not None: + kwargs['max_digits'] = max_digits + + decimal_places = getattr(model_field, 'decimal_places', None) + if decimal_places is not None: + kwargs['decimal_places'] = decimal_places + + if isinstance(model_field, models.TextField): + kwargs['style'] = {'type': 'textarea'} + if isinstance(model_field, models.AutoField) or not model_field.editable: # If this field is read-only, then return early. # Further keyword arguments are not valid. @@ -86,9 +97,6 @@ def get_field_kwargs(field_name, model_field): kwargs['choices'] = model_field.flatchoices return kwargs - if isinstance(model_field, models.TextField): - kwargs['style'] = {'type': 'textarea'} - if model_field.null and not isinstance(model_field, models.NullBooleanField): kwargs['allow_null'] = True @@ -171,14 +179,6 @@ def get_field_kwargs(field_name, model_field): validator = UniqueValidator(queryset=model_field.model._default_manager) validator_kwarg.append(validator) - max_digits = getattr(model_field, 'max_digits', None) - if max_digits is not None: - kwargs['max_digits'] = max_digits - - decimal_places = getattr(model_field, 'decimal_places', None) - if decimal_places is not None: - kwargs['decimal_places'] = decimal_places - if validator_kwarg: kwargs['validators'] = validator_kwarg diff --git a/rest_framework/utils/model_meta.py b/rest_framework/utils/model_meta.py index b6c41174..7a95bcdd 100644 --- a/rest_framework/utils/model_meta.py +++ b/rest_framework/utils/model_meta.py @@ -107,8 +107,8 @@ def get_field_info(model): related=relation.model, to_many=True, has_through_model=( - hasattr(relation.field.rel, 'through') and - not relation.field.rel.through._meta.auto_created + (getattr(relation.field.rel, 'through', None) is not None) + and not relation.field.rel.through._meta.auto_created ) ) -- cgit v1.2.3 From 4c015df28cfb7dc7cf29f6dc4985c57e1f5cdc5d Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 16:43:33 +0100 Subject: Tweaks --- docs/topics/3.0-announcement.md | 18 ++++++++++++++++++ rest_framework/relations.py | 3 ++- 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 6520f2bd..26d261ed 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -144,6 +144,24 @@ The corresponding code would now look like this: logging.info('Creating ticket "%s"' % name) serializer.save(user=request.user) # Include the user when saving. +#### Change to `validate_`. + +The `validate_` method hooks that can be attached to serializer classes change their signature slightly and return type. Previously these would take a dictionary of all incoming data, and a key representing the field name, and would return a dictionary including the validated data for that field: + + def validate_score(self, attrs, source): + if attrs[score] % 10 != 0: + raise ValidationError('This field should be a multiple of ten.') + return attrs + +This is now simplified slightly, and the method hooks simply take the value to be validated, and return it's validated value. + + def validate_score(self, value): + if value % 10 != 0: + raise ValidationError('This field should be a multiple of ten.') + return value + +Any ad-hoc validation that applies to more than one field should go in the `.validate(self, attrs)` method as usual. + #### Limitations of ModelSerializer validation. This change also means that we no longer use the `.full_clean()` method on model instances, but instead perform all validation explicitly on the serializer. This gives a cleaner separation, and ensures that there's no automatic validation behavior on `ModelSerializer` classes that can't also be easily replicated on regular `Serializer` classes. diff --git a/rest_framework/relations.py b/rest_framework/relations.py index df5025b8..e9dd7dde 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -264,9 +264,10 @@ class ManyRelation(Field): ] def to_representation(self, obj): + iterable = obj.all() if (hasattr(obj, 'all')) else obj return [ self.child_relation.to_representation(value) - for value in obj.all() + for value in iterable ] @property -- cgit v1.2.3 From 5ead8dc89d1a99d6189170dc8dac19cdc8ba7750 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 16:59:52 +0100 Subject: Support empty file fields --- rest_framework/fields.py | 2 ++ tests/test_fields.py | 3 ++- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 5fb0ec8d..f86f6626 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -913,6 +913,8 @@ class FileField(Field): def to_representation(self, value): if self.use_url: + if not value: + return None url = settings.MEDIA_URL + value.url request = self.context.get('request', None) if request is not None: diff --git a/tests/test_fields.py b/tests/test_fields.py index bbd9f93d..eaa0a3c8 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -879,7 +879,8 @@ class TestFileField(FieldValues): (MockFile(name='x' * 100, size=10), ['Ensure this filename has at most 10 characters (it has 100).']) ] outputs = [ - (MockFile(name='example.txt', url='/example.txt'), '/example.txt') + (MockFile(name='example.txt', url='/example.txt'), '/example.txt'), + ('', None) ] field = fields.FileField(max_length=10) -- cgit v1.2.3 From f7d43f530a94e686d2f93781471b9ac4e90d0f58 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 8 Oct 2014 17:03:14 +0100 Subject: Limit blank string -> None to just be on relational fields --- rest_framework/fields.py | 4 ---- rest_framework/relations.py | 8 +++++++- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index f86f6626..b371c7d0 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -110,7 +110,6 @@ class Field(object): default_validators = [] default_empty_html = empty initial = None - coerce_blank_to_null = True def __init__(self, read_only=False, write_only=False, required=None, default=empty, initial=empty, source=None, @@ -248,9 +247,6 @@ class Field(object): self.fail('required') return self.get_default() - if data == '' and self.coerce_blank_to_null: - data = None - if data is None: if not self.allow_null: self.fail('null') diff --git a/rest_framework/relations.py b/rest_framework/relations.py index e9dd7dde..c1e5aa18 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -1,5 +1,5 @@ from rest_framework.compat import smart_text, urlparse -from rest_framework.fields import Field +from rest_framework.fields import empty, Field from rest_framework.reverse import reverse from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch, Resolver404 @@ -31,6 +31,12 @@ class RelatedField(Field): ) return super(RelatedField, cls).__new__(cls, *args, **kwargs) + def run_validation(self, data=empty): + # We force empty strings to None values for relational fields. + if data == '': + data = None + return super(RelatedField, self).run_validation(data) + def get_queryset(self): queryset = self.queryset if isinstance(queryset, QuerySet): -- cgit v1.2.3 From a58cfe167d837d34994b50f52098c552f6b0860e Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 9 Oct 2014 09:38:03 +0100 Subject: Update tutorial for 3.0 --- docs/tutorial/1-serialization.md | 79 ++++++++++++----------- docs/tutorial/4-authentication-and-permissions.md | 14 ++-- 2 files changed, 50 insertions(+), 43 deletions(-) diff --git a/docs/tutorial/1-serialization.md b/docs/tutorial/1-serialization.md index b0565d91..db5b9ea7 100644 --- a/docs/tutorial/1-serialization.md +++ b/docs/tutorial/1-serialization.md @@ -41,20 +41,7 @@ Once that's done we can create an app that we'll use to create a simple Web API. python manage.py startapp snippets -The simplest way to get up and running will probably be to use an `sqlite3` database for the tutorial. Edit the `tutorial/settings.py` file, and set the default database `"ENGINE"` to `"sqlite3"`, and `"NAME"` to `"tmp.db"`. - - DATABASES = { - 'default': { - 'ENGINE': 'django.db.backends.sqlite3', - 'NAME': 'tmp.db', - 'USER': '', - 'PASSWORD': '', - 'HOST': '', - 'PORT': '', - } - } - -We'll also need to add our new `snippets` app and the `rest_framework` app to `INSTALLED_APPS`. +We'll need to add our new `snippets` app and the `rest_framework` app to `INSTALLED_APPS`. Let's edit the `tutorial/settings.py` file: INSTALLED_APPS = ( ... @@ -72,7 +59,7 @@ Okay, we're ready to roll. ## Creating a model to work with -For the purposes of this tutorial we're going to start by creating a simple `Snippet` model that is used to store code snippets. Go ahead and edit the `snippets` app's `models.py` file. Note: Good programming practices include comments. Although you will find them in our repository version of this tutorial code, we have omitted them here to focus on the code itself. +For the purposes of this tutorial we're going to start by creating a simple `Snippet` model that is used to store code snippets. Go ahead and edit the `snippets/models.py` file. Note: Good programming practices include comments. Although you will find them in our repository version of this tutorial code, we have omitted them here to focus on the code itself. from django.db import models from pygments.lexers import get_all_lexers @@ -98,9 +85,10 @@ For the purposes of this tutorial we're going to start by creating a simple `Sni class Meta: ordering = ('created',) -Don't forget to sync the database for the first time. +We'll also need to create an initial migration for our snippet model, and sync the database for the first time. - python manage.py syncdb + python manage.py makemigrations snippets + python manage.py migrate ## Creating a Serializer class @@ -112,40 +100,39 @@ The first thing we need to get started on our Web API is to provide a way of ser class SnippetSerializer(serializers.Serializer): - pk = serializers.Field() # Note: `Field` is an untyped read-only field. + pk = serializers.IntegerField(read_only=True) title = serializers.CharField(required=False, max_length=100) - code = serializers.CharField(widget=widgets.Textarea, - max_length=100000) + code = serializers.CharField(style={'type': 'textarea'}) linenos = serializers.BooleanField(required=False) language = serializers.ChoiceField(choices=LANGUAGE_CHOICES, default='python') style = serializers.ChoiceField(choices=STYLE_CHOICES, default='friendly') - def restore_object(self, attrs, instance=None): + def create(self, validated_attrs): """ - Create or update a new snippet instance, given a dictionary - of deserialized field values. + Create and return a new `Snippet` instance, given the validated data. + """ + return Snippet.objects.create(**validated_attrs) - Note that if we don't define this method, then deserializing - data will simply return a dictionary of items. + def update(self, instance, validated_attrs): + """ + Update and return an existing `Snippet` instance, given the validated data. """ - if instance: - # Update existing instance - instance.title = attrs.get('title', instance.title) - instance.code = attrs.get('code', instance.code) - instance.linenos = attrs.get('linenos', instance.linenos) - instance.language = attrs.get('language', instance.language) - instance.style = attrs.get('style', instance.style) - return instance + instance.title = validated_attrs.get('title', instance.title) + instance.code = validated_attrs.get('code', instance.code) + instance.linenos = validated_attrs.get('linenos', instance.linenos) + instance.language = validated_attrs.get('language', instance.language) + instance.style = validated_attrs.get('style', instance.style) + instance.save() + return instance - # Create new instance - return Snippet(**attrs) +The first part of the serializer class defines the fields that get serialized/deserialized. The `create()` and `update()` methods define how fully fledged instances are created or modified when calling `serializer.save()` -The first part of the serializer class defines the fields that get serialized/deserialized. The `restore_object` method defines how fully fledged instances get created when deserializing data. +A serializer class is very similar to a Django `Form` class, and includes similar validation flags on the various fields, such as `required`, `max_length` and `default`. -Notice that we can also use various attributes that would typically be used on form fields, such as `widget=widgets.Textarea`. These can be used to control how the serializer should render when displayed as an HTML form. This is particularly useful for controlling how the browsable API should be displayed, as we'll see later in the tutorial. +The field flags can also control how the serializer should be displayed in certain circumstances, such as when rendering to HTML. The `style={'type': 'textarea'}` flag above is equivelent to using `widget=widgets.Textarea` on a Django `Form` class. This is particularly useful for controlling how the browsable API should be displayed, as we'll see later in the tutorial. We can actually also save ourselves some time by using the `ModelSerializer` class, as we'll see later, but for now we'll keep our serializer definition explicit. @@ -219,6 +206,24 @@ Open the file `snippets/serializers.py` again, and edit the `SnippetSerializer` model = Snippet fields = ('id', 'title', 'code', 'linenos', 'language', 'style') +Once nice property that serializers have is that you can inspect all the fields an serializer instance, by printing it's representation. Open the Django shell with `python manange.py shell`, then try the following: + + >>> from snippets.serializers import SnippetSerializer + >>> serializer = SnippetSerializer() + >>> print repr(serializer) # In python 3 use `print(repr(serializer))` + SnippetSerializer(): + id = IntegerField(label='ID', read_only=True) + title = CharField(allow_blank=True, max_length=100, required=False) + code = CharField(style={'type': 'textarea'}) + linenos = BooleanField(required=False) + language = ChoiceField(choices=[('Clipper', 'FoxPro'), ('Cucumber', 'Gherkin'), ('RobotFramework', 'RobotFramework'), ('abap', 'ABAP'), ('ada', 'Ada')... + style = ChoiceField(choices=[('autumn', 'autumn'), ('borland', 'borland'), ('bw', 'bw'), ('colorful', 'colorful')... + +It's important to remember that `ModelSerializer` classes don't do anything particularly magically, they are simply a shortcut to creating a serializer class with: + +* An automatically determined set of fields. +* Simple default implementations for the `create()` and `update()` methods. + ## Writing regular Django views using our Serializer Let's see how we can write some API views using our new Serializer class. diff --git a/docs/tutorial/4-authentication-and-permissions.md b/docs/tutorial/4-authentication-and-permissions.md index 9120e254..adab1b55 100644 --- a/docs/tutorial/4-authentication-and-permissions.md +++ b/docs/tutorial/4-authentication-and-permissions.md @@ -92,24 +92,26 @@ Finally we need to add those views into the API, by referencing them from the UR Right now, if we created a code snippet, there'd be no way of associating the user that created the snippet, with the snippet instance. The user isn't sent as part of the serialized representation, but is instead a property of the incoming request. -The way we deal with that is by overriding a `.pre_save()` method on our snippet views, that allows us to handle any information that is implicit in the incoming request or requested URL. +The way we deal with that is by overriding a `.perform_create()` method on our snippet views, that allows us to modify how the instance save is managed, and handle any information that is implicit in the incoming request or requested URL. -On **both** the `SnippetList` and `SnippetDetail` view classes, add the following method: +On the `SnippetList` view class, add the following method: - def pre_save(self, obj): - obj.owner = self.request.user + def perform_create(self, serializer): + serializer.save(owner=self.request.user) + +The `create()` method of our serializer will now be passed an additional `'owner'` field, along with the validated data from the request. ## Updating our serializer Now that snippets are associated with the user that created them, let's update our `SnippetSerializer` to reflect that. Add the following field to the serializer definition in `serializers.py`: - owner = serializers.Field(source='owner.username') + owner = serializers.ReadOnlyField(source='owner.username') **Note**: Make sure you also add `'owner',` to the list of fields in the inner `Meta` class. This field is doing something quite interesting. The `source` argument controls which attribute is used to populate a field, and can point at any attribute on the serialized instance. It can also take the dotted notation shown above, in which case it will traverse the given attributes, in a similar way as it is used with Django's template language. -The field we've added is the untyped `Field` class, in contrast to the other typed fields, such as `CharField`, `BooleanField` etc... The untyped `Field` is always read-only, and will be used for serialized representations, but will not be used for updating model instances when they are deserialized. +The field we've added is the untyped `ReadOnlyField` class, in contrast to the other typed fields, such as `CharField`, `BooleanField` etc... The untyped `ReadOnlyField` is always read-only, and will be used for serialized representations, but will not be used for updating model instances when they are deserialized. We could have also used `CharField(read_only=True)` here. ## Adding required permissions to views -- cgit v1.2.3 From 5f4cc52ef5c0f603420c6ea809594710a372d336 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 9 Oct 2014 10:11:44 +0100 Subject: Tweaking --- rest_framework/validators.py | 6 ++++++ tests/test_validators.py | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/rest_framework/validators.py b/rest_framework/validators.py index 5bb69ad8..f76faaa4 100644 --- a/rest_framework/validators.py +++ b/rest_framework/validators.py @@ -12,6 +12,9 @@ from rest_framework.utils.representation import smart_repr class UniqueValidator: + """ + Validator that corresponds to `unique=True` on a model field. + """ # Validators with `requires_context` will have the field instance # passed to them when the field is instantiated. requires_context = True @@ -46,6 +49,9 @@ class UniqueValidator: class UniqueTogetherValidator: + """ + Validator that corresponds to `unique_together = (...)` on a model class. + """ requires_context = True message = _('The fields {field_names} must make a unique set.') diff --git a/tests/test_validators.py b/tests/test_validators.py index ac04d2b4..1d081411 100644 --- a/tests/test_validators.py +++ b/tests/test_validators.py @@ -131,7 +131,7 @@ class TestUniquenessTogetherValidation(TestCase): 'position': 1 } - def test_ignore_exlcuded_fields(self): + def test_ignore_excluded_fields(self): """ When model fields are not included in a serializer, then uniqueness validtors should not be added for that field. -- cgit v1.2.3 From 6637b2fae0dab65447ff0bfd5ac0ba68644446eb Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 9 Oct 2014 11:08:26 +0100 Subject: Document the Metadata API --- docs/api-guide/metadata.md | 103 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 103 insertions(+) create mode 100644 docs/api-guide/metadata.md diff --git a/docs/api-guide/metadata.md b/docs/api-guide/metadata.md new file mode 100644 index 00000000..c3f036b7 --- /dev/null +++ b/docs/api-guide/metadata.md @@ -0,0 +1,103 @@ + + +# Metadata + +> [The `OPTIONS`] method allows a client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval. +> +> — [RFC7231, Section 4.3.7.][cite] + +REST framework includes a configurable mechanism for determining how your API should respond to `OPTIONS` requests. This allows you to return API schema or other resource information. + +There are not currently any widely adopted conventions for exactly what style of response should be returned for HTTP `OPTIONS` requests, so we provide an ad-hoc style that returns some useful information. + +Here's an example response that demonstrates the information that is returned by default. + + HTTP 200 OK + Allow: GET, POST, HEAD, OPTIONS + Content-Type: application/json + + { + "name": "To Do List", + "description": "List existing 'To Do' items, or create a new item.", + "renders": [ + "application/json", + "text/html" + ], + "parses": [ + "application/json", + "application/x-www-form-urlencoded", + "multipart/form-data" + ], + "actions": { + "POST": { + "note": { + "type": "string", + "required": false, + "read_only": false, + "label": "title", + "max_length": 100 + } + } + } + } + +## Setting the metadata scheme + +You can set the metadata class globally using the `'DEFAULT_METADATA_CLASS'` settings key: + + REST_FRAMEWORK = { + 'DEFAULT_METADATA_CLASS': 'rest_framework.metadata.SimpleMetadata' + } + +Or you can set the metadata class individually for a view: + + class APIRoot(APIView): + metadata_class = APIRootMetadata + + def get(self, request, format=None): + return Response({ + ... + }) + +The REST framework package only includes a single metadata class implementation, named `SimpleMetadata`. If you want to use an alternative style you'll need to implement a custom metadata class. + +## Creating schema endpoints + +If you have specific requirements for creating schema endpoints that are accessed with regular `GET` requests, you might consider re-using the metadata API for doing so. + +For example, the following additional route could be used on a viewset to provide a linkable schema endpoint. + + @list_route(methods=['GET']) + def schema(self, request): + meta = self.metadata_class() + data = meta.determine_metadata(request, self) + return Response(data) + +There are a couple of reasons that you might choose to take this approach, including that `OPTIONS` responses [are not cacheable][no-options]. + +--- + +# Custom metadata classes + +If you want to provide a custom metadata class you should override `BaseMetadata` and implement the `determine_metadata(self, request, view)` method. + +Useful things that you might want to do could include returning schema information, using a format such as [JSON schema][json-schema], or returning debug information to admin users. + +## Example + +The following class could be used to limit the information that is returned to `OPTIONS` requests. + + class MinimalMetadata(BaseMetadata): + """ + Don't include field and other information for `OPTIONS` requests. + Just return the name and description. + """ + def determine_metadata(self, request, view): + return { + 'name': view.get_view_name(), + 'description': view.get_view_description() + } + +[cite]: http://tools.ietf.org/html/rfc7231#section-4.3.7 +[no-options]: https://www.mnot.net/blog/2012/10/29/NO_OPTIONS +[json-schema]: http://json-schema.org/ -- cgit v1.2.3 From babdc78e61ac915fa4a01bdfb04e11a32dbf5d79 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 9 Oct 2014 11:39:01 +0100 Subject: Typo --- docs/api-guide/validators.md | 0 docs/topics/3.0-announcement.md | 2 +- 2 files changed, 1 insertion(+), 1 deletion(-) create mode 100644 docs/api-guide/validators.md diff --git a/docs/api-guide/validators.md b/docs/api-guide/validators.md new file mode 100644 index 00000000..e69de29b diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 26d261ed..bffc608a 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -617,7 +617,7 @@ The view logic for the default method handlers has been significantly simplified The `pre_save` and `post_save` hooks no longer exist, but are replaced with `perform_create(self, serializer)` and `perform_update(self, serializer)`. -These method should save the object instance by calling `serializer.save()`, adding in any explicit additional arguments as required. They may also perform any custom pre-save or post-save behavior. +These methods should save the object instance by calling `serializer.save()`, adding in any additional arguments as required. They may also perform any custom pre-save or post-save behavior. For example: -- cgit v1.2.3 From 5d247a65c89594a7ab5ce2333612f23eadc6828d Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 9 Oct 2014 15:11:19 +0100 Subject: First pass on nested serializers in HTML --- docs/tutorial/quickstart.md | 8 ++- rest_framework/compat.py | 16 ++++- rest_framework/fields.py | 28 +++++++-- rest_framework/relations.py | 20 ++++++- rest_framework/renderers.py | 10 +++- rest_framework/serializers.py | 35 ++++++++--- .../rest_framework/fields/horizontal/fieldset.html | 5 +- .../fields/horizontal/list_fieldset.html | 13 ++++ .../rest_framework/fields/inline/fieldset.html | 5 +- .../rest_framework/fields/vertical/fieldset.html | 5 +- .../fields/vertical/list_fieldset.html | 7 +++ tests/test_bound_fields.py | 69 ++++++++++++++++++++++ 12 files changed, 194 insertions(+), 27 deletions(-) create mode 100644 rest_framework/templates/rest_framework/fields/horizontal/list_fieldset.html create mode 100644 rest_framework/templates/rest_framework/fields/vertical/list_fieldset.html create mode 100644 tests/test_bound_fields.py diff --git a/docs/tutorial/quickstart.md b/docs/tutorial/quickstart.md index 813e9872..c2dc4bea 100644 --- a/docs/tutorial/quickstart.md +++ b/docs/tutorial/quickstart.md @@ -26,11 +26,13 @@ Create a new Django project named `tutorial`, then start a new app called `quick Now sync your database for the first time: - python manage.py syncdb + python manage.py migrate -Make sure to create an initial user named `admin` with a password of `password`. We'll authenticate as that user later in our example. +We'll also create an initial user named `admin` with a password of `password`. We'll authenticate as that user later in our example. -Once you've set up a database and got everything synced and ready to go, open up the app's directory and we'll get coding... + python manage.py createsuperuser + +Once you've set up a database and initial user created and ready to go, open up the app's directory and we'll get coding... ## Serializers diff --git a/rest_framework/compat.py b/rest_framework/compat.py index e4e69580..4ab23a4d 100644 --- a/rest_framework/compat.py +++ b/rest_framework/compat.py @@ -114,12 +114,15 @@ else: -# MinValueValidator and MaxValueValidator only accept `message` in 1.8+ +# MinValueValidator, MaxValueValidator et al. only accept `message` in 1.8+ if django.VERSION >= (1, 8): from django.core.validators import MinValueValidator, MaxValueValidator + from django.core.validators import MinLengthValidator, MaxLengthValidator else: from django.core.validators import MinValueValidator as DjangoMinValueValidator from django.core.validators import MaxValueValidator as DjangoMaxValueValidator + from django.core.validators import MinLengthValidator as DjangoMinLengthValidator + from django.core.validators import MaxLengthValidator as DjangoMaxLengthValidator class MinValueValidator(DjangoMinValueValidator): def __init__(self, *args, **kwargs): @@ -131,6 +134,17 @@ else: self.message = kwargs.pop('message', self.message) super(MaxValueValidator, self).__init__(*args, **kwargs) + class MinLengthValidator(DjangoMinLengthValidator): + def __init__(self, *args, **kwargs): + self.message = kwargs.pop('message', self.message) + super(MinLengthValidator, self).__init__(*args, **kwargs) + + class MaxLengthValidator(DjangoMaxLengthValidator): + def __init__(self, *args, **kwargs): + self.message = kwargs.pop('message', self.message) + super(MaxLengthValidator, self).__init__(*args, **kwargs) + + # URLValidator only accepts `message` in 1.6+ if django.VERSION >= (1, 6): from django.core.validators import URLValidator diff --git a/rest_framework/fields.py b/rest_framework/fields.py index b371c7d0..7053acee 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -8,7 +8,10 @@ from django.utils.dateparse import parse_date, parse_datetime, parse_time from django.utils.encoding import is_protected_type from django.utils.translation import ugettext_lazy as _ from rest_framework import ISO_8601 -from rest_framework.compat import smart_text, EmailValidator, MinValueValidator, MaxValueValidator, URLValidator +from rest_framework.compat import ( + smart_text, EmailValidator, MinValueValidator, MaxValueValidator, + MinLengthValidator, MaxLengthValidator, URLValidator +) from rest_framework.settings import api_settings from rest_framework.utils import html, representation, humanize_datetime import copy @@ -138,7 +141,7 @@ class Field(object): self.label = label self.help_text = help_text self.style = {} if style is None else style - self.validators = validators or self.default_validators[:] + self.validators = validators[:] or self.default_validators[:] self.allow_null = allow_null # These are set up by `.bind()` when the field is added to a serializer. @@ -412,16 +415,24 @@ class NullBooleanField(Field): class CharField(Field): default_error_messages = { - 'blank': _('This field may not be blank.') + 'blank': _('This field may not be blank.'), + 'max_length': _('Ensure this field has no more than {max_length} characters.'), + 'min_length': _('Ensure this field has no more than {min_length} characters.') } initial = '' coerce_blank_to_null = False def __init__(self, **kwargs): self.allow_blank = kwargs.pop('allow_blank', False) - self.max_length = kwargs.pop('max_length', None) - self.min_length = kwargs.pop('min_length', None) + max_length = kwargs.pop('max_length', None) + min_length = kwargs.pop('min_length', None) super(CharField, self).__init__(**kwargs) + if max_length is not None: + message = self.error_messages['max_length'].format(max_length=max_length) + self.validators.append(MaxLengthValidator(max_length, message=message)) + if min_length is not None: + message = self.error_messages['min_length'].format(min_length=min_length) + self.validators.append(MinLengthValidator(min_length, message=message)) def run_validation(self, data=empty): # Test for the empty string here so that it does not get validated, @@ -857,6 +868,13 @@ class MultipleChoiceField(ChoiceField): } default_empty_html = [] + def get_value(self, dictionary): + # We override the default field access in order to support + # lists in HTML forms. + if html.is_html_input(dictionary): + return dictionary.getlist(self.field_name) + return dictionary.get(self.field_name, empty) + def to_internal_value(self, data): if isinstance(data, type('')) or not hasattr(data, '__iter__'): self.fail('not_a_list', input_type=type(data).__name__) diff --git a/rest_framework/relations.py b/rest_framework/relations.py index c1e5aa18..268b95cf 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -1,6 +1,7 @@ from rest_framework.compat import smart_text, urlparse from rest_framework.fields import empty, Field from rest_framework.reverse import reverse +from rest_framework.utils import html from django.core.exceptions import ObjectDoesNotExist, ImproperlyConfigured from django.core.urlresolvers import resolve, get_script_prefix, NoReverseMatch, Resolver404 from django.db.models.query import QuerySet @@ -263,6 +264,13 @@ class ManyRelation(Field): super(ManyRelation, self).__init__(*args, **kwargs) self.child_relation.bind(field_name='', parent=self) + def get_value(self, dictionary): + # We override the default field access in order to support + # lists in HTML forms. + if html.is_html_input(dictionary): + return dictionary.getlist(self.field_name) + return dictionary.get(self.field_name, empty) + def to_internal_value(self, data): return [ self.child_relation.to_internal_value(item) @@ -278,10 +286,16 @@ class ManyRelation(Field): @property def choices(self): + queryset = self.child_relation.queryset + iterable = queryset.all() if (hasattr(queryset, 'all')) else queryset + items_and_representations = [ + (item, self.child_relation.to_representation(item)) + for item in iterable + ] return dict([ ( - str(self.child_relation.to_representation(item)), - str(item) + str(item_representation), + str(item) + ' - ' + str(item_representation) ) - for item in self.child_relation.queryset.all() + for item, item_representation in items_and_representations ]) diff --git a/rest_framework/renderers.py b/rest_framework/renderers.py index 931dd434..4fb36060 100644 --- a/rest_framework/renderers.py +++ b/rest_framework/renderers.py @@ -364,6 +364,12 @@ class HTMLFormRenderer(BaseRenderer): serializers.ManyRelation: { 'default': 'select_multiple.html', 'checkbox': 'select_checkbox.html' + }, + serializers.Serializer: { + 'default': 'fieldset.html' + }, + serializers.ListSerializer: { + 'default': 'list_fieldset.html' } }) @@ -392,7 +398,9 @@ class HTMLFormRenderer(BaseRenderer): template = loader.get_template(template_name) context = Context({ 'field': field, - 'input_type': input_type + 'input_type': input_type, + 'renderer': self, + 'layout': layout }) return template.render(context) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 9fcbcba7..1c006990 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -166,14 +166,25 @@ class BoundField(object): Returned when iterating over a serializer instance, providing an API similar to Django forms and form fields. """ - def __init__(self, field, value, errors): + def __init__(self, field, value, errors, prefix=''): self._field = field self.value = value self.errors = errors + self.name = prefix + self.field_name def __getattr__(self, attr_name): return getattr(self._field, attr_name) + def __iter__(self): + for field in self.fields.values(): + yield self[field.field_name] + + def __getitem__(self, key): + field = self.fields[key] + value = self.value.get(key) if self.value else None + error = self.errors.get(key) if self.errors else None + return BoundField(field, value, error, prefix=self.name + '.') + @property def _proxy_class(self): return self._field.__class__ @@ -355,15 +366,22 @@ class Serializer(BaseSerializer): def validate(self, attrs): return attrs + def __repr__(self): + return representation.serializer_repr(self, indent=1) + + # The following are used for accessing `BoundField` instances on the + # serializer, for the purposes of presenting a form-like API onto the + # field values and field errors. + def __iter__(self): - errors = self.errors if hasattr(self, '_errors') else {} for field in self.fields.values(): - value = self.data.get(field.field_name) if self.data else None - error = errors.get(field.field_name) - yield BoundField(field, value, error) + yield self[field.field_name] - def __repr__(self): - return representation.serializer_repr(self, indent=1) + def __getitem__(self, key): + field = self.fields[key] + value = self.data.get(key) + error = self.errors.get(key) if hasattr(self, '_errors') else None + return BoundField(field, value, error) # There's some replication of `ListField` here, @@ -404,8 +422,9 @@ class ListSerializer(BaseSerializer): """ List of object instances -> List of dicts of primitive datatypes. """ + iterable = data.all() if (hasattr(data, 'all')) else data return ReturnList( - [self.child.to_representation(item) for item in data], + [self.child.to_representation(item) for item in iterable], serializer=self ) diff --git a/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html b/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html index 843a56b2..ff93c6ba 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/fieldset.html @@ -1,10 +1,11 @@ +{% load rest_framework %}
{% if field.label %}
{{ field.label }}
{% endif %} - {% for field_item in field.value.field_items.values() %} - {{ renderer.render_field(field_item, layout=layout) }} + {% for nested_field in field %} + {% render_field nested_field layout=layout renderer=renderer %} {% endfor %}
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/list_fieldset.html b/rest_framework/templates/rest_framework/fields/horizontal/list_fieldset.html new file mode 100644 index 00000000..68c75d4f --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/horizontal/list_fieldset.html @@ -0,0 +1,13 @@ +{% load rest_framework %} +
+ {% if field.label %} +
+ {{ field.label }} +
+ {% endif %} +
    + {% for child in field.value %} +
  • TODO
    • + {% endfor %} +
+
diff --git a/rest_framework/templates/rest_framework/fields/inline/fieldset.html b/rest_framework/templates/rest_framework/fields/inline/fieldset.html index 380d4627..ba9f1835 100644 --- a/rest_framework/templates/rest_framework/fields/inline/fieldset.html +++ b/rest_framework/templates/rest_framework/fields/inline/fieldset.html @@ -1,3 +1,4 @@ -{% for field_item in field.value.field_items.values() %} - {{ renderer.render_field(field_item, layout=layout) }} +{% load rest_framework %} +{% for nested_field in field %} + {% render_field nested_field layout=layout renderer=renderer %} {% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/vertical/fieldset.html b/rest_framework/templates/rest_framework/fields/vertical/fieldset.html index 8708916b..248fe904 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/fieldset.html +++ b/rest_framework/templates/rest_framework/fields/vertical/fieldset.html @@ -1,6 +1,7 @@ +{% load rest_framework %}
{% if field.label %}{{ field.label }}{% endif %} - {% for field_item in field.value.field_items.values() %} - {{ renderer.render_field(field_item, layout=layout) }} + {% for nested_field in field %} + {% render_field nested_field layout=layout renderer=renderer %} {% endfor %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/list_fieldset.html b/rest_framework/templates/rest_framework/fields/vertical/list_fieldset.html new file mode 100644 index 00000000..6b99a834 --- /dev/null +++ b/rest_framework/templates/rest_framework/fields/vertical/list_fieldset.html @@ -0,0 +1,7 @@ +
+ {% if field.label %}{{ field.label }}{% endif %} + +
diff --git a/tests/test_bound_fields.py b/tests/test_bound_fields.py new file mode 100644 index 00000000..469437e4 --- /dev/null +++ b/tests/test_bound_fields.py @@ -0,0 +1,69 @@ +from rest_framework import serializers + + +class TestSimpleBoundField: + def test_empty_bound_field(self): + class ExampleSerializer(serializers.Serializer): + text = serializers.CharField(max_length=100) + amount = serializers.IntegerField() + + serializer = ExampleSerializer() + + assert serializer['text'].value == '' + assert serializer['text'].errors is None + assert serializer['text'].name == 'text' + assert serializer['amount'].value is None + assert serializer['amount'].errors is None + assert serializer['amount'].name == 'amount' + + def test_populated_bound_field(self): + class ExampleSerializer(serializers.Serializer): + text = serializers.CharField(max_length=100) + amount = serializers.IntegerField() + + serializer = ExampleSerializer(data={'text': 'abc', 'amount': 123}) + + assert serializer['text'].value == 'abc' + assert serializer['text'].errors is None + assert serializer['text'].name == 'text' + assert serializer['amount'].value is 123 + assert serializer['amount'].errors is None + assert serializer['amount'].name == 'amount' + + def test_error_bound_field(self): + class ExampleSerializer(serializers.Serializer): + text = serializers.CharField(max_length=100) + amount = serializers.IntegerField() + + serializer = ExampleSerializer(data={'text': 'x' * 1000, 'amount': 123}) + serializer.is_valid() + + assert serializer['text'].value == 'x' * 1000 + assert serializer['text'].errors == ['Ensure this field has no more than 100 characters.'] + assert serializer['text'].name == 'text' + assert serializer['amount'].value is 123 + assert serializer['amount'].errors is None + assert serializer['amount'].name == 'amount' + + +class TestNestedBoundField: + def test_nested_empty_bound_field(self): + class Nested(serializers.Serializer): + more_text = serializers.CharField(max_length=100) + amount = serializers.IntegerField() + + class ExampleSerializer(serializers.Serializer): + text = serializers.CharField(max_length=100) + nested = Nested() + + serializer = ExampleSerializer() + + assert serializer['text'].value == '' + assert serializer['text'].errors is None + assert serializer['text'].name == 'text' + assert serializer['nested']['more_text'].value == '' + assert serializer['nested']['more_text'].errors is None + assert serializer['nested']['more_text'].name == 'nested.more_text' + assert serializer['nested']['amount'].value is None + assert serializer['nested']['amount'].errors is None + assert serializer['nested']['amount'].name == 'nested.amount' -- cgit v1.2.3 From f83ed19d22250eb646c9d77ccb1614a78d134e75 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 9 Oct 2014 16:29:34 +0100 Subject: Checks and repr on BoundField --- rest_framework/serializers.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 1c006990..3bd7b17b 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -180,6 +180,7 @@ class BoundField(object): yield self[field.field_name] def __getitem__(self, key): + assert hasattr(self, 'fields'), '"%s" is not a nested field. Cannot perform indexing.' % self.name field = self.fields[key] value = self.value.get(key) if self.value else None error = self.errors.get(key) if self.errors else None @@ -189,6 +190,9 @@ class BoundField(object): def _proxy_class(self): return self._field.__class__ + def __repr__(self): + return '<%s value=%s errors=%s>' % (self.__class__.__name__, self.value, self.errors) + class BindingDict(object): """ -- cgit v1.2.3 From a0e852a4d52558db93209b4616f030b4ae2dcedb Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 9 Oct 2014 16:30:06 +0100 Subject: Use BoundField .name on fields --- rest_framework/templates/rest_framework/fields/attrs.html | 2 +- .../templates/rest_framework/fields/horizontal/checkbox.html | 2 +- rest_framework/templates/rest_framework/fields/horizontal/select.html | 2 +- .../templates/rest_framework/fields/horizontal/select_checkbox.html | 4 ++-- .../templates/rest_framework/fields/horizontal/select_multiple.html | 2 +- .../templates/rest_framework/fields/horizontal/select_radio.html | 4 ++-- rest_framework/templates/rest_framework/fields/inline/checkbox.html | 2 +- rest_framework/templates/rest_framework/fields/inline/select.html | 2 +- .../templates/rest_framework/fields/inline/select_checkbox.html | 2 +- .../templates/rest_framework/fields/inline/select_multiple.html | 2 +- .../templates/rest_framework/fields/inline/select_radio.html | 2 +- rest_framework/templates/rest_framework/fields/vertical/checkbox.html | 2 +- rest_framework/templates/rest_framework/fields/vertical/select.html | 2 +- .../templates/rest_framework/fields/vertical/select_checkbox.html | 4 ++-- .../templates/rest_framework/fields/vertical/select_multiple.html | 2 +- .../templates/rest_framework/fields/vertical/select_radio.html | 4 ++-- 16 files changed, 20 insertions(+), 20 deletions(-) diff --git a/rest_framework/templates/rest_framework/fields/attrs.html b/rest_framework/templates/rest_framework/fields/attrs.html index b5a4dbcf..1e23c465 100644 --- a/rest_framework/templates/rest_framework/fields/attrs.html +++ b/rest_framework/templates/rest_framework/fields/attrs.html @@ -1 +1 @@ -name="{{ field.field_name }}" {% if field.style.placeholder %}placeholder="{{ field.style.placeholder }}"{% endif %} {% if field.style.rows %}rows="{{ field.style.rows }}"{% endif %} +name="{{ field.name }}" {% if field.style.placeholder %}placeholder="{{ field.style.placeholder }}"{% endif %} {% if field.style.rows %}rows="{{ field.style.rows }}"{% endif %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html b/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html index dd3c3cef..ee3bf936 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/checkbox.html @@ -2,7 +2,7 @@
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select.html b/rest_framework/templates/rest_framework/fields/horizontal/select.html index 7367d726..10b4b139 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select.html @@ -1,7 +1,7 @@
{% include "rest_framework/fields/horizontal/label.html" %}
- {% for key, text in field.choices.items %} {% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html b/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html index 381cda2c..6041fa74 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html @@ -4,7 +4,7 @@ {% if field.style.inline %} {% for key, text in field.choices.items %} {% endfor %} @@ -12,7 +12,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html b/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html index 29ba8661..c0dbb989 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html @@ -1,7 +1,7 @@
{% include "rest_framework/fields/horizontal/label.html" %}
- {% for key, text in field.choices.items %} {% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html b/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html index 20aab8b2..0eeb9bc6 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_radio.html @@ -4,7 +4,7 @@ {% if field.style.inline %} {% for key, text in field.choices.items %} {% endfor %} @@ -12,7 +12,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/inline/checkbox.html b/rest_framework/templates/rest_framework/fields/inline/checkbox.html index 289bbb4d..57fa5dc0 100644 --- a/rest_framework/templates/rest_framework/fields/inline/checkbox.html +++ b/rest_framework/templates/rest_framework/fields/inline/checkbox.html @@ -1,6 +1,6 @@
diff --git a/rest_framework/templates/rest_framework/fields/inline/select.html b/rest_framework/templates/rest_framework/fields/inline/select.html index 9f361c4a..eebb91d2 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select.html +++ b/rest_framework/templates/rest_framework/fields/inline/select.html @@ -1,6 +1,6 @@
{% include "rest_framework/fields/inline/label.html" %} - {% for key, text in field.choices.items %} {% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html b/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html index 0f33fb69..b7561cd4 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html +++ b/rest_framework/templates/rest_framework/fields/inline/select_checkbox.html @@ -3,7 +3,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/inline/select_multiple.html b/rest_framework/templates/rest_framework/fields/inline/select_multiple.html index 7c9e5168..74e17f9f 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select_multiple.html +++ b/rest_framework/templates/rest_framework/fields/inline/select_multiple.html @@ -1,6 +1,6 @@
{% include "rest_framework/fields/inline/label.html" %} - {% for key, text in field.choices.items %} {% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/inline/select_radio.html b/rest_framework/templates/rest_framework/fields/inline/select_radio.html index 177c0eeb..27927a62 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select_radio.html +++ b/rest_framework/templates/rest_framework/fields/inline/select_radio.html @@ -3,7 +3,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/checkbox.html b/rest_framework/templates/rest_framework/fields/vertical/checkbox.html index 01d30aae..9fd4cdaa 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/checkbox.html +++ b/rest_framework/templates/rest_framework/fields/vertical/checkbox.html @@ -1,6 +1,6 @@
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select.html b/rest_framework/templates/rest_framework/fields/vertical/select.html index dcc9a3cd..1a651663 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select.html @@ -1,6 +1,6 @@
{% include "rest_framework/fields/vertical/label.html" %} - {% for key, text in field.choices.items %} {% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html b/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html index 1fbe6a94..2e792e6a 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select_checkbox.html @@ -4,7 +4,7 @@
{% for key, text in field.choices.items %} {% endfor %} @@ -13,7 +13,7 @@ {% for key, text in field.choices.items %}
diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html b/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html index 2cc40d99..5f4166cd 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select_multiple.html @@ -1,6 +1,6 @@
{% include "rest_framework/fields/vertical/label.html" %} - {% for key, text in field.choices.items %} {% endfor %} diff --git a/rest_framework/templates/rest_framework/fields/vertical/select_radio.html b/rest_framework/templates/rest_framework/fields/vertical/select_radio.html index 470bcb0b..2aa0fe28 100644 --- a/rest_framework/templates/rest_framework/fields/vertical/select_radio.html +++ b/rest_framework/templates/rest_framework/fields/vertical/select_radio.html @@ -4,7 +4,7 @@
{% for key, text in field.choices.items %} {% endfor %} @@ -13,7 +13,7 @@ {% for key, text in field.choices.items %}
-- cgit v1.2.3 From d9a199ca0ddf92f999aa37b396596d0e3e0a26d9 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 10 Oct 2014 14:16:09 +0100 Subject: exceptions.ValidationFailed, not Django's ValidationError --- docs/topics/3.0-announcement.md | 6 +--- rest_framework/authtoken/serializers.py | 8 ++--- rest_framework/exceptions.py | 14 ++++++++ rest_framework/fields.py | 21 +++++++----- rest_framework/serializers.py | 60 +++++++++++++++++++-------------- rest_framework/views.py | 27 ++++++--------- tests/test_fields.py | 23 ++++++------- tests/test_relations.py | 20 +++++------ tests/test_validation.py | 11 +++--- 9 files changed, 103 insertions(+), 87 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index bffc608a..b28670cf 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -191,7 +191,7 @@ Using the `depth` option on `ModelSerializer` will now create **read-only nested def create(self, validated_data): profile_data = validated_data.pop['profile'] user = User.objects.create(**validated_data) - profile = Profile.objects.create(user=user, **profile_data) + Profile.objects.create(user=user, **profile_data) return user The single-step object creation makes this far simpler and more obvious than the previous `.restore_object()` behavior. @@ -223,10 +223,6 @@ We can now inspect the serializer representation in the Django shell, using `pyt rating = IntegerField() created_by = PrimaryKeyRelatedField(queryset=User.objects.all()) -#### Always use `fields`, not `exclude`. - -The `exclude` option on `ModelSerializer` is no longer available. You should use the more explicit `fields` option instead. - #### The `extra_kwargs` option. The `write_only_fields` option on `ModelSerializer` has been moved to `PendingDeprecation` and replaced with a more generic `extra_kwargs`. diff --git a/rest_framework/authtoken/serializers.py b/rest_framework/authtoken/serializers.py index c2c456de..a808d0a3 100644 --- a/rest_framework/authtoken/serializers.py +++ b/rest_framework/authtoken/serializers.py @@ -1,7 +1,7 @@ from django.contrib.auth import authenticate from django.utils.translation import ugettext_lazy as _ -from rest_framework import serializers +from rest_framework import exceptions, serializers class AuthTokenSerializer(serializers.Serializer): @@ -18,13 +18,13 @@ class AuthTokenSerializer(serializers.Serializer): if user: if not user.is_active: msg = _('User account is disabled.') - raise serializers.ValidationError(msg) + raise exceptions.ValidationFailed(msg) else: msg = _('Unable to log in with provided credentials.') - raise serializers.ValidationError(msg) + raise exceptions.ValidationFailed(msg) else: msg = _('Must include "username" and "password"') - raise serializers.ValidationError(msg) + raise exceptions.ValidationFailed(msg) attrs['user'] = user return attrs diff --git a/rest_framework/exceptions.py b/rest_framework/exceptions.py index 06b5e8a2..b7c2d16d 100644 --- a/rest_framework/exceptions.py +++ b/rest_framework/exceptions.py @@ -24,6 +24,20 @@ class APIException(Exception): return self.detail +class ValidationFailed(APIException): + status_code = status.HTTP_400_BAD_REQUEST + + def __init__(self, detail): + # For validation errors the 'detail' key is always required. + # The details should always be coerced to a list if not already. + if not isinstance(detail, dict) and not isinstance(detail, list): + detail = [detail] + self.detail = detail + + def __str__(self): + return str(self.detail) + + class ParseError(APIException): status_code = status.HTTP_400_BAD_REQUEST default_detail = 'Malformed request.' diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 7053acee..b881ad13 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -1,7 +1,8 @@ -from django import forms from django.conf import settings from django.core import validators -from django.core.exceptions import ObjectDoesNotExist, ValidationError +from django.core.exceptions import ObjectDoesNotExist +from django.core.exceptions import ValidationError as DjangoValidationError +from django.forms import ImageField as DjangoImageField from django.utils import six, timezone from django.utils.datastructures import SortedDict from django.utils.dateparse import parse_date, parse_datetime, parse_time @@ -12,6 +13,7 @@ from rest_framework.compat import ( smart_text, EmailValidator, MinValueValidator, MaxValueValidator, MinLengthValidator, MaxLengthValidator, URLValidator ) +from rest_framework.exceptions import ValidationFailed from rest_framework.settings import api_settings from rest_framework.utils import html, representation, humanize_datetime import copy @@ -98,7 +100,7 @@ NOT_READ_ONLY_DEFAULT = 'May not set both `read_only` and `default`' NOT_REQUIRED_DEFAULT = 'May not set both `required` and `default`' USE_READONLYFIELD = 'Field(read_only=True) should be ReadOnlyField' MISSING_ERROR_MESSAGE = ( - 'ValidationError raised by `{class_name}`, but error key `{key}` does ' + 'ValidationFailed raised by `{class_name}`, but error key `{key}` does ' 'not exist in the `error_messages` dictionary.' ) @@ -263,7 +265,7 @@ class Field(object): def run_validators(self, value): """ Test the given value against all the validators on the field, - and either raise a `ValidationError` or simply return. + and either raise a `ValidationFailed` or simply return. """ errors = [] for validator in self.validators: @@ -271,10 +273,12 @@ class Field(object): validator.serializer_field = self try: validator(value) - except ValidationError as exc: + except ValidationFailed as exc: + errors.extend(exc.detail) + except DjangoValidationError as exc: errors.extend(exc.messages) if errors: - raise ValidationError(errors) + raise ValidationFailed(errors) def validate(self, value): pass @@ -301,7 +305,8 @@ class Field(object): class_name = self.__class__.__name__ msg = MISSING_ERROR_MESSAGE.format(class_name=class_name, key=key) raise AssertionError(msg) - raise ValidationError(msg.format(**kwargs)) + message_string = msg.format(**kwargs) + raise ValidationFailed(message_string) @property def root(self): @@ -946,7 +951,7 @@ class ImageField(FileField): } def __init__(self, *args, **kwargs): - self._DjangoImageField = kwargs.pop('_DjangoImageField', forms.ImageField) + self._DjangoImageField = kwargs.pop('_DjangoImageField', DjangoImageField) super(ImageField, self).__init__(*args, **kwargs) def to_internal_value(self, data): diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 3bd7b17b..2f683562 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -10,10 +10,11 @@ python primitives. 2. The process of marshalling between python primitives and request and response content is handled by parsers and renderers. """ -from django.core.exceptions import ImproperlyConfigured, ValidationError +from django.core.exceptions import ImproperlyConfigured from django.db import models from django.utils import six from django.utils.datastructures import SortedDict +from rest_framework.exceptions import ValidationFailed from rest_framework.fields import empty, set_value, Field, SkipField from rest_framework.settings import api_settings from rest_framework.utils import html, model_meta, representation @@ -100,14 +101,14 @@ class BaseSerializer(Field): if not hasattr(self, '_validated_data'): try: self._validated_data = self.run_validation(self._initial_data) - except ValidationError as exc: + except ValidationFailed as exc: self._validated_data = {} - self._errors = exc.message_dict + self._errors = exc.detail else: self._errors = {} if self._errors and raise_exception: - raise ValidationError(self._errors) + raise ValidationFailed(self._errors) return not bool(self._errors) @@ -175,24 +176,34 @@ class BoundField(object): def __getattr__(self, attr_name): return getattr(self._field, attr_name) + @property + def _proxy_class(self): + return self._field.__class__ + + def __repr__(self): + return '<%s value=%s errors=%s>' % ( + self.__class__.__name__, self.value, self.errors + ) + + +class NestedBoundField(BoundField): + """ + This BoundField additionally implements __iter__ and __getitem__ + in order to support nested bound fields. This class is the type of + BoundField that is used for serializer fields. + """ def __iter__(self): for field in self.fields.values(): yield self[field.field_name] def __getitem__(self, key): - assert hasattr(self, 'fields'), '"%s" is not a nested field. Cannot perform indexing.' % self.name field = self.fields[key] value = self.value.get(key) if self.value else None error = self.errors.get(key) if self.errors else None + if isinstance(field, Serializer): + return NestedBoundField(field, value, error, prefix=self.name + '.') return BoundField(field, value, error, prefix=self.name + '.') - @property - def _proxy_class(self): - return self._field.__class__ - - def __repr__(self): - return '<%s value=%s errors=%s>' % (self.__class__.__name__, self.value, self.errors) - class BindingDict(object): """ @@ -308,7 +319,7 @@ class Serializer(BaseSerializer): return None if not isinstance(data, dict): - raise ValidationError({ + raise ValidationFailed({ api_settings.NON_FIELD_ERRORS_KEY: ['Invalid data'] }) @@ -317,9 +328,9 @@ class Serializer(BaseSerializer): self.run_validators(value) value = self.validate(value) assert value is not None, '.validate() should return the validated data' - except ValidationError as exc: - raise ValidationError({ - api_settings.NON_FIELD_ERRORS_KEY: exc.messages + except ValidationFailed as exc: + raise ValidationFailed({ + api_settings.NON_FIELD_ERRORS_KEY: exc.detail }) return value @@ -338,15 +349,15 @@ class Serializer(BaseSerializer): validated_value = field.run_validation(primitive_value) if validate_method is not None: validated_value = validate_method(validated_value) - except ValidationError as exc: - errors[field.field_name] = exc.messages + except ValidationFailed as exc: + errors[field.field_name] = exc.detail except SkipField: pass else: set_value(ret, field.source_attrs, validated_value) if errors: - raise ValidationError(errors) + raise ValidationFailed(errors) return ret @@ -385,6 +396,8 @@ class Serializer(BaseSerializer): field = self.fields[key] value = self.data.get(key) error = self.errors.get(key) if hasattr(self, '_errors') else None + if isinstance(field, Serializer): + return NestedBoundField(field, value, error) return BoundField(field, value, error) @@ -538,9 +551,12 @@ class ModelSerializer(Serializer): ret = SortedDict() model = getattr(self.Meta, 'model') fields = getattr(self.Meta, 'fields', None) + exclude = getattr(self.Meta, 'exclude', None) depth = getattr(self.Meta, 'depth', 0) extra_kwargs = getattr(self.Meta, 'extra_kwargs', {}) + assert not fields and exclude, "Cannot set both 'fields' and 'exclude'." + extra_kwargs = self._include_additional_options(extra_kwargs) # Retrieve metadata about fields & relationships on the model class. @@ -551,12 +567,6 @@ class ModelSerializer(Serializer): fields = self._get_default_field_names(declared_fields, info) exclude = getattr(self.Meta, 'exclude', None) if exclude is not None: - warnings.warn( - "The `Meta.exclude` option is pending deprecation. " - "Use the explicit `Meta.fields` instead.", - PendingDeprecationWarning, - stacklevel=3 - ) for field_name in exclude: fields.remove(field_name) diff --git a/rest_framework/views.py b/rest_framework/views.py index 979229eb..292431c8 100644 --- a/rest_framework/views.py +++ b/rest_framework/views.py @@ -3,7 +3,7 @@ Provides an APIView class that is the base of all views in REST framework. """ from __future__ import unicode_literals -from django.core.exceptions import PermissionDenied, ValidationError, NON_FIELD_ERRORS +from django.core.exceptions import PermissionDenied from django.http import Http404 from django.views.decorators.csrf import csrf_exempt from rest_framework import status, exceptions @@ -63,27 +63,20 @@ def exception_handler(exc): if getattr(exc, 'wait', None): headers['Retry-After'] = '%d' % exc.wait - return Response({'detail': exc.detail}, - status=exc.status_code, - headers=headers) + if isinstance(exc.detail, (list, dict)): + data = exc.detail + else: + data = {'detail': exc.detail} - elif isinstance(exc, ValidationError): - # ValidationErrors may include the non-field key named '__all__'. - # When returning a response we map this to a key name that can be - # modified in settings. - if NON_FIELD_ERRORS in exc.message_dict: - errors = exc.message_dict.pop(NON_FIELD_ERRORS) - exc.message_dict[api_settings.NON_FIELD_ERRORS_KEY] = errors - return Response(exc.message_dict, - status=status.HTTP_400_BAD_REQUEST) + return Response(data, status=exc.status_code, headers=headers) elif isinstance(exc, Http404): - return Response({'detail': 'Not found'}, - status=status.HTTP_404_NOT_FOUND) + data = {'detail': 'Not found'} + return Response(data, status=status.HTTP_404_NOT_FOUND) elif isinstance(exc, PermissionDenied): - return Response({'detail': 'Permission denied'}, - status=status.HTTP_403_FORBIDDEN) + data = {'detail': 'Permission denied'} + return Response(data, status=status.HTTP_403_FORBIDDEN) # Note: Unhandled exceptions will raise a 500 error. return None diff --git a/tests/test_fields.py b/tests/test_fields.py index eaa0a3c8..5e8c67c5 100644 --- a/tests/test_fields.py +++ b/tests/test_fields.py @@ -1,7 +1,6 @@ from decimal import Decimal -from django.core.exceptions import ValidationError from django.utils import timezone -from rest_framework import fields, serializers +from rest_framework import exceptions, fields, serializers import datetime import django import pytest @@ -19,9 +18,9 @@ class TestEmpty: By default a field must be included in the input. """ field = fields.IntegerField() - with pytest.raises(fields.ValidationError) as exc_info: + with pytest.raises(exceptions.ValidationFailed) as exc_info: field.run_validation() - assert exc_info.value.messages == ['This field is required.'] + assert exc_info.value.detail == ['This field is required.'] def test_not_required(self): """ @@ -36,9 +35,9 @@ class TestEmpty: By default `None` is not a valid input. """ field = fields.IntegerField() - with pytest.raises(fields.ValidationError) as exc_info: + with pytest.raises(exceptions.ValidationFailed) as exc_info: field.run_validation(None) - assert exc_info.value.messages == ['This field may not be null.'] + assert exc_info.value.detail == ['This field may not be null.'] def test_allow_null(self): """ @@ -53,9 +52,9 @@ class TestEmpty: By default '' is not a valid input. """ field = fields.CharField() - with pytest.raises(fields.ValidationError) as exc_info: + with pytest.raises(exceptions.ValidationFailed) as exc_info: field.run_validation('') - assert exc_info.value.messages == ['This field may not be blank.'] + assert exc_info.value.detail == ['This field may not be blank.'] def test_allow_blank(self): """ @@ -190,7 +189,7 @@ class TestInvalidErrorKey: with pytest.raises(AssertionError) as exc_info: self.field.to_native(123) expected = ( - 'ValidationError raised by `ExampleField`, but error key ' + 'ValidationFailed raised by `ExampleField`, but error key ' '`incorrect` does not exist in the `error_messages` dictionary.' ) assert str(exc_info.value) == expected @@ -244,9 +243,9 @@ class FieldValues: 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: + with pytest.raises(exceptions.ValidationFailed) as exc_info: self.field.run_validation(input_value) - assert exc_info.value.messages == expected_failure + assert exc_info.value.detail == expected_failure def test_outputs(self): for output_value, expected_output in get_items(self.outputs): @@ -901,7 +900,7 @@ class TestFieldFieldWithName(FieldValues): # call into it's regular validation, or require PIL for testing. class FailImageValidation(object): def to_python(self, value): - raise ValidationError(self.error_messages['invalid_image']) + raise exceptions.ValidationFailed(self.error_messages['invalid_image']) class PassImageValidation(object): diff --git a/tests/test_relations.py b/tests/test_relations.py index 66784195..53c1b25c 100644 --- a/tests/test_relations.py +++ b/tests/test_relations.py @@ -1,6 +1,6 @@ from .utils import mock_reverse, fail_reverse, BadType, MockObject, MockQueryset -from django.core.exceptions import ImproperlyConfigured, ValidationError -from rest_framework import serializers +from django.core.exceptions import ImproperlyConfigured +from rest_framework import exceptions, serializers from rest_framework.test import APISimpleTestCase import pytest @@ -30,15 +30,15 @@ class TestPrimaryKeyRelatedField(APISimpleTestCase): assert instance is self.instance def test_pk_related_lookup_does_not_exist(self): - with pytest.raises(ValidationError) as excinfo: + with pytest.raises(exceptions.ValidationFailed) as excinfo: self.field.to_internal_value(4) - msg = excinfo.value.messages[0] + msg = excinfo.value.detail[0] assert msg == "Invalid pk '4' - object does not exist." def test_pk_related_lookup_invalid_type(self): - with pytest.raises(ValidationError) as excinfo: + with pytest.raises(exceptions.ValidationFailed) as excinfo: self.field.to_internal_value(BadType()) - msg = excinfo.value.messages[0] + msg = excinfo.value.detail[0] assert msg == 'Incorrect type. Expected pk value, received BadType.' def test_pk_representation(self): @@ -120,15 +120,15 @@ class TestSlugRelatedField(APISimpleTestCase): assert instance is self.instance def test_slug_related_lookup_does_not_exist(self): - with pytest.raises(ValidationError) as excinfo: + with pytest.raises(exceptions.ValidationFailed) as excinfo: self.field.to_internal_value('doesnotexist') - msg = excinfo.value.messages[0] + msg = excinfo.value.detail[0] assert msg == 'Object with name=doesnotexist does not exist.' def test_slug_related_lookup_invalid_type(self): - with pytest.raises(ValidationError) as excinfo: + with pytest.raises(exceptions.ValidationFailed) as excinfo: self.field.to_internal_value(BadType()) - msg = excinfo.value.messages[0] + msg = excinfo.value.detail[0] assert msg == 'Invalid value.' def test_representation(self): diff --git a/tests/test_validation.py b/tests/test_validation.py index ce39714d..849c7e9d 100644 --- a/tests/test_validation.py +++ b/tests/test_validation.py @@ -1,9 +1,8 @@ from __future__ import unicode_literals from django.core.validators import MaxValueValidator -from django.core.exceptions import ValidationError from django.db import models from django.test import TestCase -from rest_framework import generics, serializers, status +from rest_framework import exceptions, generics, serializers, status from rest_framework.test import APIRequestFactory factory = APIRequestFactory() @@ -38,7 +37,7 @@ class ShouldValidateModelSerializer(serializers.ModelSerializer): def validate_renamed(self, value): if len(value) < 3: - raise serializers.ValidationError('Minimum 3 characters.') + raise exceptions.ValidationFailed('Minimum 3 characters.') return value class Meta: @@ -74,10 +73,10 @@ class ValidationSerializer(serializers.Serializer): foo = serializers.CharField() def validate_foo(self, attrs, source): - raise serializers.ValidationError("foo invalid") + raise exceptions.ValidationFailed("foo invalid") def validate(self, attrs): - raise serializers.ValidationError("serializer invalid") + raise exceptions.ValidationFailed("serializer invalid") class TestAvoidValidation(TestCase): @@ -159,7 +158,7 @@ class TestChoiceFieldChoicesValidate(TestCase): value = self.CHOICES[0][0] try: f.to_internal_value(value) - except ValidationError: + except exceptions.ValidationFailed: self.fail("Value %s does not validate" % str(value)) # def test_nested_choices(self): -- cgit v1.2.3 From d8a8987ab1eb6abbaee1a0de8cfea38eafe21293 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 10 Oct 2014 14:32:02 +0100 Subject: Tweaks --- docs/topics/3.0-announcement.md | 6 ++++++ rest_framework/serializers.py | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index b28670cf..aa0e0c7e 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -144,6 +144,12 @@ The corresponding code would now look like this: logging.info('Creating ticket "%s"' % name) serializer.save(user=request.user) # Include the user when saving. +#### Use `rest_framework.exceptions.ValidationFailed`. + +Django's `ValidationError` class is intended for use with HTML forms and it's API makes its use slightly awkward with nested validation errors as can occur in serializers. + +We now include a simpler `ValidationFailed` exception class in REST framework that you should use when raising validation failures. + #### Change to `validate_`. The `validate_` method hooks that can be attached to serializer classes change their signature slightly and return type. Previously these would take a dictionary of all incoming data, and a key representing the field name, and would return a dictionary including the validated data for that field: diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 2f683562..0f6cf2bc 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -555,7 +555,7 @@ class ModelSerializer(Serializer): depth = getattr(self.Meta, 'depth', 0) extra_kwargs = getattr(self.Meta, 'extra_kwargs', {}) - assert not fields and exclude, "Cannot set both 'fields' and 'exclude'." + assert not (fields and exclude), "Cannot set both 'fields' and 'exclude'." extra_kwargs = self._include_additional_options(extra_kwargs) -- cgit v1.2.3 From b5a4216aff06bfb36238d0f587d8645db0ee4a69 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 10 Oct 2014 15:08:43 +0100 Subject: Flake8 --- rest_framework/serializers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 0f6cf2bc..f3f5c837 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -555,7 +555,7 @@ class ModelSerializer(Serializer): depth = getattr(self.Meta, 'depth', 0) extra_kwargs = getattr(self.Meta, 'extra_kwargs', {}) - assert not (fields and exclude), "Cannot set both 'fields' and 'exclude'." + assert not (fields and exclude), "Cannot set both 'fields' and 'exclude'." extra_kwargs = self._include_additional_options(extra_kwargs) -- cgit v1.2.3 From 826b5a889704452c53c05a44905f9fa62889ff34 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 10 Oct 2014 15:34:00 +0100 Subject: Relations in 'read_only_fields' should not include a queryset kwarg --- rest_framework/serializers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index f3f5c837..bc9c15eb 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -640,7 +640,7 @@ class ModelSerializer(Serializer): for attr in [ 'required', 'default', 'allow_blank', 'allow_null', 'min_length', 'max_length', 'min_value', 'max_value', - 'validators' + 'validators', 'queryset' ]: kwargs.pop(attr, None) kwargs.update(extras) -- cgit v1.2.3 From 81abf2bf341d8d7b27e2974a01a78c30c796b4d6 Mon Sep 17 00:00:00 2001 From: Andy Freeland Date: Sun, 12 Oct 2014 01:19:14 -0400 Subject: Rename `preform_update` to `perform_update` --- rest_framework/mixins.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rest_framework/mixins.py b/rest_framework/mixins.py index 4c62debb..467ff515 100644 --- a/rest_framework/mixins.py +++ b/rest_framework/mixins.py @@ -67,10 +67,10 @@ class UpdateModelMixin(object): instance = self.get_object() serializer = self.get_serializer(instance, data=request.data, partial=partial) serializer.is_valid(raise_exception=True) - self.preform_update(serializer) + self.perform_update(serializer) return Response(serializer.data) - def preform_update(self, serializer): + def perform_update(self, serializer): serializer.save() def partial_update(self, request, *args, **kwargs): -- cgit v1.2.3 From f8f101268e1d3ff0621c61299c13d78914874a2b Mon Sep 17 00:00:00 2001 From: wolfe Date: Tue, 14 Oct 2014 18:58:25 -0300 Subject: Update 3.0-announcement.md Swap order of custom field API changes so the two "and" clauses are in the same order.--- docs/topics/3.0-announcement.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index aa0e0c7e..dcd6d90c 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -518,7 +518,7 @@ The `MultipleChoiceField` class has been added. This field acts like `ChoiceFiel #### Changes to the custom field API. -The `from_native(self, value)` and `to_native(self, data)` method names have been replaced with the more obviously named `to_representation(self, value)` and `to_internal_value(self, data)`. +The `from_native(self, value)` and `to_native(self, data)` method names have been replaced with the more obviously named `to_internal_value(self, data)` and `to_representation(self, value)`. The `field_from_native()` and `field_to_native()` methods are removed. -- cgit v1.2.3 From e272a36c9b444c1da3a3d8bc809070deb26d9c64 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 15 Oct 2014 09:24:49 +0100 Subject: Fix 'lookup_field' on ModelSerializer. Closes #1944. --- rest_framework/serializers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index bc9c15eb..c844605f 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -680,7 +680,7 @@ class ModelSerializer(Serializer): PendingDeprecationWarning, stacklevel=3 ) - kwargs = extra_kwargs.get(field_name, {}) + kwargs = extra_kwargs.get(api_settings.URL_FIELD_NAME, {}) kwargs['view_name'] = view_name extra_kwargs[api_settings.URL_FIELD_NAME] = kwargs @@ -692,7 +692,7 @@ class ModelSerializer(Serializer): PendingDeprecationWarning, stacklevel=3 ) - kwargs = extra_kwargs.get(field_name, {}) + kwargs = extra_kwargs.get(api_settings.URL_FIELD_NAME, {}) kwargs['lookup_field'] = lookup_field extra_kwargs[api_settings.URL_FIELD_NAME] = kwargs -- cgit v1.2.3 From e558f806c0e87a329915b7077783f9ed3a79bb07 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 15 Oct 2014 10:04:01 +0100 Subject: Drop template includes --- rest_framework/templates/rest_framework/fields/attrs.html | 1 - .../templates/rest_framework/fields/horizontal/input.html | 6 ++++-- .../templates/rest_framework/fields/horizontal/label.html | 1 - .../templates/rest_framework/fields/horizontal/select.html | 8 +++++--- .../rest_framework/fields/horizontal/select_checkbox.html | 4 +++- .../rest_framework/fields/horizontal/select_multiple.html | 4 +++- .../templates/rest_framework/fields/horizontal/select_radio.html | 4 +++- .../templates/rest_framework/fields/horizontal/textarea.html | 6 ++++-- rest_framework/templates/rest_framework/fields/inline/input.html | 6 ++++-- rest_framework/templates/rest_framework/fields/inline/label.html | 1 - rest_framework/templates/rest_framework/fields/inline/select.html | 4 +++- .../templates/rest_framework/fields/inline/select_checkbox.html | 4 +++- .../templates/rest_framework/fields/inline/select_multiple.html | 4 +++- .../templates/rest_framework/fields/inline/select_radio.html | 4 +++- .../templates/rest_framework/fields/inline/textarea.html | 6 ++++-- .../templates/rest_framework/fields/vertical/input.html | 6 ++++-- .../templates/rest_framework/fields/vertical/label.html | 1 - .../templates/rest_framework/fields/vertical/select.html | 4 +++- .../templates/rest_framework/fields/vertical/select_checkbox.html | 4 +++- .../templates/rest_framework/fields/vertical/select_multiple.html | 4 +++- .../templates/rest_framework/fields/vertical/select_radio.html | 4 +++- .../templates/rest_framework/fields/vertical/textarea.html | 6 ++++-- 22 files changed, 62 insertions(+), 30 deletions(-) delete mode 100644 rest_framework/templates/rest_framework/fields/attrs.html delete mode 100644 rest_framework/templates/rest_framework/fields/horizontal/label.html delete mode 100644 rest_framework/templates/rest_framework/fields/inline/label.html delete mode 100644 rest_framework/templates/rest_framework/fields/vertical/label.html diff --git a/rest_framework/templates/rest_framework/fields/attrs.html b/rest_framework/templates/rest_framework/fields/attrs.html deleted file mode 100644 index 1e23c465..00000000 --- a/rest_framework/templates/rest_framework/fields/attrs.html +++ /dev/null @@ -1 +0,0 @@ -name="{{ field.name }}" {% if field.style.placeholder %}placeholder="{{ field.style.placeholder }}"{% endif %} {% if field.style.rows %}rows="{{ field.style.rows }}"{% endif %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/input.html b/rest_framework/templates/rest_framework/fields/horizontal/input.html index 6f1a504b..6621c7e6 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/input.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/input.html @@ -1,7 +1,9 @@
- {% include "rest_framework/fields/horizontal/label.html" %} + {% if field.label %} + + {% endif %}
- + {% if field.help_text %}

{{ field.help_text }}

{% endif %}
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/label.html b/rest_framework/templates/rest_framework/fields/horizontal/label.html deleted file mode 100644 index bf21f78c..00000000 --- a/rest_framework/templates/rest_framework/fields/horizontal/label.html +++ /dev/null @@ -1 +0,0 @@ -{% if field.label %}{% endif %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select.html b/rest_framework/templates/rest_framework/fields/horizontal/select.html index 10b4b139..eaa6d575 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select.html @@ -1,10 +1,12 @@
- {% include "rest_framework/fields/horizontal/label.html" %} + {% if field.label %} + + {% endif %}
diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html b/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html index 6041fa74..ff3fab57 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_checkbox.html @@ -1,5 +1,7 @@
- {% include "rest_framework/fields/horizontal/label.html" %} + {% if field.label %} + + {% endif %}
{% if field.style.inline %} {% for key, text in field.choices.items %} diff --git a/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html b/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html index c0dbb989..3ed2874b 100644 --- a/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html +++ b/rest_framework/templates/rest_framework/fields/horizontal/select_multiple.html @@ -1,5 +1,7 @@
- {% include "rest_framework/fields/horizontal/label.html" %} + {% if field.label %} + + {% endif %}
+ {% if field.help_text %}

{{ field.help_text }}

{% endif %}
diff --git a/rest_framework/templates/rest_framework/fields/inline/input.html b/rest_framework/templates/rest_framework/fields/inline/input.html index e4a92ccd..bdf25ffe 100644 --- a/rest_framework/templates/rest_framework/fields/inline/input.html +++ b/rest_framework/templates/rest_framework/fields/inline/input.html @@ -1,4 +1,6 @@
- {% include "rest_framework/fields/inline/label.html" %} - + {% if field.label %} + + {% endif %} +
diff --git a/rest_framework/templates/rest_framework/fields/inline/label.html b/rest_framework/templates/rest_framework/fields/inline/label.html deleted file mode 100644 index 7d546a57..00000000 --- a/rest_framework/templates/rest_framework/fields/inline/label.html +++ /dev/null @@ -1 +0,0 @@ -{% if field.label %}{% endif %} diff --git a/rest_framework/templates/rest_framework/fields/inline/select.html b/rest_framework/templates/rest_framework/fields/inline/select.html index eebb91d2..730fcce6 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select.html +++ b/rest_framework/templates/rest_framework/fields/inline/select.html @@ -1,5 +1,7 @@
- {% include "rest_framework/fields/inline/label.html" %} + {% if field.label %} + + {% endif %} {% for key, text in field.choices.items %} diff --git a/rest_framework/templates/rest_framework/fields/inline/select_radio.html b/rest_framework/templates/rest_framework/fields/inline/select_radio.html index 27927a62..3fffceac 100644 --- a/rest_framework/templates/rest_framework/fields/inline/select_radio.html +++ b/rest_framework/templates/rest_framework/fields/inline/select_radio.html @@ -1,5 +1,7 @@
- {% include "rest_framework/fields/inline/label.html" %} + {% if field.label %} + + {% endif %} {% for key, text in field.choices.items %}
+ +
+ +
+ +
+ -
-
+
+
+ - - - - - - + + + + - // Dynamically force sidenav to no higher than browser window - $('.side-nav').css('max-height', window.innerHeight - 130); - - $(function(){ - $(window).resize(function(){ - $('.side-nav').css('max-height', window.innerHeight - 130); - }); - }); - - + diff --git a/docs_theme/base.html b/docs_theme/base.html index 67290df6..544e2188 100644 --- a/docs_theme/base.html +++ b/docs_theme/base.html @@ -1,56 +1,62 @@ - - - {{ page_title }} - - - - - - - - - - - - - - - - - - - {# TODO: This is a bit of a hack. We don't want to refer to the file specifically. #} - + + + + + {{ page_title }} + + + + + + + + + + + + + + + + + + + +{# TODO: This is a bit of a hack. We don't want to refer to the file specifically. #} + +
@@ -59,32 +65,34 @@ a.fusion-poweredby {
- - + +
@@ -98,18 +106,16 @@ a.fusion-poweredby {
    {% for toc_item in toc %} -
  • {{ toc_item.title }}
    • - {% for toc_item in toc_item.children %} -
  • {{ toc_item.title }}
    • - {% endfor %} - {% endfor %} - - {# TODO: This is a bit of a hack. We don't want to refer to the file specifically. #} - {% if current_page.input_path == 'index.md' %} -
    -
    - -
    +
  • {{ toc_item.title }} +
    • + {% for toc_item in toc_item.children %} +
  • {{ toc_item.title }} +
    • + {% endfor %} {% endfor %} {# TODO: This is a bit of a hack. We don't want to refer to the file specifically. #} {% if current_page.input_path == 'index.md' %} +
    +
    + +
    {% endif %}
@@ -127,42 +133,51 @@ a.fusion-poweredby { {% endif %} {{ content }} -
-
-
-
- -
-
+
+ +
+ +
+ +
+ +
+
+ - - - - - - - + + + + + - // Dynamically force sidenav to no higher than browser window - $('.side-nav').css('max-height', window.innerHeight - 130); - - $(function(){ - $(window).resize(function(){ - $('.side-nav').css('max-height', window.innerHeight - 130); - }); - }); - - + diff --git a/docs_theme/nav.html b/docs_theme/nav.html index a7a72d68..87e197b3 100644 --- a/docs_theme/nav.html +++ b/docs_theme/nav.html @@ -1,11 +1,10 @@ -
- GitHub - Next - Previous - Search + GitHub + Next + Previous + Search @@ -14,31 +13,29 @@ Django REST framework
{% if include_nav %} - - {% endif %} -
+
+
-- cgit v1.2.3 From 06683b86b2b15153df52fe481b5c4eeb489a80cf Mon Sep 17 00:00:00 2001 From: José Padilla Date: Fri, 31 Oct 2014 13:02:11 -0400 Subject: Use single quotes for consistency Conflicts: mkdocs.yml --- mkdocs.yml | 48 ++++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index 2d1886a0..c70de982 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -13,30 +13,30 @@ pages: - ['tutorial/4-authentication-and-permissions.md', ] - ['tutorial/5-relationships-and-hyperlinked-apis.md', ] - ['tutorial/6-viewsets-and-routers.md', ] - - ['api-guide/requests.md', "API Guide", ] - - ['api-guide/responses.md', "API Guide", ] - - ['api-guide/views.md', "API Guide", ] - - ['api-guide/generic-views.md', "API Guide", ] - - ['api-guide/viewsets.md', "API Guide", ] - - ['api-guide/routers.md', "API Guide", ] - - ['api-guide/parsers.md', "API Guide", ] - - ['api-guide/renderers.md', "API Guide", ] - - ['api-guide/serializers.md', "API Guide", ] - - ['api-guide/fields.md', "API Guide", ] - - ['api-guide/relations.md', "API Guide", ] - - ['api-guide/validators.md', "API Guide", ] - - ['api-guide/authentication.md', "API Guide", ] - - ['api-guide/permissions.md', "API Guide", ] - - ['api-guide/throttling.md', "API Guide", ] - - ['api-guide/filtering.md', "API Guide", ] - - ['api-guide/pagination.md', "API Guide", ] - - ['api-guide/content-negotiation.md', "API Guide", ] - - ['api-guide/format-suffixes.md', "API Guide", ] - - ['api-guide/reverse.md', "API Guide", ] - - ['api-guide/exceptions.md', "API Guide", ] - - ['api-guide/status-codes.md', "API Guide", ] - - ['api-guide/testing.md', "API Guide", ] - - ['api-guide/settings.md', "API Guide", ] + - ['api-guide/requests.md', 'API Guide', ] + - ['api-guide/responses.md', 'API Guide', ] + - ['api-guide/views.md', 'API Guide', ] + - ['api-guide/generic-views.md', 'API Guide', ] + - ['api-guide/viewsets.md', 'API Guide', ] + - ['api-guide/routers.md', 'API Guide', ] + - ['api-guide/parsers.md', 'API Guide', ] + - ['api-guide/renderers.md', 'API Guide', ] + - ['api-guide/serializers.md', 'API Guide', ] + - ['api-guide/fields.md', 'API Guide', ] + - ['api-guide/relations.md', 'API Guide', ] + - ['api-guide/validators.md', 'API Guide', ] + - ['api-guide/authentication.md', 'API Guide', ] + - ['api-guide/permissions.md', 'API Guide', ] + - ['api-guide/throttling.md', 'API Guide', ] + - ['api-guide/filtering.md', 'API Guide', ] + - ['api-guide/pagination.md', 'API Guide', ] + - ['api-guide/content-negotiation.md', 'API Guide', ] + - ['api-guide/format-suffixes.md', 'API Guide', ] + - ['api-guide/reverse.md', 'API Guide', ] + - ['api-guide/exceptions.md', 'API Guide', ] + - ['api-guide/status-codes.md', 'API Guide', ] + - ['api-guide/testing.md', 'API Guide', ] + - ['api-guide/settings.md', 'API Guide', ] - ['topics/documenting-your-api.md', ] - ['topics/ajax-csrf-cors.md', ] - ['topics/browser-enhancements.md', ] -- cgit v1.2.3 From 200e0b17daecd07de6d1f9926a430d29b3ee948f Mon Sep 17 00:00:00 2001 From: José Padilla Date: Fri, 31 Oct 2014 13:03:39 -0400 Subject: Clean up extra white space --- docs/topics/2.2-announcement.md | 8 ++++---- docs/topics/2.3-announcement.md | 8 ++++---- docs/topics/documenting-your-api.md | 8 ++++---- docs/topics/kickstarter-announcement.md | 2 +- docs/topics/release-notes.md | 2 +- docs/topics/rest-framework-2-announcement.md | 4 ++-- docs/topics/writable-nested-serializers.md | 10 +++++----- docs/tutorial/1-serialization.md | 2 +- 8 files changed, 22 insertions(+), 22 deletions(-) diff --git a/docs/topics/2.2-announcement.md b/docs/topics/2.2-announcement.md index a997c782..1df52cff 100644 --- a/docs/topics/2.2-announcement.md +++ b/docs/topics/2.2-announcement.md @@ -42,7 +42,7 @@ The 2.2 release makes a few changes to the API, in order to make it more consist The `ManyRelatedField()` style is being deprecated in favor of a new `RelatedField(many=True)` syntax. -For example, if a user is associated with multiple questions, which we want to represent using a primary key relationship, we might use something like the following: +For example, if a user is associated with multiple questions, which we want to represent using a primary key relationship, we might use something like the following: class UserSerializer(serializers.HyperlinkedModelSerializer): questions = serializers.PrimaryKeyRelatedField(many=True) @@ -58,10 +58,10 @@ The change also applies to serializers. If you have a nested serializer, you sh class Meta: model = Track fields = ('name', 'duration') - + class AlbumSerializer(serializer.ModelSerializer): tracks = TrackSerializer(many=True) - + class Meta: model = Album fields = ('album_name', 'artist', 'tracks') @@ -87,7 +87,7 @@ For example, is a user account has an optional foreign key to a company, that yo This is in line both with the rest of the serializer fields API, and with Django's `Form` and `ModelForm` API. -Using `required` throughout the serializers API means you won't need to consider if a particular field should take `blank` or `null` arguments instead of `required`, and also means there will be more consistent behavior for how fields are treated when they are not present in the incoming data. +Using `required` throughout the serializers API means you won't need to consider if a particular field should take `blank` or `null` arguments instead of `required`, and also means there will be more consistent behavior for how fields are treated when they are not present in the incoming data. The `null=True` argument will continue to function, and will imply `required=False`, but will raise a `PendingDeprecationWarning`. diff --git a/docs/topics/2.3-announcement.md b/docs/topics/2.3-announcement.md index 7c800afa..9c9f3e9f 100644 --- a/docs/topics/2.3-announcement.md +++ b/docs/topics/2.3-announcement.md @@ -27,7 +27,7 @@ As an example of just how simple REST framework APIs can now be, here's an API w class GroupViewSet(viewsets.ModelViewSet): model = Group - + # Routers provide an easy way of automatically determining the URL conf router = routers.DefaultRouter() router.register(r'users', UserViewSet) @@ -197,13 +197,13 @@ Usage of the old-style attributes continues to be supported, but will raise a `P For most cases APIs using model fields will behave as previously, however if you are using a custom renderer, not provided by REST framework, then you may now need to add support for rendering `Decimal` instances to your renderer implementation. -## ModelSerializers and reverse relationships +## ModelSerializers and reverse relationships The support for adding reverse relationships to the `fields` option on a `ModelSerializer` class means that the `get_related_field` and `get_nested_field` method signatures have now changed. In the unlikely event that you're providing a custom serializer class, and implementing these methods you should note the new call signature for both methods is now `(self, model_field, related_model, to_many)`. For reverse relationships `model_field` will be `None`. -The old-style signature will continue to function but will raise a `PendingDeprecationWarning`. +The old-style signature will continue to function but will raise a `PendingDeprecationWarning`. ## View names and descriptions @@ -211,7 +211,7 @@ The mechanics of how the names and descriptions used in the browseable API are g If you've been customizing this behavior, for example perhaps to use `rst` markup for the browseable API, then you'll need to take a look at the implementation to see what updates you need to make. -Note that the relevant methods have always been private APIs, and the docstrings called them out as intended to be deprecated. +Note that the relevant methods have always been private APIs, and the docstrings called them out as intended to be deprecated. --- diff --git a/docs/topics/documenting-your-api.md b/docs/topics/documenting-your-api.md index e20f9712..d65e251f 100644 --- a/docs/topics/documenting-your-api.md +++ b/docs/topics/documenting-your-api.md @@ -54,7 +54,7 @@ The title that is used in the browsable API is generated from the view class nam For example, the view `UserListView`, will be named `User List` when presented in the browsable API. -When working with viewsets, an appropriate suffix is appended to each generated view. For example, the view set `UserViewSet` will generate views named `User List` and `User Instance`. +When working with viewsets, an appropriate suffix is appended to each generated view. For example, the view set `UserViewSet` will generate views named `User List` and `User Instance`. #### Setting the description @@ -65,9 +65,9 @@ If the python `markdown` library is installed, then [markdown syntax][markdown] class AccountListView(views.APIView): """ Returns a list of all **active** accounts in the system. - + For more details on how accounts are activated please [see here][ref]. - + [ref]: http://example.com/activating-accounts """ @@ -84,7 +84,7 @@ You can modify the response behavior to `OPTIONS` requests by overriding the `me def metadata(self, request): """ Don't include the view description in OPTIONS responses. - """ + """ data = super(ExampleView, self).metadata(request) data.pop('description') return data diff --git a/docs/topics/kickstarter-announcement.md b/docs/topics/kickstarter-announcement.md index 7d1f6d0e..e8bad95b 100644 --- a/docs/topics/kickstarter-announcement.md +++ b/docs/topics/kickstarter-announcement.md @@ -160,4 +160,4 @@ The following individuals made a significant financial contribution to the devel ### Supporters -There were also almost 300 further individuals choosing to help fund the project at other levels or choosing to give anonymously. Again, thank you, thank you, thank you! \ No newline at end of file +There were also almost 300 further individuals choosing to help fund the project at other levels or choosing to give anonymously. Again, thank you, thank you, thank you! diff --git a/docs/topics/release-notes.md b/docs/topics/release-notes.md index 88780c3f..9fca949a 100644 --- a/docs/topics/release-notes.md +++ b/docs/topics/release-notes.md @@ -63,7 +63,7 @@ You can determine your currently installed version using `pip freeze`: * Bugfix: Fix migration in `authtoken` application. * Bugfix: Allow selection of integer keys in nested choices. * Bugfix: Return `None` instead of `'None'` in `CharField` with `allow_none=True`. -* Bugfix: Ensure custom model fields map to equivelent serializer fields more reliably. +* Bugfix: Ensure custom model fields map to equivelent serializer fields more reliably. * Bugfix: `DjangoFilterBackend` no longer quietly changes queryset ordering. ### 2.4.2 diff --git a/docs/topics/rest-framework-2-announcement.md b/docs/topics/rest-framework-2-announcement.md index f1060d90..a7746932 100644 --- a/docs/topics/rest-framework-2-announcement.md +++ b/docs/topics/rest-framework-2-announcement.md @@ -8,7 +8,7 @@ What it is, and why you should care. --- -**Announcement:** REST framework 2 released - Tue 30th Oct 2012 +**Announcement:** REST framework 2 released - Tue 30th Oct 2012 --- @@ -37,7 +37,7 @@ REST framework 2 includes a totally re-worked serialization engine, that was ini * A declarative serialization API, that mirrors Django's `Forms`/`ModelForms` API. * Structural concerns are decoupled from encoding concerns. * Able to support rendering and parsing to many formats, including both machine-readable representations and HTML forms. -* Validation that can be mapped to obvious and comprehensive error responses. +* Validation that can be mapped to obvious and comprehensive error responses. * Serializers that support both nested, flat, and partially-nested representations. * Relationships that can be expressed as primary keys, hyperlinks, slug fields, and other custom representations. diff --git a/docs/topics/writable-nested-serializers.md b/docs/topics/writable-nested-serializers.md index abc6a82f..ed614bd2 100644 --- a/docs/topics/writable-nested-serializers.md +++ b/docs/topics/writable-nested-serializers.md @@ -8,7 +8,7 @@ Although flat data structures serve to properly delineate between the individual Nested data structures are easy enough to work with if they're read-only - simply nest your serializer classes and you're good to go. However, there are a few more subtleties to using writable nested serializers, due to the dependencies between the various model instances, and the need to save or delete multiple instances in a single action. -## One-to-many data structures +## One-to-many data structures *Example of a **read-only** nested serializer. Nothing complex to worry about here.* @@ -16,10 +16,10 @@ Nested data structures are easy enough to work with if they're read-only - simpl class Meta: model = ToDoItem fields = ('text', 'is_completed') - + class ToDoListSerializer(serializers.ModelSerializer): items = ToDoItemSerializer(many=True, read_only=True) - + class Meta: model = ToDoList fields = ('title', 'items') @@ -31,7 +31,7 @@ Some example output from our serializer. 'items': { {'text': 'Compile playlist', 'is_completed': True}, {'text': 'Send invites', 'is_completed': False}, - {'text': 'Clean house', 'is_completed': False} + {'text': 'Clean house', 'is_completed': False} } } @@ -44,4 +44,4 @@ Let's take a look at updating our nested one-to-many data structure. ### Making PATCH requests -[cite]: http://jsonapi.org/format/#url-based-json-api \ No newline at end of file +[cite]: http://jsonapi.org/format/#url-based-json-api diff --git a/docs/tutorial/1-serialization.md b/docs/tutorial/1-serialization.md index db5b9ea7..f9027b68 100644 --- a/docs/tutorial/1-serialization.md +++ b/docs/tutorial/1-serialization.md @@ -134,7 +134,7 @@ A serializer class is very similar to a Django `Form` class, and includes simila The field flags can also control how the serializer should be displayed in certain circumstances, such as when rendering to HTML. The `style={'type': 'textarea'}` flag above is equivelent to using `widget=widgets.Textarea` on a Django `Form` class. This is particularly useful for controlling how the browsable API should be displayed, as we'll see later in the tutorial. -We can actually also save ourselves some time by using the `ModelSerializer` class, as we'll see later, but for now we'll keep our serializer definition explicit. +We can actually also save ourselves some time by using the `ModelSerializer` class, as we'll see later, but for now we'll keep our serializer definition explicit. ## Working with Serializers -- cgit v1.2.3 From b8aa7e0c34dc839a47b679aa2402d0f1b98704a0 Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Tue, 18 Nov 2014 17:16:54 +0000 Subject: Fix previous and next links --- docs_theme/nav.html | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/docs_theme/nav.html b/docs_theme/nav.html index 87e197b3..0f3b9871 100644 --- a/docs_theme/nav.html +++ b/docs_theme/nav.html @@ -2,8 +2,12 @@
GitHub - Next - Previous + + Search -- cgit v1.2.3 From 8677316959c65da1305b0bfc7c06733093d5af3e Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Tue, 18 Nov 2014 17:20:42 +0000 Subject: Disable prev and next links --- docs_theme/nav.html | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs_theme/nav.html b/docs_theme/nav.html index 0f3b9871..e6ab01ba 100644 --- a/docs_theme/nav.html +++ b/docs_theme/nav.html @@ -2,10 +2,10 @@
GitHub - - Search -- cgit v1.2.3 From 6f28adeefe21df4330fe70bc20cb457e249a29d2 Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Wed, 19 Nov 2014 08:56:14 +0000 Subject: Added nicer page titles --- mkdocs.yml | 46 +++++++++++++++++++++++----------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index c70de982..d5feab65 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -7,12 +7,12 @@ repo_url: https://github.com/tomchristie/django-rest-framework pages: - ['index.md', ] - ['tutorial/quickstart.md', ] - - ['tutorial/1-serialization.md', ] - - ['tutorial/2-requests-and-responses.md', ] - - ['tutorial/3-class-based-views.md', ] - - ['tutorial/4-authentication-and-permissions.md', ] - - ['tutorial/5-relationships-and-hyperlinked-apis.md', ] - - ['tutorial/6-viewsets-and-routers.md', ] + - ['tutorial/1-serialization.md', "Tutorial", "1 - Serialization"] + - ['tutorial/2-requests-and-responses.md', "Tutorial", "2 - Requests and responses"] + - ['tutorial/3-class-based-views.md', "Tutorial", "3 - Class based views"] + - ['tutorial/4-authentication-and-permissions.md', "Tutorial", "4 - Authentication and permissions"] + - ['tutorial/5-relationships-and-hyperlinked-apis.md', "Tutorial", "5 - Relationships and hyperlinked APIs"] + - ['tutorial/6-viewsets-and-routers.md', "Tutorial", "6- Viewsets and routers"] - ['api-guide/requests.md', 'API Guide', ] - ['api-guide/responses.md', 'API Guide', ] - ['api-guide/views.md', 'API Guide', ] @@ -22,8 +22,8 @@ pages: - ['api-guide/parsers.md', 'API Guide', ] - ['api-guide/renderers.md', 'API Guide', ] - ['api-guide/serializers.md', 'API Guide', ] - - ['api-guide/fields.md', 'API Guide', ] - - ['api-guide/relations.md', 'API Guide', ] + - ['api-guide/fields.md', 'API Guide', "Serializer fields"] + - ['api-guide/relations.md', 'API Guide', "Serializer relations"] - ['api-guide/validators.md', 'API Guide', ] - ['api-guide/authentication.md', 'API Guide', ] - ['api-guide/permissions.md', 'API Guide', ] @@ -32,25 +32,25 @@ pages: - ['api-guide/pagination.md', 'API Guide', ] - ['api-guide/content-negotiation.md', 'API Guide', ] - ['api-guide/format-suffixes.md', 'API Guide', ] - - ['api-guide/reverse.md', 'API Guide', ] + - ['api-guide/reverse.md', 'API Guide', 'Returning URLs'] - ['api-guide/exceptions.md', 'API Guide', ] - ['api-guide/status-codes.md', 'API Guide', ] - ['api-guide/testing.md', 'API Guide', ] - ['api-guide/settings.md', 'API Guide', ] - - ['topics/documenting-your-api.md', ] - - ['topics/ajax-csrf-cors.md', ] - - ['topics/browser-enhancements.md', ] - - ['topics/browsable-api.md', ] - - ['topics/rest-hypermedia-hateoas.md', ] - - ['topics/third-party-resources.md', ] - - ['topics/contributing.md', ] - - ['topics/rest-framework-2-announcement.md', ] - - ['topics/2.2-announcement.md', ] - - ['topics/2.3-announcement.md', ] - - ['topics/2.4-announcement.md', ] - - ['topics/kickstarter-announcement.md', ] - - ['topics/release-notes.md', ] - - ['topics/credits.md', ] + - ['topics/documenting-your-api.md', 'Topics', 'Documenting your API'] + - ['topics/ajax-csrf-cors.md', 'Topics', 'AJAX, CSRF & CORS'] + - ['topics/browser-enhancements.md', 'Topics',] + - ['topics/browsable-api.md', 'Topics', 'The Browsable API'] + - ['topics/rest-hypermedia-hateoas.md', 'Topics', 'REST, Hypermedia & HATEOAS'] + - ['topics/third-party-resources.md', 'Topics', 'Third Party Resources'] + - ['topics/contributing.md', 'Topics', 'Contributing to REST framework'] + - ['topics/rest-framework-2-announcement.md', 'Topics', '2.0 Announcement'] + - ['topics/2.2-announcement.md', 'Topics', '2.2 Announcement'] + - ['topics/2.3-announcement.md', 'Topics', '2.3 Announcement'] + - ['topics/2.4-announcement.md', 'Topics', '2.4 Announcement'] + - ['topics/kickstarter-announcement.md', 'Topics', 'Kickstarter Announcement'] + - ['topics/release-notes.md', 'Topics', 'Release Notes'] + - ['topics/credits.md', 'Topics', 'Credits'] site_dir: html theme_dir: docs_theme -- cgit v1.2.3 From df33538f141f5d5d4a9f905a56cad0f881fb20de Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Wed, 19 Nov 2014 12:41:58 +0000 Subject: Make the quotes consistent --- mkdocs.yml | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index d5feab65..925586d1 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -7,12 +7,12 @@ repo_url: https://github.com/tomchristie/django-rest-framework pages: - ['index.md', ] - ['tutorial/quickstart.md', ] - - ['tutorial/1-serialization.md', "Tutorial", "1 - Serialization"] - - ['tutorial/2-requests-and-responses.md', "Tutorial", "2 - Requests and responses"] - - ['tutorial/3-class-based-views.md', "Tutorial", "3 - Class based views"] - - ['tutorial/4-authentication-and-permissions.md', "Tutorial", "4 - Authentication and permissions"] - - ['tutorial/5-relationships-and-hyperlinked-apis.md', "Tutorial", "5 - Relationships and hyperlinked APIs"] - - ['tutorial/6-viewsets-and-routers.md', "Tutorial", "6- Viewsets and routers"] + - ['tutorial/1-serialization.md', 'Tutorial', '1 - Serialization'] + - ['tutorial/2-requests-and-responses.md', 'Tutorial', '2 - Requests and responses'] + - ['tutorial/3-class-based-views.md', 'Tutorial', '3 - Class based views'] + - ['tutorial/4-authentication-and-permissions.md', 'Tutorial', '4 - Authentication and permissions'] + - ['tutorial/5-relationships-and-hyperlinked-apis.md', 'Tutorial', '5 - Relationships and hyperlinked APIs'] + - ['tutorial/6-viewsets-and-routers.md', 'Tutorial', '6- Viewsets and routers'] - ['api-guide/requests.md', 'API Guide', ] - ['api-guide/responses.md', 'API Guide', ] - ['api-guide/views.md', 'API Guide', ] @@ -22,8 +22,8 @@ pages: - ['api-guide/parsers.md', 'API Guide', ] - ['api-guide/renderers.md', 'API Guide', ] - ['api-guide/serializers.md', 'API Guide', ] - - ['api-guide/fields.md', 'API Guide', "Serializer fields"] - - ['api-guide/relations.md', 'API Guide', "Serializer relations"] + - ['api-guide/fields.md', 'API Guide', 'Serializer fields'] + - ['api-guide/relations.md', 'API Guide', 'Serializer relations'] - ['api-guide/validators.md', 'API Guide', ] - ['api-guide/authentication.md', 'API Guide', ] - ['api-guide/permissions.md', 'API Guide', ] @@ -54,5 +54,5 @@ pages: site_dir: html theme_dir: docs_theme -copyright: Copyright © 2014, Tom Christie. +copyright: Copyright © 2014, Tom Christie. google_analytics: ['UA-18852272-2', 'django-rest-framework.org'] -- cgit v1.2.3 From 5a6bdd01ba9f8731c0963c355b41839860a5a4de Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Wed, 19 Nov 2014 15:59:25 +0000 Subject: Highlight H1's in the TOC --- docs_theme/base.html | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/docs_theme/base.html b/docs_theme/base.html index 544e2188..02be73ee 100644 --- a/docs_theme/base.html +++ b/docs_theme/base.html @@ -106,12 +106,21 @@
    {% for toc_item in toc %} -
  • {{ toc_item.title }} -
    • - {% for toc_item in toc_item.children %} -
  • {{ toc_item.title }} -
    • - {% endfor %} {% endfor %} {# TODO: This is a bit of a hack. We don't want to refer to the file specifically. #} {% if current_page.input_path == 'index.md' %} + +
  • + {{ toc_item.title }} +
    • + + {% for toc_item in toc_item.children %} +
  • + {{ toc_item.title }} +
    • + {% endfor %} + + {% endfor %} + + {# TODO: This is a bit of a hack. We don't want to refer to the file specifically. #} + {% if current_page.input_path == 'index.md' %}
    -- cgit v1.2.3 From deb2bb4376600187c881f91791c278d9486ea8d9 Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Wed, 19 Nov 2014 16:15:47 +0000 Subject: Add Home link to the theme --- docs_theme/nav.html | 1 + 1 file changed, 1 insertion(+) diff --git a/docs_theme/nav.html b/docs_theme/nav.html index e6ab01ba..622cb33b 100644 --- a/docs_theme/nav.html +++ b/docs_theme/nav.html @@ -19,6 +19,7 @@ {% if include_nav %}
      +
    • Home
      • {% for nav_item in nav %} {% if nav_item.children %}
    • {{ nav_item.title }} -- cgit v1.2.3 From a0c12bf7c5cf96fbbdf0a0eb12702a093ccd3a51 Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Wed, 19 Nov 2014 16:22:23 +0000 Subject: Change the background of the selected page on the dropdown --- docs/css/default.css | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) diff --git a/docs/css/default.css b/docs/css/default.css index 7f3acfed..8c9cd536 100644 --- a/docs/css/default.css +++ b/docs/css/default.css @@ -181,7 +181,7 @@ body{ } .navbar .navbar-inner .nav li, .navbar .navbar-inner .nav li a, .navbar .navbar-inner .brand{ - color: white; + color: white; } .nav-list > .active > a, .navbar .navbar-inner .nav li a:hover { @@ -190,8 +190,20 @@ body{ } .navbar .navbar-inner .dropdown-menu li a, .navbar .navbar-inner .dropdown-menu li{ - color: #A30000; + color: #A30000; +} + +.dropdown-menu .active > a, +.dropdown-menu .active > a:hover { + background-image: none; } + +.navbar-inverse .nav .dropdown .active > a, +.navbar-inverse .nav .dropdown .active > a:hover, +.navbar-inverse .nav .dropdown .active > a:focus { + background-color: #eeeeee; +} + .navbar .navbar-inner .dropdown-menu li a:hover{ background: #eeeeee; color: #c20000; -- cgit v1.2.3 From f2d4e51aaa33edf35921c459327b0a0ba2526ced Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Wed, 19 Nov 2014 16:22:39 +0000 Subject: Mark the homepage as active when visited --- docs_theme/nav.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs_theme/nav.html b/docs_theme/nav.html index 622cb33b..84982ff3 100644 --- a/docs_theme/nav.html +++ b/docs_theme/nav.html @@ -19,7 +19,7 @@ {% if include_nav %}
        -
      • Home
        • +
      • Home
        • {% for nav_item in nav %} {% if nav_item.children %}
      • {{ nav_item.title }} -- cgit v1.2.3 From aa1a844154e96719c9a91f604286eb0f436f32ea Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Tue, 25 Nov 2014 13:05:48 +0000 Subject: Add The title to the top of the TOC for the home page --- docs_theme/base.html | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/docs_theme/base.html b/docs_theme/base.html index 02be73ee..228b0ba4 100644 --- a/docs_theme/base.html +++ b/docs_theme/base.html @@ -105,6 +105,13 @@ -->
          + + {% if current_page.input_path == 'index.md' %} +
        • + Django REST framework +
          • + {% endif %} + {% for toc_item in toc %}
        • -- cgit v1.2.3 From 935d94c034b63cbe699d5d0ef04f472c3aeb3237 Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Tue, 25 Nov 2014 13:07:35 +0000 Subject: Don't add main to the top level items on the home page --- docs_theme/base.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs_theme/base.html b/docs_theme/base.html index 228b0ba4..004fbacd 100644 --- a/docs_theme/base.html +++ b/docs_theme/base.html @@ -114,7 +114,7 @@ {% for toc_item in toc %} -
        • +
        • {{ toc_item.title }}
          • -- cgit v1.2.3 From 4d28a0930995a3a73860d6a2d405e12abbf5d653 Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Tue, 25 Nov 2014 13:09:47 +0000 Subject: Refer to the current_page title rather than filename --- docs_theme/base.html | 11 ++++------- docs_theme/nav.html | 2 +- 2 files changed, 5 insertions(+), 8 deletions(-) diff --git a/docs_theme/base.html b/docs_theme/base.html index 004fbacd..cefaef48 100644 --- a/docs_theme/base.html +++ b/docs_theme/base.html @@ -54,9 +54,7 @@ } -{# TODO: This is a bit of a hack. We don't want to refer to the file specifically. #} - - +
          @@ -106,7 +104,7 @@
            - {% if current_page.input_path == 'index.md' %} + {% if current_page.title == 'Home' %}
          • Django REST framework
            • @@ -114,7 +112,7 @@ {% for toc_item in toc %} -
          • +
          • {{ toc_item.title }}
            • @@ -126,8 +124,7 @@ {% endfor %} - {# TODO: This is a bit of a hack. We don't want to refer to the file specifically. #} - {% if current_page.input_path == 'index.md' %} + {% if current_page.title == 'Home' %}
            diff --git a/docs_theme/nav.html b/docs_theme/nav.html index 84982ff3..24304b8a 100644 --- a/docs_theme/nav.html +++ b/docs_theme/nav.html @@ -19,7 +19,7 @@ {% if include_nav %}
              -
            • Home
              • +
            • Home
              • {% for nav_item in nav %} {% if nav_item.children %}
            • {{ nav_item.title }} -- cgit v1.2.3 From 673f48242f34ee6b7ba91ab4cf8a67f1bb26a272 Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Tue, 25 Nov 2014 13:11:30 +0000 Subject: Remove commented out title --- docs/index.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/docs/index.md b/docs/index.md index 6288efa3..ca10befe 100644 --- a/docs/index.md +++ b/docs/index.md @@ -26,9 +26,6 @@ Django REST Framework

              - Django REST framework is a powerful and flexible toolkit that makes it easy to build Web APIs. -- cgit v1.2.3 From 66fc51de5c4622073e7e6cfd12cc7c4a1a8ba60c Mon Sep 17 00:00:00 2001 From: Dougal Matthews Date: Tue, 25 Nov 2014 13:14:51 +0000 Subject: Use the is_homepage property. --- docs_theme/base.html | 8 ++++---- docs_theme/nav.html | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/docs_theme/base.html b/docs_theme/base.html index cefaef48..6bfccab2 100644 --- a/docs_theme/base.html +++ b/docs_theme/base.html @@ -54,7 +54,7 @@ } - +
              @@ -104,7 +104,7 @@
                - {% if current_page.title == 'Home' %} + {% if current_page.is_homepage %}
              • Django REST framework
                • @@ -112,7 +112,7 @@ {% for toc_item in toc %} -
              • +
              • {{ toc_item.title }}
                • @@ -124,7 +124,7 @@ {% endfor %} - {% if current_page.title == 'Home' %} + {% if current_page.is_homepage %}
                diff --git a/docs_theme/nav.html b/docs_theme/nav.html index 24304b8a..ca1afc0e 100644 --- a/docs_theme/nav.html +++ b/docs_theme/nav.html @@ -19,7 +19,7 @@ {% if include_nav %}
                  -
                • Home
                  • +
                • Home
                  • {% for nav_item in nav %} {% if nav_item.children %}
                • {{ nav_item.title }} -- cgit v1.2.3 From e1b8412eed18e305d7b6338a133b7f6a1270184c Mon Sep 17 00:00:00 2001 From: José Padilla Date: Tue, 25 Nov 2014 09:22:29 -0400 Subject: Add markdown and PyYAML to tox test requirements --- tox.ini | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tox.ini b/tox.ini index a7200a3f..b33c0700 100644 --- a/tox.ini +++ b/tox.ini @@ -23,6 +23,8 @@ deps = pytest-django==2.6.1 django-filter==0.7 defusedxml==0.3 + markdown>=2.1.0 + PyYAML>=3.10 [testenv:py27-flake8] deps = -- cgit v1.2.3 From 38fe2c9dad89e58c97aad26fa16d91dddf377ddd Mon Sep 17 00:00:00 2001 From: José Padilla Date: Tue, 25 Nov 2014 09:36:57 -0400 Subject: Document writing third party packages Add the following sections: - “About Third Party Packages” - “How to create a Third Party Package” - “Existing Third Party Packages” Resolve #2043--- docs/topics/third-party-resources.md | 332 +++++++++++++++++++++++++++++------ 1 file changed, 281 insertions(+), 51 deletions(-) diff --git a/docs/topics/third-party-resources.md b/docs/topics/third-party-resources.md index 0317dd64..d6a4346e 100644 --- a/docs/topics/third-party-resources.md +++ b/docs/topics/third-party-resources.md @@ -1,92 +1,322 @@ # Third Party Resources -Django REST Framework has a growing community of developers, packages, and resources. +## About Third Party Packages + +Third Party Packages allow developers to share code that extends the functionality of Django REST framework, in order to support additional use-cases. + +We **support**, **encourage** and **strongly favour** the creation of Third Party Packages to encapsulate new behaviour rather than adding additional functionality directly to Django REST Framework. + +We aim to make creating Third Party Packages as easy as possible, whilst keeping the **simplicity** of the core API and ensuring that **maintainance** of the main project remains under control. If a Third Party Package proves popular it is relatively easy to move it into the main project; removing features is much more problematic. + +If you have an idea for a new feature please consider how it may be packaged as a Third Party Package. We're always happy to dicuss ideas on the [Mailing List][discussion-group]. + +## How to create a Third Party Package + +### Creating your package + +You can use [this cookiecutter template][cookiecutter] for creating reusable Django REST Framework packages quickly. Cookiecutter creates projects from project templates. While optional, this cookiecutter template includes best practices from Django REST framework and other packages, as well as a Travis CI configuration, Tox configuration, and a sane setup.py for easy PyPI registration/distribution. + +Note: Let us know if you have an alternate cookiecuter package so we can also link to it. + +#### Running the initial cookiecutter command + +To run the initial cookiecutter command, you'll first need to install the Python `cookiecutter` package. + + $ pip install cookiecutter + +Once `cookiecutter` is installed just run the following to create a new project. + + $ cookiecutter gh:jpadilla/cookiecutter-django-rest-framework + +You'll be prompted for some questions, answer them, then it'll create your Python package in the current working directory based on those values. + + full_name (default is "Your full name here")? Johnny Appleseed + email (default is "you@example.com")? jappleseed@example.com + github_username (default is "yourname")? jappleseed + pypi_project_name (default is "dj-package")? djangorestframework-custom-auth + repo_name (default is "dj-package")? django-rest-framework-custom-auth + app_name (default is "djpackage")? custom_auth + project_short_description (default is "Your project description goes here")? + year (default is "2014")? + version (default is "0.1.0")? + +#### Getting it onto GitHub + +To put your project up on GitHub, you'll need a repository for it to live in. You can create a new repository [here][new-repo]. If you need help, check out the [Create A Repo][create-a-repo] article on GitHub. + + +#### Adding to Travis CI + +We recommend using [Travis CI][travis-ci], a hosted continuous integration service which integrates well with GitHub and is free for public repositories. + +To get started with Travis CI, [sign in][travis-ci] with your GitHub account. Once you're signed in, go to your [profile page][travis-profile] and enable the service hook for the repository you want. + +If you use the cookiecutter template, your project will already contain a `.travis.yml` file which Travis CI will use to build your project and run tests. By default, builds are triggered everytime you push to your repository or create Pull Request. + +#### Uploading to PyPI + +Once you've got at least a prototype working and tests running, you should publish it on PyPI to allow others to install it via `pip`. + +You must [register][pypi-register] an account before publishing to PyPI. + +To register your package on PyPI run the following command. + + $ python setup.py register + +If this is the first time publishing to PyPI, you'll be prompted to login. + +Note: Before publishing you'll need to make sure you have the latest pip that supports `wheel` as well as install the `wheel` package. + + $ pip install --upgrade pip + $ pip install wheel + +After this, every time you want to release a new version on PyPI just run the following command. + + $ python setup.py publish + You probably want to also tag the version now: + git tag -a {0} -m 'version 0.1.0' + git push --tags + +After releasing a new version to PyPI, it's always a good idea to tag the version and make available as a GitHub Release. + +We recommend to follow [Semantic Versioning][semver] for your package's versions. + +### Development + +#### Version requirements + +The cookiecutter template assumes a set of supported versions will be provided for Python and Django. Make sure you correctly update your requirements, docs, `tox.ini`, `.travis.yml`, and `setup.py` to match the set of versions you wish to support. + +#### Tests + +The cookiecutter template includes a `runtests.py` which uses the `pytest` package as a test runner. + +Before running, you'll need to install a couple test requirements. + + $ pip install -r requirements-test.txt -Check out a grid detailing all the packages and ecosystem around Django REST Framework at [Django Packages](https://www.djangopackages.com/grids/g/django-rest-framework/). +Once requirements installed, you can run `runtests.py`. -To submit new content, [open an issue](https://github.com/tomchristie/django-rest-framework/issues/new) or [create a pull request](https://github.com/tomchristie/django-rest-framework/). + $ ./runtests.py -## Libraries and Extensions +Run using a more concise output style. + + $ ./runtests.py -q + +Run the tests using a more concise output style, no coverage, no flake8. + + $ ./runtests.py --fast + +Don't run the flake8 code linting. + + $ ./runtests.py --nolint + +Only run the flake8 code linting, don't run the tests. + + $ ./runtests.py --lintonly + +Run the tests for a given test case. + + $ ./runtests.py MyTestCase + +Run the tests for a given test method. + + $ ./runtests.py MyTestCase.test_this_method + +Shorter form to run the tests for a given test method. + + $ ./runtests.py test_this_method + +To run your tests against multiple versions of Python as different versions of requirements such as Django we recommend using `tox`. [Tox][tox-docs] is a generic virtualenv management and test command line tool. + +First, install `tox` globally. + + $ pip install tox + +To run `tox`, just simply run: + + $ tox + +To run a particular `tox` environment: + + $ tox -e envlist + +`envlist` is a comma-separated value to that specifies the environments to run tests against. To view a list of all possible test environments, run: + + $ tox -l + +#### Version compatibility + +Sometimes, in order to ensure your code works on various different versions of Django, Python or third party libraries, you'll need to run slightly different code depending on the environment. Any code that branches in this way should be isolated into a `compat.py` module, and should provide a single common interface that the rest of the codebase can use. + +Check out Django REST framework's [compat.py][drf-compat] for an example. + +### Once your package is available + +Once your package is decently documented and available on PyPI, you might want share it with others that might find it useful. + +#### Adding to the Django REST framework grid + +We suggest adding your package to the [REST Framework][rest-framework-grid] grid on Django Packages. + +#### Adding to the Django REST framework docs + +Create a [Pull Request][drf-create-pr] or [Issue][drf-create-issue] on GitHub, and we'll add a link to it from the main REST framework documentation. You can add your package under **Third party packages** of the API Guide section that best applies, like [Authentication][authentication] or [Permissions][permissions]. You can also link your package under the [Third Party Resources][third-party-resources] section. + +#### Announce on the discussion group. + +You can also let others know about your package through the [discussion group][discussion-group]. + +## Existing Third Party Packages + +Django REST Framework has a growing community of developers, packages, and resources. + +Check out a grid detailing all the packages and ecosystem around Django REST Framework at [Django Packages][rest-framework-grid]. + +To submit new content, [open an issue][drf-create-issue] or [create a pull request][drf-create-pr]. ### Authentication -* [djangorestframework-digestauth](https://github.com/juanriaza/django-rest-framework-digestauth) - Provides Digest Access Authentication support. -* [django-oauth-toolkit](https://github.com/evonove/django-oauth-toolkit) - Provides OAuth 2.0 support. -* [doac](https://github.com/Rediker-Software/doac) - Provides OAuth 2.0 support. -* [djangorestframework-jwt](https://github.com/GetBlimp/django-rest-framework-jwt) - Provides JSON Web Token Authentication support. -* [hawkrest](https://github.com/kumar303/hawkrest) - Provides Hawk HTTP Authorization. -* [djangorestframework-httpsignature](https://github.com/etoccalino/django-rest-framework-httpsignature) - Provides an easy to use HTTP Signature Authentication mechanism. -* [djoser](https://github.com/sunscrapers/djoser) - Provides a set of views to handle basic actions such as registration, login, logout, password reset and account activation. +* [djangorestframework-digestauth][djangorestframework-digestauth] - Provides Digest Access Authentication support. +* [django-oauth-toolkit][django-oauth-toolkit] - Provides OAuth 2.0 support. +* [doac][doac] - Provides OAuth 2.0 support. +* [djangorestframework-jwt][djangorestframework-jwt] - Provides JSON Web Token Authentication support. +* [hawkrest][hawkrest] - Provides Hawk HTTP Authorization. +* [djangorestframework-httpsignature][djangorestframework-httpsignature] - Provides an easy to use HTTP Signature Authentication mechanism. +* [djoser][djoser] - Provides a set of views to handle basic actions such as registration, login, logout, password reset and account activation. ### Permissions -* [drf-any-permissions](https://github.com/kevin-brown/drf-any-permissions) - Provides alternative permission handling. -* [djangorestframework-composed-permissions](https://github.com/niwibe/djangorestframework-composed-permissions) - Provides a simple way to define complex permissions. -* [rest_condition](https://github.com/caxap/rest_condition) - Another extension for building complex permissions in a simple and convenient way. +* [drf-any-permissions][drf-any-permissions] - Provides alternative permission handling. +* [djangorestframework-composed-permissions][djangorestframework-composed-permissions] - Provides a simple way to define complex permissions. +* [rest_condition][rest-condition] - Another extension for building complex permissions in a simple and convenient way. ### Serializers -* [django-rest-framework-mongoengine](https://github.com/umutbozkurt/django-rest-framework-mongoengine) - Serializer class that supports using MongoDB as the storage layer for Django REST framework. -* [djangorestframework-gis](https://github.com/djangonauts/django-rest-framework-gis) - Geographic add-ons -* [djangorestframework-hstore](https://github.com/djangonauts/django-rest-framework-hstore) - Serializer class to support django-hstore DictionaryField model field and its schema-mode feature. +* [django-rest-framework-mongoengine][django-rest-framework-mongoengine] - Serializer class that supports using MongoDB as the storage layer for Django REST framework. +* [djangorestframework-gis][djangorestframework-gis] - Geographic add-ons +* [djangorestframework-hstore][djangorestframework-hstore] - Serializer class to support django-hstore DictionaryField model field and its schema-mode feature. ### Serializer fields -* [drf-compound-fields](https://github.com/estebistec/drf-compound-fields) - Provides "compound" serializer fields, such as lists of simple values. -* [django-extra-fields](https://github.com/Hipo/drf-extra-fields) - Provides extra serializer fields. +* [drf-compound-fields][drf-compound-fields] - Provides "compound" serializer fields, such as lists of simple values. +* [django-extra-fields][django-extra-fields] - Provides extra serializer fields. ### Views -* [djangorestframework-bulk](https://github.com/miki725/django-rest-framework-bulk) - Implements generic view mixins as well as some common concrete generic views to allow to apply bulk operations via API requests. +* [djangorestframework-bulk][djangorestframework-bulk] - Implements generic view mixins as well as some common concrete generic views to allow to apply bulk operations via API requests. ### Routers -* [drf-nested-routers](https://github.com/alanjds/drf-nested-routers) - Provides routers and relationship fields for working with nested resources. -* [wq.db.rest](http://wq.io/docs/about-rest) - Provides an admin-style model registration API with reasonable default URLs and viewsets. +* [drf-nested-routers][drf-nested-routers] - Provides routers and relationship fields for working with nested resources. +* [wq.db.rest][wq.db.rest] - Provides an admin-style model registration API with reasonable default URLs and viewsets. ### Parsers -* [djangorestframework-msgpack](https://github.com/juanriaza/django-rest-framework-msgpack) - Provides MessagePack renderer and parser support. -* [djangorestframework-camel-case](https://github.com/vbabiy/djangorestframework-camel-case) - Provides camel case JSON renderers and parsers. +* [djangorestframework-msgpack][djangorestframework-msgpack] - Provides MessagePack renderer and parser support. +* [djangorestframework-camel-case][djangorestframework-camel-case] - Provides camel case JSON renderers and parsers. ### Renderers -* [djangorestframework-csv](https://github.com/mjumbewu/django-rest-framework-csv) - Provides CSV renderer support. -* [drf_ujson](https://github.com/gizmag/drf-ujson-renderer) - Implements JSON rendering using the UJSON package. -* [Django REST Pandas](https://github.com/wq/django-rest-pandas) - Pandas DataFrame-powered renderers including Excel, CSV, and SVG formats. +* [djangorestframework-csv][djangorestframework-csv] - Provides CSV renderer support. +* [drf_ujson][drf_ujson] - Implements JSON rendering using the UJSON package. +* [rest-pandas][rest-pandas] - Pandas DataFrame-powered renderers including Excel, CSV, and SVG formats. ### Filtering -* [djangorestframework-chain](https://github.com/philipn/django-rest-framework-chain) - Allows arbitrary chaining of both relations and lookup filters. +* [djangorestframework-chain][djangorestframework-chain] - Allows arbitrary chaining of both relations and lookup filters. ### Misc -* [djangorestrelationalhyperlink](https://github.com/fredkingham/django_rest_model_hyperlink_serializers_project) - A hyperlinked serialiser that can can be used to alter relationships via hyperlinks, but otherwise like a hyperlink model serializer. -* [django-rest-swagger](https://github.com/marcgibbons/django-rest-swagger) - An API documentation generator for Swagger UI. -* [django-rest-framework-proxy ](https://github.com/eofs/django-rest-framework-proxy) - Proxy to redirect incoming request to another API server. -* [gaiarestframework](https://github.com/AppsFuel/gaiarestframework) - Utils for django-rest-framewok -* [drf-extensions](https://github.com/chibisov/drf-extensions) - A collection of custom extensions -* [ember-data-django-rest-adapter](https://github.com/toranb/ember-data-django-rest-adapter) - An ember-data adapter +* [djangorestrelationalhyperlink][djangorestrelationalhyperlink] - A hyperlinked serialiser that can can be used to alter relationships via hyperlinks, but otherwise like a hyperlink model serializer. +* [django-rest-swagger][django-rest-swagger] - An API documentation generator for Swagger UI. +* [django-rest-framework-proxy][django-rest-framework-proxy] - Proxy to redirect incoming request to another API server. +* [gaiarestframework][gaiarestframework] - Utils for django-rest-framewok +* [drf-extensions][drf-extensions] - A collection of custom extensions +* [ember-data-django-rest-adapter][ember-data-django-rest-adapter] - An ember-data adapter + +## Other Resources + +### Tutorials + +* [Beginner's Guide to the Django Rest Framework][beginners-guide-to-the-django-rest-framework] +* [Getting Started with Django Rest Framework and AngularJS][getting-started-with-django-rest-framework-and-angularjs] +* [End to end web app with Django-Rest-Framework & AngularJS][end-to-end-web-app-with-django-rest-framework-angularjs] +* [Start Your API - django-rest-framework part 1][start-your-api-django-rest-framework-part-1] +* [Permissions & Authentication - django-rest-framework part 2][permissions-authentication-django-rest-framework-part-2] +* [ViewSets and Routers - django-rest-framework part 3][viewsets-and-routers-django-rest-framework-part-3] +* [Django Rest Framework User Endpoint][django-rest-framework-user-endpoint] +* [Check credentials using Django Rest Framework][check-credentials-using-django-rest-framework] -## Tutorials +### Videos -* [Beginner's Guide to the Django Rest Framework](http://code.tutsplus.com/tutorials/beginners-guide-to-the-django-rest-framework--cms-19786) -* [Getting Started with Django Rest Framework and AngularJS](http://blog.kevinastone.com/getting-started-with-django-rest-framework-and-angularjs.html) -* [End to end web app with Django-Rest-Framework & AngularJS](http://blog.mourafiq.com/post/55034504632/end-to-end-web-app-with-django-rest-framework) -* [Start Your API - django-rest-framework part 1](https://godjango.com/41-start-your-api-django-rest-framework-part-1/) -* [Permissions & Authentication - django-rest-framework part 2](https://godjango.com/43-permissions-authentication-django-rest-framework-part-2/) -* [ViewSets and Routers - django-rest-framework part 3](https://godjango.com/45-viewsets-and-routers-django-rest-framework-part-3/) -* [Django Rest Framework User Endpoint](http://richardtier.com/2014/02/25/django-rest-framework-user-endpoint/) -* [Check credentials using Django Rest Framework](http://richardtier.com/2014/03/06/110/) +* [Ember and Django Part 1 (Video)][ember-and-django-part 1-video] +* [Django Rest Framework Part 1 (Video)][django-rest-framework-part-1-video] +* [Pyowa July 2013 - Django Rest Framework (Video)][pyowa-july-2013-django-rest-framework-video] +* [django-rest-framework and angularjs (Video)][django-rest-framework-and-angularjs-video] -## Videos +### Articles -* [Ember and Django Part 1 (Video)](http://www.neckbeardrepublic.com/screencasts/ember-and-django-part-1) -* [Django Rest Framework Part 1 (Video)](http://www.neckbeardrepublic.com/screencasts/django-rest-framework-part-1) -* [Pyowa July 2013 - Django Rest Framework (Video)](http://www.youtube.com/watch?v=E1ZrehVxpBo) -* [django-rest-framework and angularjs (Video)](http://www.youtube.com/watch?v=Q8FRBGTJ020) +* [Web API performance: profiling Django REST framework][web-api-performance-profiling-django-rest-framework] +* [API Development with Django and Django REST Framework][api-development-with-django-and-django-rest-framework] -## Articles -* [Web API performance: profiling Django REST framework](http://dabapps.com/blog/api-performance-profiling-django-rest-framework/) -* [API Development with Django and Django REST Framework](https://bnotions.com/api-development-with-django-and-django-rest-framework/) +[cookiecutter]: https://github.com/jpadilla/cookiecutter-django-rest-framework +[new-repo]: https://github.com/new +[create-a-repo]: https://help.github.com/articles/create-a-repo/ +[travis-ci]: https://travis-ci.org +[travis-profile]: https://travis-ci.org/profile +[pypi-register]: https://pypi.python.org/pypi?%3Aaction=register_form +[semver]: http://semver.org/ +[tox-docs]: https://tox.readthedocs.org/en/latest/ +[drf-compat]: https://github.com/tomchristie/django-rest-framework/blob/master/rest_framework/compat.py +[rest-framework-grid]: https://www.djangopackages.com/grids/g/django-rest-framework/ +[drf-create-pr]: https://github.com/tomchristie/django-rest-framework/compare +[drf-create-issue]: https://github.com/tomchristie/django-rest-framework/issues/new +[authentication]: ../api-guide/authentication.md +[permissions]: ../api-guide/permissions.md +[discussion-group]: https://groups.google.com/forum/#!forum/django-rest-framework +[djangorestframework-digestauth]: https://github.com/juanriaza/django-rest-framework-digestauth +[django-oauth-toolkit]: https://github.com/evonove/django-oauth-toolkit +[doac]: https://github.com/Rediker-Software/doac +[djangorestframework-jwt]: https://github.com/GetBlimp/django-rest-framework-jwt +[hawkrest]: https://github.com/kumar303/hawkrest +[djangorestframework-httpsignature]: https://github.com/etoccalino/django-rest-framework-httpsignature +[djoser]: https://github.com/sunscrapers/djoser +[drf-any-permissions]: https://github.com/kevin-brown/drf-any-permissions +[djangorestframework-composed-permissions]: https://github.com/niwibe/djangorestframework-composed-permissions +[rest-condition]: https://github.com/caxap/rest_condition +[django-rest-framework-mongoengine]: https://github.com/umutbozkurt/django-rest-framework-mongoengine +[djangorestframework-gis]: https://github.com/djangonauts/django-rest-framework-gis +[djangorestframework-hstore]: https://github.com/djangonauts/django-rest-framework-hstore +[drf-compound-fields]: https://github.com/estebistec/drf-compound-fields +[django-extra-fields]: https://github.com/Hipo/drf-extra-fields +[djangorestframework-bulk]: https://github.com/miki725/django-rest-framework-bulk +[drf-nested-routers]: https://github.com/alanjds/drf-nested-routers +[wq.db.rest]: http://wq.io/docs/about-rest +[djangorestframework-msgpack]: https://github.com/juanriaza/django-rest-framework-msgpack +[djangorestframework-camel-case]: https://github.com/vbabiy/djangorestframework-camel-case +[djangorestframework-csv]: https://github.com/mjumbewu/django-rest-framework-csv +[drf_ujson]: https://github.com/gizmag/drf-ujson-renderer +[rest-pandas]: https://github.com/wq/django-rest-pandas +[djangorestframework-chain]: https://github.com/philipn/django-rest-framework-chain +[djangorestrelationalhyperlink]: https://github.com/fredkingham/django_rest_model_hyperlink_serializers_project +[django-rest-swagger]: https://github.com/marcgibbons/django-rest-swagger +[django-rest-framework-proxy]: https://github.com/eofs/django-rest-framework-proxy +[gaiarestframework]: https://github.com/AppsFuel/gaiarestframework +[drf-extensions]: https://github.com/chibisov/drf-extensions +[ember-data-django-rest-adapter]: https://github.com/toranb/ember-data-django-rest-adapter +[beginners-guide-to-the-django-rest-framework]: http://code.tutsplus.com/tutorials/beginners-guide-to-the-django-rest-framework--cms-19786 +[getting-started-with-django-rest-framework-and-angularjs]: http://blog.kevinastone.com/getting-started-with-django-rest-framework-and-angularjs.html +[end-to-end-web-app-with-django-rest-framework-angularjs]: http://blog.mourafiq.com/post/55034504632/end-to-end-web-app-with-django-rest-framework +[start-your-api-django-rest-framework-part-1]: https://godjango.com/41-start-your-api-django-rest-framework-part-1/ +[permissions-authentication-django-rest-framework-part-2]: https://godjango.com/43-permissions-authentication-django-rest-framework-part-2/ +[viewsets-and-routers-django-rest-framework-part-3]: https://godjango.com/45-viewsets-and-routers-django-rest-framework-part-3/ +[django-rest-framework-user-endpoint]: http://richardtier.com/2014/02/25/django-rest-framework-user-endpoint/ +[check-credentials-using-django-rest-framework]: http://richardtier.com/2014/03/06/110/ +[ember-and-django-part 1-video]: http://www.neckbeardrepublic.com/screencasts/ember-and-django-part-1 +[django-rest-framework-part-1-video]: http://www.neckbeardrepublic.com/screencasts/django-rest-framework-part-1 +[pyowa-july-2013-django-rest-framework-video]: http://www.youtube.com/watch?v=e1zrehvxpbo +[django-rest-framework-and-angularjs-video]: http://www.youtube.com/watch?v=q8frbgtj020 +[web-api-performance-profiling-django-rest-framework]: http://dabapps.com/blog/api-performance-profiling-django-rest-framework/ +[api-development-with-django-and-django-rest-framework]: https://bnotions.com/api-development-with-django-and-django-rest-framework/ -- cgit v1.2.3 From 64d8e3dcb6846610e1908e067962b0c8457a86f8 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 13:50:35 +0000 Subject: Typo. Refs #2132. --- docs/topics/third-party-resources.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/topics/third-party-resources.md b/docs/topics/third-party-resources.md index d6a4346e..ffb490af 100644 --- a/docs/topics/third-party-resources.md +++ b/docs/topics/third-party-resources.md @@ -6,7 +6,7 @@ Third Party Packages allow developers to share code that extends the functionali We **support**, **encourage** and **strongly favour** the creation of Third Party Packages to encapsulate new behaviour rather than adding additional functionality directly to Django REST Framework. -We aim to make creating Third Party Packages as easy as possible, whilst keeping the **simplicity** of the core API and ensuring that **maintainance** of the main project remains under control. If a Third Party Package proves popular it is relatively easy to move it into the main project; removing features is much more problematic. +We aim to make creating Third Party Packages as easy as possible, whilst keeping the **simplicity** of the core API and ensuring that **maintenance** of the main project remains under control. If a Third Party Package proves popular it is relatively easy to move it into the main project; removing features is much more problematic. If you have an idea for a new feature please consider how it may be packaged as a Third Party Package. We're always happy to dicuss ideas on the [Mailing List][discussion-group]. -- cgit v1.2.3 From 653d626b3c3189260423bec7a1dd4faed9f8708d Mon Sep 17 00:00:00 2001 From: José Padilla Date: Tue, 25 Nov 2014 11:33:18 -0400 Subject: Fix failing YAML tests --- tests/test_renderers.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/test_renderers.py b/tests/test_renderers.py index a8fd5f46..5ef65dd7 100644 --- a/tests/test_renderers.py +++ b/tests/test_renderers.py @@ -9,7 +9,7 @@ from django.test import TestCase from django.utils import six, unittest from django.utils.translation import ugettext_lazy as _ from rest_framework import status, permissions -from rest_framework.compat import yaml, etree, StringIO +from rest_framework.compat import yaml, etree, StringIO, BytesIO from rest_framework.response import Response from rest_framework.views import APIView from rest_framework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer, \ @@ -467,7 +467,7 @@ if yaml: obj = {'foo': ['bar', 'baz']} renderer = YAMLRenderer() content = renderer.render(obj, 'application/yaml') - self.assertEqual(content, _yaml_repr) + self.assertEqual(content.decode('utf-8'), _yaml_repr) def test_render_and_parse(self): """ @@ -480,7 +480,7 @@ if yaml: parser = YAMLParser() content = renderer.render(obj, 'application/yaml') - data = parser.parse(StringIO(content)) + data = parser.parse(BytesIO(content)) self.assertEqual(obj, data) def test_render_decimal(self): @@ -489,7 +489,7 @@ if yaml: """ renderer = YAMLRenderer() content = renderer.render({'field': Decimal('111.2')}, 'application/yaml') - self.assertYAMLContains(content, "field: '111.2'") + self.assertYAMLContains(content.decode('utf-8'), "field: '111.2'") def assertYAMLContains(self, content, string): self.assertTrue(string in content, '%r not in %r' % (string, content)) -- cgit v1.2.3 From 8c91e7b742067b6d4e4ed6d476bfe2cf5839ac8b Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 15:52:13 +0000 Subject: Add missing options --- docs/api-guide/fields.md | 40 +++++++++++++++++++++++++++++++++------- 1 file changed, 33 insertions(+), 7 deletions(-) diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md index 292a51d8..aef7792b 100644 --- a/docs/api-guide/fields.md +++ b/docs/api-guide/fields.md @@ -22,7 +22,7 @@ Each serializer field class constructor takes at least these arguments. Some Fi The name of the attribute that will be used to populate the field. May be a method that only takes a `self` argument, such as `Field(source='get_absolute_url')`, or may use dotted notation to traverse attributes, such as `Field(source='user.email')`. -The value `source='*'` has a special meaning, and is used to indicate that the entire object should be passed through to the field. This can be useful for creating nested representations. (See the implementation of the `PaginationSerializer` class for an example.) +The value `source='*'` has a special meaning, and is used to indicate that the entire object should be passed through to the field. This can be useful for creating nested representations, or for fields which require access to the complete object in order to determine the output representation. Defaults to the name of the field. @@ -45,25 +45,28 @@ Set to false if this field is not required to be present during deserialization. Defaults to `True`. +### `allow_null` + +Normally an error will be raise if `None` is passed to a serializer field. Set this keyword argument to `True` if `None` should be considered a valid value. + +Defaults to `False` + ### `default` If set, this gives the default value that will be used for the field if no input value is supplied. If not set the default behavior is to not populate the attribute at all. May be set to a function or other callable, in which case the value will be evaluated each time it is used. +Note that setting a `default` value implies that the field is not required. Including both the `default` and `required` keyword arguments is invalid and will raise an error. + ### `validators` -A list of Django validators that should be used to validate deserialized values. +A list of validator functions which should be applied to the incoming field input, and which either raise a validation error or simply return. Validator functions should typically raise `serializers.ValidationError`, but Django's built-in `ValidationError` is also supported for compatibility with validators defined in the Django codebase or third party Django packages. ### `error_messages` A dictionary of error codes to error messages. -### `widget` - -Used only if rendering the field to HTML. -This argument sets the widget that should be used to render the field. For more details, and a list of available widgets, see [the Django documentation on form widgets][django-widgets]. - ### `label` A short text string that may be used as the name of the field in HTML form fields or other descriptive elements. @@ -72,6 +75,29 @@ A short text string that may be used as the name of the field in HTML form field A text string that may be used as a description of the field in HTML form fields or other descriptive elements. +### `initial` + +A value that should be used for pre-populating the value of HTML form fields. + +### `style` + +A dictionary of key-value pairs that can be used to control how renderers should render the field. The API for this should still be considered experimental, and will be formalized with the 3.1 release. + +Two options are currently used in HTML form generation, `'input_type'` and `'base_template'`. + + # Use for the input. + password = serializers.CharField( + style={'input_type': 'password'} + ) + + # Use a radio input instead of a select input. + color_channel = serializers.ChoiceField( + choices=['red', 'green', 'blue'] + style = {'base_template': 'radio.html'} + } + +**Note**: The `style` argument replaces the old-style version 2.x `widget` keyword argument. Because REST framework 3 now uses templated HTML form generation, the `widget` option that was used to support Django built-in widgets can no longer be supported. Version 3.1 is planned to include public API support for customizing HTML form generation. + --- # Generic Fields -- cgit v1.2.3 From 929135ea58d5a41f1980d23280c6ae65bb5b3443 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 16:01:32 +0000 Subject: Include CNAME file --- docs/CNAME | 1 + 1 file changed, 1 insertion(+) create mode 100644 docs/CNAME diff --git a/docs/CNAME b/docs/CNAME new file mode 100644 index 00000000..4e332899 --- /dev/null +++ b/docs/CNAME @@ -0,0 +1 @@ +www.django-rest-framework.org -- cgit v1.2.3 From 84b34d43307704ad8240b871a48dcd6e73848cd1 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 16:06:18 +0000 Subject: Use default 'site' directory for docs builds --- .gitignore | 2 +- mkdocs.yml | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index ae73f837..2bdf8f7e 100644 --- a/.gitignore +++ b/.gitignore @@ -3,7 +3,7 @@ *~ .* -html/ +site/ htmlcov/ coverage/ build/ diff --git a/mkdocs.yml b/mkdocs.yml index 925586d1..f956ecf0 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -4,6 +4,8 @@ site_description: Django REST framework - Web APIs for Django repo_url: https://github.com/tomchristie/django-rest-framework +theme_dir: docs_theme + pages: - ['index.md', ] - ['tutorial/quickstart.md', ] @@ -52,7 +54,5 @@ pages: - ['topics/release-notes.md', 'Topics', 'Release Notes'] - ['topics/credits.md', 'Topics', 'Credits'] -site_dir: html -theme_dir: docs_theme copyright: Copyright © 2014, Tom Christie. google_analytics: ['UA-18852272-2', 'django-rest-framework.org'] -- cgit v1.2.3 From c7701cd75a746a863ddf8c517a4ec9c6272d66ca Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 16:08:48 +0000 Subject: Tweak --- docs/topics/contributing.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/topics/contributing.md b/docs/topics/contributing.md index c7991a0f..7654136c 100644 --- a/docs/topics/contributing.md +++ b/docs/topics/contributing.md @@ -139,7 +139,7 @@ To build the documentation, install MkDocs with `pip install mkdocs` and then ru mkdocs build -This will build the html output into the `html` directory. +This will build the documentation into the `site` directory. You can build the documentation and open a preview in a browser window by using the `serve` command. -- cgit v1.2.3 From b733f85ff1e3f70e9f5dee6f52bebe861bc0f411 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 16:24:35 +0000 Subject: Minor docs tweaks --- docs/index.md | 2 +- mkdocs.yml | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 25 insertions(+), 26 deletions(-) diff --git a/docs/index.md b/docs/index.md index ca10befe..9312bb2f 100644 --- a/docs/index.md +++ b/docs/index.md @@ -172,7 +172,7 @@ The API guide is your complete reference manual to all the functionality provide * [Serializers][serializers] * [Serializer fields][fields] * [Serializer relations][relations] -* [Validators][validators] + * [Authentication][authentication] * [Permissions][permissions] * [Throttling][throttling] diff --git a/mkdocs.yml b/mkdocs.yml index f956ecf0..e112315b 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -7,38 +7,38 @@ repo_url: https://github.com/tomchristie/django-rest-framework theme_dir: docs_theme pages: - - ['index.md', ] - - ['tutorial/quickstart.md', ] + - ['index.md', 'Home'] + - ['tutorial/quickstart.md', 'Quickstart'] - ['tutorial/1-serialization.md', 'Tutorial', '1 - Serialization'] - ['tutorial/2-requests-and-responses.md', 'Tutorial', '2 - Requests and responses'] - ['tutorial/3-class-based-views.md', 'Tutorial', '3 - Class based views'] - ['tutorial/4-authentication-and-permissions.md', 'Tutorial', '4 - Authentication and permissions'] - ['tutorial/5-relationships-and-hyperlinked-apis.md', 'Tutorial', '5 - Relationships and hyperlinked APIs'] - - ['tutorial/6-viewsets-and-routers.md', 'Tutorial', '6- Viewsets and routers'] - - ['api-guide/requests.md', 'API Guide', ] - - ['api-guide/responses.md', 'API Guide', ] - - ['api-guide/views.md', 'API Guide', ] - - ['api-guide/generic-views.md', 'API Guide', ] - - ['api-guide/viewsets.md', 'API Guide', ] - - ['api-guide/routers.md', 'API Guide', ] - - ['api-guide/parsers.md', 'API Guide', ] - - ['api-guide/renderers.md', 'API Guide', ] - - ['api-guide/serializers.md', 'API Guide', ] + - ['tutorial/6-viewsets-and-routers.md', 'Tutorial', '6 - Viewsets and routers'] + - ['api-guide/requests.md', 'API Guide', 'Requests'] + - ['api-guide/responses.md', 'API Guide', 'Responses'] + - ['api-guide/views.md', 'API Guide', 'Views'] + - ['api-guide/generic-views.md', 'API Guide', 'Generic views'] + - ['api-guide/viewsets.md', 'API Guide', 'Viewsets'] + - ['api-guide/routers.md', 'API Guide', 'Routers'] + - ['api-guide/parsers.md', 'API Guide', 'Parsers'] + - ['api-guide/renderers.md', 'API Guide', 'Renderers'] + - ['api-guide/serializers.md', 'API Guide', 'Serializers'] - ['api-guide/fields.md', 'API Guide', 'Serializer fields'] - ['api-guide/relations.md', 'API Guide', 'Serializer relations'] - - ['api-guide/validators.md', 'API Guide', ] - - ['api-guide/authentication.md', 'API Guide', ] - - ['api-guide/permissions.md', 'API Guide', ] - - ['api-guide/throttling.md', 'API Guide', ] - - ['api-guide/filtering.md', 'API Guide', ] - - ['api-guide/pagination.md', 'API Guide', ] - - ['api-guide/content-negotiation.md', 'API Guide', ] - - ['api-guide/format-suffixes.md', 'API Guide', ] +# - ['api-guide/validators.md', 'API Guide', 'Validators'] + - ['api-guide/authentication.md', 'API Guide', 'Authentication'] + - ['api-guide/permissions.md', 'API Guide', 'Permissions'] + - ['api-guide/throttling.md', 'API Guide', 'Throttling'] + - ['api-guide/filtering.md', 'API Guide', 'Filtering'] + - ['api-guide/pagination.md', 'API Guide', 'Pagination'] + - ['api-guide/content-negotiation.md', 'API Guide', 'Content negotiation'] + - ['api-guide/format-suffixes.md', 'API Guide', 'Format suffixes'] - ['api-guide/reverse.md', 'API Guide', 'Returning URLs'] - - ['api-guide/exceptions.md', 'API Guide', ] - - ['api-guide/status-codes.md', 'API Guide', ] - - ['api-guide/testing.md', 'API Guide', ] - - ['api-guide/settings.md', 'API Guide', ] + - ['api-guide/exceptions.md', 'API Guide', 'Exceptions'] + - ['api-guide/status-codes.md', 'API Guide', 'Status codes'] + - ['api-guide/testing.md', 'API Guide', 'Testing'] + - ['api-guide/settings.md', 'API Guide', 'Settings'] - ['topics/documenting-your-api.md', 'Topics', 'Documenting your API'] - ['topics/ajax-csrf-cors.md', 'Topics', 'AJAX, CSRF & CORS'] - ['topics/browser-enhancements.md', 'Topics',] @@ -54,5 +54,4 @@ pages: - ['topics/release-notes.md', 'Topics', 'Release Notes'] - ['topics/credits.md', 'Topics', 'Credits'] -copyright: Copyright © 2014, Tom Christie. google_analytics: ['UA-18852272-2', 'django-rest-framework.org'] -- cgit v1.2.3 From 4ed0ae82e353e918c4f8e2b1c3bd27d67d349fe3 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 16:29:14 +0000 Subject: Add validators page --- docs/index.md | 4 ++-- mkdocs.yml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/index.md b/docs/index.md index 9312bb2f..b18f3d6a 100644 --- a/docs/index.md +++ b/docs/index.md @@ -172,7 +172,7 @@ The API guide is your complete reference manual to all the functionality provide * [Serializers][serializers] * [Serializer fields][fields] * [Serializer relations][relations] - +* [Validators][validators] * [Authentication][authentication] * [Permissions][permissions] * [Throttling][throttling] @@ -294,7 +294,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. [serializers]: api-guide/serializers.md [fields]: api-guide/fields.md [relations]: api-guide/relations.md -[validation]: api-guide/validation.md +[validators]: api-guide/validators.md [authentication]: api-guide/authentication.md [permissions]: api-guide/permissions.md [throttling]: api-guide/throttling.md diff --git a/mkdocs.yml b/mkdocs.yml index e112315b..1a60a742 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -26,7 +26,7 @@ pages: - ['api-guide/serializers.md', 'API Guide', 'Serializers'] - ['api-guide/fields.md', 'API Guide', 'Serializer fields'] - ['api-guide/relations.md', 'API Guide', 'Serializer relations'] -# - ['api-guide/validators.md', 'API Guide', 'Validators'] + - ['api-guide/validators.md', 'API Guide', 'Validators'] - ['api-guide/authentication.md', 'API Guide', 'Authentication'] - ['api-guide/permissions.md', 'API Guide', 'Permissions'] - ['api-guide/throttling.md', 'API Guide', 'Throttling'] -- cgit v1.2.3 From 2647e1aaaadfc2cfd947c633399dca1060c17401 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 16:30:17 +0000 Subject: Move Quickstart back into 'Tutorial' section --- mkdocs.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mkdocs.yml b/mkdocs.yml index e112315b..8932fa96 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -8,7 +8,7 @@ theme_dir: docs_theme pages: - ['index.md', 'Home'] - - ['tutorial/quickstart.md', 'Quickstart'] + - ['tutorial/quickstart.md', 'Tutorial', 'Quickstart'] - ['tutorial/1-serialization.md', 'Tutorial', '1 - Serialization'] - ['tutorial/2-requests-and-responses.md', 'Tutorial', '2 - Requests and responses'] - ['tutorial/3-class-based-views.md', 'Tutorial', '3 - Class based views'] -- cgit v1.2.3 From 31536566d7fee430fb549621b4e324ddec4081fd Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Tue, 25 Nov 2014 17:35:27 +0000 Subject: Updating fields docs --- docs/api-guide/fields.md | 254 +++++++++++++++++++++++++++++++---------------- 1 file changed, 166 insertions(+), 88 deletions(-) diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md index 68cdc622..17a65ab8 100644 --- a/docs/api-guide/fields.md +++ b/docs/api-guide/fields.md @@ -47,7 +47,7 @@ Defaults to `True`. ### `allow_null` -Normally an error will be raise if `None` is passed to a serializer field. Set this keyword argument to `True` if `None` should be considered a valid value. +Normally an error will be raised if `None` is passed to a serializer field. Set this keyword argument to `True` if `None` should be considered a valid value. Defaults to `False` @@ -100,10 +100,6 @@ Two options are currently used in HTML form generation, `'input_type'` and `'bas --- -# Generic Fields - -These generic fields are used for representing arbitrary model fields or the output of model methods. - ## Field A generic, **read-only** field. You can use this field for any attribute that does not need to support write operations. @@ -146,96 +142,143 @@ By default, the `Field` class will perform a basic translation of the source val You can customize this behavior by overriding the `.to_native(self, value)` method. -## WritableField +**TODO**: Note removal of `WritableField` -A field that supports both read and write operations. By itself `WritableField` does not perform any translation of input values into a given type. You won't typically use this field directly, but you may want to override it and implement the `.to_native(self, value)` and `.from_native(self, value)` methods. +--- -## ModelField +# Boolean fields -A generic field that can be tied to any arbitrary model field. The `ModelField` class delegates the task of serialization/deserialization to its associated model field. This field can be used to create serializer fields for custom model fields, without having to create a new custom serializer field. +## BooleanField -The `ModelField` class is generally intended for internal use, but can be used by your API if needed. In order to properly instantiate a `ModelField`, it must be passed a field that is attached to an instantiated model. For example: `ModelField(model_field=MyModel()._meta.get_field('custom_field'))` +A boolean representation. -**Signature:** `ModelField(model_field=)` +Corresponds to `django.db.models.fields.BooleanField`. -## SerializerMethodField +## NullBooleanField -This is a read-only field. It gets its value by calling a method on the serializer class it is attached to. It can be used to add any sort of data to the serialized representation of your object. The field's constructor accepts a single argument, which is the name of the method on the serializer to be called. The method should accept a single argument (in addition to `self`), which is the object being serialized. It should return whatever you want to be included in the serialized representation of the object. For example: +A boolean representation that also accepts `None` as a valid value. - from django.contrib.auth.models import User - from django.utils.timezone import now - from rest_framework import serializers +Corresponds to `django.db.models.fields.NullBooleanField`. - class UserSerializer(serializers.ModelSerializer): - days_since_joined = serializers.SerializerMethodField('get_days_since_joined') +--- - class Meta: - model = User +# String fields - def get_days_since_joined(self, obj): - return (now() - obj.date_joined).days +## CharField ---- +A text representation. Optionally validates the text to be shorter than `max_length` and longer than `min_length`. -# Typed Fields +Corresponds to `django.db.models.fields.CharField` or `django.db.models.fields.TextField`. -These fields represent basic datatypes, and support both reading and writing values. +**Signature:** `CharField(max_length=None, min_length=None, allow_none=False)` -## BooleanField +## EmailField -A Boolean representation. +A text representation, validates the text to be a valid e-mail address. -Corresponds to `django.db.models.fields.BooleanField`. +Corresponds to `django.db.models.fields.EmailField` -## CharField +**Signature:** `EmailField(max_length=None, min_length=None)` -A text representation, optionally validates the text to be shorter than `max_length` and longer than `min_length`. -If `allow_none` is `False` (default), `None` values will be converted to an empty string. +## RegexField -Corresponds to `django.db.models.fields.CharField` -or `django.db.models.fields.TextField`. +A text representation, that validates the given value matches against a certain regular expression. -**Signature:** `CharField(max_length=None, min_length=None, allow_none=False)` +The mandatory `regex` argument may either be a string, or a compiled python regular expression object. -## URLField +Uses Django's `django.core.validators.RegexValidator` for validation. -Corresponds to `django.db.models.fields.URLField`. Uses Django's `django.core.validators.URLValidator` for validation. +Corresponds to `django.forms.fields.RegexField` -**Signature:** `URLField(max_length=200, min_length=None)` +**Signature:** `RegexField(regex, max_length=None, min_length=None)` ## SlugField +A `RegexField` that validates the input against the pattern `[a-zA-Z0-9_-]+`. + Corresponds to `django.db.models.fields.SlugField`. **Signature:** `SlugField(max_length=50, min_length=None)` -## ChoiceField +## URLField -A field that can accept a value out of a limited set of choices. Optionally takes a `blank_display_value` parameter that customizes the display value of an empty choice. +A `RegexField` that validates the input against a URL matching pattern. Expects fully qualified URLs of the form `http:///`. -**Signature:** `ChoiceField(choices=(), blank_display_value=None)` +Corresponds to `django.db.models.fields.URLField`. Uses Django's `django.core.validators.URLValidator` for validation. -## EmailField +**Signature:** `URLField(max_length=200, min_length=None)` -A text representation, validates the text to be a valid e-mail address. +--- -Corresponds to `django.db.models.fields.EmailField` +# Numeric fields -## RegexField +## IntegerField -A text representation, that validates the given value matches against a certain regular expression. +An integer representation. -Uses Django's `django.core.validators.RegexValidator` for validation. +Has two optional arguments: -Corresponds to `django.forms.fields.RegexField` +- `max_value` Validate that the number provided is no greater than this value. -**Signature:** `RegexField(regex, max_length=None, min_length=None)` +- `min_value` Validate that the number provided is no less than this value. + +Corresponds to `django.db.models.fields.IntegerField`, `django.db.models.fields.SmallIntegerField`, `django.db.models.fields.PositiveIntegerField` and `django.db.models.fields.PositiveSmallIntegerField`. + +## FloatField + +A floating point representation. + +Has two optional arguments: + +- `max_value` Validate that the number provided is no greater than this value. + +- `min_value` Validate that the number provided is no less than this value. + +Corresponds to `django.db.models.fields.FloatField`. + +## DecimalField + +A decimal representation, represented in Python by a Decimal instance. + +Has two required arguments, and three optional arguments: + +- `max_digits` The maximum number of digits allowed in the number. Note that this number must be greater than or equal to decimal_places. + +- `decimal_places` The number of decimal places to store with the number. + +- `coerce_to_string` Set to `True` if string values should be returned for the representation, or `False` if `Decimal` objects should be returned. Defaults to the same value as the `COERCE_DECIMAL_TO_STRING` settings key, which will be `True` unless overridden. If `Decimal` objects are returned by the serializer, then the final output format will be determined by the renderer. + +- `max_value` Validate that the number provided is no greater than this value. + +- `min_value` Validate that the number provided is no less than this value. + +#### Example usage + +To validate numbers up to 999 with a resolution of 2 decimal places, you would use: + + serializers.DecimalField(max_digits=5, decimal_places=2) + +And to validate numbers up to anything less than one billion with a resolution of 10 decimal places: + + serializers.DecimalField(max_digits=19, decimal_places=10) + +This field also takes an optional argument, `coerce_to_string`. If set to `True` the representation will be output as a string. If set to `False` the representation will be left as a `Decimal` instance and the final representation will be determined by the renderer. + +If unset, this will default to the same value as the `COERCE_DECIMAL_TO_STRING` setting, which is `True` unless set otherwise. + +**Signature:** `DecimalField(max_digits, decimal_places, coerce_to_string=None)` + +Corresponds to `django.db.models.fields.DecimalField`. + +--- + +# Date and time fields ## DateTimeField A date and time representation. -Corresponds to `django.db.models.fields.DateTimeField` +Corresponds to `django.db.models.fields.DateTimeField`. When using `ModelSerializer` or `HyperlinkedModelSerializer`, note that any model fields with `auto_now=True` or `auto_now_add=True` will use serializer fields that are `read_only=True` by default. @@ -253,10 +296,10 @@ In the case of JSON this means the default datetime representation uses the [ECM **Signature:** `DateTimeField(format=None, input_formats=None)` -* `format` - A string representing the output format. If not specified, this defaults to `None`, which indicates that Python `datetime` objects should be returned by `to_native`. In this case the datetime encoding will be determined by the renderer. +* `format` - A string representing the output format. If not specified, this defaults to the same value as the `DATETIME_FORMAT` settings key, which will be `'iso-8601'` unless set. Setting to a format string indicates that `to_representation` return values should be coerced to string output. Format strings are described below. Setting this value to `None` indicates that Python `datetime` objects should be returned by `to_representation`. In this case the datetime encoding will be determined by the renderer. * `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `DATETIME_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`. -DateTime format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style datetimes should be used. (eg `'2013-01-29T12:34:56.000000Z'`) +**DateTimeField format strings**: Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style datetimes should be used. (eg `'2013-01-29T12:34:56.000000Z'`) ## DateField @@ -266,63 +309,47 @@ Corresponds to `django.db.models.fields.DateField` **Signature:** `DateField(format=None, input_formats=None)` -* `format` - A string representing the output format. If not specified, this defaults to `None`, which indicates that Python `date` objects should be returned by `to_native`. In this case the date encoding will be determined by the renderer. +* `format` - A string representing the output format. If not specified, this defaults to the same value as the `DATE_FORMAT` settings key, which will be `'iso-8601'` unless set. Setting to a format string indicates that `to_representation` return values should be coerced to string output. Format strings are described below. Setting this value to `None` indicates that Python `date` objects should be returned by `to_representation`. In this case the date encoding will be determined by the renderer. * `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `DATE_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`. -Date format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style dates should be used. (eg `'2013-01-29'`) +**DateField format strings**: Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style dates should be used. (eg `'2013-01-29'`) ## TimeField A time representation. -Optionally takes `format` as parameter to replace the matching pattern. - Corresponds to `django.db.models.fields.TimeField` **Signature:** `TimeField(format=None, input_formats=None)` -* `format` - A string representing the output format. If not specified, this defaults to `None`, which indicates that Python `time` objects should be returned by `to_native`. In this case the time encoding will be determined by the renderer. +* `format` - A string representing the output format. If not specified, this defaults to the same value as the `TIME_FORMAT` settings key, which will be `'iso-8601'` unless set. Setting to a format string indicates that `to_representation` return values should be coerced to string output. Format strings are described below. Setting this value to `None` indicates that Python `time` objects should be returned by `to_representation`. In this case the time encoding will be determined by the renderer. * `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `TIME_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`. -Time format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style times should be used. (eg `'12:34:56.000000'`) - -## IntegerField - -An integer representation. - -Corresponds to `django.db.models.fields.IntegerField`, `django.db.models.fields.SmallIntegerField`, `django.db.models.fields.PositiveIntegerField` and `django.db.models.fields.PositiveSmallIntegerField` +**TimeField format strings**: Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style times should be used. (eg `'12:34:56.000000'`) -## FloatField - -A floating point representation. - -Corresponds to `django.db.models.fields.FloatField`. +--- -## DecimalField +# Choice selection fields -A decimal representation, represented in Python by a Decimal instance. - -Has two required arguments: +## ChoiceField -- `max_digits` The maximum number of digits allowed in the number. Note that this number must be greater than or equal to decimal_places. +A field that can accept a value out of a limited set of choices. Takes a single mandatory argument. -- `decimal_places` The number of decimal places to store with the number. +- `choices` - A list of valid values, or a list of `(key, display_name)` tuples. -For example, to validate numbers up to 999 with a resolution of 2 decimal places, you would use: +**Signature:** `ChoiceField(choices=())` - serializers.DecimalField(max_digits=5, decimal_places=2) +## MultipleChoiceField -And to validate numbers up to anything less than one billion with a resolution of 10 decimal places: +A field that can accept a set of zero, one or many values, chosen from a limited set of choices. Takes a single mandatory argument. `to_internal_representation` returns a `set` containing the selected values. - serializers.DecimalField(max_digits=19, decimal_places=10) +- `choices` - A list of valid values, or a list of `(key, display_name)` tuples. -This field also takes an optional argument, `coerce_to_string`. If set to `True` the representation will be output as a string. If set to `False` the representation will be left as a `Decimal` instance and the final representation will be determined by the renderer. +**Signature:** `MultipleChoiceField(choices=())` -If unset, this will default to the same value as the `COERCE_DECIMAL_TO_STRING` setting, which is `True` unless set otherwise. +--- -**Signature:** `DecimalField(max_digits, decimal_places, coerce_to_string=None)` - -Corresponds to `django.db.models.fields.DecimalField`. +# File upload fields ## FileField @@ -330,15 +357,17 @@ A file representation. Performs Django's standard FileField validation. Corresponds to `django.forms.fields.FileField`. -**Signature:** `FileField(max_length=None, allow_empty_file=False)` +**Signature:** `FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)` + + - `max_length` - designates the maximum length for the file name. - - `max_length` designates the maximum length for the file name. + - `allow_empty_file` - designates if empty files are allowed. - - `allow_empty_file` designates if empty files are allowed. +- `use_url` - If set to `True` then URL string values will be used for the output representation. If set to `False` then filename string values will be used for the output representation. Defaults to the value of the `UPLOADED_FILES_USE_URL` settings key, which is `True` unless set otherwise. ## ImageField -An image representation. +An image representation. Validates the uploaded file content as matching a known image format. Corresponds to `django.forms.fields.ImageField`. @@ -348,11 +377,60 @@ Signature and validation is the same as with `FileField`. --- -**Note:** `FileFields` and `ImageFields` are only suitable for use with MultiPartParser, since e.g. json doesn't support file uploads. +**Note:** `FileFields` and `ImageFields` are only suitable for use with `MultiPartParser` or `FileUploadParser`. Most parsers, such as e.g. JSON don't support file uploads. Django's regular [FILE_UPLOAD_HANDLERS] are used for handling uploaded files. --- +# Composite fields + +## ListField + +**TODO** + +--- + +# Miscellaneous fields + +## ReadOnlyField + +**TODO** + +## HiddenField + +**TODO** + +## ModelField + +A generic field that can be tied to any arbitrary model field. The `ModelField` class delegates the task of serialization/deserialization to its associated model field. This field can be used to create serializer fields for custom model fields, without having to create a new custom serializer field. + +The `ModelField` class is generally intended for internal use, but can be used by your API if needed. In order to properly instantiate a `ModelField`, it must be passed a field that is attached to an instantiated model. For example: `ModelField(model_field=MyModel()._meta.get_field('custom_field'))` + +**Signature:** `ModelField(model_field=)` + +## SerializerMethodField + +This is a read-only field. It gets its value by calling a method on the serializer class it is attached to. It can be used to add any sort of data to the serialized representation of your object. + +The field constructor accepts a single optional argument, which is the name of the method on the serializer to be called. If not included this defaults to `get_`. + +The method should accept a single argument (in addition to `self`), which is the object being serialized. It should return whatever you want to be included in the serialized representation of the object. For example: + + from django.contrib.auth.models import User + from django.utils.timezone import now + from rest_framework import serializers + + class UserSerializer(serializers.ModelSerializer): + days_since_joined = serializers.SerializerMethodField() + + class Meta: + model = User + + def get_days_since_joined(self, obj): + return (now() - obj.date_joined).days + +--- + # Custom fields If you want to create a custom field, you'll probably want to override either one or both of the `.to_native()` and `.from_native()` methods. These two methods are used to convert between the initial datatype, and a primitive, serializable datatype. Primitive datatypes may be any of a number, string, date/time/datetime or None. They may also be any list or dictionary like object that only contains other primitive objects. -- cgit v1.2.3 From c01c631ef2c5a0f303460c505810c4987371dbcc Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 26 Nov 2014 09:04:48 +0000 Subject: perform_create, perform_update, perform_destroy hooks --- docs/api-guide/fields.md | 19 ++++++++++++------- docs/api-guide/generic-views.md | 28 ++++++++++++++-------------- 2 files changed, 26 insertions(+), 21 deletions(-) diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md index 17a65ab8..1e856853 100644 --- a/docs/api-guide/fields.md +++ b/docs/api-guide/fields.md @@ -433,9 +433,9 @@ The method should accept a single argument (in addition to `self`), which is the # Custom fields -If you want to create a custom field, you'll probably want to override either one or both of the `.to_native()` and `.from_native()` methods. These two methods are used to convert between the initial datatype, and a primitive, serializable datatype. Primitive datatypes may be any of a number, string, date/time/datetime or None. They may also be any list or dictionary like object that only contains other primitive objects. +If you want to create a custom field, you'll probably want to override either one or both of the `.to_representation()` and `.to_internal_value()` methods. These two methods are used to convert between the initial datatype, and a primitive, serializable datatype. Primitive datatypes may be any of a number, string, date/time/datetime or None. They may also be any list or dictionary like object that only contains other primitive objects. -The `.to_native()` method is called to convert the initial datatype into a primitive, serializable datatype. The `from_native()` method is called to restore a primitive datatype into its initial representation. +The `.to_representation()` method is called to convert the initial datatype into a primitive, serializable datatype. The `to_internal_value()` method is called to restore a primitive datatype into its internal python representation. ## Examples @@ -450,25 +450,30 @@ Let's look at an example of serializing a class that represents an RGB color val assert(red < 256 and green < 256 and blue < 256) self.red, self.green, self.blue = red, green, blue - class ColourField(serializers.WritableField): + class ColorField(serializers.Field): """ Color objects are serialized into "rgb(#, #, #)" notation. """ - def to_native(self, obj): + def to_representation(self, obj): return "rgb(%d, %d, %d)" % (obj.red, obj.green, obj.blue) - def from_native(self, data): + def to_internal_value(self, data): data = data.strip('rgb(').rstrip(')') red, green, blue = [int(col) for col in data.split(',')] return Color(red, green, blue) -By default field values are treated as mapping to an attribute on the object. If you need to customize how the field value is accessed and set you need to override `.field_to_native()` and/or `.field_from_native()`. +By default field values are treated as mapping to an attribute on the object. If you need to customize how the field value is accessed and set you need to override `.get_attribute()` and/or `.get_value()`. As an example, let's create a field that can be used represent the class name of the object being serialized: class ClassNameField(serializers.Field): - def field_to_native(self, obj, field_name): + def get_attribute(self, obj): + # We pass the object instance onto `to_representation`, + # not just the field attribute. + return obj + + def to_representation(self, obj): """ Serialize the object's class name. """ diff --git a/docs/api-guide/generic-views.md b/docs/api-guide/generic-views.md index 489b628f..dc51189c 100755 --- a/docs/api-guide/generic-views.md +++ b/docs/api-guide/generic-views.md @@ -7,7 +7,7 @@ source: mixins.py > > — [Django Documentation][cite] -One of the key benefits of class based views is the way they allow you to compose bits of reusable behaviour. REST framework takes advantage of this by providing a number of pre-built views that provide for commonly used patterns. +One of the key benefits of class based views is the way they allow you to compose bits of reusable behavior. REST framework takes advantage of this by providing a number of pre-built views that provide for commonly used patterns. The generic views provided by REST framework allow you to quickly build API views that map closely to your database models. @@ -171,24 +171,24 @@ For example: return 20 return 100 -**Save / deletion hooks**: +**Save and deletion hooks**: -The following methods are provided as placeholder interfaces. They contain empty implementations and are not called directly by `GenericAPIView`, but they are overridden and used by some of the mixin classes. +The following methods are provided by the mixin classes, and provide easy overriding of the object save or deletion behavior. -* `pre_save(self, obj)` - A hook that is called before saving an object. -* `post_save(self, obj, created=False)` - A hook that is called after saving an object. -* `pre_delete(self, obj)` - A hook that is called before deleting an object. -* `post_delete(self, obj)` - A hook that is called after deleting an object. +* `perform_create(self, serializer)` - Called by `CreateModelMixin` when saving a new object instance. +* `perform_update(self, serializer)` - Called by `UpdateModelMixin` when saving an existing object instance. +* `perform_destroy(self, instance)` - Called by `DestroyModelMixin` when deleting an object instance. -The `pre_save` method in particular is a useful hook for setting attributes that are implicit in the request, but are not part of the request data. For instance, you might set an attribute on the object based on the request user, or based on a URL keyword argument. +These hooks are particularly useful for setting attributes that are implicit in the request, but are not part of the request data. For instance, you might set an attribute on the object based on the request user, or based on a URL keyword argument. - def pre_save(self, obj): - """ - Set the object's owner, based on the incoming request. - """ - obj.owner = self.request.user + def perform_create(self, serializer): + serializer.save(user=self.request.user) + +These override points are also particularly useful for adding behavior that occurs before or after saving an object, such as emailing a confirmation, or logging the update. -Remember that the `pre_save()` method is not called by `GenericAPIView` itself, but it is called by `create()` and `update()` methods on the `CreateModelMixin` and `UpdateModelMixin` classes. + def perform_update(self, serializer): + instance = serializer.save() + send_email_confirmation(user=self.request.user, modified=instance) **Other methods**: -- cgit v1.2.3 From 0f5338ada90ca2c6e53b9e095bec6a3b853d107b Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 26 Nov 2014 09:06:15 +0000 Subject: Call out removal of pre_save/post_save more strongly --- docs/api-guide/generic-views.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/docs/api-guide/generic-views.md b/docs/api-guide/generic-views.md index dc51189c..8c1b7dc9 100755 --- a/docs/api-guide/generic-views.md +++ b/docs/api-guide/generic-views.md @@ -190,6 +190,8 @@ These override points are also particularly useful for adding behavior that occu instance = serializer.save() send_email_confirmation(user=self.request.user, modified=instance) +**Note**: These methods replace the old-style version 2.x `pre_save`, `post_save`, `pre_delete` and `post_delete` methods, which are no longer available. + **Other methods**: You won't typically need to override the following methods, although you might need to call into them if you're writing custom views using `GenericAPIView`. -- cgit v1.2.3 From e1b14cbe4acafa47154acf66c21cd9e627c7ba1a Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 26 Nov 2014 10:27:29 +0000 Subject: 3.0 docs for serializer fields --- docs/api-guide/fields.md | 251 +++++++++++++++++++++++++---------------------- 1 file changed, 132 insertions(+), 119 deletions(-) diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md index 1e856853..ca551540 100644 --- a/docs/api-guide/fields.md +++ b/docs/api-guide/fields.md @@ -10,7 +10,7 @@ Serializer fields handle converting between primitive values and internal dataty --- -**Note:** The serializer fields are declared in fields.py, but by convention you should import them using `from rest_framework import serializers` and refer to fields as `serializers.`. +**Note:** The serializer fields are declared in `fields.py`, but by convention you should import them using `from rest_framework import serializers` and refer to fields as `serializers.`. --- @@ -18,14 +18,6 @@ Serializer fields handle converting between primitive values and internal dataty Each serializer field class constructor takes at least these arguments. Some Field classes take additional, field-specific arguments, but the following should always be accepted: -### `source` - -The name of the attribute that will be used to populate the field. May be a method that only takes a `self` argument, such as `Field(source='get_absolute_url')`, or may use dotted notation to traverse attributes, such as `Field(source='user.email')`. - -The value `source='*'` has a special meaning, and is used to indicate that the entire object should be passed through to the field. This can be useful for creating nested representations, or for fields which require access to the complete object in order to determine the output representation. - -Defaults to the name of the field. - ### `read_only` Set this to `True` to ensure that the field is used when serializing a representation, but is not used when creating or updating an instance during deserialization. @@ -59,6 +51,14 @@ May be set to a function or other callable, in which case the value will be eval Note that setting a `default` value implies that the field is not required. Including both the `default` and `required` keyword arguments is invalid and will raise an error. +### `source` + +The name of the attribute that will be used to populate the field. May be a method that only takes a `self` argument, such as `URLField('get_absolute_url')`, or may use dotted notation to traverse attributes, such as `EmailField(source='user.email')`. + +The value `source='*'` has a special meaning, and is used to indicate that the entire object should be passed through to the field. This can be useful for creating nested representations, or for fields which require access to the complete object in order to determine the output representation. + +Defaults to the name of the field. + ### `validators` A list of validator functions which should be applied to the incoming field input, and which either raise a validation error or simply return. Validator functions should typically raise `serializers.ValidationError`, but Django's built-in `ValidationError` is also supported for compatibility with validators defined in the Django codebase or third party Django packages. @@ -100,52 +100,6 @@ Two options are currently used in HTML form generation, `'input_type'` and `'bas --- -## Field - -A generic, **read-only** field. You can use this field for any attribute that does not need to support write operations. - -For example, using the following model. - - from django.db import models - from django.utils.timezone import now - - class Account(models.Model): - owner = models.ForeignKey('auth.user') - name = models.CharField(max_length=100) - created = models.DateTimeField(auto_now_add=True) - payment_expiry = models.DateTimeField() - - def has_expired(self): - return now() > self.payment_expiry - -A serializer definition that looked like this: - - from rest_framework import serializers - - class AccountSerializer(serializers.HyperlinkedModelSerializer): - expired = serializers.Field(source='has_expired') - - class Meta: - model = Account - fields = ('url', 'owner', 'name', 'expired') - -Would produce output similar to: - - { - 'url': 'http://example.com/api/accounts/3/', - 'owner': 'http://example.com/api/users/12/', - 'name': 'FooCorp business account', - 'expired': True - } - -By default, the `Field` class will perform a basic translation of the source value into primitive datatypes, falling back to unicode representations of complex datatypes when necessary. - -You can customize this behavior by overriding the `.to_native(self, value)` method. - -**TODO**: Note removal of `WritableField` - ---- - # Boolean fields ## BooleanField @@ -154,12 +108,16 @@ A boolean representation. Corresponds to `django.db.models.fields.BooleanField`. +**Signature:** `BooleanField()` + ## NullBooleanField A boolean representation that also accepts `None` as a valid value. Corresponds to `django.db.models.fields.NullBooleanField`. +**Signature:** `NullBooleanField()` + --- # String fields @@ -170,7 +128,13 @@ A text representation. Optionally validates the text to be shorter than `max_len Corresponds to `django.db.models.fields.CharField` or `django.db.models.fields.TextField`. -**Signature:** `CharField(max_length=None, min_length=None, allow_none=False)` +**Signature:** `CharField(max_length=None, min_length=None, allow_blank=False)` + +- `max_length` - Validates that the input contains no more than this number of characters. +- `min_length` - Validates that the input contains no fewer than this number of characters. +- `allow_blank` - If set to `True` then the empty string should be considered a valid value. If set to `False` then the empty string is considered invalid and will raise a validation error. Defaults to `False`. + +The `allow_null` option is also available for string fields, although its usage is discouraged in favor of `allow_blank`. It is valid to set both `allow_blank=True` and `allow_null=True`, but doing so means that there will be two differing types of empty value permissible for string representations, which can lead to data inconsistencies and subtle application bugs. ## EmailField @@ -178,19 +142,19 @@ A text representation, validates the text to be a valid e-mail address. Corresponds to `django.db.models.fields.EmailField` -**Signature:** `EmailField(max_length=None, min_length=None)` +**Signature:** `EmailField(max_length=None, min_length=None, allow_blank=False)` ## RegexField A text representation, that validates the given value matches against a certain regular expression. -The mandatory `regex` argument may either be a string, or a compiled python regular expression object. +Corresponds to `django.forms.fields.RegexField`. -Uses Django's `django.core.validators.RegexValidator` for validation. +**Signature:** `RegexField(regex, max_length=None, min_length=None, allow_blank=False)` -Corresponds to `django.forms.fields.RegexField` +The mandatory `regex` argument may either be a string, or a compiled python regular expression object. -**Signature:** `RegexField(regex, max_length=None, min_length=None)` +Uses Django's `django.core.validators.RegexValidator` for validation. ## SlugField @@ -198,7 +162,7 @@ A `RegexField` that validates the input against the pattern `[a-zA-Z0-9_-]+`. Corresponds to `django.db.models.fields.SlugField`. -**Signature:** `SlugField(max_length=50, min_length=None)` +**Signature:** `SlugField(max_length=50, min_length=None, allow_blank=False)` ## URLField @@ -206,7 +170,7 @@ A `RegexField` that validates the input against a URL matching pattern. Expects Corresponds to `django.db.models.fields.URLField`. Uses Django's `django.core.validators.URLValidator` for validation. -**Signature:** `URLField(max_length=200, min_length=None)` +**Signature:** `URLField(max_length=200, min_length=None, allow_blank=False)` --- @@ -216,40 +180,36 @@ Corresponds to `django.db.models.fields.URLField`. Uses Django's `django.core.v An integer representation. -Has two optional arguments: +Corresponds to `django.db.models.fields.IntegerField`, `django.db.models.fields.SmallIntegerField`, `django.db.models.fields.PositiveIntegerField` and `django.db.models.fields.PositiveSmallIntegerField`. -- `max_value` Validate that the number provided is no greater than this value. +**Signature**: `IntegerField(max_value=None, min_value=None)` +- `max_value` Validate that the number provided is no greater than this value. - `min_value` Validate that the number provided is no less than this value. -Corresponds to `django.db.models.fields.IntegerField`, `django.db.models.fields.SmallIntegerField`, `django.db.models.fields.PositiveIntegerField` and `django.db.models.fields.PositiveSmallIntegerField`. - ## FloatField A floating point representation. -Has two optional arguments: +Corresponds to `django.db.models.fields.FloatField`. + +**Signature**: `FloatField(max_value=None, min_value=None)` - `max_value` Validate that the number provided is no greater than this value. - - `min_value` Validate that the number provided is no less than this value. -Corresponds to `django.db.models.fields.FloatField`. - ## DecimalField -A decimal representation, represented in Python by a Decimal instance. +A decimal representation, represented in Python by a `Decimal` instance. -Has two required arguments, and three optional arguments: +Corresponds to `django.db.models.fields.DecimalField`. -- `max_digits` The maximum number of digits allowed in the number. Note that this number must be greater than or equal to decimal_places. +**Signature**: `DecimalField(max_digits, decimal_places, coerce_to_string=None, max_value=None, min_value=None)` +- `max_digits` The maximum number of digits allowed in the number. Note that this number must be greater than or equal to decimal_places. - `decimal_places` The number of decimal places to store with the number. - - `coerce_to_string` Set to `True` if string values should be returned for the representation, or `False` if `Decimal` objects should be returned. Defaults to the same value as the `COERCE_DECIMAL_TO_STRING` settings key, which will be `True` unless overridden. If `Decimal` objects are returned by the serializer, then the final output format will be determined by the renderer. - - `max_value` Validate that the number provided is no greater than this value. - - `min_value` Validate that the number provided is no less than this value. #### Example usage @@ -266,10 +226,6 @@ This field also takes an optional argument, `coerce_to_string`. If set to `True` If unset, this will default to the same value as the `COERCE_DECIMAL_TO_STRING` setting, which is `True` unless set otherwise. -**Signature:** `DecimalField(max_digits, decimal_places, coerce_to_string=None)` - -Corresponds to `django.db.models.fields.DecimalField`. - --- # Date and time fields @@ -280,26 +236,30 @@ A date and time representation. Corresponds to `django.db.models.fields.DateTimeField`. -When using `ModelSerializer` or `HyperlinkedModelSerializer`, note that any model fields with `auto_now=True` or `auto_now_add=True` will use serializer fields that are `read_only=True` by default. +**Signature:** `DateTimeField(format=None, input_formats=None)` -If you want to override this behavior, you'll need to declare the `DateTimeField` explicitly on the serializer. For example: +* `format` - A string representing the output format. If not specified, this defaults to the same value as the `DATETIME_FORMAT` settings key, which will be `'iso-8601'` unless set. Setting to a format string indicates that `to_representation` return values should be coerced to string output. Format strings are described below. Setting this value to `None` indicates that Python `datetime` objects should be returned by `to_representation`. In this case the datetime encoding will be determined by the renderer. +* `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `DATETIME_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`. - class CommentSerializer(serializers.ModelSerializer): - created = serializers.DateTimeField() +#### `DateTimeField` format strings. - class Meta: - model = Comment +Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style datetimes should be used. (eg `'2013-01-29T12:34:56.000000Z'`) -Note that by default, datetime representations are determined by the renderer in use, although this can be explicitly overridden as detailed below. +When a value of `None` is used for the format `datetime` objects will be returned by `to_representation` and the final output representation will determined by the renderer class. In the case of JSON this means the default datetime representation uses the [ECMA 262 date time string specification][ecma262]. This is a subset of ISO 8601 which uses millisecond precision, and includes the 'Z' suffix for the UTC timezone, for example: `2013-01-29T12:34:56.123Z`. -**Signature:** `DateTimeField(format=None, input_formats=None)` +#### `auto_now` and `auto_now_add` model fields. -* `format` - A string representing the output format. If not specified, this defaults to the same value as the `DATETIME_FORMAT` settings key, which will be `'iso-8601'` unless set. Setting to a format string indicates that `to_representation` return values should be coerced to string output. Format strings are described below. Setting this value to `None` indicates that Python `datetime` objects should be returned by `to_representation`. In this case the datetime encoding will be determined by the renderer. -* `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `DATETIME_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`. +When using `ModelSerializer` or `HyperlinkedModelSerializer`, note that any model fields with `auto_now=True` or `auto_now_add=True` will use serializer fields that are `read_only=True` by default. + +If you want to override this behavior, you'll need to declare the `DateTimeField` explicitly on the serializer. For example: + + class CommentSerializer(serializers.ModelSerializer): + created = serializers.DateTimeField() -**DateTimeField format strings**: Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style datetimes should be used. (eg `'2013-01-29T12:34:56.000000Z'`) + class Meta: + model = Comment ## DateField @@ -312,7 +272,9 @@ Corresponds to `django.db.models.fields.DateField` * `format` - A string representing the output format. If not specified, this defaults to the same value as the `DATE_FORMAT` settings key, which will be `'iso-8601'` unless set. Setting to a format string indicates that `to_representation` return values should be coerced to string output. Format strings are described below. Setting this value to `None` indicates that Python `date` objects should be returned by `to_representation`. In this case the date encoding will be determined by the renderer. * `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `DATE_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`. -**DateField format strings**: Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style dates should be used. (eg `'2013-01-29'`) +#### `DateField` format strings + +Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style dates should be used. (eg `'2013-01-29'`) ## TimeField @@ -325,7 +287,9 @@ Corresponds to `django.db.models.fields.TimeField` * `format` - A string representing the output format. If not specified, this defaults to the same value as the `TIME_FORMAT` settings key, which will be `'iso-8601'` unless set. Setting to a format string indicates that `to_representation` return values should be coerced to string output. Format strings are described below. Setting this value to `None` indicates that Python `time` objects should be returned by `to_representation`. In this case the time encoding will be determined by the renderer. * `input_formats` - A list of strings representing the input formats which may be used to parse the date. If not specified, the `TIME_INPUT_FORMATS` setting will be used, which defaults to `['iso-8601']`. -**TimeField format strings**: Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style times should be used. (eg `'12:34:56.000000'`) +#### `TimeField` format strings + +Format strings may either be [Python strftime formats][strftime] which explicitly specify the format, or the special string `'iso-8601'`, which indicates that [ISO 8601][iso8601] style times should be used. (eg `'12:34:56.000000'`) --- @@ -333,24 +297,31 @@ Corresponds to `django.db.models.fields.TimeField` ## ChoiceField -A field that can accept a value out of a limited set of choices. Takes a single mandatory argument. +A field that can accept a value out of a limited set of choices. -- `choices` - A list of valid values, or a list of `(key, display_name)` tuples. +Used by `ModelSerializer` to automatically generate fields if the corresponding model field includes a `choices=…` argument. -**Signature:** `ChoiceField(choices=())` +**Signature:** `ChoiceField(choices)` + +- `choices` - A list of valid values, or a list of `(key, display_name)` tuples. ## MultipleChoiceField A field that can accept a set of zero, one or many values, chosen from a limited set of choices. Takes a single mandatory argument. `to_internal_representation` returns a `set` containing the selected values. -- `choices` - A list of valid values, or a list of `(key, display_name)` tuples. +**Signature:** `MultipleChoiceField(choices)` -**Signature:** `MultipleChoiceField(choices=())` +- `choices` - A list of valid values, or a list of `(key, display_name)` tuples. --- # File upload fields +#### Parsers and file uploads. + +The `FileField` and `ImageField` classes are only suitable for use with `MultiPartParser` or `FileUploadParser`. Most parsers, such as e.g. JSON don't support file uploads. +Django's regular [FILE_UPLOAD_HANDLERS] are used for handling uploaded files. + ## FileField A file representation. Performs Django's standard FileField validation. @@ -359,10 +330,8 @@ Corresponds to `django.forms.fields.FileField`. **Signature:** `FileField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)` - - `max_length` - designates the maximum length for the file name. - - - `allow_empty_file` - designates if empty files are allowed. - + - `max_length` - Designates the maximum length for the file name. + - `allow_empty_file` - Designates if empty files are allowed. - `use_url` - If set to `True` then URL string values will be used for the output representation. If set to `False` then filename string values will be used for the output representation. Defaults to the value of the `UPLOADED_FILES_USE_URL` settings key, which is `True` unless set otherwise. ## ImageField @@ -371,14 +340,13 @@ An image representation. Validates the uploaded file content as matching a known Corresponds to `django.forms.fields.ImageField`. -Requires either the `Pillow` package or `PIL` package. The `Pillow` package is recommended, as `PIL` is no longer actively maintained. +**Signature:** `ImageField(max_length=None, allow_empty_file=False, use_url=UPLOADED_FILES_USE_URL)` -Signature and validation is the same as with `FileField`. - ---- + - `max_length` - Designates the maximum length for the file name. + - `allow_empty_file` - Designates if empty files are allowed. +- `use_url` - If set to `True` then URL string values will be used for the output representation. If set to `False` then filename string values will be used for the output representation. Defaults to the value of the `UPLOADED_FILES_USE_URL` settings key, which is `True` unless set otherwise. -**Note:** `FileFields` and `ImageFields` are only suitable for use with `MultiPartParser` or `FileUploadParser`. Most parsers, such as e.g. JSON don't support file uploads. -Django's regular [FILE_UPLOAD_HANDLERS] are used for handling uploaded files. +Requires either the `Pillow` package or `PIL` package. The `Pillow` package is recommended, as `PIL` is no longer actively maintained. --- @@ -386,7 +354,24 @@ Django's regular [FILE_UPLOAD_HANDLERS] are used for handling uploaded files. ## ListField -**TODO** +A field class that validates a list of objects. + +**Signature**: `ListField(child)` + +- `child` - A field instance that should be used for validating the objects in the list. + +For example, to validate a list of integers you might use something like the following: + + scores = serializers.ListField( + child=serializers.IntegerField(min_value=0, max_value=100) + ) + +The `ListField` class also supports a declarative style that allows you to write reusable list field classes. + + class StringListField(serializers.ListField): + child = serializers.CharField() + +We can now reuse our custom `StringListField` class throughout our application, without having to provide a `child` argument to it. --- @@ -394,27 +379,52 @@ Django's regular [FILE_UPLOAD_HANDLERS] are used for handling uploaded files. ## ReadOnlyField -**TODO** +A field class that simply returns the value of the field without modification. + +This field is used by default with `ModelSerializer` when including field names that relate to an attribute rather than a model field. + +**Signature**: `ReadOnlyField()` + +For example, is `has_expired` was a property on the `Account` model, then the following serializer would automatically generate it as a `ReadOnlyField`: + + class AccountSerializer(serializers.ModelSerializer): + class Meta: + model = Account + fields = ('id', 'account_name', 'has_expired') ## HiddenField -**TODO** +A field class that does not take a value based on user input, but instead takes its value from a default value or callable. + +**Signature**: `HiddenField()` + +For example, to include a field that always provides the current time as part of the serializer validated data, you would use the following: + + modified = serializer.HiddenField(default=timezone.now) + +The `HiddenField` class is usually only needed if you have some validation that needs to run based on some pre-provided field values, but you do not want to expose all of those fields to the end user. + +For further examples on `HiddenField` see the [validators](validators.md) documentation. ## ModelField -A generic field that can be tied to any arbitrary model field. The `ModelField` class delegates the task of serialization/deserialization to its associated model field. This field can be used to create serializer fields for custom model fields, without having to create a new custom serializer field. +A generic field that can be tied to any arbitrary model field. The `ModelField` class delegates the task of serialization/deserialization to its associated model field. This field can be used to create serializer fields for custom model fields, without having to create a new custom serializer field. -The `ModelField` class is generally intended for internal use, but can be used by your API if needed. In order to properly instantiate a `ModelField`, it must be passed a field that is attached to an instantiated model. For example: `ModelField(model_field=MyModel()._meta.get_field('custom_field'))` +This field is used by `ModelSerializer` to correspond to custom model field classes. **Signature:** `ModelField(model_field=)` +The `ModelField` class is generally intended for internal use, but can be used by your API if needed. In order to properly instantiate a `ModelField`, it must be passed a field that is attached to an instantiated model. For example: `ModelField(model_field=MyModel()._meta.get_field('custom_field'))` + ## SerializerMethodField This is a read-only field. It gets its value by calling a method on the serializer class it is attached to. It can be used to add any sort of data to the serialized representation of your object. -The field constructor accepts a single optional argument, which is the name of the method on the serializer to be called. If not included this defaults to `get_`. +**Signature**: `SerializerMethodField(method_name=None)` + +- `method-name` - The name of the method on the serializer to be called. If not included this defaults to `get_`. -The method should accept a single argument (in addition to `self`), which is the object being serialized. It should return whatever you want to be included in the serialized representation of the object. For example: +The serializer method referred to by the `method_name` argument should accept a single argument (in addition to `self`), which is the object being serialized. It should return whatever you want to be included in the serialized representation of the object. For example: from django.contrib.auth.models import User from django.utils.timezone import now @@ -433,9 +443,13 @@ The method should accept a single argument (in addition to `self`), which is the # Custom fields -If you want to create a custom field, you'll probably want to override either one or both of the `.to_representation()` and `.to_internal_value()` methods. These two methods are used to convert between the initial datatype, and a primitive, serializable datatype. Primitive datatypes may be any of a number, string, date/time/datetime or None. They may also be any list or dictionary like object that only contains other primitive objects. +If you want to create a custom field, you'll need to subclass `Field` and then override either one or both of the `.to_representation()` and `.to_internal_value()` methods. These two methods are used to convert between the initial datatype, and a primitive, serializable datatype. Primitive datatypes will typically be any of a number, string, boolean, `date`/`time`/`datetime` or `None`. They may also be any list or dictionary like object that only contains other primitive objects. Other types might be supported, depending on the renderer that you are using. -The `.to_representation()` method is called to convert the initial datatype into a primitive, serializable datatype. The `to_internal_value()` method is called to restore a primitive datatype into its internal python representation. +The `.to_representation()` method is called to convert the initial datatype into a primitive, serializable datatype. + +The `to_internal_value()` method is called to restore a primitive datatype into its internal python representation. + +Note that the `WritableField` class that was present in version 2.x no longer exists. You should subclass `Field` and override `to_internal_value()` if the field supports data input. ## Examples @@ -462,7 +476,6 @@ Let's look at an example of serializing a class that represents an RGB color val red, green, blue = [int(col) for col in data.split(',')] return Color(red, green, blue) - By default field values are treated as mapping to an attribute on the object. If you need to customize how the field value is accessed and set you need to override `.get_attribute()` and/or `.get_value()`. As an example, let's create a field that can be used represent the class name of the object being serialized: -- cgit v1.2.3 From 678f7b4c654ccc1bc147d36e0ecb4a3a3a1cacdb Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 26 Nov 2014 10:43:45 +0000 Subject: Update notes on autocomplete --- docs/topics/browsable-api.md | 33 +++++++++++---------------------- 1 file changed, 11 insertions(+), 22 deletions(-) diff --git a/docs/topics/browsable-api.md b/docs/topics/browsable-api.md index ad812f4b..2879db74 100644 --- a/docs/topics/browsable-api.md +++ b/docs/topics/browsable-api.md @@ -130,34 +130,24 @@ You can override the `BrowsableAPIRenderer.get_context()` method to customise th For more advanced customization, such as not having a Bootstrap basis or tighter integration with the rest of your site, you can simply choose not to have `api.html` extend `base.html`. Then the page content and capabilities are entirely up to you. -#### Autocompletion +#### Handling `ChoiceField` with large numbers of items. -When a `ChoiceField` has too many items, rendering the widget containing all the options can become very slow, and cause the browsable API rendering to perform poorly. One solution is to replace the selector by an autocomplete widget, that only loads and renders a subset of the available options as needed. +When a relationship or `ChoiceField` has too many items, rendering the widget containing all the options can become very slow, and cause the browsable API rendering to perform poorly. -There are [a variety of packages for autocomplete widgets][autocomplete-packages], such as [django-autocomplete-light][django-autocomplete-light]. To setup `django-autocomplete-light`, follow the [installation documentation][django-autocomplete-light-install], add the the following to the `api.html` template: +The simplest option in this case is to replace the select input with a standard text input. For example: - {% block script %} - {{ block.super }} - {% include 'autocomplete_light/static.html' %} - {% endblock %} - -You can now add the `autocomplete_light.ChoiceWidget` widget to the serializer field. - - import autocomplete_light + author = serializers.HyperlinkedRelatedField( + queryset=User.objects.all(), + style={'base_template': 'input.html'} + ) - class BookSerializer(serializers.ModelSerializer): - author = serializers.ChoiceField( - widget=autocomplete_light.ChoiceWidget('AuthorAutocomplete') - ) +#### Autocomplete - class Meta: - model = Book - ---- +An alternative, but more complex option would be to replace the input with an autocomplete widget, that only loads and renders a subset of the available options as needed. If you need to do this you'll need to do some work to build a custom autocomplete HTML template yourself. -![Autocomplete][autocomplete-image] +There are [a variety of packages for autocomplete widgets][autocomplete-packages], such as [django-autocomplete-light][django-autocomplete-light], that you may want to refer to. Note that you will not be able to simply include these components as standard widgets, but will need to write the HTML template explicitly. This is because REST framework 3.0 no longer supports the `widget` keyword argument since it now uses templated HTML generation. -*Screenshot of the autocomplete-light widget* +Better support for autocomplete inputs is planned in future versions. --- @@ -175,4 +165,3 @@ You can now add the `autocomplete_light.ChoiceWidget` widget to the serializer f [autocomplete-packages]: https://www.djangopackages.com/grids/g/auto-complete/ [django-autocomplete-light]: https://github.com/yourlabs/django-autocomplete-light [django-autocomplete-light-install]: http://django-autocomplete-light.readthedocs.org/en/latest/#install -[autocomplete-image]: ../img/autocomplete.png -- cgit v1.2.3 From b4550c65dd339731ff3dd2b0dd3c6dad12565906 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 26 Nov 2014 11:30:28 +0000 Subject: Docstring for 'many_init' --- rest_framework/relations.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/rest_framework/relations.py b/rest_framework/relations.py index 79c8057b..5a3403f5 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -49,6 +49,21 @@ class RelatedField(Field): @classmethod def many_init(cls, *args, **kwargs): + """ + This method handles creating a parent `ManyRelatedField` instance + when the `many=True` keyword argument is passed. + + Typically you won't need to override this method. + + Note that we're over-cautious in passing most arguments to both parent + and child classes in order to try to cover the general case. If you're + overriding this method you'll probably want something much simpler, eg: + + @classmethod + def many_init(cls, *args, **kwargs): + kwargs['child'] = cls() + return CustomManyRelatedField(*args, **kwargs) + """ list_kwargs = {'child_relation': cls(*args, **kwargs)} for key in kwargs.keys(): if key in MANY_RELATION_KWARGS: -- cgit v1.2.3 From 5a5a73c7fef49899a37721e6c68228ef605e11f8 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 26 Nov 2014 11:30:49 +0000 Subject: 3.0 docs and tidy-up for serializer relationships --- docs/api-guide/relations.md | 81 +++++++++++++++++++++++---------------------- 1 file changed, 41 insertions(+), 40 deletions(-) diff --git a/docs/api-guide/relations.md b/docs/api-guide/relations.md index ad981b2b..7d19eba2 100644 --- a/docs/api-guide/relations.md +++ b/docs/api-guide/relations.md @@ -16,6 +16,20 @@ Relational fields are used to represent model relationships. They can be applie --- +#### Inspecting automatically generated relationships. + +When using the `ModelSerializer` class, serializer fields and relationships will be automatically generated for you. Inspecting these automatically generated fields can be a useful tool for determining how to customize the relationship style. + +To do so, open the Django shell, using `python manage.py shell`, then import the serializer class, instantiate it, and print the object representation… + + >>> from myapp.serializers import AccountSerializer + >>> serializer = AccountSerializer() + >>> print repr(serializer) # Or `print(repr(serializer))` in Python 3.x. + AccountSerializer(): + id = IntegerField(label='ID', read_only=True) + name = CharField(allow_blank=True, max_length=100, required=False) + owner = PrimaryKeyRelatedField(queryset=User.objects.all()) + # API Reference In order to explain the various types of relational fields, we'll use a couple of simple models for our examples. Our models will be for music albums, and the tracks listed on each album. @@ -37,14 +51,14 @@ In order to explain the various types of relational fields, we'll use a couple o def __unicode__(self): return '%d: %s' % (self.order, self.title) -## RelatedField +## StringRelatedField -`RelatedField` may be used to represent the target of the relationship using its `__unicode__` method. +`StringRelatedField` may be used to represent the target of the relationship using its `__unicode__` method. For example, the following serializer. class AlbumSerializer(serializers.ModelSerializer): - tracks = serializers.RelatedField(many=True) + tracks = serializers.StringRelatedField(many=True) class Meta: model = Album @@ -99,9 +113,9 @@ By default this field is read-write, although you can change this behavior using **Arguments**: +* `queryset` - The queryset used for model instance lookups when validating the field input. Relationships must either set a queryset explicitly, or set `read_only=True`. * `many` - If applied to a to-many relationship, you should set this argument to `True`. -* `required` - If set to `False`, the field will accept values of `None` or the empty-string for nullable relationships. -* `queryset` - By default `ModelSerializer` classes will use the default queryset for the relationship. `Serializer` classes must either set a queryset explicitly, or set `read_only=True`. +* `allow_null` - If set to `True`, the field will accept values of `None` or the empty string for nullable relationships. Defaults to `False`. ## HyperlinkedRelatedField @@ -110,8 +124,11 @@ By default this field is read-write, although you can change this behavior using For example, the following serializer: class AlbumSerializer(serializers.ModelSerializer): - tracks = serializers.HyperlinkedRelatedField(many=True, read_only=True, - view_name='track-detail') + tracks = serializers.HyperlinkedRelatedField( + many=True, + read_only=True, + view_name='track-detail' + ) class Meta: model = Album @@ -134,11 +151,12 @@ By default this field is read-write, although you can change this behavior using **Arguments**: -* `view_name` - The view name that should be used as the target of the relationship. If you're using [the standard router classes][routers] this wil be a string with the format `-detail`. **required**. +* `view_name` - The view name that should be used as the target of the relationship. If you're using [the standard router classes][routers] this will be a string with the format `-detail`. **required**. +* `queryset` - The queryset used for model instance lookups when validating the field input. Relationships must either set a queryset explicitly, or set `read_only=True`. * `many` - If applied to a to-many relationship, you should set this argument to `True`. -* `required` - If set to `False`, the field will accept values of `None` or the empty-string for nullable relationships. -* `queryset` - By default `ModelSerializer` classes will use the default queryset for the relationship. `Serializer` classes must either set a queryset explicitly, or set `read_only=True`. +* `allow_null` - If set to `True`, the field will accept values of `None` or the empty string for nullable relationships. Defaults to `False`. * `lookup_field` - The field on the target that should be used for the lookup. Should correspond to a URL keyword argument on the referenced view. Default is `'pk'`. +* `lookup_url_kwarg` - The name of the keyword argument defined in the URL conf that corresponds to the lookup field. Defaults to using the same value as `lookup_field`. * `format` - If using format suffixes, hyperlinked fields will use the same format suffix for the target unless overridden by using the `format` argument. ## SlugRelatedField @@ -148,8 +166,11 @@ By default this field is read-write, although you can change this behavior using For example, the following serializer: class AlbumSerializer(serializers.ModelSerializer): - tracks = serializers.SlugRelatedField(many=True, read_only=True, - slug_field='title') + tracks = serializers.SlugRelatedField( + many=True, + read_only=True, + slug_field='title' + ) class Meta: model = Album @@ -175,9 +196,9 @@ When using `SlugRelatedField` as a read-write field, you will normally want to e **Arguments**: * `slug_field` - The field on the target that should be used to represent it. This should be a field that uniquely identifies any given instance. For example, `username`. **required** +* `queryset` - The queryset used for model instance lookups when validating the field input. Relationships must either set a queryset explicitly, or set `read_only=True`. * `many` - If applied to a to-many relationship, you should set this argument to `True`. -* `required` - If set to `False`, the field will accept values of `None` or the empty-string for nullable relationships. -* `queryset` - By default `ModelSerializer` classes will use the default queryset for the relationship. `Serializer` classes must either set a queryset explicitly, or set `read_only=True`. +* `allow_null` - If set to `True`, the field will accept values of `None` or the empty string for nullable relationships. Defaults to `False`. ## HyperlinkedIdentityField @@ -245,9 +266,9 @@ Would serialize to a nested representation like this: # Custom relational fields -To implement a custom relational field, you should override `RelatedField`, and implement the `.to_native(self, value)` method. This method takes the target of the field as the `value` argument, and should return the representation that should be used to serialize the target. +To implement a custom relational field, you should override `RelatedField`, and implement the `.to_representation(self, value)` method. This method takes the target of the field as the `value` argument, and should return the representation that should be used to serialize the target. The `value` argument will typically be a model instance. -If you want to implement a read-write relational field, you must also implement the `.from_native(self, data)` method, and add `read_only = False` to the class definition. +If you want to implement a read-write relational field, you must also implement the `.to_internal_value(self, data)` method. ## Example @@ -256,7 +277,7 @@ For, example, we could define a relational field, to serialize a track to a cust import time class TrackListingField(serializers.RelatedField): - def to_native(self, value): + def to_representation(self, value): duration = time.strftime('%M:%S', time.gmtime(value.duration)) return 'Track %d: %s (%s)' % (value.order, value.name, duration) @@ -350,7 +371,7 @@ We could define a custom field that could be used to serialize tagged instances, A custom field to use for the `tagged_object` generic relationship. """ - def to_native(self, value): + def to_representation(self, value): """ Serialize tagged objects to a simple textual representation. """ @@ -360,9 +381,9 @@ We could define a custom field that could be used to serialize tagged instances, return 'Note: ' + value.text raise Exception('Unexpected type of tagged object') -If you need the target of the relationship to have a nested representation, you can use the required serializers inside the `.to_native()` method: +If you need the target of the relationship to have a nested representation, you can use the required serializers inside the `.to_native()` method: - def to_native(self, value): + def to_representation(self, value): """ Serialize bookmark instances using a bookmark serializer, and note instances using a note serializer. @@ -404,7 +425,6 @@ attributes are not configured to correctly match the URL conf. #### get_object(self, queryset, view_name, view_args, view_kwargs) - This method should the object that corresponds to the matched URL conf arguments. May raise an `ObjectDoesNotExist` exception. @@ -425,25 +445,6 @@ For example, if all your object URLs used both a account and a slug in the the U --- -## Deprecated APIs - -The following classes have been deprecated, in favor of the `many=` syntax. -They continue to function, but their usage will raise a `PendingDeprecationWarning`, which is silent by default. - -* `ManyRelatedField` -* `ManyPrimaryKeyRelatedField` -* `ManyHyperlinkedRelatedField` -* `ManySlugRelatedField` - -The `null=` flag has been deprecated in favor of the `required=` flag. It will continue to function, but will raise a `PendingDeprecationWarning`. - -In the 2.3 release, these warnings will be escalated to a `DeprecationWarning`, which is loud by default. -In the 2.4 release, these parts of the API will be removed entirely. - -For more details see the [2.2 release announcement][2.2-announcement]. - ---- - # Third Party Packages The following third party packages are also available. -- cgit v1.2.3 From 786cab705a37f6b2196560d0e476e5c849420a61 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 26 Nov 2014 11:38:48 +0000 Subject: Tweak to 3.0 relationship docs --- docs/api-guide/relations.md | 12 +++++++++++- rest_framework/relations.py | 4 +++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/docs/api-guide/relations.md b/docs/api-guide/relations.md index 7d19eba2..17009bbc 100644 --- a/docs/api-guide/relations.md +++ b/docs/api-guide/relations.md @@ -245,7 +245,7 @@ For example, the following serializer: fields = ('order', 'title') class AlbumSerializer(serializers.ModelSerializer): - tracks = TrackSerializer(many=True) + tracks = TrackSerializer(many=True, read_only=True) class Meta: model = Album @@ -305,6 +305,16 @@ This custom field would then serialize to the following representation. # Further notes +## The `queryset` argument + +The `queryset` argument is only ever required for *writable* relationship field, in which case it is used for performing the model instance lookup, that maps from the primitive user input, into a model instance. + +In version 2.x a serializer class could *sometimes* automatically determine the `queryset` argument *if* a `ModelSerializer` class was being used. + +This behavior is now replaced with *always* using an explicit `queryset` argument for writable relational fields. + +Doing so reduces the amount of hidden 'magic' that `ModelSerializer` provides, makes the behavior of the field more clear, and ensures that it is trivial to move between using the `ModelSerializer` shortcut, or using fully explicit `Serializer` classes. + ## Reverse relations Note that reverse relationships are not automatically included by the `ModelSerializer` and `HyperlinkedModelSerializer` classes. To include a reverse relationship, you must explicitly add it to the fields list. For example: diff --git a/rest_framework/relations.py b/rest_framework/relations.py index 5a3403f5..d1ea497a 100644 --- a/rest_framework/relations.py +++ b/rest_framework/relations.py @@ -321,7 +321,9 @@ class ManyRelatedField(Field): The `ManyRelatedField` class is responsible for handling iterating through the values and passing each one to the child relationship. - You shouldn't need to be using this class directly yourself. + This class is treated as private API. + You shouldn't generally need to be using this class directly yourself, + and should instead simply set 'many=True' on the relationship. """ initial = [] default_empty_html = [] -- cgit v1.2.3 From 34bd2b782875f93471c346230579cc75e52fb2c9 Mon Sep 17 00:00:00 2001 From: Will Stott Date: Wed, 26 Nov 2014 15:48:08 +0000 Subject: a few typos --- docs/tutorial/1-serialization.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorial/1-serialization.md b/docs/tutorial/1-serialization.md index f9027b68..84ed247a 100644 --- a/docs/tutorial/1-serialization.md +++ b/docs/tutorial/1-serialization.md @@ -206,7 +206,7 @@ Open the file `snippets/serializers.py` again, and edit the `SnippetSerializer` model = Snippet fields = ('id', 'title', 'code', 'linenos', 'language', 'style') -Once nice property that serializers have is that you can inspect all the fields an serializer instance, by printing it's representation. Open the Django shell with `python manange.py shell`, then try the following: +One nice property that serializers have is that you can inspect all the fields in a serializer instance, by printing it's representation. Open the Django shell with `python manange.py shell`, then try the following: >>> from snippets.serializers import SnippetSerializer >>> serializer = SnippetSerializer() -- cgit v1.2.3 From d0e245baba63dd8e2c0a497fc4f65b34b3d25a4a Mon Sep 17 00:00:00 2001 From: Will Stott Date: Wed, 26 Nov 2014 15:51:28 +0000 Subject: grammar --- docs/tutorial/1-serialization.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tutorial/1-serialization.md b/docs/tutorial/1-serialization.md index 84ed247a..a3c19858 100644 --- a/docs/tutorial/1-serialization.md +++ b/docs/tutorial/1-serialization.md @@ -219,7 +219,7 @@ One nice property that serializers have is that you can inspect all the fields i language = ChoiceField(choices=[('Clipper', 'FoxPro'), ('Cucumber', 'Gherkin'), ('RobotFramework', 'RobotFramework'), ('abap', 'ABAP'), ('ada', 'Ada')... style = ChoiceField(choices=[('autumn', 'autumn'), ('borland', 'borland'), ('bw', 'bw'), ('colorful', 'colorful')... -It's important to remember that `ModelSerializer` classes don't do anything particularly magically, they are simply a shortcut to creating a serializer class with: +It's important to remember that `ModelSerializer` classes don't do anything particularly magical, they are simply a shortcut for creating serializer classes: * An automatically determined set of fields. * Simple default implementations for the `create()` and `update()` methods. -- cgit v1.2.3 From 767414439b5553d6cb4e1825b39ff7de65d39a35 Mon Sep 17 00:00:00 2001 From: Xavier Ordoquy Date: Wed, 26 Nov 2014 22:20:14 +0100 Subject: Be nicer with __closable_objects. --- tests/test_renderers.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/test_renderers.py b/tests/test_renderers.py index a842baba..416d7f22 100644 --- a/tests/test_renderers.py +++ b/tests/test_renderers.py @@ -646,7 +646,8 @@ class CacheRenderTest(TestCase): """ method = getattr(self.client, http_method) resp = method(url) - del resp.client, resp.request, resp._closable_objects + resp._closable_objects = [] + del resp.client, resp.request try: del resp.wsgi_request except AttributeError: -- cgit v1.2.3 From 9b88c096e0627f1f054a50097d653543909662ab Mon Sep 17 00:00:00 2001 From: José Padilla Date: Wed, 26 Nov 2014 18:12:12 -0400 Subject: Remove Third party packages section Information about Third party packages is already covered under the Third Party Resources topic--- docs/topics/contributing.md | 20 -------------------- 1 file changed, 20 deletions(-) diff --git a/docs/topics/contributing.md b/docs/topics/contributing.md index 7654136c..30a9678f 100644 --- a/docs/topics/contributing.md +++ b/docs/topics/contributing.md @@ -198,21 +198,6 @@ If you want to draw attention to a note or warning, use a pair of enclosing line --- -# Third party packages - -New features to REST framework are generally recommended to be implemented as third party libraries that are developed outside of the core framework. Ideally third party libraries should be properly documented and packaged, and made available on PyPI. - -## Getting started - -If you have some functionality that you would like to implement as a third party package it's worth contacting the [discussion group][google-group] as others may be willing to get involved. We strongly encourage third party package development and will always try to prioritize time spent helping their development, documentation and packaging. - -We recommend the [`django-reusable-app`][django-reusable-app] template as a good resource for getting up and running with implementing a third party Django package. - -## Linking to your package - -Once your package is decently documented and available on PyPI open a pull request or issue, and we'll add a link to it from the main REST framework documentation. You can add your package under **Third party packages** of the API Guide section that best applies, like [Authentication][authentication] or [Permissions][permissions]. You can also link your package under the [Third Party Resources][third-party-resources] section. - -We also suggest adding it to the [REST Framework][rest-framework-grid] grid on Django Packages. [cite]: http://www.w3.org/People/Berners-Lee/FAQ.html [code-of-conduct]: https://www.djangoproject.com/conduct/ @@ -226,8 +211,3 @@ We also suggest adding it to the [REST Framework][rest-framework-grid] grid on D [markdown]: http://daringfireball.net/projects/markdown/basics [docs]: https://github.com/tomchristie/django-rest-framework/tree/master/docs [mou]: http://mouapp.com/ -[django-reusable-app]: https://github.com/dabapps/django-reusable-app -[authentication]: ../api-guide/authentication.md -[permissions]: ../api-guide/permissions.md -[third-party-resources]: third-party-resources.md -[rest-framework-grid]: https://www.djangopackages.com/grids/g/django-rest-framework/ -- cgit v1.2.3 From 0262262feefc1a8130cb852a6b710a16ebc24cb9 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 27 Nov 2014 08:09:58 +0000 Subject: 3.0 serializer docs --- docs/api-guide/serializers.md | 335 ++++++++++++++++++++++++++---------------- 1 file changed, 206 insertions(+), 129 deletions(-) diff --git a/docs/api-guide/serializers.md b/docs/api-guide/serializers.md index 2d0ff79a..e476d957 100644 --- a/docs/api-guide/serializers.md +++ b/docs/api-guide/serializers.md @@ -10,7 +10,7 @@ will take some serious design work. Serializers allow complex data such as querysets and model instances to be converted to native Python datatypes that can then be easily rendered into `JSON`, `XML` or other content types. Serializers also provide deserialization, allowing parsed data to be converted back into complex types, after first validating the incoming data. -REST framework's serializers work very similarly to Django's `Form` and `ModelForm` classes. It provides a `Serializer` class which gives you a powerful, generic way to control the output of your responses, as well as a `ModelSerializer` class which provides a useful shortcut for creating serializers that deal with model instances and querysets. +The serializers in REST framework work very similarly to Django's `Form` and `ModelForm` classes. We provide a `Serializer` class which gives you a powerful, generic way to control the output of your responses, as well as a `ModelSerializer` class which provides a useful shortcut for creating serializers that deal with model instances and querysets. ## Declaring Serializers @@ -24,7 +24,7 @@ Let's start by creating a simple object we can use for example purposes: comment = Comment(email='leila@example.com', content='foo bar') -We'll declare a serializer that we can use to serialize and deserialize `Comment` objects. +We'll declare a serializer that we can use to serialize and deserialize data that corresponds to `Comment` objects. Declaring a serializer looks very similar to declaring a form: @@ -35,25 +35,9 @@ Declaring a serializer looks very similar to declaring a form: content = serializers.CharField(max_length=200) created = serializers.DateTimeField() - def restore_object(self, attrs, instance=None): - """ - Given a dictionary of deserialized field values, either update - an existing model instance, or create a new model instance. - """ - if instance is not None: - instance.email = attrs.get('email', instance.email) - instance.content = attrs.get('content', instance.content) - instance.created = attrs.get('created', instance.created) - return instance - return Comment(**attrs) - -The first part of serializer class defines the fields that get serialized/deserialized. The `restore_object` method defines how fully fledged instances get created when deserializing data. - -The `restore_object` method is optional, and is only required if we want our serializer to support deserialization into fully fledged object instances. If we don't define this method, then deserializing data will simply return a dictionary of items. - ## Serializing objects -We can now use `CommentSerializer` to serialize a comment, or list of comments. Again, using the `Serializer` class looks a lot like using a `Form` class. +We can now use `CommentSerializer` to serialize a comment, or list of comments. Again, using the `Serializer` class looks a lot like using a `Form` class. serializer = CommentSerializer(comment) serializer.data @@ -67,24 +51,9 @@ At this point we've translated the model instance into Python native datatypes. json # '{"email": "leila@example.com", "content": "foo bar", "created": "2012-08-22T16:20:09.822"}' -### Customizing field representation - -Sometimes when serializing objects, you may not want to represent everything exactly the way it is in your model. - -If you need to customize the serialized value of a particular field, you can do this by creating a `transform_` method. For example if you needed to render some markdown from a text field: - - description = serializers.CharField() - description_html = serializers.CharField(source='description', read_only=True) - - def transform_description_html(self, obj, value): - from django.contrib.markup.templatetags.markup import markdown - return markdown(value) - -These methods are essentially the reverse of `validate_` (see *Validation* below.) - ## Deserializing objects -Deserialization is similar. First we parse a stream into Python native datatypes... +Deserialization is similar. First we parse a stream into Python native datatypes... from StringIO import StringIO from rest_framework.parsers import JSONParser @@ -92,26 +61,90 @@ Deserialization is similar. First we parse a stream into Python native datatype stream = StringIO(json) data = JSONParser().parse(stream) -...then we restore those native datatypes into a fully populated object instance. +...then we restore those native datatypes into a dictionary of validated data. serializer = CommentSerializer(data=data) serializer.is_valid() # True - serializer.object - # + serializer.validated_data + # {'content': 'foo bar', 'email': 'leila@example.com', 'created': datetime.datetime(2012, 08, 22, 16, 20, 09, 822243)} + +## Saving instances + +If we want to be able to return complete object instances based on the validated data we need to implement one or both of the `.create()` and `update()` methods. For example: + + class CommentSerializer(serializers.Serializer): + email = serializers.EmailField() + content = serializers.CharField(max_length=200) + created = serializers.DateTimeField() + + def create(self, validated_data): + return Comment(**validated_data) + + def update(self, instance, validated_data): + instance.email = validated_data.get('email', instance.email) + instance.content = validated_data.get('content', instance.content) + instance.created = validated_data.get('created', instance.created) + return instance + +If your object instances correspond to Django models you'll also want to ensure that these methods save the object to the database. For example, if `Comment` was a Django model, the methods might look like this: + + def create(self, validated_data): + return Comment.objcts.create(**validated_data) + + def update(self, instance, validated_data): + instance.email = validated_data.get('email', instance.email) + instance.content = validated_data.get('content', instance.content) + instance.created = validated_data.get('created', instance.created) + instance.save() + return instance + +Now when deserializing data, we can call `.save()` to return an object instance, based on the validated data. + + comment = serializer.save() + +Calling `.save()` will either create a new instance, or update an existing instance, depending on if an existing instance was passed when instantiating the serializer class: + + # .save() will create a new instance. + serializer = CommentSerializer(data=data) + + # .save() will update the existing `comment` instance. + serializer = CommentSerializer(comment, data=data) -When deserializing data, we can either create a new instance, or update an existing instance. +Both the `.create()` and `.update()` methods are optional. You can implement either neither, one, or both of them, depending on the use-case for your serializer class. - serializer = CommentSerializer(data=data) # Create new instance - serializer = CommentSerializer(comment, data=data) # Update `comment` +#### Passing additional attributes to `.save()` -By default, serializers must be passed values for all required fields or they will throw validation errors. You can use the `partial` argument in order to allow partial updates. +Sometimes you'll want your view code to be able to inject additional data at the point of saving the instance. This additional data might include information like the current user, the current time, or anything else that is not part of the request data. - serializer = CommentSerializer(comment, data={'content': u'foo bar'}, partial=True) # Update `comment` with partial data +You can do so by including additional keyword arguments when calling `.save()`. For example: + + serializer.save(owner=request.user) + +Any additional keyword arguments will be included in the `validated_data` argument when `.create()` or `.update()` are called. + +#### Overriding `.save()` directly. + +In some cases the `.create()` and `.update()` method names may not be meaningful. For example, in a contact form we may not be creating new instances, but instead sending an email or other message. + +In these cases you might instead choose to override `.save()` directly, as being more readable and meaningful. + +For example: + + class ContactForm(serializers.Serializer): + email = serializers.EmailField() + message = serializers.CharField() + + def save(self): + email = self.validated_data['email'] + message = self.validated_data['message'] + send_email(from=email, message=message) + +Note that in the case above we're now having to access the serializer `.validated_data` property directly. ## Validation -When deserializing data, you always need to call `is_valid()` before attempting to access the deserialized object. If any validation errors occur, the `.errors` property will contain a dictionary representing the resulting error messages. For example: +When deserializing data, you always need to call `is_valid()` before attempting to access the validated data, or save an object instance. If any validation errors occur, the `.errors` property will contain a dictionary representing the resulting error messages. For example: serializer = CommentSerializer(data={'email': 'foobar', 'content': 'baz'}) serializer.is_valid() @@ -119,17 +152,26 @@ When deserializing data, you always need to call `is_valid()` before attempting serializer.errors # {'email': [u'Enter a valid e-mail address.'], 'created': [u'This field is required.']} -Each key in the dictionary will be the field name, and the values will be lists of strings of any error messages corresponding to that field. The `non_field_errors` key may also be present, and will list any general validation errors. +Each key in the dictionary will be the field name, and the values will be lists of strings of any error messages corresponding to that field. The `non_field_errors` key may also be present, and will list any general validation errors. The name of the `non_field_errors` key may be customized using the `NON_FIELD_ERRORS_KEY` REST framework setting. When deserializing a list of items, errors will be returned as a list of dictionaries representing each of the deserialized items. +#### Raising an exception on invalid data + +The `.is_valid()` method takes an optional `raise_exception` flag that will cause it to raise a `serializers.ValidationError` exception if there are validation errors. + +These exceptions are automatically dealt with by the default exception handler that REST framework provides, and will return `HTTP 400 Bad Request` responses by default. + + # Return a 400 response if the data was invalid. + serializer.is_valid(raise_exception=True) + #### Field-level validation -You can specify custom field-level validation by adding `.validate_` methods to your `Serializer` subclass. These are analogous to `.clean_` methods on Django forms, but accept slightly different arguments. +You can specify custom field-level validation by adding `.validate_` methods to your `Serializer` subclass. These are similar to the `.clean_` methods on Django forms. -They take a dictionary of deserialized attributes as a first argument, and the field name in that dictionary as a second argument (which will be either the name of the field or the value of the `source` argument to the field, if one was provided). +These methods take a single argument, which is the field value that requires validation. -Your `validate_` methods should either just return the `attrs` dictionary or raise a `ValidationError`. For example: +Your `validate_` methods should return the validated value or raise a `ValidationError`. For example: from rest_framework import serializers @@ -137,18 +179,17 @@ Your `validate_` methods should either just return the `attrs` dictio title = serializers.CharField(max_length=100) content = serializers.CharField() - def validate_title(self, attrs, source): + def validate_title(self, value): """ Check that the blog post is about Django. """ - value = attrs[source] - if "django" not in value.lower(): + if 'django' not in value.lower(): raise serializers.ValidationError("Blog post is not about Django") - return attrs + return value #### Object-level validation -To do any other validation that requires access to multiple fields, add a method called `.validate()` to your `Serializer` subclass. This method takes a single argument, which is the `attrs` dictionary. It should raise a `ValidationError` if necessary, or just return `attrs`. For example: +To do any other validation that requires access to multiple fields, add a method called `.validate()` to your `Serializer` subclass. This method takes a single argument, which is a dictionary of field values. It should raise a `ValidationError` if necessary, or just return the validated values. For example: from rest_framework import serializers @@ -157,24 +198,48 @@ To do any other validation that requires access to multiple fields, add a method start = serializers.DateTimeField() finish = serializers.DateTimeField() - def validate(self, attrs): + def validate(self, data): """ Check that the start is before the stop. """ - if attrs['start'] > attrs['finish']: + if data['start'] > data['finish']: raise serializers.ValidationError("finish must occur after start") - return attrs + return data + +#### Validators + +Individual fields on a serializer can include validators, by declaring them on the field instance, for example: + + def multiple_of_ten(value): + if value % 10 != 0: + raise serializers.ValidationError('Not a multiple of ten') -## Saving object state + class GameRecord(serializers.Serializer): + score = IntegerField(validators=[multiple_of_ten]) + ... -To save the deserialized objects created by a serializer, call the `.save()` method: +Serializer classes can also include reusable validators that are applied to the complete set of field data. These validators are included by declaring them on an inner `Meta` class, like so: + + class EventSerializer(serializers.Serializer): + name = serializers.CharField() + room_number = serializers.IntegerField(choices=[101, 102, 103, 201]) + date = serializers.DateField() + + class Meta: + # Each room only has one event per day. + validators = UniqueTogetherValidator( + queryset=Event.objects.all(), + fields=['room_number', 'date'] + ) - if serializer.is_valid(): - serializer.save() +For more information see the [validators documentation](validators.md). -The default behavior of the method is to simply call `.save()` on the deserialized object instance. You can override the default save behaviour by overriding the `.save_object(obj)` method on the serializer class. +## Partial updates -The generic views provided by REST framework call the `.save()` method when updating or creating entities. +By default, serializers must be passed values for all required fields or they will raise validation errors. You can use the `partial` argument in order to allow partial updates. + + # Update `comment` with partial data + serializer = CommentSerializer(comment, data={'content': u'foo bar'}, partial=True) ## Dealing with nested objects @@ -214,6 +279,8 @@ Validation of nested objects will work the same as before. Errors with nested o serializer.errors # {'user': {'email': [u'Enter a valid e-mail address.']}, 'created': [u'This field is required.']} +**TODO** Document create and update for nested serializers + ## Dealing with multiple objects The `Serializer` class can also handle serializing or deserializing lists of objects. @@ -233,6 +300,8 @@ To serialize a queryset or list of objects instead of a single object instance, #### Deserializing multiple objects for creation +**TODO** + To deserialize a list of object data, and create multiple object instances in a single pass, you should also set the `many=True` flag, and pass a list of data to be deserialized. This allows you to write views that create multiple items when a `POST` request is made. @@ -250,6 +319,8 @@ For example: #### Deserializing multiple objects for update +**TODO** + You can also deserialize a list of objects as part of a bulk update of multiple existing items. In this case you need to supply both an existing list or queryset of items, as well as a list of data to update those items with. @@ -278,32 +349,6 @@ When performing a bulk update you may want to allow new items to be created, and Passing `allow_add_remove=True` ensures that any update operations will completely overwrite the existing queryset, rather than simply updating existing objects. -#### How identity is determined when performing bulk updates - -Performing a bulk update is slightly more complicated than performing a bulk creation, because the serializer needs a way to determine how the items in the incoming data should be matched against the existing object instances. - -By default the serializer class will use the `id` key on the incoming data to determine the canonical identity of an object. If you need to change this behavior you should override the `get_identity` method on the `Serializer` class. For example: - - class AccountSerializer(serializers.Serializer): - slug = serializers.CharField(max_length=100) - created = serializers.DateTimeField() - ... # Various other fields - - def get_identity(self, data): - """ - This hook is required for bulk update. - We need to override the default, to use the slug as the identity. - - Note that the data has not yet been validated at this point, - so we need to deal gracefully with incorrect datatypes. - """ - try: - return data.get('slug', None) - except AttributeError: - return None - -To map the incoming data items to their corresponding object instances, the `.get_identity()` method will be called both against the incoming data, and against the serialized representation of the existing objects. - ## Including extra context There are some cases where you need to provide extra context to the serializer in addition to the object being serialized. One common case is if you're using a serializer that includes hyperlinked relations, which requires the serializer to have access to the current request so that it can properly generate fully qualified URLs. @@ -314,28 +359,46 @@ You can provide arbitrary additional context by passing a `context` argument whe serializer.data # {'id': 6, 'owner': u'denvercoder9', 'created': datetime.datetime(2013, 2, 12, 09, 44, 56, 678870), 'details': 'http://example.com/accounts/6/details'} -The context dictionary can be used within any serializer field logic, such as a custom `.to_native()` method, by accessing the `self.context` attribute. +The context dictionary can be used within any serializer field logic, such as a custom `.to_representation()` method, by accessing the `self.context` attribute. + +--- -- # ModelSerializer -Often you'll want serializer classes that map closely to model definitions. -The `ModelSerializer` class lets you automatically create a Serializer class with fields that correspond to the Model fields. +Often you'll want serializer classes that map closely to Django model definitions. + +The `ModelSerializer` class provides a shortcut that lets you automatically create a `Serializer` class with fields that correspond to the Model fields. + +**The `ModelSerializer` class is the same as a regular `Serializer` class, except that**: + +* It will automatically generate a set of fields for you, based on the model. +* It will automatically generate validators for the serializer, such as unique_together validators. +* It includes simple default implementations of `.create()` and `.update()`. + +Declaring a `ModelSerializer` looks like this: class AccountSerializer(serializers.ModelSerializer): class Meta: model = Account -By default, all the model fields on the class will be mapped to corresponding serializer fields. +By default, all the model fields on the class will be mapped to a corresponding serializer fields. -Any relationships such as foreign keys on the model will be mapped to `PrimaryKeyRelatedField`. Other models fields will be mapped to a corresponding serializer field. +Any relationships such as foreign keys on the model will be mapped to `PrimaryKeyRelatedField`. Reverse relationships are not included by default unless explicitly included as described below. ---- +#### Inspecting the generated `ModelSerializer` class. -**Note**: When validation is applied to a `ModelSerializer`, both the serializer fields, and their corresponding model fields must correctly validate. If you have optional fields on your model, make sure to correctly set `blank=True` on the model field, as well as setting `required=False` on the serializer field. +Serializer classes generate helpful verbose representation strings, that allow you to fully inspect the state of their fields. This is particularly useful when working with `ModelSerializers` where you want to determine what set of fields and validators are being automatically created for you. ---- +To do so, open the Django shell, using `python manage.py shell`, then import the serializer class, instantiate it, and print the object representation… + >>> from myapp.serializers import AccountSerializer + >>> serializer = AccountSerializer() + >>> print repr(serializer) # Or `print(repr(serializer))` in Python 3.x. + AccountSerializer(): + id = IntegerField(label='ID', read_only=True) + name = CharField(allow_blank=True, max_length=100, required=False) + owner = PrimaryKeyRelatedField(queryset=User.objects.all()) + ## Specifying which fields should be included If you only want a subset of the default fields to be used in a model serializer, you can do so using `fields` or `exclude` options, just as you would with a `ModelForm`. @@ -347,6 +410,10 @@ For example: model = Account fields = ('id', 'account_name', 'users', 'created') +The names in the `fields` option will normally map to model fields on the model class. + +Alternatively names in the `fields` options can map to properties or methods which take no arguments that exist on the model class. + ## Specifying nested serialization The default `ModelSerializer` uses primary keys for relationships, but you can also easily generate nested representations using the `depth` option: @@ -361,9 +428,24 @@ The `depth` option should be set to an integer value that indicates the depth of If you want to customize the way the serialization is done (e.g. using `allow_add_remove`) you'll need to define the field yourself. +## Specifying fields explicitly + +You can add extra fields to a `ModelSerializer` or override the default fields by declaring fields on the class, just as you would for a `Serializer` class. + + class AccountSerializer(serializers.ModelSerializer): + url = serializers.CharField(source='get_absolute_url', read_only=True) + groups = serializers.PrimaryKeyRelatedField(many=True) + + class Meta: + model = Account + +Extra fields can correspond to any property or callable on the model. + ## Specifying which fields should be read-only -You may wish to specify multiple fields as read-only. Instead of adding each field explicitly with the `read_only=True` attribute, you may use the `read_only_fields` Meta option, like so: +You may wish to specify multiple fields as read-only. Instead of adding each field explicitly with the `read_only=True` attribute, you may use the shortcut Meta option, `read_only_fields`. + +This option should be a list or tuple of field names, and is declared as follows: class AccountSerializer(serializers.ModelSerializer): class Meta: @@ -373,38 +455,27 @@ You may wish to specify multiple fields as read-only. Instead of adding each fi Model fields which have `editable=False` set, and `AutoField` fields will be set to read-only by default, and do not need to be added to the `read_only_fields` option. -## Specifying which fields should be write-only +## Specifying additional keyword arguments for fields. + +There is also a shortcut allowing you to specify arbitrary additional keyword arguments on fields, using the `extra_kwargs` option. Similarly to `read_only_fields` this means you do not need to explicitly declare the field on the serializer. -You may wish to specify multiple fields as write-only. Instead of adding each field explicitly with the `write_only=True` attribute, you may use the `write_only_fields` Meta option, like so: +This option is a dictionary, mapping field names to a dictionary of keyword arguments. For example: class CreateUserSerializer(serializers.ModelSerializer): class Meta: model = User fields = ('email', 'username', 'password') - write_only_fields = ('password',) # Note: Password field is write-only - - def restore_object(self, attrs, instance=None): - """ - Instantiate a new User instance. - """ - assert instance is None, 'Cannot update users with CreateUserSerializer' - user = User(email=attrs['email'], username=attrs['username']) - user.set_password(attrs['password']) + extra_kwargs = {'password': {'write_only': True}} + + def create(self, validated_data): + user = User( + email=validated_data['email'], + username=validated_data['username'] + ) + user.set_password(validated_data['password']) + user.save() return user -## Specifying fields explicitly - -You can add extra fields to a `ModelSerializer` or override the default fields by declaring fields on the class, just as you would for a `Serializer` class. - - class AccountSerializer(serializers.ModelSerializer): - url = serializers.CharField(source='get_absolute_url', read_only=True) - groups = serializers.PrimaryKeyRelatedField(many=True) - - class Meta: - model = Account - -Extra fields can correspond to any property or callable on the model. - ## Relational fields When serializing model instances, there are a number of different ways you might choose to represent relationships. The default representation for `ModelSerializer` is to use the primary keys of the related instances. @@ -415,7 +486,7 @@ For full details see the [serializer relations][relations] documentation. ## Inheritance of the 'Meta' class -The inner `Meta` class on serializers is not inherited from parent classes by default. This is the same behaviour as with Django's `Model` and `ModelForm` classes. If you want the `Meta` class to inherit from a parent class you must do so explicitly. For example: +The inner `Meta` class on serializers is not inherited from parent classes by default. This is the same behavior as with Django's `Model` and `ModelForm` classes. If you want the `Meta` class to inherit from a parent class you must do so explicitly. For example: class AccountSerializer(MyBaseSerializer): class Meta(MyBaseSerializer.Meta): @@ -446,7 +517,7 @@ There needs to be a way of determining which views should be used for hyperlinki By default hyperlinks are expected to correspond to a view name that matches the style `'{model_name}-detail'`, and looks up the instance by a `pk` keyword argument. -You can change the field that is used for object lookups by setting the `lookup_field` option. The value of this option should correspond both with a kwarg in the URL conf, and with a field on the model. For example: +You can change the field that is used for object lookups by setting the `lookup_field` option. The value of this option should correspond both with a kwarg in the URL conf, and with a field on the model. For example: class AccountSerializer(serializers.HyperlinkedModelSerializer): class Meta: @@ -460,8 +531,8 @@ For more specific requirements such as specifying a different lookup for each fi class AccountSerializer(serializers.HyperlinkedModelSerializer): url = serializers.HyperlinkedIdentityField( - view_name='account_detail', - lookup_field='account_name' + view_name='account-detail', + lookup_field='slug' ) users = serializers.HyperlinkedRelatedField( view_name='user-detail', @@ -486,7 +557,7 @@ You can also override this on a per-serializer basis by using the `url_field_nam fields = ('account_url', 'account_name', 'users', 'created') url_field_name = 'account_url' -**Note**: The generic view implementations normally generate a `Location` header in response to successful `POST` requests. Serializers using `url_field_name` option will not have this header automatically included by the view. If you need to do so you will ned to also override the view's `get_success_headers()` method. +**Note**: The generic view implementations normally generate a `Location` header in response to successful `POST` requests. Serializers using `url_field_name` option will not have this header automatically included by the view. If you need to do so you will ned to also override the view's `get_success_headers()` method. You can also override the URL field's view name and lookup field without overriding the field explicitly, by using the `view_name` and `lookup_field` options, like so: @@ -499,8 +570,12 @@ You can also override the URL field's view name and lookup field without overrid --- +**TODO**: ListSerializer, BaseSerializer, overriding `to_representation` on serializers. + # Advanced serializer usage +**TODO**: Tweak section below + You can create customized subclasses of `ModelSerializer` or `HyperlinkedModelSerializer` that use a different set of default fields. Doing so should be considered advanced usage, and will only be needed if you have some particular serializer requirements that you often need to repeat. @@ -528,7 +603,7 @@ For example, if you wanted to be able to set which fields should be used by a se # Instantiate the superclass normally super(DynamicFieldsModelSerializer, self).__init__(*args, **kwargs) - if fields: + if fields is not None: # Drop any fields that are not specified in the `fields` argument. allowed = set(fields) existing = set(self.fields.keys()) @@ -548,7 +623,9 @@ This would then allow you to do the following: >>> print UserSerializer(user, fields=('id', 'email')) {'id': 2, 'email': 'jon@example.com'} -## Customising the default fields +## Customizing the default fields + +**TODO**: Remove and note incoming API. The `field_mapping` attribute is a dictionary that maps model classes to serializer classes. Overriding the attribute will let you set a different set of default serializer classes. -- cgit v1.2.3 From 1ffe4857ec51c3b6c5a90059cca0fb82820d759e Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 27 Nov 2014 08:10:52 +0000 Subject: Support callable attributes in dotted source. Closes #2142. --- rest_framework/fields.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 3cf34886..ca770f77 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -68,8 +68,8 @@ def get_attribute(instance, attrs): return instance[attr] except (KeyError, TypeError, AttributeError): raise exc - if is_simple_callable(instance): - return instance() + if is_simple_callable(instance): + return instance() return instance -- cgit v1.2.3 From 2fe6709769048944127c8c48af4364101914e690 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 27 Nov 2014 11:00:57 +0000 Subject: Fix sponsor images for mkdocs --- docs/topics/kickstarter-announcement.md | 142 ++++++++++++++++---------------- 1 file changed, 71 insertions(+), 71 deletions(-) diff --git a/docs/topics/kickstarter-announcement.md b/docs/topics/kickstarter-announcement.md index e8bad95b..91ead751 100644 --- a/docs/topics/kickstarter-announcement.md +++ b/docs/topics/kickstarter-announcement.md @@ -43,20 +43,20 @@ We've now blazed way past all our goals, with a staggering £30,000 (~$50,000), Our platinum sponsors have each made a hugely substantial contribution to the future development of Django REST framework, and I simply can't thank them enough.
                  @@ -68,31 +68,31 @@ Our platinum sponsors have each made a hugely substantial contribution to the fu Our gold sponsors include companies large and small. Many thanks for their significant funding of the project and their commitment to sustainable open-source development. @@ -105,41 +105,41 @@ Our gold sponsors include companies large and small. Many thanks for their signi The serious financial contribution that our silver sponsors have made is very much appreciated. I'd like to say a particular thank you to individuals who have choosen to privately support the project at this level.
                  -- cgit v1.2.3 From fceeecf1e229de5ecf8930d3aacf4ef914d50b20 Mon Sep 17 00:00:00 2001 From: José Padilla Date: Thu, 27 Nov 2014 09:06:37 -0400 Subject: Update to latest minor Django versions --- tox.ini | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tox.ini b/tox.ini index 11ea17b9..d5cb9ef9 100644 --- a/tox.ini +++ b/tox.ini @@ -10,10 +10,10 @@ commands = ./runtests.py --fast setenv = PYTHONDONTWRITEBYTECODE=1 deps = - django14: django==1.4.11 - django15: django==1.5.6 - django16: Django==1.6.3 - django17: Django==1.7 + django14: Django==1.4.16 + django15: Django==1.5.11 + django16: Django==1.6.8 + django17: Django==1.7.1 djangomaster: https://github.com/django/django/zipball/master {py26,py27}-django{14,15,16,17}: django-guardian==1.2.3 {py26,py27}-django{14,15,16}: oauth2==1.5.211 -- cgit v1.2.3 From 8579222cbdff98aef50e244e179b7c32a76ce8ad Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 27 Nov 2014 15:14:11 +0000 Subject: Fix for nested attribute lookups where one is a callable --- rest_framework/fields.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index ca770f77..2e2a68b8 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -69,7 +69,7 @@ def get_attribute(instance, attrs): except (KeyError, TypeError, AttributeError): raise exc if is_simple_callable(instance): - return instance() + instance = instance() return instance -- cgit v1.2.3 From 6b2033f7894319c827c04a5caded7187797fc0b3 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 27 Nov 2014 16:40:58 +0000 Subject: Drop transform_ --- rest_framework/serializers.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 00362dbb..e86e67f7 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -371,14 +371,9 @@ class Serializer(BaseSerializer): for field in fields: attribute = field.get_attribute(instance) if attribute is None: - value = None + ret[field.field_name] = None else: - value = field.to_representation(attribute) - transform_method = getattr(self, 'transform_' + field.field_name, None) - if transform_method is not None: - value = transform_method(value) - - ret[field.field_name] = value + ret[field.field_name] = field.to_representation(attribute) return ret -- cgit v1.2.3 From d2d7e1dfde2a62ee8f6d904368dbd6581de278c9 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 27 Nov 2014 16:41:53 +0000 Subject: Drop Field.validate --- rest_framework/fields.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 2e2a68b8..ca9c479f 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -321,7 +321,6 @@ class Field(object): value = self.to_internal_value(data) self.run_validators(value) - self.validate(value) return value def run_validators(self, value): @@ -348,9 +347,6 @@ class Field(object): if errors: raise ValidationError(errors) - def validate(self, value): - pass - def to_internal_value(self, data): """ Transform the *incoming* primitive data into a native value. -- cgit v1.2.3 From c61c59f8b7260f0d6beb95c34f531e8c6c5929c9 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 27 Nov 2014 17:01:46 +0000 Subject: Notes on removal of Field.validate() and Serializer.transform_ --- docs/topics/3.0-announcement.md | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index f20a4296..c925b5f0 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -199,6 +199,33 @@ Alternatively if you want the errors to be against a specific field, use a dicti This ensures you can still write validation that compares all the input fields, but that marks the error against a particular field. +#### Removal of `transform_`. + +The under-used `transform_` on serializer classes is no longer provided. Instead you should just override `to_representation()` if you need to apply any modifications to the representation style. + +For example: + + def to_representation(self, instance): + ret = super(UserSerializer, self).to_representation(instance) + ret['username'] = ret['username'].lower() + return ret + +Dropping the extra point of API means there's now only one right way to do things. This helps with repetition and reinforcement of the core API, rather than having multiple differing approaches. + +If you absolutely need to preserve `transform_` behavior, for example, in order to provide a simpler 2.x to 3.0 upgrade, you can use a mixin, or serializer base class that add the behavior back in. For example: + + class BaseModelSerializer(ModelSerializer): + """ + A custom ModelSerializer class that preserves 2.x style `transform_` behavior. + """ + def to_representation(self, instance): + ret = super(BaseModelSerializer, self).to_representation(instance) + for key, value in ret.items(): + method = getattr(self, 'transform_' + key, None) + if method is not None: + ret[key] = method(value) + return ret + #### Differences between ModelSerializer validation and ModelForm. This change also means that we no longer use the `.full_clean()` method on model instances, but instead perform all validation explicitly on the serializer. This gives a cleaner separation, and ensures that there's no automatic validation behavior on `ModelSerializer` classes that can't also be easily replicated on regular `Serializer` classes. @@ -544,6 +571,19 @@ The `default` argument is also available and always implies that the field is no The previous field implementations did not forcibly coerce returned values into the correct type in many cases. For example, an `IntegerField` would return a string output if the attribute value was a string. We now more strictly coerce to the correct return type, leading to more constrained and expected behavior. +#### Removal of `.validate()`. + +The `.validate()` method is now removed from field classes. This method was in any case undocumented and not public API. You should instead simply override `to_internal_value()`. + + class UppercaseCharField(serializers.CharField): + def to_internal_value(self, data): + value = super(UppercaseCharField, self).to_internal_value(data) + if value != value.upper(): + raise serializers.ValidationError('The input should be uppercase only.') + return value + +Previously validation errors could be raised in either `.to_native()` or `.validate()`, making it non-obvious which should be used. Providing only a single point of API ensures more repetition and reinforcement of the core API. + #### The `ListField` class. The `ListField` class has now been added. This field validates list input. It takes a `child` keyword argument which is used to specify the field used to validate each item in the list. For example: -- cgit v1.2.3 From 34ca8cd2a5c030d9acc89720876ba9583c1dc988 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 09:56:44 +0000 Subject: Moar docs. Amazing. --- docs/api-guide/serializers.md | 306 ++++++++++++++++++++++++++++++++++------ docs/topics/3.0-announcement.md | 12 +- rest_framework/serializers.py | 4 +- 3 files changed, 273 insertions(+), 49 deletions(-) diff --git a/docs/api-guide/serializers.md b/docs/api-guide/serializers.md index e476d957..6c370f75 100644 --- a/docs/api-guide/serializers.md +++ b/docs/api-guide/serializers.md @@ -167,11 +167,11 @@ These exceptions are automatically dealt with by the default exception handler t #### Field-level validation -You can specify custom field-level validation by adding `.validate_` methods to your `Serializer` subclass. These are similar to the `.clean_` methods on Django forms. +You can specify custom field-level validation by adding `.validate_` methods to your `Serializer` subclass. These are similar to the `.clean_` methods on Django forms. These methods take a single argument, which is the field value that requires validation. -Your `validate_` methods should return the validated value or raise a `ValidationError`. For example: +Your `validate_` methods should return the validated value or raise a `serializers.ValidationError`. For example: from rest_framework import serializers @@ -317,6 +317,20 @@ For example: # True serializer.save() # `.save()` will be called on each deserialized instance +The default implementation for multiple object creation is to simply call `.create()` for each item in the list. If you want to customize this behavior, you'll need to customize the `.create()` method on `ListSerializer` class that is used when `many=True` is passed. + +For example: + + class BookListSerializer(serializers.ListSerializer): + def create(self, validated_data): + books = [Book(**item) for item in validated_data] + return Book.objects.bulk_create(books) + + class BookSerializer(serializers.Serializer): + … + class Meta: + list_serializer_class = BookListSerializer + #### Deserializing multiple objects for update **TODO** @@ -570,15 +584,253 @@ You can also override the URL field's view name and lookup field without overrid --- -**TODO**: ListSerializer, BaseSerializer, overriding `to_representation` on serializers. +# ListSerializer + +The `ListSerializer` class provides the behavior for serializing and validating multiple objects at once. You won't *typically* need to use `ListSerializer` directly, but should instead simply pass `many=True` when instantiating a serializer. + +When a serializer is instantiated and `many=True` is passed, a `ListSerializer` instance will be created. The serializer class then becomes a child of the parent `ListSerializer` + +There *are* a few use cases when you might want to customize the `ListSerializer` behavior. For example: + +* You want to provide particular validation of the lists, such as always ensuring that there is at least one element in a list. +* You want to customize the create or update behavior of multiple objects. + +For these cases you can modify the class that is used when `many=True` is passed, by using the `list_serializer_class` option on the serializer `Meta` class. + +For example: + + class CustomListSerializer(serializers.ListSerializer): + ... + + class CustomSerializer(serializers.Serializer): + ... + class Meta: + list_serializer_class = CustomListSerializer + +#### Customizing `.create()` for multiple objects. + +The default implementation for multiple object creation is to simply call `.create()` for each item in the list. If you want to customize this behavior, you'll need to customize the `.create()` method on `ListSerializer` class that is used when `many=True` is passed. + +For example: + + class BookListSerializer(serializers.ListSerializer): + def create(self, validated_data): + books = [Book(**item) for item in validated_data] + return Book.objects.bulk_create(books) + + class BookSerializer(serializers.Serializer): + ... + class Meta: + list_serializer_class = BookListSerializer + +#### Customizing `.update()` for multiple objects. + +By default the `ListSerializer` class does not support multiple updates. This is because the behavior that should be expected for insertions and deletions is ambiguous. + +To support multiple updates you'll need to do so explicitly. When writing your multiple update code make sure to keep the following in mind: + +* How do you determine which instance should be updated for each item in the list of data? +* How should insertions be handled? Are they invalid, or do they create new objects? +* How should removals be handled? Do they imply object deletion, or removing a relationship? Should they be silently ignored, or are they invalid? +* How should ordering be handled? Does changing the position of two items imply any state change or is it ignored? + +Here's an example of how you might choose to implement multiple updates: + + class BookListSerializer(serializers.ListSerializer): + def update(self, instance, validated_data): + # Maps for id->instance and id->data item. + book_mapping = {book.id: book for book in instance} + data_mapping = {item['id']: item for item in validated_data} + + # Perform creations and updates. + ret = [] + for book_id, data in data_mapping.items(): + book = book_mapping.get(book_id, None): + if book is None: + ret.append(self.child.create(data)) + else: + ret.append(self.child.update(book, data)) + + # Perform deletions. + for book_id, book in book_mapping.items(): + if book_id not in data_mapping: + book.delete() + + return ret + + class BookSerializer(serializers.Serializer): + ... + class Meta: + list_serializer_class = BookListSerializer + +--- + +# BaseSerializer + +`BaseSerializer` class that can be used to easily support alternative serialization and deserialization styles. + +This class implements the same basic API as the `Serializer` class: + +* `.data` - Returns the outgoing primitive representation. +* `.is_valid()` - Deserializes and validates incoming data. +* `.validated_data` - Returns the validated incoming data. +* `.errors` - Returns an errors during validation. +* `.save()` - Persists the validated data into an object instance. + +There are four methods that can be overridden, depending on what functionality you want the serializer class to support: + +* `.to_representation()` - Override this to support serialization, for read operations. +* `.to_internal_value()` - Override this to support deserialization, for write operations. +* `.create()` and `.update()` - Overide either or both of these to support saving instances. + +Because this class provides the same interface as the `Serializer` class, you can use it with the existing generic class based views exactly as you would for a regular `Serializer` or `ModelSerializer`. + +The only difference you'll notice when doing so is the `BaseSerializer` classes will not generate HTML forms in the browsable API. This is because the data they return does not include all the field information that would allow each field to be rendered into a suitable HTML input. + +##### Read-only `BaseSerializer` classes. + +To implement a read-only serializer using the `BaseSerializer` class, we just need to override the `.to_representation()` method. Let's take a look at an example using a simple Django model: + + class HighScore(models.Model): + created = models.DateTimeField(auto_now_add=True) + player_name = models.CharField(max_length=10) + score = models.IntegerField() + +It's simple to create a read-only serializer for converting `HighScore` instances into primitive data types. + + class HighScoreSerializer(serializers.BaseSerializer): + def to_representation(self, obj): + return { + 'score': obj.score, + 'player_name': obj.player_name + } + +We can now use this class to serialize single `HighScore` instances: + + @api_view(['GET']) + def high_score(request, pk): + instance = HighScore.objects.get(pk=pk) + serializer = HighScoreSerializer(instance) + return Response(serializer.data) + +Or use it to serialize multiple instances: + + @api_view(['GET']) + def all_high_scores(request): + queryset = HighScore.objects.order_by('-score') + serializer = HighScoreSerializer(queryset, many=True) + return Response(serializer.data) + +##### Read-write `BaseSerializer` classes. + +To create a read-write serializer we first need to implement a `.to_internal_value()` method. This method returns the validated values that will be used to construct the object instance, and may raise a `ValidationError` if the supplied data is in an incorrect format. + +Once you've implemented `.to_internal_value()`, the basic validation API will be available on the serializer, and you will be able to use `.is_valid()`, `.validated_data` and `.errors`. + +If you want to also support `.save()` you'll need to also implement either or both of the `.create()` and `.update()` methods. + +Here's a complete example of our previous `HighScoreSerializer`, that's been updated to support both read and write operations. + + class HighScoreSerializer(serializers.BaseSerializer): + def to_internal_value(self, data): + score = data.get('score') + player_name = data.get('player_name') + + # Perform the data validation. + if not score: + raise ValidationError({ + 'score': 'This field is required.' + }) + if not player_name: + raise ValidationError({ + 'player_name': 'This field is required.' + }) + if len(player_name) > 10: + raise ValidationError({ + 'player_name': 'May not be more than 10 characters.' + }) + + # Return the validated values. This will be available as + # the `.validated_data` property. + return { + 'score': int(score), + 'player_name': player_name + } + + def to_representation(self, obj): + return { + 'score': obj.score, + 'player_name': obj.player_name + } + + def create(self, validated_data): + return HighScore.objects.create(**validated_data) + +#### Creating new generic serializers with `BaseSerializer`. + +The `BaseSerializer` class is also useful if you want to implement new generic serializer classes for dealing with particular serialization styles, or for integrating with alternative storage backends. + +The following class is an example of a generic serializer that can handle coercing arbitrary objects into primitive representations. + + class ObjectSerializer(serializers.BaseSerializer): + """ + A read-only serializer that coerces arbitrary complex objects + into primitive representations. + """ + def to_representation(self, obj): + for attribute_name in dir(obj): + attribute = getattr(obj, attribute_name) + if attribute_name('_'): + # Ignore private attributes. + pass + elif hasattr(attribute, '__call__'): + # Ignore methods and other callables. + pass + elif isinstance(attribute, (str, int, bool, float, type(None))): + # Primitive types can be passed through unmodified. + output[attribute_name] = attribute + elif isinstance(attribute, list): + # Recursively deal with items in lists. + output[attribute_name] = [ + self.to_representation(item) for item in attribute + ] + elif isinstance(attribute, dict): + # Recursively deal with items in dictionaries. + output[attribute_name] = { + str(key): self.to_representation(value) + for key, value in attribute.items() + } + else: + # Force anything else to its string representation. + output[attribute_name] = str(attribute) + +--- # Advanced serializer usage -**TODO**: Tweak section below +## Overriding serialization and deserialization behavior -You can create customized subclasses of `ModelSerializer` or `HyperlinkedModelSerializer` that use a different set of default fields. +If you need to alter the serialization, deserialization or validation of a serializer class you can do so by overriding the `.to_representation()` or `.to_internal_value()` methods. -Doing so should be considered advanced usage, and will only be needed if you have some particular serializer requirements that you often need to repeat. +Some reasons this might be useful include... + +* Adding new behavior for new serializer base classes. +* Modifying the behavior slightly for an existing class. +* Improving serialization performance for a frequently accessed API endpoint that returns lots of data. + +The signatures for these methods are as follows: + +#### `.to_representation(self, obj)` + +Takes the object instance that requires serialization, and should return a primitive representation. Typically this means returning a structure of built-in Python datatypes. The exact types that can be handled will depend on the render classes you have configured for your API. + +#### ``.to_internal_value(self, data)`` + +Takes the unvalidated incoming data as input and should return the validated data that will be made available as `serializer.validated_data`. The return value will also be passed to the `.create()` or `.update()` methods if `.save()` is called on the serializer class. + +If any of the validation fails, then the method should raise a `serializers.ValidationError(errors)`. Typically the `errors` argument here will be a dictionary mapping field names to error messages. + +The `data` argument passed to this method will normally be the value of `request.data`, so the datatype it provides will depend on the parser classes you have configured for your API. ## Dynamically modifying fields @@ -625,47 +877,13 @@ This would then allow you to do the following: ## Customizing the default fields -**TODO**: Remove and note incoming API. - -The `field_mapping` attribute is a dictionary that maps model classes to serializer classes. Overriding the attribute will let you set a different set of default serializer classes. - -For more advanced customization than simply changing the default serializer class you can override various `get__field` methods. Doing so will allow you to customize the arguments that each serializer field is initialized with. Each of these methods may either return a field or serializer instance, or `None`. - -### get_pk_field - -**Signature**: `.get_pk_field(self, model_field)` - -Returns the field instance that should be used to represent the pk field. +REST framework 2 provided an API to allow developers to override how a `ModelSerializer` class would automatically generate the default set of fields. -### get_nested_field - -**Signature**: `.get_nested_field(self, model_field, related_model, to_many)` - -Returns the field instance that should be used to represent a related field when `depth` is specified as being non-zero. - -Note that the `model_field` argument will be `None` for reverse relationships. The `related_model` argument will be the model class for the target of the field. The `to_many` argument will be a boolean indicating if this is a to-one or to-many relationship. - -### get_related_field - -**Signature**: `.get_related_field(self, model_field, related_model, to_many)` - -Returns the field instance that should be used to represent a related field when `depth` is not specified, or when nested representations are being used and the depth reaches zero. - -Note that the `model_field` argument will be `None` for reverse relationships. The `related_model` argument will be the model class for the target of the field. The `to_many` argument will be a boolean indicating if this is a to-one or to-many relationship. - -### get_field - -**Signature**: `.get_field(self, model_field)` - -Returns the field instance that should be used for non-relational, non-pk fields. - -### Example +This API included the `.get_field()`, `.get_pk_field()` and other methods. -The following custom model serializer could be used as a base class for model serializers that should always exclude the pk by default. +Because the serializers have been fundamentally redesigned with 3.0 this API no longer exists. You can still modify the fields that get created but you'll need to refer to the source code, and be aware that if the changes you make are against private bits of API then they may be subject to change. - class NoPKModelSerializer(serializers.ModelSerializer): - def get_pk_field(self, model_field): - return None +A new interface for controlling this behavior is currently planned for REST framework 3.1. --- diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index c925b5f0..9087e2ae 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -413,7 +413,11 @@ There are four methods that can be overridden, depending on what functionality y * `.to_representation()` - Override this to support serialization, for read operations. * `.to_internal_value()` - Override this to support deserialization, for write operations. -* `.create()` and `.update()` - Overide either or both of these to support saving instances. +* `.create()` and `.update()` - Override either or both of these to support saving instances. + +Because this class provides the same interface as the `Serializer` class, you can use it with the existing generic class based views exactly as you would for a regular `Serializer` or `ModelSerializer`. + +The only difference you'll notice when doing so is the `BaseSerializer` classes will not generate HTML forms in the browsable API. This is because the data they return does not include all the field information that would allow each field to be rendered into a suitable HTML input. ##### Read-only `BaseSerializer` classes. @@ -498,7 +502,7 @@ Here's a complete example of our previous `HighScoreSerializer`, that's been upd The `BaseSerializer` class is also useful if you want to implement new generic serializer classes for dealing with particular serialization styles, or for integrating with alternative storage backends. -The following class is an example of a generic serializer that can handle coercing aribitrary objects into primitive representations. +The following class is an example of a generic serializer that can handle coercing arbitrary objects into primitive representations. class ObjectSerializer(serializers.BaseSerializer): """ @@ -518,12 +522,12 @@ The following class is an example of a generic serializer that can handle coerci # Primitive types can be passed through unmodified. output[attribute_name] = attribute elif isinstance(attribute, list): - # Recursivly deal with items in lists. + # Recursively deal with items in lists. output[attribute_name] = [ self.to_representation(item) for item in attribute ] elif isinstance(attribute, dict): - # Recursivly deal with items in dictionarys. + # Recursively deal with items in dictionaries. output[attribute_name] = { str(key): self.to_representation(value) for key, value in attribute.items() diff --git a/rest_framework/serializers.py b/rest_framework/serializers.py index 00362dbb..14078e64 100644 --- a/rest_framework/serializers.py +++ b/rest_framework/serializers.py @@ -102,7 +102,9 @@ class BaseSerializer(Field): (key, value) for key, value in kwargs.items() if key in LIST_SERIALIZER_KWARGS ])) - return ListSerializer(*args, **list_kwargs) + meta = getattr(cls, 'Meta', None) + list_serializer_class = getattr(meta, 'list_serializer_class', ListSerializer) + return list_serializer_class(*args, **list_kwargs) def to_internal_value(self, data): raise NotImplementedError('`to_internal_value()` must be implemented.') -- cgit v1.2.3 From 276a2a52eedb97a15d85e059424870bf2d21854d Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 11:26:35 +0000 Subject: Docs on nested creates/updates and suchlike --- docs/api-guide/serializers.md | 166 +++++++++++++++++++++++++----------------- 1 file changed, 100 insertions(+), 66 deletions(-) diff --git a/docs/api-guide/serializers.md b/docs/api-guide/serializers.md index 6c370f75..cd076b4f 100644 --- a/docs/api-guide/serializers.md +++ b/docs/api-guide/serializers.md @@ -271,7 +271,9 @@ Similarly if a nested representation should be a list of items, you should pass content = serializers.CharField(max_length=200) created = serializers.DateTimeField() -Validation of nested objects will work the same as before. Errors with nested objects will be nested under the field name of the nested object. +## Writable nested representations + +When dealing with nested representations that support deserializing the data, an errors with nested objects will be nested under the field name of the nested object. serializer = CommentSerializer(data={'user': {'email': 'foobar', 'username': 'doe'}, 'content': 'baz'}) serializer.is_valid() @@ -279,89 +281,117 @@ Validation of nested objects will work the same as before. Errors with nested o serializer.errors # {'user': {'email': [u'Enter a valid e-mail address.']}, 'created': [u'This field is required.']} -**TODO** Document create and update for nested serializers +Similarly, the `.validated_data` property will include nested data structures. -## Dealing with multiple objects +#### Writing `.create()` methods for nested representations -The `Serializer` class can also handle serializing or deserializing lists of objects. +If you're supporting writable nested representations you'll need to write `.create()` or `.update()` methods that handle saving multiple objects. -#### Serializing multiple objects +The following example demonstrates how you might handle creating a user with a nested profile object. -To serialize a queryset or list of objects instead of a single object instance, you should pass the `many=True` flag when instantiating the serializer. You can then pass a queryset or list of objects to be serialized. + class UserSerializer(serializers.ModelSerializer): + profile = ProfileSerializer() - queryset = Book.objects.all() - serializer = BookSerializer(queryset, many=True) - serializer.data - # [ - # {'id': 0, 'title': 'The electric kool-aid acid test', 'author': 'Tom Wolfe'}, - # {'id': 1, 'title': 'If this is a man', 'author': 'Primo Levi'}, - # {'id': 2, 'title': 'The wind-up bird chronicle', 'author': 'Haruki Murakami'} - # ] + class Meta: + model = User + fields = ('username', 'email', 'profile') -#### Deserializing multiple objects for creation + def create(self, validated_data): + profile_data = validated_data.pop('profile') + user = User.objects.create(**validated_data) + Profile.objects.create(user=user, **profile_data) + return user -**TODO** +#### Writing `.update()` methods for nested representations -To deserialize a list of object data, and create multiple object instances in a single pass, you should also set the `many=True` flag, and pass a list of data to be deserialized. +For updates you'll want to think carefully about how to handle updates to relationships. For example if the data for the relationship is `None`, or not provided, which of the following should occur? -This allows you to write views that create multiple items when a `POST` request is made. +* Set the relationship to `NULL` in the database. +* Delete the associated instance. +* Ignore the data and leave the instance as it is. +* Raise a validation error. -For example: +Here's an example for an `update()` method on our previous `UserSerializer` class. - data = [ - {'title': 'The bell jar', 'author': 'Sylvia Plath'}, - {'title': 'For whom the bell tolls', 'author': 'Ernest Hemingway'} - ] - serializer = BookSerializer(data=data, many=True) - serializer.is_valid() - # True - serializer.save() # `.save()` will be called on each deserialized instance + def update(self, instance, validated_data): + profile_data = validated_data.pop('profile') + # Unless the application properly enforces that this field is + # always set, the follow could raise a `DoesNotExist`, which + # would need to be handled. + profile = instance.profile + + user.username = validated_data.get('username', instance.username) + user.email = validated_data.get('email', instance.email) + user.save() -The default implementation for multiple object creation is to simply call `.create()` for each item in the list. If you want to customize this behavior, you'll need to customize the `.create()` method on `ListSerializer` class that is used when `many=True` is passed. + profile.is_premium_member = profile_data.get( + 'is_premium_member', + profile.is_premium_member + ) + profile.has_support_contract = profile_data.get( + 'has_support_contract', + profile.has_support_contract + ) + profile.save() -For example: + return user - class BookListSerializer(serializers.ListSerializer): - def create(self, validated_data): - books = [Book(**item) for item in validated_data] - return Book.objects.bulk_create(books) +Because the behavior of nested creates and updates can be ambiguous, and may require complex dependancies between related models, REST framework 3 requires you to always write these methods explicitly. The default `ModelSerializer` `.create()` and `.update()` methods do not include support for writable nested representations. - class BookSerializer(serializers.Serializer): - … - class Meta: - list_serializer_class = BookListSerializer +It is possible that a third party package, providing automatic support some kinds of automatic writable nested representations may be released alongside the 3.1 release. -#### Deserializing multiple objects for update +#### Handling saving related instances in model manager classes -**TODO** +An alternative to saving multiple related instances in the serializer is to write custom model manager classes handle creating the correct instances. -You can also deserialize a list of objects as part of a bulk update of multiple existing items. -In this case you need to supply both an existing list or queryset of items, as well as a list of data to update those items with. +For example, suppose we wanted to ensure that `User` instances and `Profile` instances are always created together as a pair. We might write a custom manager class that looks something like this: -This allows you to write views that update or create multiple items when a `PUT` request is made. + class UserManager(models.Manager): + ... - # Capitalizing the titles of the books - queryset = Book.objects.all() - data = [ - {'id': 3, 'title': 'The Bell Jar', 'author': 'Sylvia Plath'}, - {'id': 4, 'title': 'For Whom the Bell Tolls', 'author': 'Ernest Hemingway'} - ] - serializer = BookSerializer(queryset, data=data, many=True) - serializer.is_valid() - # True - serializer.save() # `.save()` will be called on each updated or newly created instance. + def create(self, username, email, is_premium_member=False, has_support_contract=False): + user = User(username=username, email=email) + user.save() + profile = Profile( + user=user, + is_premium_member=is_premium_member, + has_support_contract=has_support_contract + ) + profile.save() + return user -By default bulk updates will be limited to updating instances that already exist in the provided queryset. +This manager class now more nicely encapsulates that user instances and profile instances are always created at the same time. Our `.create()` method on the serializer class can now be re-written to use the new manager method. -When performing a bulk update you may want to allow new items to be created, and missing items to be deleted. To do so, pass `allow_add_remove=True` to the serializer. + def create(self, validated_data): + return User.objects.create( + username=validated_data['username'], + email=validated_data['email'] + is_premium_member=validated_data['profile']['is_premium_member'] + has_support_contract=validated_data['profile']['has_support_contract'] + ) - serializer = BookSerializer(queryset, data=data, many=True, allow_add_remove=True) - serializer.is_valid() - # True - serializer.save() # `.save()` will be called on updated or newly created instances. - # `.delete()` will be called on any other items in the `queryset`. +For more details on this approach see the Django documentation on [model managers](model-managers), and [this blogpost on using model and manger classes](encapsulation-blogpost). -Passing `allow_add_remove=True` ensures that any update operations will completely overwrite the existing queryset, rather than simply updating existing objects. +## Dealing with multiple objects + +The `Serializer` class can also handle serializing or deserializing lists of objects. + +#### Serializing multiple objects + +To serialize a queryset or list of objects instead of a single object instance, you should pass the `many=True` flag when instantiating the serializer. You can then pass a queryset or list of objects to be serialized. + + queryset = Book.objects.all() + serializer = BookSerializer(queryset, many=True) + serializer.data + # [ + # {'id': 0, 'title': 'The electric kool-aid acid test', 'author': 'Tom Wolfe'}, + # {'id': 1, 'title': 'If this is a man', 'author': 'Primo Levi'}, + # {'id': 2, 'title': 'The wind-up bird chronicle', 'author': 'Haruki Murakami'} + # ] + +#### Deserializing multiple objects + +The default behavior for deserializing multiple objects is to support multiple object creation, but not support multiple object updates. For more information on how to support or customize either of these cases, see the [ListSerializer](#ListSerializer) documentation below. ## Including extra context @@ -399,7 +429,7 @@ By default, all the model fields on the class will be mapped to a corresponding Any relationships such as foreign keys on the model will be mapped to `PrimaryKeyRelatedField`. Reverse relationships are not included by default unless explicitly included as described below. -#### Inspecting the generated `ModelSerializer` class. +#### Inspecting a `ModelSerializer` Serializer classes generate helpful verbose representation strings, that allow you to fully inspect the state of their fields. This is particularly useful when working with `ModelSerializers` where you want to determine what set of fields and validators are being automatically created for you. @@ -607,7 +637,7 @@ For example: class Meta: list_serializer_class = CustomListSerializer -#### Customizing `.create()` for multiple objects. +#### Customizing multiple create The default implementation for multiple object creation is to simply call `.create()` for each item in the list. If you want to customize this behavior, you'll need to customize the `.create()` method on `ListSerializer` class that is used when `many=True` is passed. @@ -623,7 +653,7 @@ For example: class Meta: list_serializer_class = BookListSerializer -#### Customizing `.update()` for multiple objects. +#### Customizing multiple update By default the `ListSerializer` class does not support multiple updates. This is because the behavior that should be expected for insertions and deletions is ambiguous. @@ -663,6 +693,8 @@ Here's an example of how you might choose to implement multiple updates: class Meta: list_serializer_class = BookListSerializer +It is possible that a third party package may be included alongside the 3.1 release that provides some automatic support for multiple update operations, similar to the `allow_add_remove` behavior that was present in REST framework 2. + --- # BaseSerializer @@ -687,7 +719,7 @@ Because this class provides the same interface as the `Serializer` class, you ca The only difference you'll notice when doing so is the `BaseSerializer` classes will not generate HTML forms in the browsable API. This is because the data they return does not include all the field information that would allow each field to be rendered into a suitable HTML input. -##### Read-only `BaseSerializer` classes. +##### Read-only `BaseSerializer` classes To implement a read-only serializer using the `BaseSerializer` class, we just need to override the `.to_representation()` method. Let's take a look at an example using a simple Django model: @@ -721,7 +753,7 @@ Or use it to serialize multiple instances: serializer = HighScoreSerializer(queryset, many=True) return Response(serializer.data) -##### Read-write `BaseSerializer` classes. +##### Read-write `BaseSerializer` classes To create a read-write serializer we first need to implement a `.to_internal_value()` method. This method returns the validated values that will be used to construct the object instance, and may raise a `ValidationError` if the supplied data is in an incorrect format. @@ -766,7 +798,7 @@ Here's a complete example of our previous `HighScoreSerializer`, that's been upd def create(self, validated_data): return HighScore.objects.create(**validated_data) -#### Creating new generic serializers with `BaseSerializer`. +#### Creating new base classes The `BaseSerializer` class is also useful if you want to implement new generic serializer classes for dealing with particular serialization styles, or for integrating with alternative storage backends. @@ -905,6 +937,8 @@ The [django-rest-framework-hstore][django-rest-framework-hstore] package provide [cite]: https://groups.google.com/d/topic/django-users/sVFaOfQi4wY/discussion [relations]: relations.md +[model-managers]: https://docs.djangoproject.com/en/dev/topics/db/managers/ +[encapsulation-blogpost]: http://www.dabapps.com/blog/django-models-and-encapsulation/ [mongoengine]: https://github.com/umutbozkurt/django-rest-framework-mongoengine [django-rest-framework-gis]: https://github.com/djangonauts/django-rest-framework-gis [django-rest-framework-hstore]: https://github.com/djangonauts/django-rest-framework-hstore -- cgit v1.2.3 From 0539b1be01fd9c6b842a4a8bbdf23b65af8357d1 Mon Sep 17 00:00:00 2001 From: Tymur Maryokhin Date: Fri, 28 Nov 2014 12:27:05 +0100 Subject: Update token auth view. Closes #2151. --- rest_framework/authtoken/views.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/rest_framework/authtoken/views.py b/rest_framework/authtoken/views.py index 103abb27..1fee5068 100644 --- a/rest_framework/authtoken/views.py +++ b/rest_framework/authtoken/views.py @@ -12,16 +12,13 @@ class ObtainAuthToken(APIView): permission_classes = () parser_classes = (parsers.FormParser, parsers.MultiPartParser, parsers.JSONParser,) renderer_classes = (renderers.JSONRenderer,) - serializer_class = AuthTokenSerializer - model = Token def post(self, request): - serializer = self.serializer_class(data=request.data) - if serializer.is_valid(): - user = serializer.validated_data['user'] - token, created = Token.objects.get_or_create(user=user) - return Response({'token': token.key}) - return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) + serializer = AuthTokenSerializer(data=request.data) + serializer.is_valid(raise_exception=True) + user = serializer.validated_data['user'] + token, created = Token.objects.get_or_create(user=user) + return Response({'token': token.key}) obtain_auth_token = ObtainAuthToken.as_view() -- cgit v1.2.3 From d9a09f7826d7faf7e6bfa10fc83e0b7db4689a72 Mon Sep 17 00:00:00 2001 From: Tymur Maryokhin Date: Fri, 28 Nov 2014 13:33:07 +0100 Subject: Removed unused import --- rest_framework/authtoken/views.py | 1 - 1 file changed, 1 deletion(-) diff --git a/rest_framework/authtoken/views.py b/rest_framework/authtoken/views.py index 1fee5068..b75c2e25 100644 --- a/rest_framework/authtoken/views.py +++ b/rest_framework/authtoken/views.py @@ -1,5 +1,4 @@ from rest_framework.views import APIView -from rest_framework import status from rest_framework import parsers from rest_framework import renderers from rest_framework.response import Response -- cgit v1.2.3 From 05a86e3d6539f4f33d440daf04fa8b0e9b1e371a Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 12:51:44 +0000 Subject: Docs. Minor tweaks. --- docs/topics/contributing.md | 1 - docs/topics/rest-hypermedia-hateoas.md | 8 ++++---- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/docs/topics/contributing.md b/docs/topics/contributing.md index 30a9678f..99f4fc3c 100644 --- a/docs/topics/contributing.md +++ b/docs/topics/contributing.md @@ -152,7 +152,6 @@ Documentation should be in American English. The tone of the documentation is v Some other tips: * Keep paragraphs reasonably short. -* Use double spacing after the end of sentences. * Don't use abbreviations such as 'e.g.' but instead use the long form, such as 'For example'. ## Markdown style diff --git a/docs/topics/rest-hypermedia-hateoas.md b/docs/topics/rest-hypermedia-hateoas.md index 4e3ccf92..7e6d2408 100644 --- a/docs/topics/rest-hypermedia-hateoas.md +++ b/docs/topics/rest-hypermedia-hateoas.md @@ -1,12 +1,12 @@ # REST, Hypermedia & HATEOAS -> You keep using that word "REST". I do not think it means what you think it means. +> You keep using that word "REST". I do not think it means what you think it means. > > — Mike Amundsen, [REST fest 2012 keynote][cite]. -First off, the disclaimer. The name "Django REST framework" was chosen simply to sure the project would be easily found by developers. Throughout the documentation we try to use the more simple and technically correct terminology of "Web APIs". +First off, the disclaimer. The name "Django REST framework" was decided back in early 2011 and was chosen simply to sure the project would be easily found by developers. Throughout the documentation we try to use the more simple and technically correct terminology of "Web APIs". -If you are serious about designing a Hypermedia APIs, you should look to resources outside of this documentation to help inform your design choices. +If you are serious about designing a Hypermedia API, you should look to resources outside of this documentation to help inform your design choices. The following fall into the "required reading" category. @@ -32,7 +32,7 @@ REST framework also includes [serialization] and [parser]/[renderer] components ## What REST framework doesn't provide. -What REST framework doesn't do is give you is machine readable hypermedia formats such as [HAL][hal], [Collection+JSON][collection], [JSON API][json-api] or HTML [microformats] by default, or the ability to auto-magically create fully HATEOAS style APIs that include hypermedia-based form descriptions and semantically labelled hyperlinks. Doing so would involve making opinionated choices about API design that should really remain outside of the framework's scope. +What REST framework doesn't do is give you is machine readable hypermedia formats such as [HAL][hal], [Collection+JSON][collection], [JSON API][json-api] or HTML [microformats] by default, or the ability to auto-magically create fully HATEOAS style APIs that include hypermedia-based form descriptions and semantically labelled hyperlinks. Doing so would involve making opinionated choices about API design that should really remain outside of the framework's scope. [cite]: http://vimeo.com/channels/restfest/page:2 [dissertation]: http://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm -- cgit v1.2.3 From 9e03b0843ad8b9b3481d7e64f9159daf33d04136 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 12:53:59 +0000 Subject: Drop google_analytics config since it's in the base template anyways. --- mkdocs.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/mkdocs.yml b/mkdocs.yml index 89763acd..cc31b1be 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -53,5 +53,3 @@ pages: - ['topics/kickstarter-announcement.md', 'Topics', 'Kickstarter Announcement'] - ['topics/release-notes.md', 'Topics', 'Release Notes'] - ['topics/credits.md', 'Topics', 'Credits'] - -google_analytics: ['UA-18852272-2', 'django-rest-framework.org'] -- cgit v1.2.3 From d84582fe1f5ca0fb0694e5bde40a8e34f22947f7 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 12:55:08 +0000 Subject: Add 'built with MkDocs' footer --- docs_theme/base.html | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs_theme/base.html b/docs_theme/base.html index 6bfccab2..25bd33ef 100644 --- a/docs_theme/base.html +++ b/docs_theme/base.html @@ -159,7 +159,7 @@ -- cgit v1.2.3 From c8764de7881f419c9269913ec3654fc1d904ab2e Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 13:04:42 +0000 Subject: Drop defunct tests --- tests/test_files.py | 92 -- tests/test_hyperlinkedserializers.py | 406 ------- tests/test_nullable_fields.py | 39 - tests/test_relations.py | 152 --- tests/test_relations_hyperlink.py | 93 -- tests/test_relations_nested.py | 326 ------ tests/test_relations_pk.py | 131 --- tests/test_request.py | 95 -- tests/test_serializer.py | 2004 ---------------------------------- tests/test_serializer_bulk_update.py | 158 --- tests/test_serializer_empty.py | 15 - tests/test_serializer_nested.py | 350 ------ tests/test_validation.py | 11 - 13 files changed, 3872 deletions(-) delete mode 100644 tests/test_files.py delete mode 100644 tests/test_hyperlinkedserializers.py delete mode 100644 tests/test_nullable_fields.py delete mode 100644 tests/test_relations_nested.py delete mode 100644 tests/test_serializer_empty.py diff --git a/tests/test_files.py b/tests/test_files.py deleted file mode 100644 index a5613fcb..00000000 --- a/tests/test_files.py +++ /dev/null @@ -1,92 +0,0 @@ -# from __future__ import unicode_literals -# from django.test import TestCase -# from django.utils import six -# from rest_framework import serializers -# from rest_framework.compat import BytesIO -# import datetime - - -# class UploadedFile(object): -# def __init__(self, file=None, created=None): -# self.file = file -# self.created = created or datetime.datetime.now() - - -# class UploadedFileSerializer(serializers.Serializer): -# file = serializers.FileField(required=False) -# created = serializers.DateTimeField() - -# def restore_object(self, attrs, instance=None): -# if instance: -# instance.file = attrs['file'] -# instance.created = attrs['created'] -# return instance -# return UploadedFile(**attrs) - - -# class FileSerializerTests(TestCase): -# def test_create(self): -# now = datetime.datetime.now() -# file = BytesIO(six.b('stuff')) -# file.name = 'stuff.txt' -# file.size = len(file.getvalue()) -# serializer = UploadedFileSerializer(data={'created': now}, files={'file': file}) -# uploaded_file = UploadedFile(file=file, created=now) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.object.created, uploaded_file.created) -# self.assertEqual(serializer.object.file, uploaded_file.file) -# self.assertFalse(serializer.object is uploaded_file) - -# def test_creation_failure(self): -# """ -# Passing files=None should result in an ValidationError - -# Regression test for: -# https://github.com/tomchristie/django-rest-framework/issues/542 -# """ -# now = datetime.datetime.now() - -# serializer = UploadedFileSerializer(data={'created': now}) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.object.created, now) -# self.assertIsNone(serializer.object.file) - -# def test_remove_with_empty_string(self): -# """ -# Passing empty string as data should cause file to be removed - -# Test for: -# https://github.com/tomchristie/django-rest-framework/issues/937 -# """ -# now = datetime.datetime.now() -# file = BytesIO(six.b('stuff')) -# file.name = 'stuff.txt' -# file.size = len(file.getvalue()) - -# uploaded_file = UploadedFile(file=file, created=now) - -# serializer = UploadedFileSerializer(instance=uploaded_file, data={'created': now, 'file': ''}) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.object.created, uploaded_file.created) -# self.assertIsNone(serializer.object.file) - -# def test_validation_error_with_non_file(self): -# """ -# Passing non-files should raise a validation error. -# """ -# now = datetime.datetime.now() -# errmsg = 'No file was submitted. Check the encoding type on the form.' - -# serializer = UploadedFileSerializer(data={'created': now, 'file': 'abc'}) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'file': [errmsg]}) - -# def test_validation_with_no_data(self): -# """ -# Validation should still function when no data dictionary is provided. -# """ -# uploaded_file = BytesIO(six.b('stuff')) -# uploaded_file.name = 'stuff.txt' -# uploaded_file.size = len(uploaded_file.getvalue()) -# serializer = UploadedFileSerializer(files={'file': uploaded_file}) -# self.assertFalse(serializer.is_valid()) diff --git a/tests/test_hyperlinkedserializers.py b/tests/test_hyperlinkedserializers.py deleted file mode 100644 index ff3663dd..00000000 --- a/tests/test_hyperlinkedserializers.py +++ /dev/null @@ -1,406 +0,0 @@ -# from __future__ import unicode_literals -# import json -# from django.test import TestCase -# from rest_framework import generics, status, serializers -# from django.conf.urls import patterns, url -# from rest_framework.settings import api_settings -# from rest_framework.test import APIRequestFactory -# from tests.models import ( -# Anchor, BasicModel, ManyToManyModel, BlogPost, BlogPostComment, -# Album, Photo, OptionalRelationModel -# ) - -# factory = APIRequestFactory() - - -# class BlogPostCommentSerializer(serializers.ModelSerializer): -# url = serializers.HyperlinkedIdentityField(view_name='blogpostcomment-detail') -# text = serializers.CharField() -# blog_post_url = serializers.HyperlinkedRelatedField(source='blog_post', view_name='blogpost-detail') - -# class Meta: -# model = BlogPostComment -# fields = ('text', 'blog_post_url', 'url') - - -# class PhotoSerializer(serializers.Serializer): -# description = serializers.CharField() -# album_url = serializers.HyperlinkedRelatedField(source='album', view_name='album-detail', queryset=Album.objects.all(), lookup_field='title') - -# def restore_object(self, attrs, instance=None): -# return Photo(**attrs) - - -# class AlbumSerializer(serializers.ModelSerializer): -# url = serializers.HyperlinkedIdentityField(view_name='album-detail', lookup_field='title') - -# class Meta: -# model = Album -# fields = ('title', 'url') - - -# class BasicSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = BasicModel - - -# class AnchorSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = Anchor - - -# class ManyToManySerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = ManyToManyModel - - -# class BlogPostSerializer(serializers.ModelSerializer): -# class Meta: -# model = BlogPost - - -# class OptionalRelationSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = OptionalRelationModel - - -# class BasicList(generics.ListCreateAPIView): -# queryset = BasicModel.objects.all() -# serializer_class = BasicSerializer - - -# class BasicDetail(generics.RetrieveUpdateDestroyAPIView): -# queryset = BasicModel.objects.all() -# serializer_class = BasicSerializer - - -# class AnchorDetail(generics.RetrieveAPIView): -# queryset = Anchor.objects.all() -# serializer_class = AnchorSerializer - - -# class ManyToManyList(generics.ListAPIView): -# queryset = ManyToManyModel.objects.all() -# serializer_class = ManyToManySerializer - - -# class ManyToManyDetail(generics.RetrieveAPIView): -# queryset = ManyToManyModel.objects.all() -# serializer_class = ManyToManySerializer - - -# class BlogPostCommentListCreate(generics.ListCreateAPIView): -# queryset = BlogPostComment.objects.all() -# serializer_class = BlogPostCommentSerializer - - -# class BlogPostCommentDetail(generics.RetrieveAPIView): -# queryset = BlogPostComment.objects.all() -# serializer_class = BlogPostCommentSerializer - - -# class BlogPostDetail(generics.RetrieveAPIView): -# queryset = BlogPost.objects.all() -# serializer_class = BlogPostSerializer - - -# class PhotoListCreate(generics.ListCreateAPIView): -# queryset = Photo.objects.all() -# serializer_class = PhotoSerializer - - -# class AlbumDetail(generics.RetrieveAPIView): -# queryset = Album.objects.all() -# serializer_class = AlbumSerializer -# lookup_field = 'title' - - -# class OptionalRelationDetail(generics.RetrieveUpdateDestroyAPIView): -# queryset = OptionalRelationModel.objects.all() -# serializer_class = OptionalRelationSerializer - - -# urlpatterns = patterns( -# '', -# url(r'^basic/$', BasicList.as_view(), name='basicmodel-list'), -# url(r'^basic/(?P\d+)/$', BasicDetail.as_view(), name='basicmodel-detail'), -# url(r'^anchor/(?P\d+)/$', AnchorDetail.as_view(), name='anchor-detail'), -# url(r'^manytomany/$', ManyToManyList.as_view(), name='manytomanymodel-list'), -# url(r'^manytomany/(?P\d+)/$', ManyToManyDetail.as_view(), name='manytomanymodel-detail'), -# url(r'^posts/(?P\d+)/$', BlogPostDetail.as_view(), name='blogpost-detail'), -# url(r'^comments/$', BlogPostCommentListCreate.as_view(), name='blogpostcomment-list'), -# url(r'^comments/(?P\d+)/$', BlogPostCommentDetail.as_view(), name='blogpostcomment-detail'), -# url(r'^albums/(?P\w[\w-]*)/$', AlbumDetail.as_view(), name='album-detail'), -# url(r'^photos/$', PhotoListCreate.as_view(), name='photo-list'), -# url(r'^optionalrelation/(?P<pk>\d+)/$', OptionalRelationDetail.as_view(), name='optionalrelationmodel-detail'), -# ) - - -# class TestBasicHyperlinkedView(TestCase): -# urls = 'tests.test_hyperlinkedserializers' - -# def setUp(self): -# """ -# Create 3 BasicModel instances. -# """ -# items = ['foo', 'bar', 'baz'] -# for item in items: -# BasicModel(text=item).save() -# self.objects = BasicModel.objects -# self.data = [ -# {'url': 'http://testserver/basic/%d/' % obj.id, 'text': obj.text} -# for obj in self.objects.all() -# ] -# self.list_view = BasicList.as_view() -# self.detail_view = BasicDetail.as_view() - -# def test_get_list_view(self): -# """ -# GET requests to ListCreateAPIView should return list of objects. -# """ -# request = factory.get('/basic/') -# response = self.list_view(request).render() -# self.assertEqual(response.status_code, status.HTTP_200_OK) -# self.assertEqual(response.data, self.data) - -# def test_get_detail_view(self): -# """ -# GET requests to ListCreateAPIView should return list of objects. -# """ -# request = factory.get('/basic/1') -# response = self.detail_view(request, pk=1).render() -# self.assertEqual(response.status_code, status.HTTP_200_OK) -# self.assertEqual(response.data, self.data[0]) - - -# class TestManyToManyHyperlinkedView(TestCase): -# urls = 'tests.test_hyperlinkedserializers' - -# def setUp(self): -# """ -# Create 3 BasicModel instances. -# """ -# items = ['foo', 'bar', 'baz'] -# anchors = [] -# for item in items: -# anchor = Anchor(text=item) -# anchor.save() -# anchors.append(anchor) - -# manytomany = ManyToManyModel() -# manytomany.save() -# manytomany.rel.add(*anchors) - -# self.data = [{ -# 'url': 'http://testserver/manytomany/1/', -# 'rel': [ -# 'http://testserver/anchor/1/', -# 'http://testserver/anchor/2/', -# 'http://testserver/anchor/3/', -# ] -# }] -# self.list_view = ManyToManyList.as_view() -# self.detail_view = ManyToManyDetail.as_view() - -# def test_get_list_view(self): -# """ -# GET requests to ListCreateAPIView should return list of objects. -# """ -# request = factory.get('/manytomany/') -# response = self.list_view(request) -# self.assertEqual(response.status_code, status.HTTP_200_OK) -# self.assertEqual(response.data, self.data) - -# def test_get_detail_view(self): -# """ -# GET requests to ListCreateAPIView should return list of objects. -# """ -# request = factory.get('/manytomany/1/') -# response = self.detail_view(request, pk=1) -# self.assertEqual(response.status_code, status.HTTP_200_OK) -# self.assertEqual(response.data, self.data[0]) - - -# class TestHyperlinkedIdentityFieldLookup(TestCase): -# urls = 'tests.test_hyperlinkedserializers' - -# def setUp(self): -# """ -# Create 3 Album instances. -# """ -# titles = ['foo', 'bar', 'baz'] -# for title in titles: -# album = Album(title=title) -# album.save() -# self.detail_view = AlbumDetail.as_view() -# self.data = { -# 'foo': {'title': 'foo', 'url': 'http://testserver/albums/foo/'}, -# 'bar': {'title': 'bar', 'url': 'http://testserver/albums/bar/'}, -# 'baz': {'title': 'baz', 'url': 'http://testserver/albums/baz/'} -# } - -# def test_lookup_field(self): -# """ -# GET requests to AlbumDetail view should return serialized Albums -# with a url field keyed by `title`. -# """ -# for album in Album.objects.all(): -# request = factory.get('/albums/{0}/'.format(album.title)) -# response = self.detail_view(request, title=album.title) -# self.assertEqual(response.status_code, status.HTTP_200_OK) -# self.assertEqual(response.data, self.data[album.title]) - - -# class TestCreateWithForeignKeys(TestCase): -# urls = 'tests.test_hyperlinkedserializers' - -# def setUp(self): -# """ -# Create a blog post -# """ -# self.post = BlogPost.objects.create(title="Test post") -# self.create_view = BlogPostCommentListCreate.as_view() - -# def test_create_comment(self): - -# data = { -# 'text': 'A test comment', -# 'blog_post_url': 'http://testserver/posts/1/' -# } - -# request = factory.post('/comments/', data=data) -# response = self.create_view(request) -# self.assertEqual(response.status_code, status.HTTP_201_CREATED) -# self.assertEqual(response['Location'], 'http://testserver/comments/1/') -# self.assertEqual(self.post.blogpostcomment_set.count(), 1) -# self.assertEqual(self.post.blogpostcomment_set.all()[0].text, 'A test comment') - - -# class TestCreateWithForeignKeysAndCustomSlug(TestCase): -# urls = 'tests.test_hyperlinkedserializers' - -# def setUp(self): -# """ -# Create an Album -# """ -# self.post = Album.objects.create(title='test-album') -# self.list_create_view = PhotoListCreate.as_view() - -# def test_create_photo(self): - -# data = { -# 'description': 'A test photo', -# 'album_url': 'http://testserver/albums/test-album/' -# } - -# request = factory.post('/photos/', data=data) -# response = self.list_create_view(request) -# self.assertEqual(response.status_code, status.HTTP_201_CREATED) -# self.assertNotIn('Location', response, msg='Location should only be included if there is a "url" field on the serializer') -# self.assertEqual(self.post.photo_set.count(), 1) -# self.assertEqual(self.post.photo_set.all()[0].description, 'A test photo') - - -# class TestOptionalRelationHyperlinkedView(TestCase): -# urls = 'tests.test_hyperlinkedserializers' - -# def setUp(self): -# """ -# Create 1 OptionalRelationModel instances. -# """ -# OptionalRelationModel().save() -# self.objects = OptionalRelationModel.objects -# self.detail_view = OptionalRelationDetail.as_view() -# self.data = {"url": "http://testserver/optionalrelation/1/", "other": None} - -# def test_get_detail_view(self): -# """ -# GET requests to RetrieveAPIView with optional relations should return None -# for non existing relations. -# """ -# request = factory.get('/optionalrelationmodel-detail/1') -# response = self.detail_view(request, pk=1) -# self.assertEqual(response.status_code, status.HTTP_200_OK) -# self.assertEqual(response.data, self.data) - -# def test_put_detail_view(self): -# """ -# PUT requests to RetrieveUpdateDestroyAPIView with optional relations -# should accept None for non existing relations. -# """ -# response = self.client.put('/optionalrelation/1/', -# data=json.dumps(self.data), -# content_type='application/json') -# self.assertEqual(response.status_code, status.HTTP_200_OK) - - -# class TestOverriddenURLField(TestCase): -# def setUp(self): -# class OverriddenURLSerializer(serializers.HyperlinkedModelSerializer): -# url = serializers.SerializerMethodField('get_url') - -# class Meta: -# model = BlogPost -# fields = ('title', 'url') - -# def get_url(self, obj): -# return 'foo bar' - -# self.Serializer = OverriddenURLSerializer -# self.obj = BlogPost.objects.create(title='New blog post') - -# def test_overridden_url_field(self): -# """ -# The 'url' field should respect overriding. -# Regression test for #936. -# """ -# serializer = self.Serializer(self.obj) -# self.assertEqual( -# serializer.data, -# {'title': 'New blog post', 'url': 'foo bar'} -# ) - - -# class TestURLFieldNameBySettings(TestCase): -# urls = 'tests.test_hyperlinkedserializers' - -# def setUp(self): -# self.saved_url_field_name = api_settings.URL_FIELD_NAME -# api_settings.URL_FIELD_NAME = 'global_url_field' - -# class Serializer(serializers.HyperlinkedModelSerializer): - -# class Meta: -# model = BlogPost -# fields = ('title', api_settings.URL_FIELD_NAME) - -# self.Serializer = Serializer -# self.obj = BlogPost.objects.create(title="New blog post") - -# def tearDown(self): -# api_settings.URL_FIELD_NAME = self.saved_url_field_name - -# def test_overridden_url_field_name(self): -# request = factory.get('/posts/') -# serializer = self.Serializer(self.obj, context={'request': request}) -# self.assertIn(api_settings.URL_FIELD_NAME, serializer.data) - - -# class TestURLFieldNameByOptions(TestCase): -# urls = 'tests.test_hyperlinkedserializers' - -# def setUp(self): -# class Serializer(serializers.HyperlinkedModelSerializer): - -# class Meta: -# model = BlogPost -# fields = ('title', 'serializer_url_field') -# url_field_name = 'serializer_url_field' - -# self.Serializer = Serializer -# self.obj = BlogPost.objects.create(title="New blog post") - -# def test_overridden_url_field_name(self): -# request = factory.get('/posts/') -# serializer = self.Serializer(self.obj, context={'request': request}) -# self.assertIn(self.Serializer.Meta.url_field_name, serializer.data) diff --git a/tests/test_nullable_fields.py b/tests/test_nullable_fields.py deleted file mode 100644 index 9843182a..00000000 --- a/tests/test_nullable_fields.py +++ /dev/null @@ -1,39 +0,0 @@ -# from django.core.urlresolvers import reverse - -# from django.conf.urls import patterns, url -# from rest_framework import serializers, generics -# from rest_framework.test import APITestCase -# from tests.models import NullableForeignKeySource - - -# class NullableFKSourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = NullableForeignKeySource - - -# class NullableFKSourceDetail(generics.RetrieveUpdateDestroyAPIView): -# queryset = NullableForeignKeySource.objects.all() -# serializer_class = NullableFKSourceSerializer - - -# urlpatterns = patterns( -# '', -# url(r'^objects/(?P<pk>\d+)/$', NullableFKSourceDetail.as_view(), name='object-detail'), -# ) - - -# class NullableForeignKeyTests(APITestCase): -# """ -# DRF should be able to handle nullable foreign keys when a test -# Client POST/PUT request is made with its own serialized object. -# """ -# urls = 'tests.test_nullable_fields' - -# def test_updating_object_with_null_fk(self): -# obj = NullableForeignKeySource(name='example', target=None) -# obj.save() -# serialized_data = NullableFKSourceSerializer(obj).data - -# response = self.client.put(reverse('object-detail', args=[obj.pk]), serialized_data) - -# self.assertEqual(response.data, serialized_data) diff --git a/tests/test_relations.py b/tests/test_relations.py index 16ead1f2..62353dc2 100644 --- a/tests/test_relations.py +++ b/tests/test_relations.py @@ -134,155 +134,3 @@ class TestSlugRelatedField(APISimpleTestCase): def test_representation(self): representation = self.field.to_representation(self.instance) assert representation == self.instance.name - -# Older tests, for review... - -# """ -# General tests for relational fields. -# """ -# from __future__ import unicode_literals -# from django import get_version -# from django.db import models -# from django.test import TestCase -# from django.utils import unittest -# from rest_framework import serializers -# from tests.models import BlogPost - - -# class NullModel(models.Model): -# pass - - -# class FieldTests(TestCase): -# def test_pk_related_field_with_empty_string(self): -# """ -# Regression test for #446 - -# https://github.com/tomchristie/django-rest-framework/issues/446 -# """ -# field = serializers.PrimaryKeyRelatedField(queryset=NullModel.objects.all()) -# self.assertRaises(serializers.ValidationError, field.to_primitive, '') -# self.assertRaises(serializers.ValidationError, field.to_primitive, []) - -# def test_hyperlinked_related_field_with_empty_string(self): -# field = serializers.HyperlinkedRelatedField(queryset=NullModel.objects.all(), view_name='') -# self.assertRaises(serializers.ValidationError, field.to_primitive, '') -# self.assertRaises(serializers.ValidationError, field.to_primitive, []) - -# def test_slug_related_field_with_empty_string(self): -# field = serializers.SlugRelatedField(queryset=NullModel.objects.all(), slug_field='pk') -# self.assertRaises(serializers.ValidationError, field.to_primitive, '') -# self.assertRaises(serializers.ValidationError, field.to_primitive, []) - - -# class TestManyRelatedMixin(TestCase): -# def test_missing_many_to_many_related_field(self): -# ''' -# Regression test for #632 - -# https://github.com/tomchristie/django-rest-framework/pull/632 -# ''' -# field = serializers.RelatedField(many=True, read_only=False) - -# into = {} -# field.field_from_native({}, None, 'field_name', into) -# self.assertEqual(into['field_name'], []) - - -# # Regression tests for #694 (`source` attribute on related fields) - -# class RelatedFieldSourceTests(TestCase): -# def test_related_manager_source(self): -# """ -# Relational fields should be able to use manager-returning methods as their source. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.RelatedField(many=True, source='get_blogposts_manager') - -# class ClassWithManagerMethod(object): -# def get_blogposts_manager(self): -# return BlogPost.objects - -# obj = ClassWithManagerMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, ['BlogPost object']) - -# def test_related_queryset_source(self): -# """ -# Relational fields should be able to use queryset-returning methods as their source. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.RelatedField(many=True, source='get_blogposts_queryset') - -# class ClassWithQuerysetMethod(object): -# def get_blogposts_queryset(self): -# return BlogPost.objects.all() - -# obj = ClassWithQuerysetMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, ['BlogPost object']) - -# def test_dotted_source(self): -# """ -# Source argument should support dotted.source notation. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.RelatedField(many=True, source='a.b.c') - -# class ClassWithQuerysetMethod(object): -# a = { -# 'b': { -# 'c': BlogPost.objects.all() -# } -# } - -# obj = ClassWithQuerysetMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, ['BlogPost object']) - -# # Regression for #1129 -# def test_exception_for_incorect_fk(self): -# """ -# Check that the exception message are correct if the source field -# doesn't exist. -# """ -# from tests.models import ManyToManySource - -# class Meta: -# model = ManyToManySource - -# attrs = { -# 'name': serializers.SlugRelatedField( -# slug_field='name', source='banzai'), -# 'Meta': Meta, -# } - -# TestSerializer = type( -# str('TestSerializer'), -# (serializers.ModelSerializer,), -# attrs -# ) -# with self.assertRaises(AttributeError): -# TestSerializer(data={'name': 'foo'}) - - -# @unittest.skipIf(get_version() < '1.6.0', 'Upstream behaviour changed in v1.6') -# class RelatedFieldChoicesTests(TestCase): -# """ -# Tests for #1408 "Web browseable API doesn't have blank option on drop down list box" -# https://github.com/tomchristie/django-rest-framework/issues/1408 -# """ -# def test_blank_option_is_added_to_choice_if_required_equals_false(self): -# """ - -# """ -# post = BlogPost(title="Checking blank option is added") -# post.save() - -# queryset = BlogPost.objects.all() -# field = serializers.RelatedField(required=False, queryset=queryset) - -# choice_count = BlogPost.objects.count() -# widget_count = len(field.widget.choices) - -# self.assertEqual(widget_count, choice_count + 1, 'BLANK_CHOICE_DASH option should have been added') diff --git a/tests/test_relations_hyperlink.py b/tests/test_relations_hyperlink.py index 0337f359..b938e385 100644 --- a/tests/test_relations_hyperlink.py +++ b/tests/test_relations_hyperlink.py @@ -411,30 +411,6 @@ class HyperlinkedNullableForeignKeyTests(TestCase): ] self.assertEqual(serializer.data, expected) -# # reverse foreign keys MUST be read_only -# # In the general case they do not provide .remove() or .clear() -# # and cannot be arbitrarily set. - - # def test_reverse_foreign_key_update(self): - # data = {'id': 1, 'name': 'target-1', 'sources': [1]} - # instance = ForeignKeyTarget.objects.get(pk=1) - # serializer = ForeignKeyTargetSerializer(instance, data=data) - # print serializer.is_valid() - # print serializer.errors - # print serializer - # self.assertTrue(serializer.is_valid()) - # serializer.save() - # self.assertEqual(serializer.data, data) - - # # Ensure target 1 is updated, and everything else is as expected - # queryset = ForeignKeyTarget.objects.all() - # serializer = ForeignKeyTargetSerializer(queryset, many=True) - # expected = [ - # {'id': 1, 'name': 'target-1', 'sources': [1]}, - # {'id': 2, 'name': 'target-2', 'sources': []}, - # ] - # self.assertEqual(serializer.data, expected) - class HyperlinkedNullableOneToOneTests(TestCase): urls = 'tests.test_relations_hyperlink' @@ -455,72 +431,3 @@ class HyperlinkedNullableOneToOneTests(TestCase): {'url': 'http://testserver/onetoonetarget/2/', 'name': 'target-2', 'nullable_source': None}, ] self.assertEqual(serializer.data, expected) - - -# # Regression tests for #694 (`source` attribute on related fields) - -# class HyperlinkedRelatedFieldSourceTests(TestCase): -# urls = 'tests.test_relations_hyperlink' - -# def test_related_manager_source(self): -# """ -# Relational fields should be able to use manager-returning methods as their source. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.HyperlinkedRelatedField( -# many=True, -# source='get_blogposts_manager', -# view_name='dummy-url', -# ) -# field.context = {'request': request} - -# class ClassWithManagerMethod(object): -# def get_blogposts_manager(self): -# return BlogPost.objects - -# obj = ClassWithManagerMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, ['http://testserver/dummyurl/1/']) - -# def test_related_queryset_source(self): -# """ -# Relational fields should be able to use queryset-returning methods as their source. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.HyperlinkedRelatedField( -# many=True, -# source='get_blogposts_queryset', -# view_name='dummy-url', -# ) -# field.context = {'request': request} - -# class ClassWithQuerysetMethod(object): -# def get_blogposts_queryset(self): -# return BlogPost.objects.all() - -# obj = ClassWithQuerysetMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, ['http://testserver/dummyurl/1/']) - -# def test_dotted_source(self): -# """ -# Source argument should support dotted.source notation. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.HyperlinkedRelatedField( -# many=True, -# source='a.b.c', -# view_name='dummy-url', -# ) -# field.context = {'request': request} - -# class ClassWithQuerysetMethod(object): -# a = { -# 'b': { -# 'c': BlogPost.objects.all() -# } -# } - -# obj = ClassWithQuerysetMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, ['http://testserver/dummyurl/1/']) diff --git a/tests/test_relations_nested.py b/tests/test_relations_nested.py deleted file mode 100644 index 4a99fee9..00000000 --- a/tests/test_relations_nested.py +++ /dev/null @@ -1,326 +0,0 @@ -# from __future__ import unicode_literals -# from django.db import models -# from django.test import TestCase -# from rest_framework import serializers - -# from .models import OneToOneTarget - - -# class OneToOneSource(models.Model): -# name = models.CharField(max_length=100) -# target = models.OneToOneField(OneToOneTarget, related_name='source', -# null=True, blank=True) - - -# class OneToManyTarget(models.Model): -# name = models.CharField(max_length=100) - - -# class OneToManySource(models.Model): -# name = models.CharField(max_length=100) -# target = models.ForeignKey(OneToManyTarget, related_name='sources') - - -# class ReverseNestedOneToOneTests(TestCase): -# def setUp(self): -# class OneToOneSourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = OneToOneSource -# fields = ('id', 'name') - -# class OneToOneTargetSerializer(serializers.ModelSerializer): -# source = OneToOneSourceSerializer() - -# class Meta: -# model = OneToOneTarget -# fields = ('id', 'name', 'source') - -# self.Serializer = OneToOneTargetSerializer - -# for idx in range(1, 4): -# target = OneToOneTarget(name='target-%d' % idx) -# target.save() -# source = OneToOneSource(name='source-%d' % idx, target=target) -# source.save() - -# def test_one_to_one_retrieve(self): -# queryset = OneToOneTarget.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, -# {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, -# {'id': 3, 'name': 'target-3', 'source': {'id': 3, 'name': 'source-3'}} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_one_to_one_create(self): -# data = {'id': 4, 'name': 'target-4', 'source': {'id': 4, 'name': 'source-4'}} -# serializer = self.Serializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-4') - -# # Ensure (target 4, target_source 4, source 4) are added, and -# # everything else is as expected. -# queryset = OneToOneTarget.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, -# {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, -# {'id': 3, 'name': 'target-3', 'source': {'id': 3, 'name': 'source-3'}}, -# {'id': 4, 'name': 'target-4', 'source': {'id': 4, 'name': 'source-4'}} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_one_to_one_create_with_invalid_data(self): -# data = {'id': 4, 'name': 'target-4', 'source': {'id': 4}} -# serializer = self.Serializer(data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'source': [{'name': ['This field is required.']}]}) - -# def test_one_to_one_update(self): -# data = {'id': 3, 'name': 'target-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}} -# instance = OneToOneTarget.objects.get(pk=3) -# serializer = self.Serializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-3-updated') - -# # Ensure (target 3, target_source 3, source 3) are updated, -# # and everything else is as expected. -# queryset = OneToOneTarget.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, -# {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, -# {'id': 3, 'name': 'target-3-updated', 'source': {'id': 3, 'name': 'source-3-updated'}} -# ] -# self.assertEqual(serializer.data, expected) - - -# class ForwardNestedOneToOneTests(TestCase): -# def setUp(self): -# class OneToOneTargetSerializer(serializers.ModelSerializer): -# class Meta: -# model = OneToOneTarget -# fields = ('id', 'name') - -# class OneToOneSourceSerializer(serializers.ModelSerializer): -# target = OneToOneTargetSerializer() - -# class Meta: -# model = OneToOneSource -# fields = ('id', 'name', 'target') - -# self.Serializer = OneToOneSourceSerializer - -# for idx in range(1, 4): -# target = OneToOneTarget(name='target-%d' % idx) -# target.save() -# source = OneToOneSource(name='source-%d' % idx, target=target) -# source.save() - -# def test_one_to_one_retrieve(self): -# queryset = OneToOneSource.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, -# {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, -# {'id': 3, 'name': 'source-3', 'target': {'id': 3, 'name': 'target-3'}} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_one_to_one_create(self): -# data = {'id': 4, 'name': 'source-4', 'target': {'id': 4, 'name': 'target-4'}} -# serializer = self.Serializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-4') - -# # Ensure (target 4, target_source 4, source 4) are added, and -# # everything else is as expected. -# queryset = OneToOneSource.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, -# {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, -# {'id': 3, 'name': 'source-3', 'target': {'id': 3, 'name': 'target-3'}}, -# {'id': 4, 'name': 'source-4', 'target': {'id': 4, 'name': 'target-4'}} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_one_to_one_create_with_invalid_data(self): -# data = {'id': 4, 'name': 'source-4', 'target': {'id': 4}} -# serializer = self.Serializer(data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'target': [{'name': ['This field is required.']}]}) - -# def test_one_to_one_update(self): -# data = {'id': 3, 'name': 'source-3-updated', 'target': {'id': 3, 'name': 'target-3-updated'}} -# instance = OneToOneSource.objects.get(pk=3) -# serializer = self.Serializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-3-updated') - -# # Ensure (target 3, target_source 3, source 3) are updated, -# # and everything else is as expected. -# queryset = OneToOneSource.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, -# {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, -# {'id': 3, 'name': 'source-3-updated', 'target': {'id': 3, 'name': 'target-3-updated'}} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_one_to_one_update_to_null(self): -# data = {'id': 3, 'name': 'source-3-updated', 'target': None} -# instance = OneToOneSource.objects.get(pk=3) -# serializer = self.Serializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() - -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'source-3-updated') -# self.assertEqual(obj.target, None) - -# queryset = OneToOneSource.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'source-1', 'target': {'id': 1, 'name': 'target-1'}}, -# {'id': 2, 'name': 'source-2', 'target': {'id': 2, 'name': 'target-2'}}, -# {'id': 3, 'name': 'source-3-updated', 'target': None} -# ] -# self.assertEqual(serializer.data, expected) - -# # TODO: Nullable 1-1 tests -# # def test_one_to_one_delete(self): -# # data = {'id': 3, 'name': 'target-3', 'target_source': None} -# # instance = OneToOneTarget.objects.get(pk=3) -# # serializer = self.Serializer(instance, data=data) -# # self.assertTrue(serializer.is_valid()) -# # serializer.save() - -# # # Ensure (target_source 3, source 3) are deleted, -# # # and everything else is as expected. -# # queryset = OneToOneTarget.objects.all() -# # serializer = self.Serializer(queryset) -# # expected = [ -# # {'id': 1, 'name': 'target-1', 'source': {'id': 1, 'name': 'source-1'}}, -# # {'id': 2, 'name': 'target-2', 'source': {'id': 2, 'name': 'source-2'}}, -# # {'id': 3, 'name': 'target-3', 'source': None} -# # ] -# # self.assertEqual(serializer.data, expected) - - -# class ReverseNestedOneToManyTests(TestCase): -# def setUp(self): -# class OneToManySourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = OneToManySource -# fields = ('id', 'name') - -# class OneToManyTargetSerializer(serializers.ModelSerializer): -# sources = OneToManySourceSerializer(many=True, allow_add_remove=True) - -# class Meta: -# model = OneToManyTarget -# fields = ('id', 'name', 'sources') - -# self.Serializer = OneToManyTargetSerializer - -# target = OneToManyTarget(name='target-1') -# target.save() -# for idx in range(1, 4): -# source = OneToManySource(name='source-%d' % idx, target=target) -# source.save() - -# def test_one_to_many_retrieve(self): -# queryset = OneToManyTarget.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, -# {'id': 2, 'name': 'source-2'}, -# {'id': 3, 'name': 'source-3'}]}, -# ] -# self.assertEqual(serializer.data, expected) - -# def test_one_to_many_create(self): -# data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, -# {'id': 2, 'name': 'source-2'}, -# {'id': 3, 'name': 'source-3'}, -# {'id': 4, 'name': 'source-4'}]} -# instance = OneToManyTarget.objects.get(pk=1) -# serializer = self.Serializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-1') - -# # Ensure source 4 is added, and everything else is as -# # expected. -# queryset = OneToManyTarget.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, -# {'id': 2, 'name': 'source-2'}, -# {'id': 3, 'name': 'source-3'}, -# {'id': 4, 'name': 'source-4'}]} -# ] -# self.assertEqual(serializer.data, expected) - -# def test_one_to_many_create_with_invalid_data(self): -# data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, -# {'id': 2, 'name': 'source-2'}, -# {'id': 3, 'name': 'source-3'}, -# {'id': 4}]} -# serializer = self.Serializer(data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'sources': [{}, {}, {}, {'name': ['This field is required.']}]}) - -# def test_one_to_many_update(self): -# data = {'id': 1, 'name': 'target-1-updated', 'sources': [{'id': 1, 'name': 'source-1-updated'}, -# {'id': 2, 'name': 'source-2'}, -# {'id': 3, 'name': 'source-3'}]} -# instance = OneToManyTarget.objects.get(pk=1) -# serializer = self.Serializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(serializer.data, data) -# self.assertEqual(obj.name, 'target-1-updated') - -# # Ensure (target 1, source 1) are updated, -# # and everything else is as expected. -# queryset = OneToManyTarget.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1-updated', 'sources': [{'id': 1, 'name': 'source-1-updated'}, -# {'id': 2, 'name': 'source-2'}, -# {'id': 3, 'name': 'source-3'}]} - -# ] -# self.assertEqual(serializer.data, expected) - -# def test_one_to_many_delete(self): -# data = {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, -# {'id': 3, 'name': 'source-3'}]} -# instance = OneToManyTarget.objects.get(pk=1) -# serializer = self.Serializer(instance, data=data) -# self.assertTrue(serializer.is_valid()) -# serializer.save() - -# # Ensure source 2 is deleted, and everything else is as -# # expected. -# queryset = OneToManyTarget.objects.all() -# serializer = self.Serializer(queryset, many=True) -# expected = [ -# {'id': 1, 'name': 'target-1', 'sources': [{'id': 1, 'name': 'source-1'}, -# {'id': 3, 'name': 'source-3'}]} - -# ] -# self.assertEqual(serializer.data, expected) diff --git a/tests/test_relations_pk.py b/tests/test_relations_pk.py index ba5f6c17..e95a877e 100644 --- a/tests/test_relations_pk.py +++ b/tests/test_relations_pk.py @@ -398,27 +398,6 @@ class PKNullableForeignKeyTests(TestCase): ] self.assertEqual(serializer.data, expected) - # reverse foreign keys MUST be read_only - # In the general case they do not provide .remove() or .clear() - # and cannot be arbitrarily set. - - # def test_reverse_foreign_key_update(self): - # data = {'id': 1, 'name': 'target-1', 'sources': [1]} - # instance = ForeignKeyTarget.objects.get(pk=1) - # serializer = ForeignKeyTargetSerializer(instance, data=data) - # self.assertTrue(serializer.is_valid()) - # self.assertEqual(serializer.data, data) - # serializer.save() - - # # Ensure target 1 is updated, and everything else is as expected - # queryset = ForeignKeyTarget.objects.all() - # serializer = ForeignKeyTargetSerializer(queryset, many=True) - # expected = [ - # {'id': 1, 'name': 'target-1', 'sources': [1]}, - # {'id': 2, 'name': 'target-2', 'sources': []}, - # ] - # self.assertEqual(serializer.data, expected) - class PKNullableOneToOneTests(TestCase): def setUp(self): @@ -437,113 +416,3 @@ class PKNullableOneToOneTests(TestCase): {'id': 2, 'name': 'target-2', 'nullable_source': 1}, ] self.assertEqual(serializer.data, expected) - - -# The below models and tests ensure that serializer fields corresponding -# to a ManyToManyField field with a user-specified ``through`` model are -# set to read only - - -# class ManyToManyThroughTarget(models.Model): -# name = models.CharField(max_length=100) - - -# class ManyToManyThrough(models.Model): -# source = models.ForeignKey('ManyToManyThroughSource') -# target = models.ForeignKey(ManyToManyThroughTarget) - - -# class ManyToManyThroughSource(models.Model): -# name = models.CharField(max_length=100) -# targets = models.ManyToManyField(ManyToManyThroughTarget, -# related_name='sources', -# through='ManyToManyThrough') - - -# class ManyToManyThroughTargetSerializer(serializers.ModelSerializer): -# class Meta: -# model = ManyToManyThroughTarget -# fields = ('id', 'name', 'sources') - - -# class ManyToManyThroughSourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = ManyToManyThroughSource -# fields = ('id', 'name', 'targets') - - -# class PKManyToManyThroughTests(TestCase): -# def setUp(self): -# self.source = ManyToManyThroughSource.objects.create( -# name='through-source-1') -# self.target = ManyToManyThroughTarget.objects.create( -# name='through-target-1') - -# def test_many_to_many_create(self): -# data = {'id': 2, 'name': 'source-2', 'targets': [self.target.pk]} -# serializer = ManyToManyThroughSourceSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(obj.name, 'source-2') -# self.assertEqual(obj.targets.count(), 0) - -# def test_many_to_many_reverse_create(self): -# data = {'id': 2, 'name': 'target-2', 'sources': [self.source.pk]} -# serializer = ManyToManyThroughTargetSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# obj = serializer.save() -# self.assertEqual(obj.name, 'target-2') -# self.assertEqual(obj.sources.count(), 0) - - -# # Regression tests for #694 (`source` attribute on related fields) - - -# class PrimaryKeyRelatedFieldSourceTests(TestCase): -# def test_related_manager_source(self): -# """ -# Relational fields should be able to use manager-returning methods as their source. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.PrimaryKeyRelatedField(many=True, source='get_blogposts_manager') - -# class ClassWithManagerMethod(object): -# def get_blogposts_manager(self): -# return BlogPost.objects - -# obj = ClassWithManagerMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, [1]) - -# def test_related_queryset_source(self): -# """ -# Relational fields should be able to use queryset-returning methods as their source. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.PrimaryKeyRelatedField(many=True, source='get_blogposts_queryset') - -# class ClassWithQuerysetMethod(object): -# def get_blogposts_queryset(self): -# return BlogPost.objects.all() - -# obj = ClassWithQuerysetMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, [1]) - -# def test_dotted_source(self): -# """ -# Source argument should support dotted.source notation. -# """ -# BlogPost.objects.create(title='blah') -# field = serializers.PrimaryKeyRelatedField(many=True, source='a.b.c') - -# class ClassWithQuerysetMethod(object): -# a = { -# 'b': { -# 'c': BlogPost.objects.all() -# } -# } - -# obj = ClassWithQuerysetMethod() -# value = field.field_to_native(obj, 'field_name') -# self.assertEqual(value, [1]) diff --git a/tests/test_request.py b/tests/test_request.py index 8ddaf0a7..44afd243 100644 --- a/tests/test_request.py +++ b/tests/test_request.py @@ -179,89 +179,6 @@ class TestContentParsing(TestCase): self.assertEqual(request._data, Empty) self.assertEqual(request._files, Empty) - # def test_accessing_post_after_data_form(self): - # """ - # Ensures request.POST can be accessed after request.DATA in - # form request. - # """ - # data = {'qwerty': 'uiop'} - # request = factory.post('/', data=data) - # self.assertEqual(request.DATA.items(), data.items()) - # self.assertEqual(request.POST.items(), data.items()) - - # def test_accessing_post_after_data_for_json(self): - # """ - # Ensures request.POST can be accessed after request.DATA in - # json request. - # """ - # data = {'qwerty': 'uiop'} - # content = json.dumps(data) - # content_type = 'application/json' - # parsers = (JSONParser, ) - - # request = factory.post('/', content, content_type=content_type, - # parsers=parsers) - # self.assertEqual(request.DATA.items(), data.items()) - # self.assertEqual(request.POST.items(), []) - - # def test_accessing_post_after_data_for_overloaded_json(self): - # """ - # Ensures request.POST can be accessed after request.DATA in overloaded - # json request. - # """ - # data = {'qwerty': 'uiop'} - # content = json.dumps(data) - # content_type = 'application/json' - # parsers = (JSONParser, ) - # form_data = {Request._CONTENT_PARAM: content, - # Request._CONTENTTYPE_PARAM: content_type} - - # request = factory.post('/', form_data, parsers=parsers) - # self.assertEqual(request.DATA.items(), data.items()) - # self.assertEqual(request.POST.items(), form_data.items()) - - # def test_accessing_data_after_post_form(self): - # """ - # Ensures request.DATA can be accessed after request.POST in - # form request. - # """ - # data = {'qwerty': 'uiop'} - # parsers = (FormParser, MultiPartParser) - # request = factory.post('/', data, parsers=parsers) - - # self.assertEqual(request.POST.items(), data.items()) - # self.assertEqual(request.DATA.items(), data.items()) - - # def test_accessing_data_after_post_for_json(self): - # """ - # Ensures request.DATA can be accessed after request.POST in - # json request. - # """ - # data = {'qwerty': 'uiop'} - # content = json.dumps(data) - # content_type = 'application/json' - # parsers = (JSONParser, ) - # request = factory.post('/', content, content_type=content_type, - # parsers=parsers) - # self.assertEqual(request.POST.items(), []) - # self.assertEqual(request.DATA.items(), data.items()) - - # def test_accessing_data_after_post_for_overloaded_json(self): - # """ - # Ensures request.DATA can be accessed after request.POST in overloaded - # json request - # """ - # data = {'qwerty': 'uiop'} - # content = json.dumps(data) - # content_type = 'application/json' - # parsers = (JSONParser, ) - # form_data = {Request._CONTENT_PARAM: content, - # Request._CONTENTTYPE_PARAM: content_type} - - # request = factory.post('/', form_data, parsers=parsers) - # self.assertEqual(request.POST.items(), form_data.items()) - # self.assertEqual(request.DATA.items(), data.items()) - class MockView(APIView): authentication_classes = (SessionAuthentication,) @@ -301,18 +218,6 @@ class TestContentParsingWithAuthentication(TestCase): response = self.csrf_client.post('/', content) self.assertEqual(status.HTTP_200_OK, response.status_code) - # def test_user_logged_in_authentication_has_post_when_logged_in(self): - # """Ensures request.POST exists after UserLoggedInAuthentication when user does log in""" - # self.client.login(username='john', password='password') - # self.csrf_client.login(username='john', password='password') - # content = {'example': 'example'} - - # response = self.client.post('/', content) - # self.assertEqual(status.OK, response.status_code, "POST data is malformed") - - # response = self.csrf_client.post('/', content) - # self.assertEqual(status.OK, response.status_code, "POST data is malformed") - class TestUserSetter(TestCase): diff --git a/tests/test_serializer.py b/tests/test_serializer.py index 77d5c319..6dabaf42 100644 --- a/tests/test_serializer.py +++ b/tests/test_serializer.py @@ -175,2007 +175,3 @@ class TestStarredSource: instance = {'a': 1, 'b': 2, 'c': 3, 'd': 4} serializer = self.Serializer(instance) assert serializer.data == self.data - -# # -*- coding: utf-8 -*- -# from __future__ import unicode_literals -# from django.db import models -# from django.db.models.fields import BLANK_CHOICE_DASH -# from django.test import TestCase -# from django.utils import unittest -# from django.utils.datastructures import MultiValueDict -# from django.utils.translation import ugettext_lazy as _ -# from rest_framework import serializers, fields, relations -# from tests.models import ( -# HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel, -# BlankFieldModel, BlogPost, BlogPostComment, Book, CallableDefaultValueModel, -# DefaultValueModel, ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo, -# RESTFrameworkModel, ForeignKeySource -# ) -# from tests.models import BasicModelSerializer -# import datetime -# import pickle -# try: -# import PIL -# except: -# PIL = None - - -# if PIL is not None: -# class AMOAFModel(RESTFrameworkModel): -# char_field = models.CharField(max_length=1024, blank=True) -# comma_separated_integer_field = models.CommaSeparatedIntegerField(max_length=1024, blank=True) -# decimal_field = models.DecimalField(max_digits=64, decimal_places=32, blank=True) -# email_field = models.EmailField(max_length=1024, blank=True) -# file_field = models.FileField(upload_to='test', max_length=1024, blank=True) -# image_field = models.ImageField(upload_to='test', max_length=1024, blank=True) -# slug_field = models.SlugField(max_length=1024, blank=True) -# url_field = models.URLField(max_length=1024, blank=True) -# nullable_char_field = models.CharField(max_length=1024, blank=True, null=True) - -# class DVOAFModel(RESTFrameworkModel): -# positive_integer_field = models.PositiveIntegerField(blank=True) -# positive_small_integer_field = models.PositiveSmallIntegerField(blank=True) -# email_field = models.EmailField(blank=True) -# file_field = models.FileField(upload_to='test', blank=True) -# image_field = models.ImageField(upload_to='test', blank=True) -# slug_field = models.SlugField(blank=True) -# url_field = models.URLField(blank=True) - - -# class SubComment(object): -# def __init__(self, sub_comment): -# self.sub_comment = sub_comment - - -# class Comment(object): -# def __init__(self, email, content, created): -# self.email = email -# self.content = content -# self.created = created or datetime.datetime.now() - -# def __eq__(self, other): -# return all([getattr(self, attr) == getattr(other, attr) -# for attr in ('email', 'content', 'created')]) - -# def get_sub_comment(self): -# sub_comment = SubComment('And Merry Christmas!') -# return sub_comment - - -# class CommentSerializer(serializers.Serializer): -# email = serializers.EmailField() -# content = serializers.CharField(max_length=1000) -# created = serializers.DateTimeField() -# sub_comment = serializers.Field(source='get_sub_comment.sub_comment') - -# def restore_object(self, data, instance=None): -# if instance is None: -# return Comment(**data) -# for key, val in data.items(): -# setattr(instance, key, val) -# return instance - - -# class NamesSerializer(serializers.Serializer): -# first = serializers.CharField() -# last = serializers.CharField(required=False, default='') -# initials = serializers.CharField(required=False, default='') - - -# class PersonIdentifierSerializer(serializers.Serializer): -# ssn = serializers.CharField() -# names = NamesSerializer(source='names', required=False) - - -# class BookSerializer(serializers.ModelSerializer): -# isbn = serializers.RegexField(regex=r'^[0-9]{13}$', error_messages={'invalid': 'isbn has to be exact 13 numbers'}) - -# class Meta: -# model = Book - - -# class ActionItemSerializer(serializers.ModelSerializer): - -# class Meta: -# model = ActionItem - - -# class ActionItemSerializerOptionalFields(serializers.ModelSerializer): -# """ -# Intended to test that fields with `required=False` are excluded from validation. -# """ -# title = serializers.CharField(required=False) - -# class Meta: -# model = ActionItem -# fields = ('title',) - - -# class ActionItemSerializerCustomRestore(serializers.ModelSerializer): - -# class Meta: -# model = ActionItem - -# def restore_object(self, data, instance=None): -# if instance is None: -# return ActionItem(**data) -# for key, val in data.items(): -# setattr(instance, key, val) -# return instance - - -# class PersonSerializer(serializers.ModelSerializer): -# info = serializers.Field(source='info') - -# class Meta: -# model = Person -# fields = ('name', 'age', 'info') -# read_only_fields = ('age',) - - -# class NestedSerializer(serializers.Serializer): -# info = serializers.Field() - - -# class ModelSerializerWithNestedSerializer(serializers.ModelSerializer): -# nested = NestedSerializer(source='*') - -# class Meta: -# model = Person - - -# class NestedSerializerWithRenamedField(serializers.Serializer): -# renamed_info = serializers.Field(source='info') - - -# class ModelSerializerWithNestedSerializerWithRenamedField(serializers.ModelSerializer): -# nested = NestedSerializerWithRenamedField(source='*') - -# class Meta: -# model = Person - - -# class PersonSerializerInvalidReadOnly(serializers.ModelSerializer): -# """ -# Testing for #652. -# """ -# info = serializers.Field(source='info') - -# class Meta: -# model = Person -# fields = ('name', 'age', 'info') -# read_only_fields = ('age', 'info') - - -# class AlbumsSerializer(serializers.ModelSerializer): - -# class Meta: -# model = Album -# fields = ['title', 'ref'] # lists are also valid options - - -# class PositiveIntegerAsChoiceSerializer(serializers.ModelSerializer): -# class Meta: -# model = HasPositiveIntegerAsChoice -# fields = ['some_integer'] - - -# class ForeignKeySourceSerializer(serializers.ModelSerializer): -# class Meta: -# model = ForeignKeySource - - -# class HyperlinkedForeignKeySourceSerializer(serializers.HyperlinkedModelSerializer): -# class Meta: -# model = ForeignKeySource - - -# class BasicTests(TestCase): -# def setUp(self): -# self.comment = Comment( -# 'tom@example.com', -# 'Happy new year!', -# datetime.datetime(2012, 1, 1) -# ) -# self.actionitem = ActionItem(title='Some to do item',) -# self.data = { -# 'email': 'tom@example.com', -# 'content': 'Happy new year!', -# 'created': datetime.datetime(2012, 1, 1), -# 'sub_comment': 'This wont change' -# } -# self.expected = { -# 'email': 'tom@example.com', -# 'content': 'Happy new year!', -# 'created': datetime.datetime(2012, 1, 1), -# 'sub_comment': 'And Merry Christmas!' -# } -# self.person_data = {'name': 'dwight', 'age': 35} -# self.person = Person(**self.person_data) -# self.person.save() - -# def test_empty(self): -# serializer = CommentSerializer() -# expected = { -# 'email': '', -# 'content': '', -# 'created': None -# } -# self.assertEqual(serializer.data, expected) - -# def test_retrieve(self): -# serializer = CommentSerializer(self.comment) -# self.assertEqual(serializer.data, self.expected) - -# def test_create(self): -# serializer = CommentSerializer(data=self.data) -# expected = self.comment -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, expected) -# self.assertFalse(serializer.object is expected) -# self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!') - -# def test_create_nested(self): -# """Test a serializer with nested data.""" -# names = {'first': 'John', 'last': 'Doe', 'initials': 'jd'} -# data = {'ssn': '1234567890', 'names': names} -# serializer = PersonIdentifierSerializer(data=data) - -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, data) -# self.assertFalse(serializer.object is data) -# self.assertEqual(serializer.data['names'], names) - -# def test_create_partial_nested(self): -# """Test a serializer with nested data which has missing fields.""" -# names = {'first': 'John'} -# data = {'ssn': '1234567890', 'names': names} -# serializer = PersonIdentifierSerializer(data=data) - -# expected_names = {'first': 'John', 'last': '', 'initials': ''} -# data['names'] = expected_names - -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, data) -# self.assertFalse(serializer.object is expected_names) -# self.assertEqual(serializer.data['names'], expected_names) - -# def test_null_nested(self): -# """Test a serializer with a nonexistent nested field""" -# data = {'ssn': '1234567890'} -# serializer = PersonIdentifierSerializer(data=data) - -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, data) -# self.assertFalse(serializer.object is data) -# expected = {'ssn': '1234567890', 'names': None} -# self.assertEqual(serializer.data, expected) - -# def test_update(self): -# serializer = CommentSerializer(self.comment, data=self.data) -# expected = self.comment -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, expected) -# self.assertTrue(serializer.object is expected) -# self.assertEqual(serializer.data['sub_comment'], 'And Merry Christmas!') - -# def test_partial_update(self): -# msg = 'Merry New Year!' -# partial_data = {'content': msg} -# serializer = CommentSerializer(self.comment, data=partial_data) -# self.assertEqual(serializer.is_valid(), False) -# serializer = CommentSerializer(self.comment, data=partial_data, partial=True) -# expected = self.comment -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, expected) -# self.assertTrue(serializer.object is expected) -# self.assertEqual(serializer.data['content'], msg) - -# def test_model_fields_as_expected(self): -# """ -# Make sure that the fields returned are the same as defined -# in the Meta data -# """ -# serializer = PersonSerializer(self.person) -# self.assertEqual( -# set(serializer.data.keys()), -# set(['name', 'age', 'info']) -# ) - -# def test_field_with_dictionary(self): -# """ -# Make sure that dictionaries from fields are left intact -# """ -# serializer = PersonSerializer(self.person) -# expected = self.person_data -# self.assertEqual(serializer.data['info'], expected) - -# def test_read_only_fields(self): -# """ -# Attempting to update fields set as read_only should have no effect. -# """ -# serializer = PersonSerializer(self.person, data={'name': 'dwight', 'age': 99}) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(serializer.errors, {}) -# # Assert age is unchanged (35) -# self.assertEqual(instance.age, self.person_data['age']) - -# def test_invalid_read_only_fields(self): -# """ -# Regression test for #652. -# """ -# self.assertRaises(AssertionError, PersonSerializerInvalidReadOnly, []) - -# def test_serializer_data_is_cleared_on_save(self): -# """ -# Check _data attribute is cleared on `save()` - -# Regression test for #1116 -# """ -# serializer = ActionItemSerializer(self.actionitem) -# self.assertIsNone(serializer.data.get('id', None), 'New instance. `id` should not be set.') -# serializer.save() -# self.assertIsNotNone(serializer.data.get('id', None), 'Model is saved. `id` should be set.') - -# def test_fields_marked_as_not_required_are_excluded_from_validation(self): -# """ -# Check that fields with `required=False` are included in list of exclusions. -# """ -# serializer = ActionItemSerializerOptionalFields(self.actionitem) -# exclusions = serializer.get_validation_exclusions() -# self.assertTrue('title' in exclusions, '`title` field was marked `required=False` and should be excluded') - - -# class DictStyleSerializer(serializers.Serializer): -# """ -# Note that we don't have any `restore_object` method, so the default -# case of simply returning a dict will apply. -# """ -# email = serializers.EmailField() - - -# class DictStyleSerializerTests(TestCase): -# def test_dict_style_deserialize(self): -# """ -# Ensure serializers can deserialize into a dict. -# """ -# data = {'email': 'foo@example.com'} -# serializer = DictStyleSerializer(data=data) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, data) - -# def test_dict_style_serialize(self): -# """ -# Ensure serializers can serialize dict objects. -# """ -# data = {'email': 'foo@example.com'} -# serializer = DictStyleSerializer(data) -# self.assertEqual(serializer.data, data) - - -# class ValidationTests(TestCase): -# def setUp(self): -# self.comment = Comment( -# 'tom@example.com', -# 'Happy new year!', -# datetime.datetime(2012, 1, 1) -# ) -# self.data = { -# 'email': 'tom@example.com', -# 'content': 'x' * 1001, -# 'created': datetime.datetime(2012, 1, 1) -# } -# self.actionitem = ActionItem(title='Some to do item',) - -# def test_create(self): -# serializer = CommentSerializer(data=self.data) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']}) - -# def test_update(self): -# serializer = CommentSerializer(self.comment, data=self.data) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, {'content': ['Ensure this value has at most 1000 characters (it has 1001).']}) - -# def test_update_missing_field(self): -# data = { -# 'content': 'xxx', -# 'created': datetime.datetime(2012, 1, 1) -# } -# serializer = CommentSerializer(self.comment, data=data) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, {'email': ['This field is required.']}) - -# def test_missing_bool_with_default(self): -# """Make sure that a boolean value with a 'False' value is not -# mistaken for not having a default.""" -# data = { -# 'title': 'Some action item', -# # No 'done' value. -# } -# serializer = ActionItemSerializer(self.actionitem, data=data) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.errors, {}) - -# def test_cross_field_validation(self): - -# class CommentSerializerWithCrossFieldValidator(CommentSerializer): - -# def validate(self, attrs): -# if attrs["email"] not in attrs["content"]: -# raise serializers.ValidationError("Email address not in content") -# return attrs - -# data = { -# 'email': 'tom@example.com', -# 'content': 'A comment from tom@example.com', -# 'created': datetime.datetime(2012, 1, 1) -# } - -# serializer = CommentSerializerWithCrossFieldValidator(data=data) -# self.assertTrue(serializer.is_valid()) - -# data['content'] = 'A comment from foo@bar.com' - -# serializer = CommentSerializerWithCrossFieldValidator(data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'non_field_errors': ['Email address not in content']}) - -# def test_null_is_true_fields(self): -# """ -# Omitting a value for null-field should validate. -# """ -# serializer = PersonSerializer(data={'name': 'marko'}) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.errors, {}) - -# def test_modelserializer_max_length_exceeded(self): -# data = { -# 'title': 'x' * 201, -# } -# serializer = ActionItemSerializer(data=data) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']}) - -# def test_modelserializer_max_length_exceeded_with_custom_restore(self): -# """ -# When overriding ModelSerializer.restore_object, validation tests should still apply. -# Regression test for #623. - -# https://github.com/tomchristie/django-rest-framework/pull/623 -# """ -# data = { -# 'title': 'x' * 201, -# } -# serializer = ActionItemSerializerCustomRestore(data=data) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, {'title': ['Ensure this value has at most 200 characters (it has 201).']}) - -# def test_default_modelfield_max_length_exceeded(self): -# data = { -# 'title': 'Testing "info" field...', -# 'info': 'x' * 13, -# } -# serializer = ActionItemSerializer(data=data) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, {'info': ['Ensure this value has at most 12 characters (it has 13).']}) - -# def test_datetime_validation_failure(self): -# """ -# Test DateTimeField validation errors on non-str values. -# Regression test for #669. - -# https://github.com/tomchristie/django-rest-framework/issues/669 -# """ -# data = self.data -# data['created'] = 0 - -# serializer = CommentSerializer(data=data) -# self.assertEqual(serializer.is_valid(), False) - -# self.assertIn('created', serializer.errors) - -# def test_missing_model_field_exception_msg(self): -# """ -# Assert that a meaningful exception message is outputted when the model -# field is missing (e.g. when mistyping ``model``). -# """ -# class BrokenModelSerializer(serializers.ModelSerializer): -# class Meta: -# fields = ['some_field'] - -# try: -# BrokenModelSerializer() -# except AssertionError as e: -# self.assertEqual(e.args[0], "Serializer class 'BrokenModelSerializer' is missing 'model' Meta option") -# except: -# self.fail('Wrong exception type thrown.') - -# def test_writable_star_source_on_nested_serializer(self): -# """ -# Assert that a nested serializer instantiated with source='*' correctly -# expands the data into the outer serializer. -# """ -# serializer = ModelSerializerWithNestedSerializer(data={ -# 'name': 'marko', -# 'nested': {'info': 'hi'}}, -# ) -# self.assertEqual(serializer.is_valid(), True) - -# def test_writable_star_source_on_nested_serializer_with_parent_object(self): -# class TitleSerializer(serializers.Serializer): -# title = serializers.WritableField(source='title') - -# class AlbumSerializer(serializers.ModelSerializer): -# nested = TitleSerializer(source='*') - -# class Meta: -# model = Album -# fields = ('nested',) - -# class PhotoSerializer(serializers.ModelSerializer): -# album = AlbumSerializer(source='album') - -# class Meta: -# model = Photo -# fields = ('album', ) - -# photo = Photo(album=Album()) - -# data = {'album': {'nested': {'title': 'test'}}} - -# serializer = PhotoSerializer(photo, data=data) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.data, data) - -# def test_writable_star_source_with_inner_source_fields(self): -# """ -# Tests that a serializer with source="*" correctly expands the -# it's fields into the outer serializer even if they have their -# own 'source' parameters. -# """ - -# serializer = ModelSerializerWithNestedSerializerWithRenamedField(data={ -# 'name': 'marko', -# 'nested': {'renamed_info': 'hi'}}, -# ) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.errors, {}) - - -# class CustomValidationTests(TestCase): -# class CommentSerializerWithFieldValidator(CommentSerializer): - -# def validate_email(self, attrs, source): -# attrs[source] -# return attrs - -# def validate_content(self, attrs, source): -# value = attrs[source] -# if "test" not in value: -# raise serializers.ValidationError("Test not in value") -# return attrs - -# def test_field_validation(self): -# data = { -# 'email': 'tom@example.com', -# 'content': 'A test comment', -# 'created': datetime.datetime(2012, 1, 1) -# } - -# serializer = self.CommentSerializerWithFieldValidator(data=data) -# self.assertTrue(serializer.is_valid()) - -# data['content'] = 'This should not validate' - -# serializer = self.CommentSerializerWithFieldValidator(data=data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'content': ['Test not in value']}) - -# def test_missing_data(self): -# """ -# Make sure that validate_content isn't called if the field is missing -# """ -# incomplete_data = { -# 'email': 'tom@example.com', -# 'created': datetime.datetime(2012, 1, 1) -# } -# serializer = self.CommentSerializerWithFieldValidator(data=incomplete_data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'content': ['This field is required.']}) - -# def test_wrong_data(self): -# """ -# Make sure that validate_content isn't called if the field input is wrong -# """ -# wrong_data = { -# 'email': 'not an email', -# 'content': 'A test comment', -# 'created': datetime.datetime(2012, 1, 1) -# } -# serializer = self.CommentSerializerWithFieldValidator(data=wrong_data) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'email': ['Enter a valid email address.']}) - -# def test_partial_update(self): -# """ -# Make sure that validate_email isn't called when partial=True and email -# isn't found in data. -# """ -# initial_data = { -# 'email': 'tom@example.com', -# 'content': 'A test comment', -# 'created': datetime.datetime(2012, 1, 1) -# } - -# serializer = self.CommentSerializerWithFieldValidator(data=initial_data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.object - -# new_content = 'An *updated* test comment' -# partial_data = { -# 'content': new_content -# } - -# serializer = self.CommentSerializerWithFieldValidator(instance=instance, -# data=partial_data, -# partial=True) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.object -# self.assertEqual(instance.content, new_content) - - -# class PositiveIntegerAsChoiceTests(TestCase): -# def test_positive_integer_in_json_is_correctly_parsed(self): -# data = {'some_integer': 1} -# serializer = PositiveIntegerAsChoiceSerializer(data=data) -# self.assertEqual(serializer.is_valid(), True) - - -# class ModelValidationTests(TestCase): -# def test_validate_unique(self): -# """ -# Just check if serializers.ModelSerializer handles unique checks via .full_clean() -# """ -# serializer = AlbumsSerializer(data={'title': 'a', 'ref': '1'}) -# serializer.is_valid() -# serializer.save() -# second_serializer = AlbumsSerializer(data={'title': 'a'}) -# self.assertFalse(second_serializer.is_valid()) -# self.assertEqual(second_serializer.errors, {'title': ['Album with this Title already exists.']}) -# third_serializer = AlbumsSerializer(data=[{'title': 'b', 'ref': '1'}, {'title': 'c'}], many=True) -# self.assertFalse(third_serializer.is_valid()) -# self.assertEqual(third_serializer.errors, [{'ref': ['Album with this Ref already exists.']}, {}]) - -# def test_foreign_key_is_null_with_partial(self): -# """ -# Test ModelSerializer validation with partial=True - -# Specifically test that a null foreign key does not pass validation -# """ -# album = Album(title='test') -# album.save() - -# class PhotoSerializer(serializers.ModelSerializer): -# class Meta: -# model = Photo - -# photo_serializer = PhotoSerializer(data={'description': 'test', 'album': album.pk}) -# self.assertTrue(photo_serializer.is_valid()) -# photo = photo_serializer.save() - -# # Updating only the album (foreign key) -# photo_serializer = PhotoSerializer(instance=photo, data={'album': ''}, partial=True) -# self.assertFalse(photo_serializer.is_valid()) -# self.assertTrue('album' in photo_serializer.errors) -# self.assertEqual(photo_serializer.errors['album'], [photo_serializer.error_messages['required']]) - -# def test_foreign_key_with_partial(self): -# """ -# Test ModelSerializer validation with partial=True - -# Specifically test foreign key validation. -# """ - -# album = Album(title='test') -# album.save() - -# class PhotoSerializer(serializers.ModelSerializer): -# class Meta: -# model = Photo - -# photo_serializer = PhotoSerializer(data={'description': 'test', 'album': album.pk}) -# self.assertTrue(photo_serializer.is_valid()) -# photo = photo_serializer.save() - -# # Updating only the album (foreign key) -# photo_serializer = PhotoSerializer(instance=photo, data={'album': album.pk}, partial=True) -# self.assertTrue(photo_serializer.is_valid()) -# self.assertTrue(photo_serializer.save()) - -# # Updating only the description -# photo_serializer = PhotoSerializer(instance=photo, -# data={'description': 'new'}, -# partial=True) - -# self.assertTrue(photo_serializer.is_valid()) -# self.assertTrue(photo_serializer.save()) - - -# class RegexValidationTest(TestCase): -# def test_create_failed(self): -# serializer = BookSerializer(data={'isbn': '1234567890'}) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) - -# serializer = BookSerializer(data={'isbn': '12345678901234'}) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) - -# serializer = BookSerializer(data={'isbn': 'abcdefghijklm'}) -# self.assertFalse(serializer.is_valid()) -# self.assertEqual(serializer.errors, {'isbn': ['isbn has to be exact 13 numbers']}) - -# def test_create_success(self): -# serializer = BookSerializer(data={'isbn': '1234567890123'}) -# self.assertTrue(serializer.is_valid()) - - -# class MetadataTests(TestCase): -# def test_empty(self): -# serializer = CommentSerializer() -# expected = { -# 'email': serializers.CharField, -# 'content': serializers.CharField, -# 'created': serializers.DateTimeField -# } -# for field_name, field in expected.items(): -# self.assertTrue(isinstance(serializer.data.fields[field_name], field)) - - -# class ManyToManyTests(TestCase): -# def setUp(self): -# class ManyToManySerializer(serializers.ModelSerializer): -# class Meta: -# model = ManyToManyModel - -# self.serializer_class = ManyToManySerializer - -# # An anchor instance to use for the relationship -# self.anchor = Anchor() -# self.anchor.save() - -# # A model instance with a many to many relationship to the anchor -# self.instance = ManyToManyModel() -# self.instance.save() -# self.instance.rel.add(self.anchor) - -# # A serialized representation of the model instance -# self.data = {'id': 1, 'rel': [self.anchor.id]} - -# def test_retrieve(self): -# """ -# Serialize an instance of a model with a ManyToMany relationship. -# """ -# serializer = self.serializer_class(instance=self.instance) -# expected = self.data -# self.assertEqual(serializer.data, expected) - -# def test_create(self): -# """ -# Create an instance of a model with a ManyToMany relationship. -# """ -# data = {'rel': [self.anchor.id]} -# serializer = self.serializer_class(data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(ManyToManyModel.objects.all()), 2) -# self.assertEqual(instance.pk, 2) -# self.assertEqual(list(instance.rel.all()), [self.anchor]) - -# def test_update(self): -# """ -# Update an instance of a model with a ManyToMany relationship. -# """ -# new_anchor = Anchor() -# new_anchor.save() -# data = {'rel': [self.anchor.id, new_anchor.id]} -# serializer = self.serializer_class(self.instance, data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(ManyToManyModel.objects.all()), 1) -# self.assertEqual(instance.pk, 1) -# self.assertEqual(list(instance.rel.all()), [self.anchor, new_anchor]) - -# def test_create_empty_relationship(self): -# """ -# Create an instance of a model with a ManyToMany relationship, -# containing no items. -# """ -# data = {'rel': []} -# serializer = self.serializer_class(data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(ManyToManyModel.objects.all()), 2) -# self.assertEqual(instance.pk, 2) -# self.assertEqual(list(instance.rel.all()), []) - -# def test_update_empty_relationship(self): -# """ -# Update an instance of a model with a ManyToMany relationship, -# containing no items. -# """ -# new_anchor = Anchor() -# new_anchor.save() -# data = {'rel': []} -# serializer = self.serializer_class(self.instance, data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(ManyToManyModel.objects.all()), 1) -# self.assertEqual(instance.pk, 1) -# self.assertEqual(list(instance.rel.all()), []) - -# def test_create_empty_relationship_flat_data(self): -# """ -# Create an instance of a model with a ManyToMany relationship, -# containing no items, using a representation that does not support -# lists (eg form data). -# """ -# data = MultiValueDict() -# data.setlist('rel', ['']) -# serializer = self.serializer_class(data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(ManyToManyModel.objects.all()), 2) -# self.assertEqual(instance.pk, 2) -# self.assertEqual(list(instance.rel.all()), []) - - -# class ReadOnlyManyToManyTests(TestCase): -# def setUp(self): -# class ReadOnlyManyToManySerializer(serializers.ModelSerializer): -# rel = serializers.RelatedField(many=True, read_only=True) - -# class Meta: -# model = ReadOnlyManyToManyModel - -# self.serializer_class = ReadOnlyManyToManySerializer - -# # An anchor instance to use for the relationship -# self.anchor = Anchor() -# self.anchor.save() - -# # A model instance with a many to many relationship to the anchor -# self.instance = ReadOnlyManyToManyModel() -# self.instance.save() -# self.instance.rel.add(self.anchor) - -# # A serialized representation of the model instance -# self.data = {'rel': [self.anchor.id], 'id': 1, 'text': 'anchor'} - -# def test_update(self): -# """ -# Attempt to update an instance of a model with a ManyToMany -# relationship. Not updated due to read_only=True -# """ -# new_anchor = Anchor() -# new_anchor.save() -# data = {'rel': [self.anchor.id, new_anchor.id]} -# serializer = self.serializer_class(self.instance, data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1) -# self.assertEqual(instance.pk, 1) -# # rel is still as original (1 entry) -# self.assertEqual(list(instance.rel.all()), [self.anchor]) - -# def test_update_without_relationship(self): -# """ -# Attempt to update an instance of a model where many to ManyToMany -# relationship is not supplied. Not updated due to read_only=True -# """ -# new_anchor = Anchor() -# new_anchor.save() -# data = {} -# serializer = self.serializer_class(self.instance, data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(ReadOnlyManyToManyModel.objects.all()), 1) -# self.assertEqual(instance.pk, 1) -# # rel is still as original (1 entry) -# self.assertEqual(list(instance.rel.all()), [self.anchor]) - - -# class DefaultValueTests(TestCase): -# def setUp(self): -# class DefaultValueSerializer(serializers.ModelSerializer): -# class Meta: -# model = DefaultValueModel - -# self.serializer_class = DefaultValueSerializer -# self.objects = DefaultValueModel.objects - -# def test_create_using_default(self): -# data = {} -# serializer = self.serializer_class(data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(self.objects.all()), 1) -# self.assertEqual(instance.pk, 1) -# self.assertEqual(instance.text, 'foobar') - -# def test_create_overriding_default(self): -# data = {'text': 'overridden'} -# serializer = self.serializer_class(data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(self.objects.all()), 1) -# self.assertEqual(instance.pk, 1) -# self.assertEqual(instance.text, 'overridden') - -# def test_partial_update_default(self): -# """ Regression test for issue #532 """ -# data = {'text': 'overridden'} -# serializer = self.serializer_class(data=data, partial=True) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() - -# data = {'extra': 'extra_value'} -# serializer = self.serializer_class(instance=instance, data=data, partial=True) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() - -# self.assertEqual(instance.extra, 'extra_value') -# self.assertEqual(instance.text, 'overridden') - - -# class WritableFieldDefaultValueTests(TestCase): - -# def setUp(self): -# self.expected = {'default': 'value'} -# self.create_field = fields.WritableField - -# def test_get_default_value_with_noncallable(self): -# field = self.create_field(default=self.expected) -# got = field.get_default_value() -# self.assertEqual(got, self.expected) - -# def test_get_default_value_with_callable(self): -# field = self.create_field(default=lambda: self.expected) -# got = field.get_default_value() -# self.assertEqual(got, self.expected) - -# def test_get_default_value_when_not_required(self): -# field = self.create_field(default=self.expected, required=False) -# got = field.get_default_value() -# self.assertEqual(got, self.expected) - -# def test_get_default_value_returns_None(self): -# field = self.create_field() -# got = field.get_default_value() -# self.assertIsNone(got) - -# def test_get_default_value_returns_non_True_values(self): -# values = [None, '', False, 0, [], (), {}] # values that assumed as 'False' in the 'if' clause -# for expected in values: -# field = self.create_field(default=expected) -# got = field.get_default_value() -# self.assertEqual(got, expected) - - -# class RelatedFieldDefaultValueTests(WritableFieldDefaultValueTests): - -# def setUp(self): -# self.expected = {'foo': 'bar'} -# self.create_field = relations.RelatedField - -# def test_get_default_value_returns_empty_list(self): -# field = self.create_field(many=True) -# got = field.get_default_value() -# self.assertListEqual(got, []) - -# def test_get_default_value_returns_expected(self): -# expected = [1, 2, 3] -# field = self.create_field(many=True, default=expected) -# got = field.get_default_value() -# self.assertListEqual(got, expected) - - -# class CallableDefaultValueTests(TestCase): -# def setUp(self): -# class CallableDefaultValueSerializer(serializers.ModelSerializer): -# class Meta: -# model = CallableDefaultValueModel - -# self.serializer_class = CallableDefaultValueSerializer -# self.objects = CallableDefaultValueModel.objects - -# def test_create_using_default(self): -# data = {} -# serializer = self.serializer_class(data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(self.objects.all()), 1) -# self.assertEqual(instance.pk, 1) -# self.assertEqual(instance.text, 'foobar') - -# def test_create_overriding_default(self): -# data = {'text': 'overridden'} -# serializer = self.serializer_class(data=data) -# self.assertEqual(serializer.is_valid(), True) -# instance = serializer.save() -# self.assertEqual(len(self.objects.all()), 1) -# self.assertEqual(instance.pk, 1) -# self.assertEqual(instance.text, 'overridden') - - -# class ManyRelatedTests(TestCase): -# def test_reverse_relations(self): -# post = BlogPost.objects.create(title="Test blog post") -# post.blogpostcomment_set.create(text="I hate this blog post") -# post.blogpostcomment_set.create(text="I love this blog post") - -# class BlogPostCommentSerializer(serializers.Serializer): -# text = serializers.CharField() - -# class BlogPostSerializer(serializers.Serializer): -# title = serializers.CharField() -# comments = BlogPostCommentSerializer(source='blogpostcomment_set') - -# serializer = BlogPostSerializer(instance=post) -# expected = { -# 'title': 'Test blog post', -# 'comments': [ -# {'text': 'I hate this blog post'}, -# {'text': 'I love this blog post'} -# ] -# } - -# self.assertEqual(serializer.data, expected) - -# def test_include_reverse_relations(self): -# post = BlogPost.objects.create(title="Test blog post") -# post.blogpostcomment_set.create(text="I hate this blog post") -# post.blogpostcomment_set.create(text="I love this blog post") - -# class BlogPostSerializer(serializers.ModelSerializer): -# class Meta: -# model = BlogPost -# fields = ('id', 'title', 'blogpostcomment_set') - -# serializer = BlogPostSerializer(instance=post) -# expected = { -# 'id': 1, 'title': 'Test blog post', 'blogpostcomment_set': [1, 2] -# } -# self.assertEqual(serializer.data, expected) - -# def test_depth_include_reverse_relations(self): -# post = BlogPost.objects.create(title="Test blog post") -# post.blogpostcomment_set.create(text="I hate this blog post") -# post.blogpostcomment_set.create(text="I love this blog post") - -# class BlogPostSerializer(serializers.ModelSerializer): -# class Meta: -# model = BlogPost -# fields = ('id', 'title', 'blogpostcomment_set') -# depth = 1 - -# serializer = BlogPostSerializer(instance=post) -# expected = { -# 'id': 1, 'title': 'Test blog post', -# 'blogpostcomment_set': [ -# {'id': 1, 'text': 'I hate this blog post', 'blog_post': 1}, -# {'id': 2, 'text': 'I love this blog post', 'blog_post': 1} -# ] -# } -# self.assertEqual(serializer.data, expected) - -# def test_callable_source(self): -# post = BlogPost.objects.create(title="Test blog post") -# post.blogpostcomment_set.create(text="I love this blog post") - -# class BlogPostCommentSerializer(serializers.Serializer): -# text = serializers.CharField() - -# class BlogPostSerializer(serializers.Serializer): -# title = serializers.CharField() -# first_comment = BlogPostCommentSerializer(source='get_first_comment') - -# serializer = BlogPostSerializer(post) - -# expected = { -# 'title': 'Test blog post', -# 'first_comment': {'text': 'I love this blog post'} -# } -# self.assertEqual(serializer.data, expected) - - -# class RelatedTraversalTest(TestCase): -# def test_nested_traversal(self): -# """ -# Source argument should support dotted.source notation. -# """ -# user = Person.objects.create(name="django") -# post = BlogPost.objects.create(title="Test blog post", writer=user) -# post.blogpostcomment_set.create(text="I love this blog post") - -# class PersonSerializer(serializers.ModelSerializer): -# class Meta: -# model = Person -# fields = ("name", "age") - -# class BlogPostCommentSerializer(serializers.ModelSerializer): -# class Meta: -# model = BlogPostComment -# fields = ("text", "post_owner") - -# text = serializers.CharField() -# post_owner = PersonSerializer(source='blog_post.writer') - -# class BlogPostSerializer(serializers.Serializer): -# title = serializers.CharField() -# comments = BlogPostCommentSerializer(source='blogpostcomment_set') - -# serializer = BlogPostSerializer(instance=post) - -# expected = { -# 'title': 'Test blog post', -# 'comments': [{ -# 'text': 'I love this blog post', -# 'post_owner': { -# "name": "django", -# "age": None -# } -# }] -# } - -# self.assertEqual(serializer.data, expected) - -# def test_nested_traversal_with_none(self): -# """ -# If a component of the dotted.source is None, return None for the field. -# """ -# from tests.models import NullableForeignKeySource -# instance = NullableForeignKeySource.objects.create(name='Source with null FK') - -# class NullableSourceSerializer(serializers.Serializer): -# target_name = serializers.Field(source='target.name') - -# serializer = NullableSourceSerializer(instance=instance) - -# expected = { -# 'target_name': None, -# } - -# self.assertEqual(serializer.data, expected) - - -# class SerializerMethodFieldTests(TestCase): -# def setUp(self): - -# class BoopSerializer(serializers.Serializer): -# beep = serializers.SerializerMethodField('get_beep') -# boop = serializers.Field() -# boop_count = serializers.SerializerMethodField('get_boop_count') - -# def get_beep(self, obj): -# return 'hello!' - -# def get_boop_count(self, obj): -# return len(obj.boop) - -# self.serializer_class = BoopSerializer - -# def test_serializer_method_field(self): - -# class MyModel(object): -# boop = ['a', 'b', 'c'] - -# source_data = MyModel() - -# serializer = self.serializer_class(source_data) - -# expected = { -# 'beep': 'hello!', -# 'boop': ['a', 'b', 'c'], -# 'boop_count': 3, -# } - -# self.assertEqual(serializer.data, expected) - - -# # Test for issue #324 -# class BlankFieldTests(TestCase): -# def setUp(self): - -# class BlankFieldModelSerializer(serializers.ModelSerializer): -# class Meta: -# model = BlankFieldModel - -# class BlankFieldSerializer(serializers.Serializer): -# title = serializers.CharField(required=False) - -# class NotBlankFieldModelSerializer(serializers.ModelSerializer): -# class Meta: -# model = BasicModel - -# class NotBlankFieldSerializer(serializers.Serializer): -# title = serializers.CharField() - -# self.model_serializer_class = BlankFieldModelSerializer -# self.serializer_class = BlankFieldSerializer -# self.not_blank_model_serializer_class = NotBlankFieldModelSerializer -# self.not_blank_serializer_class = NotBlankFieldSerializer -# self.data = {'title': ''} - -# def test_create_blank_field(self): -# serializer = self.serializer_class(data=self.data) -# self.assertEqual(serializer.is_valid(), True) - -# def test_create_model_blank_field(self): -# serializer = self.model_serializer_class(data=self.data) -# self.assertEqual(serializer.is_valid(), True) - -# def test_create_model_null_field(self): -# serializer = self.model_serializer_class(data={'title': None}) -# self.assertEqual(serializer.is_valid(), True) -# serializer.save() -# self.assertIsNot(serializer.object.pk, None) -# self.assertEqual(serializer.object.title, '') - -# def test_create_not_blank_field(self): -# """ -# Test to ensure blank data in a field not marked as blank=True -# is considered invalid in a non-model serializer -# """ -# serializer = self.not_blank_serializer_class(data=self.data) -# self.assertEqual(serializer.is_valid(), False) - -# def test_create_model_not_blank_field(self): -# """ -# Test to ensure blank data in a field not marked as blank=True -# is considered invalid in a model serializer -# """ -# serializer = self.not_blank_model_serializer_class(data=self.data) -# self.assertEqual(serializer.is_valid(), False) - -# def test_create_model_empty_field(self): -# serializer = self.model_serializer_class(data={}) -# self.assertEqual(serializer.is_valid(), True) - -# def test_create_model_null_field_save(self): -# """ -# Regression test for #1330. - -# https://github.com/tomchristie/django-rest-framework/pull/1330 -# """ -# serializer = self.model_serializer_class(data={'title': None}) -# self.assertEqual(serializer.is_valid(), True) - -# try: -# serializer.save() -# except Exception: -# self.fail('Exception raised on save() after validation passes') - - -# # Test for issue #460 -# class SerializerPickleTests(TestCase): -# """ -# Test pickleability of the output of Serializers -# """ -# def test_pickle_simple_model_serializer_data(self): -# """ -# Test simple serializer -# """ -# pickle.dumps(PersonSerializer(Person(name="Methusela", age=969)).data) - -# def test_pickle_inner_serializer(self): -# """ -# Test pickling a serializer whose resulting .data (a SortedDictWithMetadata) will -# have unpickleable meta data--in order to make sure metadata doesn't get pulled into the pickle. -# See DictWithMetadata.__getstate__ -# """ -# class InnerPersonSerializer(serializers.ModelSerializer): -# class Meta: -# model = Person -# fields = ('name', 'age') -# pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data, 0) - -# def test_getstate_method_should_not_return_none(self): -# """ -# Regression test for #645. -# """ -# data = serializers.DictWithMetadata({1: 1}) -# self.assertEqual(data.__getstate__(), serializers.SortedDict({1: 1})) - -# def test_serializer_data_is_pickleable(self): -# """ -# Another regression test for #645. -# """ -# data = serializers.SortedDictWithMetadata({1: 1}) -# repr(pickle.loads(pickle.dumps(data, 0))) - - -# # test for issue #725 -# class SeveralChoicesModel(models.Model): -# color = models.CharField( -# max_length=10, -# choices=[('red', 'Red'), ('green', 'Green'), ('blue', 'Blue')], -# blank=False -# ) -# drink = models.CharField( -# max_length=10, -# choices=[('beer', 'Beer'), ('wine', 'Wine'), ('cider', 'Cider')], -# blank=False, -# default='beer' -# ) -# os = models.CharField( -# max_length=10, -# choices=[('linux', 'Linux'), ('osx', 'OSX'), ('windows', 'Windows')], -# blank=True -# ) -# music_genre = models.CharField( -# max_length=10, -# choices=[('rock', 'Rock'), ('metal', 'Metal'), ('grunge', 'Grunge')], -# blank=True, -# default='metal' -# ) - - -# class SerializerChoiceFields(TestCase): - -# def setUp(self): -# super(SerializerChoiceFields, self).setUp() - -# class SeveralChoicesSerializer(serializers.ModelSerializer): -# class Meta: -# model = SeveralChoicesModel -# fields = ('color', 'drink', 'os', 'music_genre') - -# self.several_choices_serializer = SeveralChoicesSerializer - -# def test_choices_blank_false_not_default(self): -# serializer = self.several_choices_serializer() -# self.assertEqual( -# serializer.fields['color'].choices, -# [('red', 'Red'), ('green', 'Green'), ('blue', 'Blue')] -# ) - -# def test_choices_blank_false_with_default(self): -# serializer = self.several_choices_serializer() -# self.assertEqual( -# serializer.fields['drink'].choices, -# [('beer', 'Beer'), ('wine', 'Wine'), ('cider', 'Cider')] -# ) - -# def test_choices_blank_true_not_default(self): -# serializer = self.several_choices_serializer() -# self.assertEqual( -# serializer.fields['os'].choices, -# BLANK_CHOICE_DASH + [('linux', 'Linux'), ('osx', 'OSX'), ('windows', 'Windows')] -# ) - -# def test_choices_blank_true_with_default(self): -# serializer = self.several_choices_serializer() -# self.assertEqual( -# serializer.fields['music_genre'].choices, -# BLANK_CHOICE_DASH + [('rock', 'Rock'), ('metal', 'Metal'), ('grunge', 'Grunge')] -# ) - - -# # Regression tests for #675 -# class Ticket(models.Model): -# assigned = models.ForeignKey( -# Person, related_name='assigned_tickets') -# reviewer = models.ForeignKey( -# Person, blank=True, null=True, related_name='reviewed_tickets') - - -# class SerializerRelatedChoicesTest(TestCase): - -# def setUp(self): -# super(SerializerRelatedChoicesTest, self).setUp() - -# class RelatedChoicesSerializer(serializers.ModelSerializer): -# class Meta: -# model = Ticket -# fields = ('assigned', 'reviewer') - -# self.related_fields_serializer = RelatedChoicesSerializer - -# def test_empty_queryset_required(self): -# serializer = self.related_fields_serializer() -# self.assertEqual(serializer.fields['assigned'].queryset.count(), 0) -# self.assertEqual( -# [x for x in serializer.fields['assigned'].widget.choices], -# [] -# ) - -# def test_empty_queryset_not_required(self): -# serializer = self.related_fields_serializer() -# self.assertEqual(serializer.fields['reviewer'].queryset.count(), 0) -# self.assertEqual( -# [x for x in serializer.fields['reviewer'].widget.choices], -# [('', '---------')] -# ) - -# def test_with_some_persons_required(self): -# Person.objects.create(name="Lionel Messi") -# Person.objects.create(name="Xavi Hernandez") -# serializer = self.related_fields_serializer() -# self.assertEqual(serializer.fields['assigned'].queryset.count(), 2) -# self.assertEqual( -# [x for x in serializer.fields['assigned'].widget.choices], -# [(1, 'Person object - 1'), (2, 'Person object - 2')] -# ) - -# def test_with_some_persons_not_required(self): -# Person.objects.create(name="Lionel Messi") -# Person.objects.create(name="Xavi Hernandez") -# serializer = self.related_fields_serializer() -# self.assertEqual(serializer.fields['reviewer'].queryset.count(), 2) -# self.assertEqual( -# [x for x in serializer.fields['reviewer'].widget.choices], -# [('', '---------'), (1, 'Person object - 1'), (2, 'Person object - 2')] -# ) - - -# class DepthTest(TestCase): -# def test_implicit_nesting(self): - -# writer = Person.objects.create(name="django", age=1) -# post = BlogPost.objects.create(title="Test blog post", writer=writer) -# comment = BlogPostComment.objects.create(text="Test blog post comment", blog_post=post) - -# class BlogPostCommentSerializer(serializers.ModelSerializer): -# class Meta: -# model = BlogPostComment -# depth = 2 - -# serializer = BlogPostCommentSerializer(instance=comment) -# expected = {'id': 1, 'text': 'Test blog post comment', 'blog_post': {'id': 1, 'title': 'Test blog post', -# 'writer': {'id': 1, 'name': 'django', 'age': 1}}} - -# self.assertEqual(serializer.data, expected) - -# def test_explicit_nesting(self): -# writer = Person.objects.create(name="django", age=1) -# post = BlogPost.objects.create(title="Test blog post", writer=writer) -# comment = BlogPostComment.objects.create(text="Test blog post comment", blog_post=post) - -# class PersonSerializer(serializers.ModelSerializer): -# class Meta: -# model = Person - -# class BlogPostSerializer(serializers.ModelSerializer): -# writer = PersonSerializer() - -# class Meta: -# model = BlogPost - -# class BlogPostCommentSerializer(serializers.ModelSerializer): -# blog_post = BlogPostSerializer() - -# class Meta: -# model = BlogPostComment - -# serializer = BlogPostCommentSerializer(instance=comment) -# expected = {'id': 1, 'text': 'Test blog post comment', 'blog_post': {'id': 1, 'title': 'Test blog post', -# 'writer': {'id': 1, 'name': 'django', 'age': 1}}} - -# self.assertEqual(serializer.data, expected) - - -# class NestedSerializerContextTests(TestCase): - -# def test_nested_serializer_context(self): -# """ -# Regression for #497 - -# https://github.com/tomchristie/django-rest-framework/issues/497 -# """ -# class PhotoSerializer(serializers.ModelSerializer): -# class Meta: -# model = Photo -# fields = ("description", "callable") - -# callable = serializers.SerializerMethodField('_callable') - -# def _callable(self, instance): -# if 'context_item' not in self.context: -# raise RuntimeError("context isn't getting passed into 2nd level nested serializer") -# return "success" - -# class AlbumSerializer(serializers.ModelSerializer): -# class Meta: -# model = Album -# fields = ("photo_set", "callable") - -# photo_set = PhotoSerializer(source="photo_set", many=True) -# callable = serializers.SerializerMethodField("_callable") - -# def _callable(self, instance): -# if 'context_item' not in self.context: -# raise RuntimeError("context isn't getting passed into 1st level nested serializer") -# return "success" - -# class AlbumCollection(object): -# albums = None - -# class AlbumCollectionSerializer(serializers.Serializer): -# albums = AlbumSerializer(source="albums", many=True) - -# album1 = Album.objects.create(title="album 1") -# album2 = Album.objects.create(title="album 2") -# Photo.objects.create(description="Bigfoot", album=album1) -# Photo.objects.create(description="Unicorn", album=album1) -# Photo.objects.create(description="Yeti", album=album2) -# Photo.objects.create(description="Sasquatch", album=album2) -# album_collection = AlbumCollection() -# album_collection.albums = [album1, album2] - -# # This will raise RuntimeError if context doesn't get passed correctly to the nested Serializers -# AlbumCollectionSerializer(album_collection, context={'context_item': 'album context'}).data - - -# class DeserializeListTestCase(TestCase): - -# def setUp(self): -# self.data = { -# 'email': 'nobody@nowhere.com', -# 'content': 'This is some test content', -# 'created': datetime.datetime(2013, 3, 7), -# } - -# def test_no_errors(self): -# data = [self.data.copy() for x in range(0, 3)] -# serializer = CommentSerializer(data=data, many=True) -# self.assertTrue(serializer.is_valid()) -# self.assertTrue(isinstance(serializer.object, list)) -# self.assertTrue( -# all((isinstance(item, Comment) for item in serializer.object)) -# ) - -# def test_errors_return_as_list(self): -# invalid_item = self.data.copy() -# invalid_item['email'] = '' -# data = [self.data.copy(), invalid_item, self.data.copy()] - -# serializer = CommentSerializer(data=data, many=True) -# self.assertFalse(serializer.is_valid()) -# expected = [{}, {'email': ['This field is required.']}, {}] -# self.assertEqual(serializer.errors, expected) - - -# # Test for issue 747 - -# class LazyStringModel(object): -# def __init__(self, lazystring): -# self.lazystring = lazystring - - -# class LazyStringSerializer(serializers.Serializer): -# lazystring = serializers.Field() - -# def restore_object(self, attrs, instance=None): -# if instance is not None: -# instance.lazystring = attrs.get('lazystring', instance.lazystring) -# return instance -# return LazyStringModel(**attrs) - - -# class LazyStringsTestCase(TestCase): -# def setUp(self): -# self.model = LazyStringModel(lazystring=_('lazystring')) - -# def test_lazy_strings_are_translated(self): -# serializer = LazyStringSerializer(self.model) -# self.assertEqual(type(serializer.data['lazystring']), -# type('lazystring')) - - -# # Test for issue #467 - -# class FieldLabelTest(TestCase): -# def setUp(self): -# self.serializer_class = BasicModelSerializer - -# def test_label_from_model(self): -# """ -# Validates that label and help_text are correctly copied from the model class. -# """ -# serializer = self.serializer_class() -# text_field = serializer.fields['text'] - -# self.assertEqual('Text comes here', text_field.label) -# self.assertEqual('Text description.', text_field.help_text) - -# def test_field_ctor(self): -# """ -# This is check that ctor supports both label and help_text. -# """ -# self.assertEqual('Label', fields.Field(label='Label', help_text='Help').label) -# self.assertEqual('Help', fields.CharField(label='Label', help_text='Help').help_text) -# self.assertEqual('Label', relations.HyperlinkedRelatedField(view_name='fake', label='Label', help_text='Help', many=True).label) - - -# # Test for issue #961 - -# class ManyFieldHelpTextTest(TestCase): -# def test_help_text_no_hold_down_control_msg(self): -# """ -# Validate that help_text doesn't contain the 'Hold down "Control" ...' -# message that Django appends to choice fields. -# """ -# rel_field = fields.Field(help_text=ManyToManyModel._meta.get_field('rel').help_text) -# self.assertEqual('Some help text.', rel_field.help_text) - - -# class AttributeMappingOnAutogeneratedRelatedFields(TestCase): - -# def test_primary_key_related_field(self): -# serializer = ForeignKeySourceSerializer() -# self.assertEqual(serializer.fields['target'].help_text, 'Target') -# self.assertEqual(serializer.fields['target'].label, 'Target') - -# def test_hyperlinked_related_field(self): -# serializer = HyperlinkedForeignKeySourceSerializer() -# self.assertEqual(serializer.fields['target'].help_text, 'Target') -# self.assertEqual(serializer.fields['target'].label, 'Target') - - -# @unittest.skipUnless(PIL is not None, 'PIL is not installed') -# class AttributeMappingOnAutogeneratedFieldsTests(TestCase): - -# def setUp(self): - -# class AMOAFSerializer(serializers.ModelSerializer): -# class Meta: -# model = AMOAFModel - -# self.serializer_class = AMOAFSerializer -# self.fields_attributes = { -# 'char_field': [ -# ('max_length', 1024), -# ], -# 'comma_separated_integer_field': [ -# ('max_length', 1024), -# ], -# 'decimal_field': [ -# ('max_digits', 64), -# ('decimal_places', 32), -# ], -# 'email_field': [ -# ('max_length', 1024), -# ], -# 'file_field': [ -# ('max_length', 1024), -# ], -# 'image_field': [ -# ('max_length', 1024), -# ], -# 'slug_field': [ -# ('max_length', 1024), -# ], -# 'url_field': [ -# ('max_length', 1024), -# ], -# 'nullable_char_field': [ -# ('max_length', 1024), -# ('allow_none', True), -# ], -# } - -# def field_test(self, field): -# serializer = self.serializer_class(data={}) -# self.assertEqual(serializer.is_valid(), True) - -# for attribute in self.fields_attributes[field]: -# self.assertEqual( -# getattr(serializer.fields[field], attribute[0]), -# attribute[1] -# ) - -# def test_char_field(self): -# self.field_test('char_field') - -# def test_comma_separated_integer_field(self): -# self.field_test('comma_separated_integer_field') - -# def test_decimal_field(self): -# self.field_test('decimal_field') - -# def test_email_field(self): -# self.field_test('email_field') - -# def test_file_field(self): -# self.field_test('file_field') - -# def test_image_field(self): -# self.field_test('image_field') - -# def test_slug_field(self): -# self.field_test('slug_field') - -# def test_url_field(self): -# self.field_test('url_field') - -# def test_nullable_char_field(self): -# self.field_test('nullable_char_field') - - -# @unittest.skipUnless(PIL is not None, 'PIL is not installed') -# class DefaultValuesOnAutogeneratedFieldsTests(TestCase): - -# def setUp(self): - -# class DVOAFSerializer(serializers.ModelSerializer): -# class Meta: -# model = DVOAFModel - -# self.serializer_class = DVOAFSerializer -# self.fields_attributes = { -# 'positive_integer_field': [ -# ('min_value', 0), -# ], -# 'positive_small_integer_field': [ -# ('min_value', 0), -# ], -# 'email_field': [ -# ('max_length', 75), -# ], -# 'file_field': [ -# ('max_length', 100), -# ], -# 'image_field': [ -# ('max_length', 100), -# ], -# 'slug_field': [ -# ('max_length', 50), -# ], -# 'url_field': [ -# ('max_length', 200), -# ], -# } - -# def field_test(self, field): -# serializer = self.serializer_class(data={}) -# self.assertEqual(serializer.is_valid(), True) - -# for attribute in self.fields_attributes[field]: -# self.assertEqual( -# getattr(serializer.fields[field], attribute[0]), -# attribute[1] -# ) - -# def test_positive_integer_field(self): -# self.field_test('positive_integer_field') - -# def test_positive_small_integer_field(self): -# self.field_test('positive_small_integer_field') - -# def test_email_field(self): -# self.field_test('email_field') - -# def test_file_field(self): -# self.field_test('file_field') - -# def test_image_field(self): -# self.field_test('image_field') - -# def test_slug_field(self): -# self.field_test('slug_field') - -# def test_url_field(self): -# self.field_test('url_field') - - -# class MetadataSerializer(serializers.Serializer): -# field1 = serializers.CharField(max_length=3, required=True) -# field2 = serializers.CharField(max_length=10, required=False) - - -# class MetadataSerializerTestCase(TestCase): -# def setUp(self): -# self.serializer = MetadataSerializer() - -# def test_serializer_metadata(self): -# metadata = self.serializer.metadata() -# expected = { -# 'field1': { -# 'required': True, -# 'max_length': 3, -# 'type': 'string', -# 'read_only': False -# }, -# 'field2': { -# 'required': False, -# 'max_length': 10, -# 'type': 'string', -# 'read_only': False -# } -# } -# self.assertEqual(expected, metadata) - - -# # Regression test for #840 - -# class SimpleModel(models.Model): -# text = models.CharField(max_length=100) - - -# class SimpleModelSerializer(serializers.ModelSerializer): -# text = serializers.CharField() -# other = serializers.CharField() - -# class Meta: -# model = SimpleModel - -# def validate_other(self, attrs, source): -# del attrs['other'] -# return attrs - - -# class FieldValidationRemovingAttr(TestCase): -# def test_removing_non_model_field_in_validation(self): -# """ -# Removing an attr during field valiation should ensure that it is not -# passed through when restoring the object. - -# This allows additional non-model fields to be supported. - -# Regression test for #840. -# """ -# serializer = SimpleModelSerializer(data={'text': 'foo', 'other': 'bar'}) -# self.assertTrue(serializer.is_valid()) -# serializer.save() -# self.assertEqual(serializer.object.text, 'foo') - - -# # Regression test for #878 - -# class SimpleTargetModel(models.Model): -# text = models.CharField(max_length=100) - - -# class SimplePKSourceModelSerializer(serializers.Serializer): -# targets = serializers.PrimaryKeyRelatedField(queryset=SimpleTargetModel.objects.all(), many=True) -# text = serializers.CharField() - - -# class SimpleSlugSourceModelSerializer(serializers.Serializer): -# targets = serializers.SlugRelatedField(queryset=SimpleTargetModel.objects.all(), many=True, slug_field='pk') -# text = serializers.CharField() - - -# class SerializerSupportsManyRelationships(TestCase): -# def setUp(self): -# SimpleTargetModel.objects.create(text='foo') -# SimpleTargetModel.objects.create(text='bar') - -# def test_serializer_supports_pk_many_relationships(self): -# """ -# Regression test for #878. - -# Note that pk behavior has a different code path to usual cases, -# for performance reasons. -# """ -# serializer = SimplePKSourceModelSerializer(data={'text': 'foo', 'targets': [1, 2]}) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, {'text': 'foo', 'targets': [1, 2]}) - -# def test_serializer_supports_slug_many_relationships(self): -# """ -# Regression test for #878. -# """ -# serializer = SimpleSlugSourceModelSerializer(data={'text': 'foo', 'targets': [1, 2]}) -# self.assertTrue(serializer.is_valid()) -# self.assertEqual(serializer.data, {'text': 'foo', 'targets': [1, 2]}) - - -# class TransformMethodsSerializer(serializers.Serializer): -# a = serializers.CharField() -# b_renamed = serializers.CharField(source='b') - -# def transform_a(self, obj, value): -# return value.lower() - -# def transform_b_renamed(self, obj, value): -# if value is not None: -# return 'and ' + value - - -# class TestSerializerTransformMethods(TestCase): -# def setUp(self): -# self.s = TransformMethodsSerializer() - -# def test_transform_methods(self): -# self.assertEqual( -# self.s.to_native({'a': 'GREEN EGGS', 'b': 'HAM'}), -# { -# 'a': 'green eggs', -# 'b_renamed': 'and HAM', -# } -# ) - -# def test_missing_fields(self): -# self.assertEqual( -# self.s.to_native({'a': 'GREEN EGGS'}), -# { -# 'a': 'green eggs', -# 'b_renamed': None, -# } -# ) - - -# class DefaultTrueBooleanModel(models.Model): -# cat = models.BooleanField(default=True) -# dog = models.BooleanField(default=False) - - -# class SerializerDefaultTrueBoolean(TestCase): - -# def setUp(self): -# super(SerializerDefaultTrueBoolean, self).setUp() - -# class DefaultTrueBooleanSerializer(serializers.ModelSerializer): -# class Meta: -# model = DefaultTrueBooleanModel -# fields = ('cat', 'dog') - -# self.default_true_boolean_serializer = DefaultTrueBooleanSerializer - -# def test_enabled_as_false(self): -# serializer = self.default_true_boolean_serializer(data={'cat': False, -# 'dog': False}) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.data['cat'], False) -# self.assertEqual(serializer.data['dog'], False) - -# def test_enabled_as_true(self): -# serializer = self.default_true_boolean_serializer(data={'cat': True, -# 'dog': True}) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.data['cat'], True) -# self.assertEqual(serializer.data['dog'], True) - -# def test_enabled_partial(self): -# serializer = self.default_true_boolean_serializer(data={'cat': False}, -# partial=True) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.data['cat'], False) -# self.assertEqual(serializer.data['dog'], False) - - -# class BoolenFieldTypeTest(TestCase): -# ''' -# Ensure the various Boolean based model fields are rendered as the proper -# field type - -# ''' - -# def setUp(self): -# ''' -# Setup an ActionItemSerializer for BooleanTesting -# ''' -# data = { -# 'title': 'b' * 201, -# } -# self.serializer = ActionItemSerializer(data=data) - -# def test_booleanfield_type(self): -# ''' -# Test that BooleanField is infered from models.BooleanField -# ''' -# bfield = self.serializer.get_fields()['done'] -# self.assertEqual(type(bfield), fields.BooleanField) - -# def test_nullbooleanfield_type(self): -# ''' -# Test that BooleanField is infered from models.NullBooleanField - -# https://groups.google.com/forum/#!topic/django-rest-framework/D9mXEftpuQ8 -# ''' -# bfield = self.serializer.get_fields()['started'] -# self.assertEqual(type(bfield), fields.BooleanField) diff --git a/tests/test_serializer_bulk_update.py b/tests/test_serializer_bulk_update.py index 2259ee31..fb881a75 100644 --- a/tests/test_serializer_bulk_update.py +++ b/tests/test_serializer_bulk_update.py @@ -121,161 +121,3 @@ class BulkCreateSerializerTests(TestCase): expected_errors = {'non_field_errors': ['Expected a list of items but got type `dict`.']} self.assertEqual(serializer.errors, expected_errors) - - -# class BulkUpdateSerializerTests(TestCase): -# """ -# Updating multiple instances using serializers. -# """ - -# def setUp(self): -# class Book(object): -# """ -# A data type that can be persisted to a mock storage backend -# with `.save()` and `.delete()`. -# """ -# object_map = {} - -# def __init__(self, id, title, author): -# self.id = id -# self.title = title -# self.author = author - -# def save(self): -# Book.object_map[self.id] = self - -# def delete(self): -# del Book.object_map[self.id] - -# class BookSerializer(serializers.Serializer): -# id = serializers.IntegerField() -# title = serializers.CharField(max_length=100) -# author = serializers.CharField(max_length=100) - -# def restore_object(self, attrs, instance=None): -# if instance: -# instance.id = attrs['id'] -# instance.title = attrs['title'] -# instance.author = attrs['author'] -# return instance -# return Book(**attrs) - -# self.Book = Book -# self.BookSerializer = BookSerializer - -# data = [ -# { -# 'id': 0, -# 'title': 'The electric kool-aid acid test', -# 'author': 'Tom Wolfe' -# }, { -# 'id': 1, -# 'title': 'If this is a man', -# 'author': 'Primo Levi' -# }, { -# 'id': 2, -# 'title': 'The wind-up bird chronicle', -# 'author': 'Haruki Murakami' -# } -# ] - -# for item in data: -# book = Book(item['id'], item['title'], item['author']) -# book.save() - -# def books(self): -# """ -# Return all the objects in the mock storage backend. -# """ -# return self.Book.object_map.values() - -# def test_bulk_update_success(self): -# """ -# Correct bulk update serialization should return the input data. -# """ -# data = [ -# { -# 'id': 0, -# 'title': 'The electric kool-aid acid test', -# 'author': 'Tom Wolfe' -# }, { -# 'id': 2, -# 'title': 'Kafka on the shore', -# 'author': 'Haruki Murakami' -# } -# ] -# serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.data, data) -# serializer.save() -# new_data = self.BookSerializer(self.books(), many=True).data - -# self.assertEqual(data, new_data) - -# def test_bulk_update_and_create(self): -# """ -# Bulk update serialization may also include created items. -# """ -# data = [ -# { -# 'id': 0, -# 'title': 'The electric kool-aid acid test', -# 'author': 'Tom Wolfe' -# }, { -# 'id': 3, -# 'title': 'Kafka on the shore', -# 'author': 'Haruki Murakami' -# } -# ] -# serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.data, data) -# serializer.save() -# new_data = self.BookSerializer(self.books(), many=True).data -# self.assertEqual(data, new_data) - -# def test_bulk_update_invalid_create(self): -# """ -# Bulk update serialization without allow_add_remove may not create items. -# """ -# data = [ -# { -# 'id': 0, -# 'title': 'The electric kool-aid acid test', -# 'author': 'Tom Wolfe' -# }, { -# 'id': 3, -# 'title': 'Kafka on the shore', -# 'author': 'Haruki Murakami' -# } -# ] -# expected_errors = [ -# {}, -# {'non_field_errors': ['Cannot create a new item, only existing items may be updated.']} -# ] -# serializer = self.BookSerializer(self.books(), data=data, many=True) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, expected_errors) - -# def test_bulk_update_error(self): -# """ -# Incorrect bulk update serialization should return error data. -# """ -# data = [ -# { -# 'id': 0, -# 'title': 'The electric kool-aid acid test', -# 'author': 'Tom Wolfe' -# }, { -# 'id': 'foo', -# 'title': 'Kafka on the shore', -# 'author': 'Haruki Murakami' -# } -# ] -# expected_errors = [ -# {}, -# {'id': ['Enter a whole number.']} -# ] -# serializer = self.BookSerializer(self.books(), data=data, many=True, allow_add_remove=True) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, expected_errors) diff --git a/tests/test_serializer_empty.py b/tests/test_serializer_empty.py deleted file mode 100644 index 805ac7d4..00000000 --- a/tests/test_serializer_empty.py +++ /dev/null @@ -1,15 +0,0 @@ -# from django.test import TestCase -# from rest_framework import serializers - - -# class EmptySerializerTestCase(TestCase): -# def test_empty_serializer(self): -# class FooBarSerializer(serializers.Serializer): -# foo = serializers.IntegerField() -# bar = serializers.SerializerMethodField() - -# def get_bar(self, obj): -# return 'bar' - -# serializer = FooBarSerializer() -# self.assertEquals(serializer.data, {'foo': 0}) diff --git a/tests/test_serializer_nested.py b/tests/test_serializer_nested.py index 5e207449..f5e4b26a 100644 --- a/tests/test_serializer_nested.py +++ b/tests/test_serializer_nested.py @@ -38,353 +38,3 @@ class TestNestedSerializer: } serializer = self.Serializer() assert serializer.data == expected_data - -# """ -# Tests to cover nested serializers. - -# Doesn't cover model serializers. -# """ -# from __future__ import unicode_literals -# from django.test import TestCase -# from rest_framework import serializers -# from . import models - - -# class WritableNestedSerializerBasicTests(TestCase): -# """ -# Tests for deserializing nested entities. -# Basic tests that use serializers that simply restore to dicts. -# """ - -# def setUp(self): -# class TrackSerializer(serializers.Serializer): -# order = serializers.IntegerField() -# title = serializers.CharField(max_length=100) -# duration = serializers.IntegerField() - -# class AlbumSerializer(serializers.Serializer): -# album_name = serializers.CharField(max_length=100) -# artist = serializers.CharField(max_length=100) -# tracks = TrackSerializer(many=True) - -# self.AlbumSerializer = AlbumSerializer - -# def test_nested_validation_success(self): -# """ -# Correct nested serialization should return the input data. -# """ - -# data = { -# 'album_name': 'Discovery', -# 'artist': 'Daft Punk', -# 'tracks': [ -# {'order': 1, 'title': 'One More Time', 'duration': 235}, -# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, -# {'order': 3, 'title': 'Digital Love', 'duration': 239} -# ] -# } - -# serializer = self.AlbumSerializer(data=data) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, data) - -# def test_nested_validation_error(self): -# """ -# Incorrect nested serialization should return appropriate error data. -# """ - -# data = { -# 'album_name': 'Discovery', -# 'artist': 'Daft Punk', -# 'tracks': [ -# {'order': 1, 'title': 'One More Time', 'duration': 235}, -# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, -# {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'} -# ] -# } -# expected_errors = { -# 'tracks': [ -# {}, -# {}, -# {'duration': ['Enter a whole number.']} -# ] -# } - -# serializer = self.AlbumSerializer(data=data) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, expected_errors) - -# def test_many_nested_validation_error(self): -# """ -# Incorrect nested serialization should return appropriate error data -# when multiple entities are being deserialized. -# """ - -# data = [ -# { -# 'album_name': 'Russian Red', -# 'artist': 'I Love Your Glasses', -# 'tracks': [ -# {'order': 1, 'title': 'Cigarettes', 'duration': 121}, -# {'order': 2, 'title': 'No Past Land', 'duration': 198}, -# {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191} -# ] -# }, -# { -# 'album_name': 'Discovery', -# 'artist': 'Daft Punk', -# 'tracks': [ -# {'order': 1, 'title': 'One More Time', 'duration': 235}, -# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, -# {'order': 3, 'title': 'Digital Love', 'duration': 'foobar'} -# ] -# } -# ] -# expected_errors = [ -# {}, -# { -# 'tracks': [ -# {}, -# {}, -# {'duration': ['Enter a whole number.']} -# ] -# } -# ] - -# serializer = self.AlbumSerializer(data=data, many=True) -# self.assertEqual(serializer.is_valid(), False) -# self.assertEqual(serializer.errors, expected_errors) - - -# class WritableNestedSerializerObjectTests(TestCase): -# """ -# Tests for deserializing nested entities. -# These tests use serializers that restore to concrete objects. -# """ - -# def setUp(self): -# # Couple of concrete objects that we're going to deserialize into -# class Track(object): -# def __init__(self, order, title, duration): -# self.order, self.title, self.duration = order, title, duration - -# def __eq__(self, other): -# return ( -# self.order == other.order and -# self.title == other.title and -# self.duration == other.duration -# ) - -# class Album(object): -# def __init__(self, album_name, artist, tracks): -# self.album_name, self.artist, self.tracks = album_name, artist, tracks - -# def __eq__(self, other): -# return ( -# self.album_name == other.album_name and -# self.artist == other.artist and -# self.tracks == other.tracks -# ) - -# # And their corresponding serializers -# class TrackSerializer(serializers.Serializer): -# order = serializers.IntegerField() -# title = serializers.CharField(max_length=100) -# duration = serializers.IntegerField() - -# def restore_object(self, attrs, instance=None): -# return Track(attrs['order'], attrs['title'], attrs['duration']) - -# class AlbumSerializer(serializers.Serializer): -# album_name = serializers.CharField(max_length=100) -# artist = serializers.CharField(max_length=100) -# tracks = TrackSerializer(many=True) - -# def restore_object(self, attrs, instance=None): -# return Album(attrs['album_name'], attrs['artist'], attrs['tracks']) - -# self.Album, self.Track = Album, Track -# self.AlbumSerializer = AlbumSerializer - -# def test_nested_validation_success(self): -# """ -# Correct nested serialization should return a restored object -# that corresponds to the input data. -# """ - -# data = { -# 'album_name': 'Discovery', -# 'artist': 'Daft Punk', -# 'tracks': [ -# {'order': 1, 'title': 'One More Time', 'duration': 235}, -# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, -# {'order': 3, 'title': 'Digital Love', 'duration': 239} -# ] -# } -# expected_object = self.Album( -# album_name='Discovery', -# artist='Daft Punk', -# tracks=[ -# self.Track(order=1, title='One More Time', duration=235), -# self.Track(order=2, title='Aerodynamic', duration=184), -# self.Track(order=3, title='Digital Love', duration=239), -# ] -# ) - -# serializer = self.AlbumSerializer(data=data) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, expected_object) - -# def test_many_nested_validation_success(self): -# """ -# Correct nested serialization should return multiple restored objects -# that corresponds to the input data when multiple objects are -# being deserialized. -# """ - -# data = [ -# { -# 'album_name': 'Russian Red', -# 'artist': 'I Love Your Glasses', -# 'tracks': [ -# {'order': 1, 'title': 'Cigarettes', 'duration': 121}, -# {'order': 2, 'title': 'No Past Land', 'duration': 198}, -# {'order': 3, 'title': 'They Don\'t Believe', 'duration': 191} -# ] -# }, -# { -# 'album_name': 'Discovery', -# 'artist': 'Daft Punk', -# 'tracks': [ -# {'order': 1, 'title': 'One More Time', 'duration': 235}, -# {'order': 2, 'title': 'Aerodynamic', 'duration': 184}, -# {'order': 3, 'title': 'Digital Love', 'duration': 239} -# ] -# } -# ] -# expected_object = [ -# self.Album( -# album_name='Russian Red', -# artist='I Love Your Glasses', -# tracks=[ -# self.Track(order=1, title='Cigarettes', duration=121), -# self.Track(order=2, title='No Past Land', duration=198), -# self.Track(order=3, title='They Don\'t Believe', duration=191), -# ] -# ), -# self.Album( -# album_name='Discovery', -# artist='Daft Punk', -# tracks=[ -# self.Track(order=1, title='One More Time', duration=235), -# self.Track(order=2, title='Aerodynamic', duration=184), -# self.Track(order=3, title='Digital Love', duration=239), -# ] -# ) -# ] - -# serializer = self.AlbumSerializer(data=data, many=True) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, expected_object) - - -# class ForeignKeyNestedSerializerUpdateTests(TestCase): -# def setUp(self): -# class Artist(object): -# def __init__(self, name): -# self.name = name - -# def __eq__(self, other): -# return self.name == other.name - -# class Album(object): -# def __init__(self, name, artist): -# self.name, self.artist = name, artist - -# def __eq__(self, other): -# return self.name == other.name and self.artist == other.artist - -# class ArtistSerializer(serializers.Serializer): -# name = serializers.CharField() - -# def restore_object(self, attrs, instance=None): -# if instance: -# instance.name = attrs['name'] -# else: -# instance = Artist(attrs['name']) -# return instance - -# class AlbumSerializer(serializers.Serializer): -# name = serializers.CharField() -# by = ArtistSerializer(source='artist') - -# def restore_object(self, attrs, instance=None): -# if instance: -# instance.name = attrs['name'] -# instance.artist = attrs['artist'] -# else: -# instance = Album(attrs['name'], attrs['artist']) -# return instance - -# self.Artist = Artist -# self.Album = Album -# self.AlbumSerializer = AlbumSerializer - -# def test_create_via_foreign_key_with_source(self): -# """ -# Check that we can both *create* and *update* into objects across -# ForeignKeys that have a `source` specified. -# Regression test for #1170 -# """ -# data = { -# 'name': 'Discovery', -# 'by': {'name': 'Daft Punk'}, -# } - -# expected = self.Album(artist=self.Artist('Daft Punk'), name='Discovery') - -# # create -# serializer = self.AlbumSerializer(data=data) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, expected) - -# # update -# original = self.Album(artist=self.Artist('The Bats'), name='Free All the Monsters') -# serializer = self.AlbumSerializer(instance=original, data=data) -# self.assertEqual(serializer.is_valid(), True) -# self.assertEqual(serializer.object, expected) - - -# class NestedModelSerializerUpdateTests(TestCase): -# def test_second_nested_level(self): -# john = models.Person.objects.create(name="john") - -# post = john.blogpost_set.create(title="Test blog post") -# post.blogpostcomment_set.create(text="I hate this blog post") -# post.blogpostcomment_set.create(text="I love this blog post") - -# class BlogPostCommentSerializer(serializers.ModelSerializer): -# class Meta: -# model = models.BlogPostComment - -# class BlogPostSerializer(serializers.ModelSerializer): -# comments = BlogPostCommentSerializer(many=True, source='blogpostcomment_set') - -# class Meta: -# model = models.BlogPost -# fields = ('id', 'title', 'comments') - -# class PersonSerializer(serializers.ModelSerializer): -# posts = BlogPostSerializer(many=True, source='blogpost_set') - -# class Meta: -# model = models.Person -# fields = ('id', 'name', 'age', 'posts') - -# serialize = PersonSerializer(instance=john) -# deserialize = PersonSerializer(data=serialize.data, instance=john) -# self.assertTrue(deserialize.is_valid()) - -# result = deserialize.object -# result.save() -# self.assertEqual(result.id, john.id) diff --git a/tests/test_validation.py b/tests/test_validation.py index 3db82555..4234efd3 100644 --- a/tests/test_validation.py +++ b/tests/test_validation.py @@ -165,17 +165,6 @@ class TestChoiceFieldChoicesValidate(TestCase): except serializers.ValidationError: self.fail("Value %s does not validate" % str(value)) - # def test_nested_choices(self): - # """ - # Make sure a nested value for choices works as expected. - # """ - # f = serializers.ChoiceField(choices=self.CHOICES_NESTED) - # value = self.CHOICES_NESTED[0][1][0][0] - # try: - # f.to_native(value) - # except ValidationError: - # self.fail("Value %s does not validate" % str(value)) - class RegexSerializer(serializers.Serializer): pin = serializers.CharField( -- cgit v1.2.3 From 66b3daebbd0da8aee178585cae9ebe561494533e Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 13:14:47 +0000 Subject: Docs. Sponsor call-out. --- docs/topics/3.0-announcement.md | 21 +++++---------------- 1 file changed, 5 insertions(+), 16 deletions(-) diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 9087e2ae..72268247 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -1,19 +1,3 @@ -## Pre-release notes: - -The 3.0 release is now in beta and ready for final testing. You can install the development version directly from GitHub like so: - - pip install https://github.com/tomchristie/django-rest-framework/archive/3.0-beta.zip - -Currently the only known remaining blockers are documentation issues and tickets. Any critical bugs raised in the next week or two will be resolved for the 3.0 release, but otherwise consider this as code-complete. - -Please work through this document throughly in order to understand the API differences that exist between 2.4 and 3.0. - -**Your feedback on the upgrade process and 3.0 changes is hugely important!** - -Please do get in touch via twitter, IRC, a GitHub ticket, or the discussion group. - ---- - # REST framework 3.0 The 3.0 release of Django REST framework is the result of almost four years of iteration and refinement. It comprehensively addresses some of the previous remaining design issues in serializers, fields and the generic views. @@ -22,6 +6,10 @@ This release is incremental in nature. There *are* some breaking API changes, an The difference in quality of the REST framework API and implementation should make writing, maintaining and debugging your application far easier. +3.0 is the first of three releases that have been funded by our recent [Kickstarter campaign](kickstarter.com/projects/tomchristie/django-rest-framework-3). + +As ever, a huge thank you to our many [wonderful sponsors](sponsors). If you're looking for a Django gig, and want to work with smart community-minded folks, you should probably check out that list and see who's hiring. + ## New features Notable features of this new release include: @@ -931,4 +919,5 @@ The 3.2 release is planned to introduce an alternative admin-style interface to You can follow development on the GitHub site, where we use [milestones to indicate planning timescales](https://github.com/tomchristie/django-rest-framework/milestones). +[sponsors]: http://www.django-rest-framework.org/topics/kickstarter-announcement/#sponsors [mixins.py]: https://github.com/tomchristie/django-rest-framework/blob/master/rest_framework/mixins.py -- cgit v1.2.3 From 8e549a76ea0ff6b44e1dcf08ba733a5fbfc004ed Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 14:26:03 +0000 Subject: Add 2.x notes and links --- docs/api-guide/fields.md | 6 ++++++ docs/api-guide/generic-views.md | 6 ++++++ docs/api-guide/metadata.md | 6 ++++++ docs/api-guide/relations.md | 6 ++++++ docs/api-guide/requests.md | 6 ++++++ docs/api-guide/serializers.md | 6 ++++++ docs/api-guide/validators.md | 6 ++++++ docs/index.md | 2 +- 8 files changed, 43 insertions(+), 1 deletion(-) diff --git a/docs/api-guide/fields.md b/docs/api-guide/fields.md index ca551540..391a52e5 100644 --- a/docs/api-guide/fields.md +++ b/docs/api-guide/fields.md @@ -1,5 +1,11 @@ source: fields.py +--- + +**Note**: This is the documentation for the **version 3.0** of REST framework. Documentation for [version 2.4](http://tomchristie.github.io/rest-framework-2-docs/) is also available. + +--- + # Serializer fields > Each field in a Form class is responsible not only for validating data, but also for "cleaning" it — normalizing it to a consistent format. diff --git a/docs/api-guide/generic-views.md b/docs/api-guide/generic-views.md index 8c1b7dc9..f5bbdfdd 100755 --- a/docs/api-guide/generic-views.md +++ b/docs/api-guide/generic-views.md @@ -1,6 +1,12 @@ source: mixins.py generics.py +--- + +**Note**: This is the documentation for the **version 3.0** of REST framework. Documentation for [version 2.4](http://tomchristie.github.io/rest-framework-2-docs/) is also available. + +--- + # Generic views > Django’s generic views... were developed as a shortcut for common usage patterns... They take certain common idioms and patterns found in view development and abstract them so that you can quickly write common views of data without having to repeat yourself. diff --git a/docs/api-guide/metadata.md b/docs/api-guide/metadata.md index c3f036b7..c3e51148 100644 --- a/docs/api-guide/metadata.md +++ b/docs/api-guide/metadata.md @@ -1,5 +1,11 @@ <a class="github" href="metadata.py"></a> +--- + +**Note**: This is the documentation for the **version 3.0** of REST framework. Documentation for [version 2.4](http://tomchristie.github.io/rest-framework-2-docs/) is also available. + +--- + # Metadata > [The `OPTIONS`] method allows a client to determine the options and/or requirements associated with a resource, or the capabilities of a server, without implying a resource action or initiating a resource retrieval. diff --git a/docs/api-guide/relations.md b/docs/api-guide/relations.md index 17009bbc..a79b6ea5 100644 --- a/docs/api-guide/relations.md +++ b/docs/api-guide/relations.md @@ -1,5 +1,11 @@ source: relations.py +--- + +**Note**: This is the documentation for the **version 3.0** of REST framework. Documentation for [version 2.4](http://tomchristie.github.io/rest-framework-2-docs/) is also available. + +--- + # Serializer relations > Bad programmers worry about the code. diff --git a/docs/api-guide/requests.md b/docs/api-guide/requests.md index 433d666c..77000ffa 100644 --- a/docs/api-guide/requests.md +++ b/docs/api-guide/requests.md @@ -1,5 +1,11 @@ source: request.py +--- + +**Note**: This is the documentation for the **version 3.0** of REST framework. Documentation for [version 2.4](http://tomchristie.github.io/rest-framework-2-docs/) is also available. + +--- + # Requests > If you're doing REST-based web service stuff ... you should ignore request.POST. diff --git a/docs/api-guide/serializers.md b/docs/api-guide/serializers.md index cd076b4f..4d6c491f 100644 --- a/docs/api-guide/serializers.md +++ b/docs/api-guide/serializers.md @@ -1,5 +1,11 @@ source: serializers.py +--- + +**Note**: This is the documentation for the **version 3.0** of REST framework. Documentation for [version 2.4](http://tomchristie.github.io/rest-framework-2-docs/) is also available. + +--- + # Serializers > Expanding the usefulness of the serializers is something that we would diff --git a/docs/api-guide/validators.md b/docs/api-guide/validators.md index ac2f3248..f087e191 100644 --- a/docs/api-guide/validators.md +++ b/docs/api-guide/validators.md @@ -1,5 +1,11 @@ <a class="github" href="validators.py"></a> +--- + +**Note**: This is the documentation for the **version 3.0** of REST framework. Documentation for [version 2.4](http://tomchristie.github.io/rest-framework-2-docs/) is also available. + +--- + # Validators > Validators can be useful for re-using validation logic between different types of fields. diff --git a/docs/index.md b/docs/index.md index b18f3d6a..b5257c73 100644 --- a/docs/index.md +++ b/docs/index.md @@ -9,7 +9,7 @@ --- -**Note**: The incoming 3.0 version has now been merged to the `master` branch on GitHub. For the source of the currently available PyPI version, please see the `2.4.4` tag. +**Note**: This is the documentation for the **version 3.0** of REST framework. Documentation for [version 2.4](http://tomchristie.github.io/rest-framework-2-docs/) is also available. --- -- cgit v1.2.3 From 9ba29a88d6674d65bf5e8438eba2a072f0d44bf1 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 14:43:33 +0000 Subject: Finalizing 3.0 release notes --- docs/api-guide/serializers.md | 38 +++++++++++++------------------------- docs/topics/3.0-announcement.md | 2 +- 2 files changed, 14 insertions(+), 26 deletions(-) diff --git a/docs/api-guide/serializers.md b/docs/api-guide/serializers.md index 4d6c491f..0ee80d53 100644 --- a/docs/api-guide/serializers.md +++ b/docs/api-guide/serializers.md @@ -567,21 +567,22 @@ There needs to be a way of determining which views should be used for hyperlinki By default hyperlinks are expected to correspond to a view name that matches the style `'{model_name}-detail'`, and looks up the instance by a `pk` keyword argument. -You can change the field that is used for object lookups by setting the `lookup_field` option. The value of this option should correspond both with a kwarg in the URL conf, and with a field on the model. For example: +You can override a URL field view name and lookup field by using either, or both of, the `view_name` and `lookup_field` options in the `extra_field_kwargs` setting, like so: class AccountSerializer(serializers.HyperlinkedModelSerializer): class Meta: model = Account - fields = ('url', 'account_name', 'users', 'created') - lookup_field = 'slug' - -Note that the `lookup_field` will be used as the default on *all* hyperlinked fields, including both the URL identity, and any hyperlinked relationships. + fields = ('account_url', 'account_name', 'users', 'created') + extra_field_kwargs = { + 'url': {'view_name': 'accounts', 'lookup_field': 'account_name'} + 'users': {'lookup_field': 'username'} + } -For more specific requirements such as specifying a different lookup for each field, you'll want to set the fields on the serializer explicitly. For example: +Alternatively you can set the fields on the serializer explicitly. For example: class AccountSerializer(serializers.HyperlinkedModelSerializer): url = serializers.HyperlinkedIdentityField( - view_name='account-detail', + view_name='accounts', lookup_field='slug' ) users = serializers.HyperlinkedRelatedField( @@ -595,28 +596,15 @@ For more specific requirements such as specifying a different lookup for each fi model = Account fields = ('url', 'account_name', 'users', 'created') -## Overriding the URL field behavior - -The name of the URL field defaults to 'url'. You can override this globally, by using the `URL_FIELD_NAME` setting. - -You can also override this on a per-serializer basis by using the `url_field_name` option on the serializer, like so: +--- - class AccountSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = Account - fields = ('account_url', 'account_name', 'users', 'created') - url_field_name = 'account_url' +**Tip**: Properly matching together hyperlinked representations and your URL conf can sometimes be a bit fiddly. Printing the `repr` of a `HyperlinkedModelSerializer` instance is a particularly useful way to inspect exactly which view names and lookup fields the relationships are expected to map too. -**Note**: The generic view implementations normally generate a `Location` header in response to successful `POST` requests. Serializers using `url_field_name` option will not have this header automatically included by the view. If you need to do so you will ned to also override the view's `get_success_headers()` method. +--- -You can also override the URL field's view name and lookup field without overriding the field explicitly, by using the `view_name` and `lookup_field` options, like so: +## Changing the URL field name - class AccountSerializer(serializers.HyperlinkedModelSerializer): - class Meta: - model = Account - fields = ('account_url', 'account_name', 'users', 'created') - view_name = 'account_detail' - lookup_field='account_name' +The name of the URL field defaults to 'url'. You can override this globally, by using the `URL_FIELD_NAME` setting. --- diff --git a/docs/topics/3.0-announcement.md b/docs/topics/3.0-announcement.md index 72268247..b32fe510 100644 --- a/docs/topics/3.0-announcement.md +++ b/docs/topics/3.0-announcement.md @@ -329,7 +329,7 @@ The `view_name` and `lookup_field` options have been moved to `PendingDeprecatio model = MyModel fields = ('url', 'email', 'notes', 'is_admin') extra_kwargs = { - 'url': {'lookup_field': 'uuid'} + 'url': {'lookup_field': 'uuid'} } Alternatively, specify the field explicitly on the serializer class: -- cgit v1.2.3 From 3a5b3772fefc3c2f2c0899947cbc07bfe6e6b5d2 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 28 Nov 2014 15:36:04 +0000 Subject: Use ImproperlyConfigured when model meta lookup fails --- rest_framework/utils/model_meta.py | 7 ++++--- tests/test_utils.py | 3 ++- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/rest_framework/utils/model_meta.py b/rest_framework/utils/model_meta.py index 54f9310d..c98725c6 100644 --- a/rest_framework/utils/model_meta.py +++ b/rest_framework/utils/model_meta.py @@ -6,6 +6,7 @@ relationships and their associated metadata. Usage: `get_field_info(model)` returns a `FieldInfo` instance. """ from collections import namedtuple +from django.core.exceptions import ImproperlyConfigured from django.db import models from django.utils import six from rest_framework.compat import OrderedDict @@ -44,9 +45,9 @@ def _resolve_model(obj): if isinstance(obj, six.string_types) and len(obj.split('.')) == 2: app_name, model_name = obj.split('.') resolved_model = models.get_model(app_name, model_name) - if not resolved_model: - raise ValueError("Django did not return a model for " - "{0}.{1}".format(app_name, model_name)) + if resolved_model is None: + msg = "Django did not return a model for {0}.{1}" + raise ImproperlyConfigured(msg.format(app_name, model_name)) return resolved_model elif inspect.isclass(obj) and issubclass(obj, models.Model): return obj diff --git a/tests/test_utils.py b/tests/test_utils.py index 0bdb36bb..8c286ea4 100644 --- a/tests/test_utils.py +++ b/tests/test_utils.py @@ -1,4 +1,5 @@ from __future__ import unicode_literals +from django.core.exceptions import ImproperlyConfigured from django.conf.urls import patterns, url from django.test import TestCase from django.utils import six @@ -161,5 +162,5 @@ class ResolveModelWithPatchedDjangoTests(TestCase): rest_framework.utils.model_meta.models.get_model = self.get_model def test_blows_up_if_model_does_not_resolve(self): - with self.assertRaises(ValueError): + with self.assertRaises(ImproperlyConfigured): _resolve_model('tests.BasicModel') -- cgit v1.2.3