From 027c9079f62322fe933bdfd4438f23cf4848e3cc Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Wed, 31 Oct 2012 20:11:32 +0000 Subject: PUT as create should return 201. Fixes #340. --- rest_framework/mixins.py | 7 +++---- rest_framework/tests/generics.py | 6 +++--- 2 files changed, 6 insertions(+), 7 deletions(-) (limited to 'rest_framework') diff --git a/rest_framework/mixins.py b/rest_framework/mixins.py index 8873e4ae..0f2a0d93 100644 --- a/rest_framework/mixins.py +++ b/rest_framework/mixins.py @@ -3,9 +3,6 @@ Basic building blocks for generic class based views. We don't bind behaviour to http method handlers yet, which allows mixin classes to be composed in interesting ways. - -Eg. Use mixins to build a Resource class, and have a Router class - perform the binding of http methods to actions for us. """ from django.http import Http404 from rest_framework import status @@ -78,15 +75,17 @@ class UpdateModelMixin(object): def update(self, request, *args, **kwargs): try: self.object = self.get_object() + success_status = status.HTTP_200_OK except Http404: self.object = None + success_status = status.HTTP_201_CREATED serializer = self.get_serializer(data=request.DATA, instance=self.object) if serializer.is_valid(): self.pre_save(serializer.object) self.object = serializer.save() - return Response(serializer.data) + return Response(serializer.data, status=success_status) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py index d45ea976..a8279ef2 100644 --- a/rest_framework/tests/generics.py +++ b/rest_framework/tests/generics.py @@ -236,7 +236,7 @@ class TestInstanceView(TestCase): request = factory.put('/1', json.dumps(content), content_type='application/json') response = self.view(request, pk=1).render() - self.assertEquals(response.status_code, status.HTTP_200_OK) + self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEquals(response.data, {'id': 1, 'text': 'foobar'}) updated = self.objects.get(id=1) self.assertEquals(updated.text, 'foobar') @@ -251,7 +251,7 @@ class TestInstanceView(TestCase): request = factory.put('/5', json.dumps(content), content_type='application/json') response = self.view(request, pk=5).render() - self.assertEquals(response.status_code, status.HTTP_200_OK) + self.assertEquals(response.status_code, status.HTTP_201_CREATED) new_obj = self.objects.get(pk=5) self.assertEquals(new_obj.text, 'foobar') @@ -264,7 +264,7 @@ class TestInstanceView(TestCase): request = factory.put('/test_slug', json.dumps(content), content_type='application/json') response = self.slug_based_view(request, slug='test_slug').render() - self.assertEquals(response.status_code, status.HTTP_200_OK) + self.assertEquals(response.status_code, status.HTTP_201_CREATED) self.assertEquals(response.data, {'slug': 'test_slug', 'text': 'foobar'}) new_obj = SlugBasedModel.objects.get(slug='test_slug') self.assertEquals(new_obj.text, 'foobar') -- cgit v1.2.3 From 756297ad1d07f56459471bff041828850ace0496 Mon Sep 17 00:00:00 2001 From: Otto Yiu Date: Wed, 31 Oct 2012 21:40:20 -0700 Subject: fix 'from_native' method when rel is None 'NoneType' object has no attribute 'to' --- rest_framework/fields.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'rest_framework') diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 1d6d760e..73c8f72b 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -211,9 +211,9 @@ class ModelField(WritableField): def from_native(self, value): try: rel = self.model_field.rel + return rel.to._meta.get_field(rel.field_name).to_python(value) except: return self.model_field.to_python(value) - return rel.to._meta.get_field(rel.field_name).to_python(value) def field_to_native(self, obj, field_name): value = self.model_field._get_val_from_obj(obj) -- cgit v1.2.3 From d3aedd5fb1d8c50e9b7047469163dc75ac3de022 Mon Sep 17 00:00:00 2001 From: Pavel Savchenko Date: Thu, 1 Nov 2012 15:00:22 +0200 Subject: return choices as unicode and not string, might as well have jsonp return unicode --- rest_framework/renderers.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'rest_framework') diff --git a/rest_framework/renderers.py b/rest_framework/renderers.py index 8dff0c77..fd6f9499 100644 --- a/rest_framework/renderers.py +++ b/rest_framework/renderers.py @@ -100,7 +100,7 @@ class JSONPRenderer(JSONRenderer): callback = self.get_callback(renderer_context) json = super(JSONPRenderer, self).render(data, accepted_media_type, renderer_context) - return "%s(%s);" % (callback, json) + return u"%s(%s);" % (callback, json) class XMLRenderer(BaseRenderer): @@ -306,7 +306,7 @@ class BrowsableAPIRenderer(BaseRenderer): if getattr(widget, 'choices', None): choices = widget.choices if any([ident != desc for (ident, desc) in choices]): - choices = [(ident, "%s (%s)" % (desc, ident)) + choices = [(ident, u"%s (%s)" % (desc, ident)) for (ident, desc) in choices] widget.choices = choices kwargs['widget'] = widget -- cgit v1.2.3 From 9a0cc7c720d40f7d2408672c49a5d8bfb62c3979 Mon Sep 17 00:00:00 2001 From: Pavel Savchenko Date: Thu, 1 Nov 2012 15:06:11 +0200 Subject: since MultipleObjectBaseView was renamed MultipleObjectAPIView, it stands to reason to complete the renaming in docs and comments as well. --- rest_framework/mixins.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'rest_framework') diff --git a/rest_framework/mixins.py b/rest_framework/mixins.py index 0f2a0d93..47e4edf7 100644 --- a/rest_framework/mixins.py +++ b/rest_framework/mixins.py @@ -29,7 +29,7 @@ class CreateModelMixin(object): class ListModelMixin(object): """ List a queryset. - Should be mixed in with `MultipleObjectBaseView`. + Should be mixed in with `MultipleObjectAPIView`. """ empty_error = u"Empty list and '%(class_name)s.allow_empty' is False." -- cgit v1.2.3 From d327c5f531b341ad980d20454211b02b87f34d0e Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 1 Nov 2012 23:04:13 +0000 Subject: Relational field support in browseable API. Add slug relational fields. Add quickstart. --- rest_framework/fields.py | 107 ++++++++++++++++++++- rest_framework/renderers.py | 25 +++-- .../static/rest_framework/css/default.css | 7 ++ rest_framework/templates/rest_framework/base.html | 4 +- 4 files changed, 122 insertions(+), 21 deletions(-) (limited to 'rest_framework') diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 1d6d760e..6d858087 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -8,6 +8,7 @@ from django.core.exceptions import ObjectDoesNotExist, ValidationError from django.core.urlresolvers import resolve, get_script_prefix from django.conf import settings from django.forms import widgets +from django.forms.models import ModelChoiceIterator from django.utils.encoding import is_protected_type, smart_unicode from django.utils.translation import ugettext_lazy as _ from rest_framework.reverse import reverse @@ -232,11 +233,72 @@ class ModelField(WritableField): class RelatedField(WritableField): """ Base class for related model fields. + + If not overridden, this represents a to-one relatinship, using the unicode + representation of the target. """ + widget = widgets.Select + cache_choices = False + empty_label = None + def __init__(self, *args, **kwargs): self.queryset = kwargs.pop('queryset', None) super(RelatedField, self).__init__(*args, **kwargs) + ### We need this stuff to make form choices work... + + # def __deepcopy__(self, memo): + # result = super(RelatedField, self).__deepcopy__(memo) + # result.queryset = result.queryset + # return result + + def prepare_value(self, obj): + return self.to_native(obj) + + def label_from_instance(self, obj): + """ + Return a readable representation for use with eg. select widgets. + """ + desc = smart_unicode(obj) + ident = self.to_native(obj) + if desc == ident: + return desc + return "%s - %s" % (desc, ident) + + def _get_queryset(self): + return self._queryset + + def _set_queryset(self, queryset): + self._queryset = queryset + self.widget.choices = self.choices + + queryset = property(_get_queryset, _set_queryset) + + def _get_choices(self): + # If self._choices is set, then somebody must have manually set + # the property self.choices. In this case, just return self._choices. + if hasattr(self, '_choices'): + return self._choices + + # Otherwise, execute the QuerySet in self.queryset to determine the + # choices dynamically. Return a fresh ModelChoiceIterator that has not been + # consumed. Note that we're instantiating a new ModelChoiceIterator *each* + # time _get_choices() is called (and, thus, each time self.choices is + # accessed) so that we can ensure the QuerySet has not been consumed. This + # construct might look complicated but it allows for lazy evaluation of + # the queryset. + return ModelChoiceIterator(self) + + def _set_choices(self, value): + # Setting choices also sets the choices on the widget. + # choices can be any iterable, but we call list() on it because + # it will be consumed more than once. + self._choices = self.widget.choices = list(value) + + choices = property(_get_choices, _set_choices) + + ### Regular serializier stuff... + def field_to_native(self, obj, field_name): value = getattr(obj, self.source or field_name) return self.to_native(value) @@ -253,6 +315,8 @@ class ManyRelatedMixin(object): """ Mixin to convert a related field to a many related field. """ + widget = widgets.SelectMultiple + def field_to_native(self, obj, field_name): value = getattr(obj, self.source or field_name) return [self.to_native(item) for item in value.all()] @@ -276,6 +340,9 @@ class ManyRelatedMixin(object): class ManyRelatedField(ManyRelatedMixin, RelatedField): """ Base class for related model managers. + + If not overridden, this represents a to-many relatinship, using the unicode + representations of the target, and is read-only. """ pass @@ -284,7 +351,7 @@ class ManyRelatedField(ManyRelatedMixin, RelatedField): class PrimaryKeyRelatedField(RelatedField): """ - Serializes a related field or related object to a pk value. + Represents a to-one relationship as a pk value. """ def to_native(self, pk): @@ -313,7 +380,7 @@ class PrimaryKeyRelatedField(RelatedField): class ManyPrimaryKeyRelatedField(ManyRelatedField): """ - Serializes a to-many related field or related manager to a pk value. + Represents a to-many relationship as a pk value. """ def to_native(self, pk): return pk @@ -329,10 +396,36 @@ class ManyPrimaryKeyRelatedField(ManyRelatedField): # Forward relationship return [self.to_native(item.pk) for item in queryset.all()] +### Slug relationships + + +class SlugRelatedField(RelatedField): + def __init__(self, *args, **kwargs): + self.slug_field = kwargs.pop('slug_field', None) + assert self.slug_field, 'slug_field is required' + super(SlugRelatedField, self).__init__(*args, **kwargs) + + def to_native(self, obj): + return getattr(obj, self.slug_field) + + def from_native(self, data): + try: + return self.queryset.get(**{self.slug_field: data}) + except ObjectDoesNotExist: + raise ValidationError('Object with %s=%s does not exist.' % + (self.slug_field, unicode(data))) + + +class ManySlugRelatedField(ManyRelatedMixin, SlugRelatedField): + pass + ### Hyperlinked relationships class HyperlinkedRelatedField(RelatedField): + """ + Represents a to-one relationship, using hyperlinking. + """ pk_url_kwarg = 'pk' slug_url_kwarg = 'slug' slug_field = 'slug' @@ -417,16 +510,20 @@ class HyperlinkedRelatedField(RelatedField): class ManyHyperlinkedRelatedField(ManyRelatedMixin, HyperlinkedRelatedField): + """ + Represents a to-many relationship, using hyperlinking. + """ pass class HyperlinkedIdentityField(Field): """ - A field that represents the model's identity using a hyperlink. + Represents the instance, or a property on the instance, using hyperlinking. """ + def __init__(self, *args, **kwargs): - # TODO: Make this mandatory, and have the HyperlinkedModelSerializer - # set it on-the-fly + # TODO: Make view_name mandatory, and have the + # HyperlinkedModelSerializer set it on-the-fly self.view_name = kwargs.pop('view_name', None) self.format = kwargs.pop('format', None) super(HyperlinkedIdentityField, self).__init__(*args, **kwargs) diff --git a/rest_framework/renderers.py b/rest_framework/renderers.py index 8dff0c77..63578b14 100644 --- a/rest_framework/renderers.py +++ b/rest_framework/renderers.py @@ -282,10 +282,12 @@ class BrowsableAPIRenderer(BaseRenderer): serializers.EmailField: forms.EmailField, serializers.CharField: forms.CharField, serializers.BooleanField: forms.BooleanField, - serializers.PrimaryKeyRelatedField: forms.ModelChoiceField, - serializers.ManyPrimaryKeyRelatedField: forms.ModelMultipleChoiceField, - serializers.HyperlinkedRelatedField: forms.ModelChoiceField, - serializers.ManyHyperlinkedRelatedField: forms.ModelMultipleChoiceField + serializers.PrimaryKeyRelatedField: forms.ChoiceField, + serializers.ManyPrimaryKeyRelatedField: forms.MultipleChoiceField, + serializers.SlugRelatedField: forms.ChoiceField, + serializers.ManySlugRelatedField: forms.MultipleChoiceField, + serializers.HyperlinkedRelatedField: forms.ChoiceField, + serializers.ManyHyperlinkedRelatedField: forms.MultipleChoiceField } fields = {} @@ -296,19 +298,14 @@ class BrowsableAPIRenderer(BaseRenderer): kwargs = {} kwargs['required'] = v.required - if getattr(v, 'queryset', None): - kwargs['queryset'] = v.queryset + #if getattr(v, 'queryset', None): + # kwargs['queryset'] = v.queryset + + if getattr(v, 'choices', None) is not None: + kwargs['choices'] = v.choices if getattr(v, 'widget', None): widget = copy.deepcopy(v.widget) - # If choices have friendly readable names, - # then add in the identities too - if getattr(widget, 'choices', None): - choices = widget.choices - if any([ident != desc for (ident, desc) in choices]): - choices = [(ident, "%s (%s)" % (desc, ident)) - for (ident, desc) in choices] - widget.choices = choices kwargs['widget'] = widget if getattr(v, 'default', None) is not None: diff --git a/rest_framework/static/rest_framework/css/default.css b/rest_framework/static/rest_framework/css/default.css index e29da395..fdf45659 100644 --- a/rest_framework/static/rest_framework/css/default.css +++ b/rest_framework/static/rest_framework/css/default.css @@ -36,6 +36,13 @@ ul.breadcrumb { margin: 58px 0 0 0; } +form select, form input { + width: 90%; +} + +form select[multiple] { + height: 150px; +} /* To allow tooltips to work on disabled elements */ .disabled-tooltip-shield { position: absolute; diff --git a/rest_framework/templates/rest_framework/base.html b/rest_framework/templates/rest_framework/base.html index e0f79481..9b0a0dca 100644 --- a/rest_framework/templates/rest_framework/base.html +++ b/rest_framework/templates/rest_framework/base.html @@ -134,7 +134,7 @@
{{ field.label_tag|add_class:"control-label" }}
- {{ field|add_class:"input-xlarge" }} + {{ field }} {{ field.help_text }} {{ field.errors|add_class:"help-block" }}
@@ -159,7 +159,7 @@
{{ field.label_tag|add_class:"control-label" }}
- {{ field|add_class:"input-xlarge" }} + {{ field }} {{ field.help_text }} {{ field.errors|add_class:"help-block" }}
-- cgit v1.2.3 From 062f5caef3dcb76e19f9eed59779f45849a166a1 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Thu, 1 Nov 2012 23:40:34 +0000 Subject: Tweaks fields docs, and fix 2.0.1 version. --- rest_framework/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'rest_framework') diff --git a/rest_framework/__init__.py b/rest_framework/__init__.py index 557f5943..d6e76286 100644 --- a/rest_framework/__init__.py +++ b/rest_framework/__init__.py @@ -1,3 +1,3 @@ -__version__ = '2.0.0' +__version__ = '2.0.1' VERSION = __version__ # synonym -- cgit v1.2.3 From b9bff2a984767c4258cad4860addc53a9623bb11 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 2 Nov 2012 14:05:14 +0000 Subject: Fix issues with pk related fields in the browsable API. --- rest_framework/__init__.py | 2 +- rest_framework/fields.py | 39 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 39 insertions(+), 2 deletions(-) (limited to 'rest_framework') diff --git a/rest_framework/__init__.py b/rest_framework/__init__.py index d6e76286..56b9a35c 100644 --- a/rest_framework/__init__.py +++ b/rest_framework/__init__.py @@ -1,3 +1,3 @@ -__version__ = '2.0.1' +__version__ = '2.0.2' VERSION = __version__ # synonym diff --git a/rest_framework/fields.py b/rest_framework/fields.py index b7d02234..375d7a46 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -230,6 +230,7 @@ class ModelField(WritableField): ##### Relational fields ##### +# Not actually Writable, but subclasses may need to be. class RelatedField(WritableField): """ Base class for related model fields. @@ -240,10 +241,12 @@ class RelatedField(WritableField): widget = widgets.Select cache_choices = False empty_label = None + default_read_only = True # TODO: Remove this def __init__(self, *args, **kwargs): self.queryset = kwargs.pop('queryset', None) super(RelatedField, self).__init__(*args, **kwargs) + self.read_only = self.default_read_only ### We need this stuff to make form choices work... @@ -260,7 +263,7 @@ class RelatedField(WritableField): Return a readable representation for use with eg. select widgets. """ desc = smart_unicode(obj) - ident = self.to_native(obj) + ident = smart_unicode(self.to_native(obj)) if desc == ident: return desc return "%s - %s" % (desc, ident) @@ -353,7 +356,23 @@ class PrimaryKeyRelatedField(RelatedField): """ Represents a to-one relationship as a pk value. """ + default_read_only = False + # TODO: Remove these field hacks... + def prepare_value(self, obj): + return self.to_native(obj.pk) + + def label_from_instance(self, obj): + """ + Return a readable representation for use with eg. select widgets. + """ + desc = smart_unicode(obj) + ident = smart_unicode(self.to_native(obj.pk)) + if desc == ident: + return desc + return "%s - %s" % (desc, ident) + + # TODO: Possibly change this to just take `obj`, through prob less performant def to_native(self, pk): return pk @@ -382,6 +401,21 @@ class ManyPrimaryKeyRelatedField(ManyRelatedField): """ Represents a to-many relationship as a pk value. """ + default_read_only = False + + def prepare_value(self, obj): + return self.to_native(obj.pk) + + def label_from_instance(self, obj): + """ + Return a readable representation for use with eg. select widgets. + """ + desc = smart_unicode(obj) + ident = smart_unicode(self.to_native(obj.pk)) + if desc == ident: + return desc + return "%s - %s" % (desc, ident) + def to_native(self, pk): return pk @@ -400,6 +434,8 @@ class ManyPrimaryKeyRelatedField(ManyRelatedField): class SlugRelatedField(RelatedField): + default_read_only = False + def __init__(self, *args, **kwargs): self.slug_field = kwargs.pop('slug_field', None) assert self.slug_field, 'slug_field is required' @@ -429,6 +465,7 @@ class HyperlinkedRelatedField(RelatedField): pk_url_kwarg = 'pk' slug_url_kwarg = 'slug' slug_field = 'slug' + default_read_only = False def __init__(self, *args, **kwargs): try: -- cgit v1.2.3 From e84ce60a0da77c0e07e0d6e5f627694ae3f4422f Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 2 Nov 2012 19:11:40 +0000 Subject: Initial PK relationship tests --- rest_framework/tests/pk_relations.py | 86 ++++++++++++++++++++++++++++++++++++ 1 file changed, 86 insertions(+) create mode 100644 rest_framework/tests/pk_relations.py (limited to 'rest_framework') diff --git a/rest_framework/tests/pk_relations.py b/rest_framework/tests/pk_relations.py new file mode 100644 index 00000000..eca534c2 --- /dev/null +++ b/rest_framework/tests/pk_relations.py @@ -0,0 +1,86 @@ +from django.db import models +from django.test import TestCase +from rest_framework import serializers + + +class Target(models.Model): + name = models.CharField(max_length=100) + + +class Source(models.Model): + name = models.CharField(max_length=100) + targets = models.ManyToManyField(Target, related_name='sources') + + +class TargetSerializer(serializers.ModelSerializer): + sources = serializers.ManyPrimaryKeyRelatedField() + + class Meta: + fields = ('id', 'name', 'sources') + model = Target + + +class SourceSerializer(serializers.ModelSerializer): + class Meta: + model = Source + + +# TODO: Add test that .data cannot be accessed prior to .is_valid + +class PrimaryKeyManyToManyTests(TestCase): + def setUp(self): + for idx in range(1, 4): + target = Target(name='target-%d' % idx) + target.save() + source = Source(name='source-%d' % idx) + source.save() + for target in Target.objects.all(): + source.targets.add(target) + + def test_many_to_many_retrieve(self): + serializer = SourceSerializer(instance=Source.objects.all()) + expected = [ + {'id': 1, 'name': u'source-1', 'targets': [1]}, + {'id': 2, 'name': u'source-2', 'targets': [1, 2]}, + {'id': 3, 'name': u'source-3', 'targets': [1, 2, 3]} + ] + self.assertEquals(serializer.data, expected) + + def test_reverse_many_to_many_retrieve(self): + serializer = TargetSerializer(instance=Target.objects.all()) + expected = [ + {'id': 1, 'name': u'target-1', 'sources': [1, 2, 3]}, + {'id': 2, 'name': u'target-2', 'sources': [2, 3]}, + {'id': 3, 'name': u'target-3', 'sources': [3]} + ] + self.assertEquals(serializer.data, expected) + + def test_many_to_many_update(self): + data = {'id': 1, 'name': u'source-1', 'targets': [1, 2, 3]} + serializer = SourceSerializer(data, instance=Source.objects.get(pk=1)) + self.assertTrue(serializer.is_valid()) + self.assertEquals(serializer.data, data) + + # Ensure source 1 is updated, and everything else is as expected + serializer = SourceSerializer(instance=Source.objects.all()) + expected = [ + {'id': 1, 'name': u'source-1', 'targets': [1, 2, 3]}, + {'id': 2, 'name': u'source-2', 'targets': [1, 2]}, + {'id': 3, 'name': u'source-3', 'targets': [1, 2, 3]} + ] + self.assertEquals(serializer.data, expected) + + def test_reverse_many_to_many_update(self): + data = {'id': 1, 'name': u'target-0', 'sources': [1]} + serializer = TargetSerializer(data, instance=Target.objects.get(pk=1)) + self.assertTrue(serializer.is_valid()) + self.assertEquals(serializer.data, data) + + # Ensure target 1 is updated, and everything else is as expected + serializer = TargetSerializer(instance=Target.objects.all()) + expected = [ + {'id': 1, 'name': u'target-1', 'sources': [1]}, + {'id': 2, 'name': u'target-2', 'sources': [2, 3]}, + {'id': 3, 'name': u'target-3', 'sources': [3]} + ] + self.assertEquals(serializer.data, expected) -- cgit v1.2.3 From 3de61d200ccfe51a8e7e2fd900838c9c1c91b0f2 Mon Sep 17 00:00:00 2001 From: Jacob Magnusson Date: Fri, 2 Nov 2012 20:55:58 +0100 Subject: Don't convert dictionary into a string representation --- rest_framework/fields.py | 2 ++ 1 file changed, 2 insertions(+) (limited to 'rest_framework') diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 375d7a46..6dfe7458 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -90,6 +90,8 @@ class Field(object): return value elif hasattr(value, '__iter__') and not isinstance(value, (dict, basestring)): return [self.to_native(item) for item in value] + elif isinstance(value, dict): + return dict((k, self.to_native(v)) for k, v in value.items()) return smart_unicode(value) def attributes(self): -- cgit v1.2.3 From a6806f03078fbdda598e10260f9d9bcdf07c1dce Mon Sep 17 00:00:00 2001 From: Jacob Magnusson Date: Fri, 2 Nov 2012 21:48:16 +0100 Subject: Apply to_native on dictionary keys as well --- rest_framework/fields.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'rest_framework') diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 6dfe7458..515ccbcf 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -91,7 +91,7 @@ class Field(object): elif hasattr(value, '__iter__') and not isinstance(value, (dict, basestring)): return [self.to_native(item) for item in value] elif isinstance(value, dict): - return dict((k, self.to_native(v)) for k, v in value.items()) + return dict(map(self.to_native, (k, v)) for k, v in value.items()) return smart_unicode(value) def attributes(self): -- cgit v1.2.3 From 6eaec7a0eccabb3e1b010d07633632e8a3ecd86f Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 2 Nov 2012 20:53:33 +0000 Subject: foreign key tests --- rest_framework/fields.py | 13 +++- rest_framework/tests/pk_relations.py | 139 ++++++++++++++++++++++++++++++----- 2 files changed, 132 insertions(+), 20 deletions(-) (limited to 'rest_framework') diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 375d7a46..965e22c4 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -383,7 +383,8 @@ class PrimaryKeyRelatedField(RelatedField): try: return self.queryset.get(pk=data) except ObjectDoesNotExist: - raise ValidationError('Invalid hyperlink - object does not exist.') + msg = "Invalid pk '%s' - object does not exist." % smart_unicode(data) + raise ValidationError(msg) def field_to_native(self, obj, field_name): try: @@ -430,6 +431,16 @@ class ManyPrimaryKeyRelatedField(ManyRelatedField): # Forward relationship return [self.to_native(item.pk) for item in queryset.all()] + def from_native(self, data): + if self.queryset is None: + raise Exception('Writable related fields must include a `queryset` argument') + + try: + return self.queryset.get(pk=data) + except ObjectDoesNotExist: + msg = "Invalid pk '%s' - object does not exist." % smart_unicode(data) + raise ValidationError(msg) + ### Slug relationships diff --git a/rest_framework/tests/pk_relations.py b/rest_framework/tests/pk_relations.py index eca534c2..a0934344 100644 --- a/rest_framework/tests/pk_relations.py +++ b/rest_framework/tests/pk_relations.py @@ -3,26 +3,50 @@ from django.test import TestCase from rest_framework import serializers -class Target(models.Model): +# ManyToMany + +class ManyToManyTarget(models.Model): name = models.CharField(max_length=100) -class Source(models.Model): +class ManyToManySource(models.Model): name = models.CharField(max_length=100) - targets = models.ManyToManyField(Target, related_name='sources') + targets = models.ManyToManyField(ManyToManyTarget, related_name='sources') -class TargetSerializer(serializers.ModelSerializer): - sources = serializers.ManyPrimaryKeyRelatedField() +class ManyToManyTargetSerializer(serializers.ModelSerializer): + sources = serializers.ManyPrimaryKeyRelatedField(queryset=ManyToManySource.objects.all()) class Meta: - fields = ('id', 'name', 'sources') - model = Target + model = ManyToManyTarget -class SourceSerializer(serializers.ModelSerializer): +class ManyToManySourceSerializer(serializers.ModelSerializer): class Meta: - model = Source + model = ManyToManySource + + +# ForeignKey + +class ForeignKeyTarget(models.Model): + name = models.CharField(max_length=100) + + +class ForeignKeySource(models.Model): + name = models.CharField(max_length=100) + target = models.ForeignKey(ForeignKeyTarget, related_name='sources') + + +class ForeignKeyTargetSerializer(serializers.ModelSerializer): + sources = serializers.ManyPrimaryKeyRelatedField(queryset=ForeignKeySource.objects.all()) + + class Meta: + model = ForeignKeyTarget + + +class ForeignKeySourceSerializer(serializers.ModelSerializer): + class Meta: + model = ForeignKeySource # TODO: Add test that .data cannot be accessed prior to .is_valid @@ -30,15 +54,16 @@ class SourceSerializer(serializers.ModelSerializer): class PrimaryKeyManyToManyTests(TestCase): def setUp(self): for idx in range(1, 4): - target = Target(name='target-%d' % idx) + target = ManyToManyTarget(name='target-%d' % idx) target.save() - source = Source(name='source-%d' % idx) + source = ManyToManySource(name='source-%d' % idx) source.save() - for target in Target.objects.all(): + for target in ManyToManyTarget.objects.all(): source.targets.add(target) def test_many_to_many_retrieve(self): - serializer = SourceSerializer(instance=Source.objects.all()) + queryset = ManyToManySource.objects.all() + serializer = ManyToManySourceSerializer(instance=queryset) expected = [ {'id': 1, 'name': u'source-1', 'targets': [1]}, {'id': 2, 'name': u'source-2', 'targets': [1, 2]}, @@ -47,7 +72,8 @@ class PrimaryKeyManyToManyTests(TestCase): self.assertEquals(serializer.data, expected) def test_reverse_many_to_many_retrieve(self): - serializer = TargetSerializer(instance=Target.objects.all()) + queryset = ManyToManyTarget.objects.all() + serializer = ManyToManyTargetSerializer(instance=queryset) expected = [ {'id': 1, 'name': u'target-1', 'sources': [1, 2, 3]}, {'id': 2, 'name': u'target-2', 'sources': [2, 3]}, @@ -57,12 +83,15 @@ class PrimaryKeyManyToManyTests(TestCase): def test_many_to_many_update(self): data = {'id': 1, 'name': u'source-1', 'targets': [1, 2, 3]} - serializer = SourceSerializer(data, instance=Source.objects.get(pk=1)) + instance = ManyToManySource.objects.get(pk=1) + serializer = ManyToManySourceSerializer(data, instance=instance) self.assertTrue(serializer.is_valid()) self.assertEquals(serializer.data, data) + serializer.save() # Ensure source 1 is updated, and everything else is as expected - serializer = SourceSerializer(instance=Source.objects.all()) + queryset = ManyToManySource.objects.all() + serializer = ManyToManySourceSerializer(instance=queryset) expected = [ {'id': 1, 'name': u'source-1', 'targets': [1, 2, 3]}, {'id': 2, 'name': u'source-2', 'targets': [1, 2]}, @@ -71,16 +100,88 @@ class PrimaryKeyManyToManyTests(TestCase): self.assertEquals(serializer.data, expected) def test_reverse_many_to_many_update(self): - data = {'id': 1, 'name': u'target-0', 'sources': [1]} - serializer = TargetSerializer(data, instance=Target.objects.get(pk=1)) + data = {'id': 1, 'name': u'target-1', 'sources': [1]} + instance = ManyToManyTarget.objects.get(pk=1) + serializer = ManyToManyTargetSerializer(data, instance=instance) self.assertTrue(serializer.is_valid()) self.assertEquals(serializer.data, data) + serializer.save() # Ensure target 1 is updated, and everything else is as expected - serializer = TargetSerializer(instance=Target.objects.all()) + queryset = ManyToManyTarget.objects.all() + serializer = ManyToManyTargetSerializer(instance=queryset) expected = [ {'id': 1, 'name': u'target-1', 'sources': [1]}, {'id': 2, 'name': u'target-2', 'sources': [2, 3]}, {'id': 3, 'name': u'target-3', 'sources': [3]} ] self.assertEquals(serializer.data, expected) + + +class PrimaryKeyForeignKeyTests(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(instance=queryset) + expected = [ + {'id': 1, 'name': u'source-1', 'target': 1}, + {'id': 2, 'name': u'source-2', 'target': 1}, + {'id': 3, 'name': u'source-3', 'target': 1} + ] + self.assertEquals(serializer.data, expected) + + def test_reverse_foreign_key_retrieve(self): + queryset = ForeignKeyTarget.objects.all() + serializer = ForeignKeyTargetSerializer(instance=queryset) + expected = [ + {'id': 1, 'name': u'target-1', 'sources': [1, 2, 3]}, + {'id': 2, 'name': u'target-2', 'sources': []}, + ] + self.assertEquals(serializer.data, expected) + + def test_foreign_key_update(self): + data = {'id': 1, 'name': u'source-1', 'target': 2} + instance = ForeignKeySource.objects.get(pk=1) + serializer = ForeignKeySourceSerializer(data, instance=instance) + self.assertTrue(serializer.is_valid()) + self.assertEquals(serializer.data, data) + serializer.save() + + # # Ensure source 1 is updated, and everything else is as expected + queryset = ForeignKeySource.objects.all() + serializer = ForeignKeySourceSerializer(instance=queryset) + expected = [ + {'id': 1, 'name': u'source-1', 'target': 2}, + {'id': 2, 'name': u'source-2', 'target': 1}, + {'id': 3, 'name': u'source-3', 'target': 1} + ] + self.assertEquals(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': u'target-1', 'sources': [1]} + # instance = ForeignKeyTarget.objects.get(pk=1) + # serializer = ForeignKeyTargetSerializer(data, instance=instance) + # self.assertTrue(serializer.is_valid()) + # self.assertEquals(serializer.data, data) + # serializer.save() + + # # Ensure target 1 is updated, and everything else is as expected + # queryset = ForeignKeyTarget.objects.all() + # serializer = ForeignKeyTargetSerializer(instance=queryset) + # expected = [ + # {'id': 1, 'name': u'target-1', 'sources': [1]}, + # {'id': 2, 'name': u'target-2', 'sources': []}, + # ] + # self.assertEquals(serializer.data, expected) -- cgit v1.2.3 From 8ec54e6a9fe8e46955098ca8e7d728d8bb4f7053 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Fri, 2 Nov 2012 20:56:51 +0000 Subject: Tweaks --- rest_framework/fields.py | 2 +- rest_framework/runtests/runcoverage.py | 4 ++-- rest_framework/tests/pk_relations.py | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) (limited to 'rest_framework') diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 965e22c4..661d02de 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -344,7 +344,7 @@ class ManyRelatedField(ManyRelatedMixin, RelatedField): """ Base class for related model managers. - If not overridden, this represents a to-many relatinship, using the unicode + If not overridden, this represents a to-many relationship, using the unicode representations of the target, and is read-only. """ pass diff --git a/rest_framework/runtests/runcoverage.py b/rest_framework/runtests/runcoverage.py index ea2e3d45..0ce379eb 100755 --- a/rest_framework/runtests/runcoverage.py +++ b/rest_framework/runtests/runcoverage.py @@ -32,10 +32,10 @@ def main(): 'Function-based test runners are deprecated. Test runners should be classes with a run_tests() method.', DeprecationWarning ) - failures = TestRunner(['rest_framework']) + failures = TestRunner(['tests']) else: test_runner = TestRunner() - failures = test_runner.run_tests(['rest_framework']) + failures = test_runner.run_tests(['tests']) cov.stop() # Discover the list of all modules that we should test coverage for diff --git a/rest_framework/tests/pk_relations.py b/rest_framework/tests/pk_relations.py index a0934344..9095dcd8 100644 --- a/rest_framework/tests/pk_relations.py +++ b/rest_framework/tests/pk_relations.py @@ -38,7 +38,7 @@ class ForeignKeySource(models.Model): class ForeignKeyTargetSerializer(serializers.ModelSerializer): - sources = serializers.ManyPrimaryKeyRelatedField(queryset=ForeignKeySource.objects.all()) + sources = serializers.ManyPrimaryKeyRelatedField(read_only=True) class Meta: model = ForeignKeyTarget -- cgit v1.2.3 From 19a218f85973b4c478ec0b8373e971e1d787281a Mon Sep 17 00:00:00 2001 From: Jacob Magnusson Date: Sat, 3 Nov 2012 00:27:56 +0100 Subject: Bye bye star import --- rest_framework/tests/serializer.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) (limited to 'rest_framework') diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py index d4b43862..9febc9c8 100644 --- a/rest_framework/tests/serializer.py +++ b/rest_framework/tests/serializer.py @@ -1,7 +1,9 @@ import datetime from django.test import TestCase from rest_framework import serializers -from rest_framework.tests.models import * +from rest_framework.tests.models import (ActionItem, Anchor, BasicModel, + BlankFieldModel, BlogPost, CallableDefaultValueModel, DefaultValueModel, + ManyToManyModel, Person, ReadOnlyManyToManyModel) class SubComment(object): -- cgit v1.2.3 From 1b49615c00793b658f40d08617965316a3f71a7e Mon Sep 17 00:00:00 2001 From: Jacob Magnusson Date: Sat, 3 Nov 2012 00:32:02 +0100 Subject: Added test that makes sure that fields with dictionaries as data are returned as expected and not turned into string representations --- rest_framework/tests/models.py | 7 +++++++ rest_framework/tests/serializer.py | 13 +++++++++++++ 2 files changed, 20 insertions(+) (limited to 'rest_framework') diff --git a/rest_framework/tests/models.py b/rest_framework/tests/models.py index 415e4d06..1a0078e8 100644 --- a/rest_framework/tests/models.py +++ b/rest_framework/tests/models.py @@ -122,6 +122,13 @@ class Person(RESTFrameworkModel): name = models.CharField(max_length=10) age = models.IntegerField(null=True, blank=True) + @property + def info(self): + return { + 'name': self.name, + 'age': self.age, + } + # Model for issue #324 class BlankFieldModel(RESTFrameworkModel): diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py index 9febc9c8..5d46ff68 100644 --- a/rest_framework/tests/serializer.py +++ b/rest_framework/tests/serializer.py @@ -46,8 +46,11 @@ class ActionItemSerializer(serializers.ModelSerializer): class PersonSerializer(serializers.ModelSerializer): + info = serializers.Field(source='info') + class Meta: model = Person + fields = ('name', 'age', 'info') class BasicTests(TestCase): @@ -69,6 +72,9 @@ class BasicTests(TestCase): '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() @@ -100,6 +106,13 @@ class BasicTests(TestCase): self.assertTrue(serializer.object is expected) self.assertEquals(serializer.data['sub_comment'], 'And Merry Christmas!') + def test_field_with_dictionary(self): + """ Make sure that dictionaries from fields are left intact + """ + serializer = PersonSerializer(instance=self.person) + expected = self.person_data + self.assertEquals(serializer.data['info'], expected) + class ValidationTests(TestCase): def setUp(self): -- cgit v1.2.3 From 38af6107b5fb26e2dffdeeadad80df70e256a5f3 Mon Sep 17 00:00:00 2001 From: Jacob Magnusson Date: Sat, 3 Nov 2012 00:32:08 +0100 Subject: Added test for ModelSerializer Meta fields returning as expected --- rest_framework/tests/serializer.py | 8 ++++++++ 1 file changed, 8 insertions(+) (limited to 'rest_framework') diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py index 5d46ff68..3fd49064 100644 --- a/rest_framework/tests/serializer.py +++ b/rest_framework/tests/serializer.py @@ -105,6 +105,14 @@ class BasicTests(TestCase): self.assertEquals(serializer.object, expected) self.assertTrue(serializer.object is expected) self.assertEquals(serializer.data['sub_comment'], 'And Merry Christmas!') + + def test_model_fields_as_expected(self): + """ Make sure that the fields returned are the same as defined + in the Meta data + """ + serializer = PersonSerializer(instance=self.person) + self.assertEquals(set(serializer.data.keys()), + set(['name', 'age', 'info'])) def test_field_with_dictionary(self): """ Make sure that dictionaries from fields are left intact -- cgit v1.2.3 From 44f280c3abf3832a4a43be4fc52dc807f4cb6a70 Mon Sep 17 00:00:00 2001 From: Jacob Magnusson Date: Sun, 4 Nov 2012 12:47:46 +0100 Subject: Add tests for caching of GET/HEAD requests using Django's built in caching framework. Currently fails as some attributes on the Response object are not pickable --- rest_framework/runtests/settings.py | 6 +++ rest_framework/tests/renderers.py | 88 +++++++++++++++++++++++++++++++++++++ 2 files changed, 94 insertions(+) (limited to 'rest_framework') diff --git a/rest_framework/runtests/settings.py b/rest_framework/runtests/settings.py index 951b1e72..b48f85e4 100644 --- a/rest_framework/runtests/settings.py +++ b/rest_framework/runtests/settings.py @@ -21,6 +21,12 @@ DATABASES = { } } +CACHES = { + 'default': { + 'BACKEND': 'django.core.cache.backends.locmem.LocMemCache', + } +} + # Local time zone for this installation. Choices can be found here: # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name # although not all choices may be available on all operating systems. diff --git a/rest_framework/tests/renderers.py b/rest_framework/tests/renderers.py index 48d8d9bd..1dd03c80 100644 --- a/rest_framework/tests/renderers.py +++ b/rest_framework/tests/renderers.py @@ -1,6 +1,8 @@ +import pickle import re from django.conf.urls.defaults import patterns, url, include +from django.core.cache import cache from django.test import TestCase from django.test.client import RequestFactory @@ -83,6 +85,7 @@ class HTMLView1(APIView): urlpatterns = patterns('', url(r'^.*\.(?P.+)$', MockView.as_view(renderer_classes=[RendererA, RendererB])), url(r'^$', MockView.as_view(renderer_classes=[RendererA, RendererB])), + url(r'^cache$', MockGETView.as_view()), url(r'^jsonp/jsonrenderer$', MockGETView.as_view(renderer_classes=[JSONRenderer, JSONPRenderer])), url(r'^jsonp/nojsonrenderer$', MockGETView.as_view(renderer_classes=[JSONPRenderer])), url(r'^html$', HTMLView.as_view()), @@ -416,3 +419,88 @@ class XMLRendererTestCase(TestCase): self.assertTrue(xml.startswith('\n')) self.assertTrue(xml.endswith('')) self.assertTrue(string in xml, '%r not in %r' % (string, xml)) + + +# Tests for caching issue, #346 +class CacheRenderTest(TestCase): + """ + Tests specific to caching responses + """ + + urls = 'rest_framework.tests.renderers' + + cache_key = 'just_a_cache_key' + + @classmethod + def _get_pickling_errors(cls, obj, seen=None): + """ Return any errors that would be raised if `obj' is pickled + Courtesy of koffie @ http://stackoverflow.com/a/7218986/109897 + """ + if seen == None: + seen = [] + try: + state = obj.__getstate__() + except AttributeError: + return + if state == None: + return + if isinstance(state,tuple): + if not isinstance(state[0],dict): + state=state[1] + else: + state=state[0].update(state[1]) + result = {} + for i in state: + try: + pickle.dumps(state[i],protocol=2) + except pickle.PicklingError: + if not state[i] in seen: + seen.append(state[i]) + result[i] = cls._get_pickling_errors(state[i],seen) + return result + + def http_resp(self, http_method, url): + """ + Simple wrapper for Client http requests + Removes the `client' attribute from the response as an instance + of `django.test.client.Client' is not pickable + """ + method = getattr(self.client, http_method) + resp = method(url) + del resp.client + return resp + + def test_obj_pickling(self): + """ + Test that responses are properly pickled + """ + resp = self.http_resp('get', '/cache') + + # Make sure that no pickling errors occurred + self.assertEqual(self._get_pickling_errors(resp), {}) + + # Unfortunately LocMem backend doesn't raise PickleErrors but returns + # None instead. + cache.set(self.cache_key, resp) + self.assertTrue(cache.get(self.cache_key) is not None) + + def test_head_caching(self): + """ + Test caching of HEAD requests + """ + resp = self.http_resp('head', '/cache') + cache.set(self.cache_key, resp) + + cached_resp = cache.get(self.cache_key) + self.assertIsInstance(cached_resp, Response) + + def test_get_caching(self): + """ + Test caching of GET requests + """ + resp = self.http_resp('get', '/cache') + cache.set(self.cache_key, resp) + + cached_resp = cache.get(self.cache_key) + self.assertIsInstance(cached_resp, Response) + self.assertEqual(cached_resp.content, resp.content) -- cgit v1.2.3 From 963c5fe4a702f906576ae66e2c4c3193896fcd38 Mon Sep 17 00:00:00 2001 From: Jacob Magnusson Date: Sun, 4 Nov 2012 12:48:41 +0100 Subject: Remove attributes that are not needed when caching the Response object. This fixes #346 --- rest_framework/response.py | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'rest_framework') diff --git a/rest_framework/response.py b/rest_framework/response.py index 7a459c8f..006d7eeb 100644 --- a/rest_framework/response.py +++ b/rest_framework/response.py @@ -45,3 +45,13 @@ class Response(SimpleTemplateResponse): # TODO: Deprecate and use a template tag instead # TODO: Status code text for RFC 6585 status codes return STATUS_CODE_TEXT.get(self.status_code, '') + + def __getstate__(self): + """ + Remove attributes from the response that shouldn't be cached + """ + state = super(Response, self).__getstate__() + for key in ('accepted_renderer', 'renderer_context', 'data'): + if key in state: + del state[key] + return state -- cgit v1.2.3 From 7df7dadccdba83d87fcc1ec6b5977fde26aab881 Mon Sep 17 00:00:00 2001 From: Jacob Magnusson Date: Sun, 4 Nov 2012 13:42:29 +0100 Subject: Remove `request' from response instance while testing caching --- rest_framework/tests/renderers.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'rest_framework') diff --git a/rest_framework/tests/renderers.py b/rest_framework/tests/renderers.py index 1dd03c80..9be4b114 100644 --- a/rest_framework/tests/renderers.py +++ b/rest_framework/tests/renderers.py @@ -462,12 +462,13 @@ class CacheRenderTest(TestCase): def http_resp(self, http_method, url): """ Simple wrapper for Client http requests - Removes the `client' attribute from the response as an instance - of `django.test.client.Client' is not pickable + Removes the `client' and `request' attributes from as they are + added by django.test.client.Client and not part of caching + responses outside of tests. """ method = getattr(self.client, http_method) resp = method(url) - del resp.client + del resp.client, resp.request return resp def test_obj_pickling(self): -- cgit v1.2.3 From 3d0f8b792ffcd85702f917de59cf51d21c9f6b43 Mon Sep 17 00:00:00 2001 From: Michael Shepanski Date: Sun, 4 Nov 2012 12:31:37 -0500 Subject: Fix for bug #363: ChoiceField missing in renderers.py --- rest_framework/renderers.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) (limited to 'rest_framework') diff --git a/rest_framework/renderers.py b/rest_framework/renderers.py index 73ae6edc..0a659bd1 100644 --- a/rest_framework/renderers.py +++ b/rest_framework/renderers.py @@ -281,6 +281,7 @@ class BrowsableAPIRenderer(BaseRenderer): serializers.DateField: forms.DateField, serializers.EmailField: forms.EmailField, serializers.CharField: forms.CharField, + serializers.ChoiceField: forms.ChoiceField, serializers.BooleanField: forms.BooleanField, serializers.PrimaryKeyRelatedField: forms.ChoiceField, serializers.ManyPrimaryKeyRelatedField: forms.MultipleChoiceField, @@ -316,7 +317,10 @@ class BrowsableAPIRenderer(BaseRenderer): try: fields[k] = field_mapping[v.__class__](**kwargs) except KeyError: - fields[k] = forms.CharField(**kwargs) + if getattr(v, 'choices', None) is not None: + fields[k] = forms.ChoiceField(**kwargs) + else: + fields[k] = forms.CharField(**kwargs) return fields def get_form(self, view, method, request): -- cgit v1.2.3 From 5b397e50ddb999f85949a7359d0a26c3531c78a9 Mon Sep 17 00:00:00 2001 From: Tom Christie Date: Mon, 5 Nov 2012 10:16:23 +0000 Subject: Include queryset missing exception on writable SlugField --- rest_framework/fields.py | 3 +++ 1 file changed, 3 insertions(+) (limited to 'rest_framework') diff --git a/rest_framework/fields.py b/rest_framework/fields.py index 5b28463c..eb4c5e1f 100644 --- a/rest_framework/fields.py +++ b/rest_framework/fields.py @@ -458,6 +458,9 @@ class SlugRelatedField(RelatedField): return getattr(obj, self.slug_field) def from_native(self, data): + if self.queryset is None: + raise Exception('Writable related fields must include a `queryset` argument') + try: return self.queryset.get(**{self.slug_field: data}) except ObjectDoesNotExist: -- cgit v1.2.3