django-rest-framework/tests/test_generics.py

684 lines
24 KiB
Python
Raw Normal View History

2012-11-22 03:20:49 +04:00
from __future__ import unicode_literals
2012-12-18 01:59:51 +04:00
from django.db import models
from django.shortcuts import get_object_or_404
2012-09-28 17:28:50 +04:00
from django.test import TestCase
from rest_framework import generics, renderers, serializers, status
2013-06-28 20:17:39 +04:00
from rest_framework.test import APIRequestFactory
from tests.models import BasicModel, Comment, SlugBasedModel
from tests.models import ForeignKeySource, ForeignKeyTarget
from rest_framework.compat import six
2012-09-28 17:28:50 +04:00
2013-06-28 20:17:39 +04:00
factory = APIRequestFactory()
2012-09-28 17:28:50 +04:00
2012-10-03 12:26:15 +04:00
class RootView(generics.ListCreateAPIView):
2012-09-28 19:41:35 +04:00
"""
Example description for OPTIONS.
"""
2012-09-28 17:28:50 +04:00
model = BasicModel
class InstanceView(generics.RetrieveUpdateDestroyAPIView):
2012-09-28 19:41:35 +04:00
"""
Example description for OPTIONS.
"""
2012-09-28 18:54:00 +04:00
model = BasicModel
def get_queryset(self):
queryset = super(InstanceView, self).get_queryset()
return queryset.exclude(text='filtered out')
2012-09-28 18:54:00 +04:00
class FKInstanceView(generics.RetrieveUpdateDestroyAPIView):
"""
FK: example description for OPTIONS.
"""
model = ForeignKeySource
2012-10-29 21:20:06 +04:00
class SlugSerializer(serializers.ModelSerializer):
slug = serializers.Field() # read only
class Meta:
model = SlugBasedModel
exclude = ('id',)
class SlugBasedInstanceView(InstanceView):
"""
A model with a slug-field.
"""
model = SlugBasedModel
2012-10-29 21:20:06 +04:00
serializer_class = SlugSerializer
lookup_field = 'slug'
2012-09-28 18:54:00 +04:00
class TestRootView(TestCase):
2012-09-28 17:28:50 +04:00
def setUp(self):
2012-09-28 18:54:00 +04:00
"""
2013-02-25 17:44:19 +04:00
Create 3 BasicModel instances.
2012-09-28 18:54:00 +04:00
"""
2012-09-28 17:28:50 +04:00
items = ['foo', 'bar', 'baz']
for item in items:
BasicModel(text=item).save()
self.objects = BasicModel.objects
self.data = [
{'id': obj.id, 'text': obj.text}
for obj in self.objects.all()
]
2012-09-28 19:23:46 +04:00
self.view = RootView.as_view()
2012-09-28 17:28:50 +04:00
def test_get_root_view(self):
2012-09-28 18:54:00 +04:00
"""
2012-10-03 12:26:15 +04:00
GET requests to ListCreateAPIView should return list of objects.
2012-09-28 18:54:00 +04:00
"""
2012-09-28 17:28:50 +04:00
request = factory.get('/')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(1):
response = self.view(request).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, self.data)
2012-09-28 18:54:00 +04:00
def test_post_root_view(self):
"""
2012-10-03 12:26:15 +04:00
POST requests to ListCreateAPIView should create a new object.
2012-09-28 18:54:00 +04:00
"""
2013-06-28 20:17:39 +04:00
data = {'text': 'foobar'}
request = factory.post('/', data, format='json')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(1):
response = self.view(request).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data, {'id': 4, 'text': 'foobar'})
2012-09-28 18:54:00 +04:00
created = self.objects.get(id=4)
2013-02-28 01:15:00 +04:00
self.assertEqual(created.text, 'foobar')
2012-09-28 18:54:00 +04:00
2012-09-28 19:23:46 +04:00
def test_put_root_view(self):
"""
2012-10-03 12:26:15 +04:00
PUT requests to ListCreateAPIView should not be allowed
2012-09-28 19:23:46 +04:00
"""
2013-06-28 20:17:39 +04:00
data = {'text': 'foobar'}
request = factory.put('/', data, format='json')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(0):
response = self.view(request).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
self.assertEqual(response.data, {"detail": "Method 'PUT' not allowed."})
2012-09-28 19:23:46 +04:00
def test_delete_root_view(self):
"""
2012-10-03 12:26:15 +04:00
DELETE requests to ListCreateAPIView should not be allowed
2012-09-28 19:23:46 +04:00
"""
request = factory.delete('/')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(0):
response = self.view(request).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
self.assertEqual(response.data, {"detail": "Method 'DELETE' not allowed."})
2012-09-28 19:41:35 +04:00
def test_options_root_view(self):
"""
2012-10-03 12:26:15 +04:00
OPTIONS requests to ListCreateAPIView should return metadata
2012-09-28 19:41:35 +04:00
"""
request = factory.options('/')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(0):
response = self.view(request).render()
2012-09-28 19:41:35 +04:00
expected = {
'parses': [
'application/json',
'application/x-www-form-urlencoded',
'multipart/form-data'
],
'renders': [
'application/json',
'text/html'
],
'name': 'Root',
'description': 'Example description for OPTIONS.',
2013-05-25 02:44:23 +04:00
'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',
},
}
}
}
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, expected)
2012-09-28 19:23:46 +04:00
def test_post_cannot_set_id(self):
"""
POST requests to create a new object should not be able to set the id.
"""
2013-06-28 20:17:39 +04:00
data = {'id': 999, 'text': 'foobar'}
request = factory.post('/', data, format='json')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(1):
response = self.view(request).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data, {'id': 4, 'text': 'foobar'})
created = self.objects.get(id=4)
2013-02-28 01:15:00 +04:00
self.assertEqual(created.text, 'foobar')
2012-09-28 18:54:00 +04:00
class TestInstanceView(TestCase):
def setUp(self):
"""
Create 3 BasicModel intances.
"""
items = ['foo', 'bar', 'baz', 'filtered out']
2012-09-28 18:54:00 +04:00
for item in items:
BasicModel(text=item).save()
self.objects = BasicModel.objects.exclude(text='filtered out')
2012-09-28 18:54:00 +04:00
self.data = [
{'id': obj.id, 'text': obj.text}
for obj in self.objects.all()
]
2012-09-28 19:23:46 +04:00
self.view = InstanceView.as_view()
self.slug_based_view = SlugBasedInstanceView.as_view()
2012-09-28 18:54:00 +04:00
def test_get_instance_view(self):
"""
2012-10-03 12:26:15 +04:00
GET requests to RetrieveUpdateDestroyAPIView should return a single object.
2012-09-28 18:54:00 +04:00
"""
request = factory.get('/1')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(1):
response = self.view(request, pk=1).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, self.data[0])
2012-09-28 18:54:00 +04:00
2012-09-28 19:23:46 +04:00
def test_post_instance_view(self):
"""
2012-10-03 12:26:15 +04:00
POST requests to RetrieveUpdateDestroyAPIView should not be allowed
2012-09-28 19:23:46 +04:00
"""
2013-06-28 20:17:39 +04:00
data = {'text': 'foobar'}
request = factory.post('/', data, format='json')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(0):
response = self.view(request).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
self.assertEqual(response.data, {"detail": "Method 'POST' not allowed."})
2012-09-28 19:23:46 +04:00
2012-09-28 18:54:00 +04:00
def test_put_instance_view(self):
"""
2012-10-03 12:26:15 +04:00
PUT requests to RetrieveUpdateDestroyAPIView should update an object.
2012-09-28 18:54:00 +04:00
"""
2013-06-28 20:17:39 +04:00
data = {'text': 'foobar'}
request = factory.put('/1', data, format='json')
with self.assertNumQueries(2):
2013-03-08 21:36:43 +04:00
response = self.view(request, pk='1').render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
2012-09-28 18:54:00 +04:00
updated = self.objects.get(id=1)
2013-02-28 01:15:00 +04:00
self.assertEqual(updated.text, 'foobar')
2012-09-28 18:54:00 +04:00
def test_patch_instance_view(self):
"""
PATCH requests to RetrieveUpdateDestroyAPIView should update an object.
"""
2013-06-28 20:17:39 +04:00
data = {'text': 'foobar'}
request = factory.patch('/1', data, format='json')
with self.assertNumQueries(2):
2013-03-08 21:36:43 +04:00
response = self.view(request, pk=1).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
updated = self.objects.get(id=1)
2013-02-28 01:15:00 +04:00
self.assertEqual(updated.text, 'foobar')
2012-09-28 18:54:00 +04:00
def test_delete_instance_view(self):
"""
2012-10-03 12:26:15 +04:00
DELETE requests to RetrieveUpdateDestroyAPIView should delete an object.
2012-09-28 18:54:00 +04:00
"""
request = factory.delete('/1')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(2):
response = self.view(request, pk=1).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
self.assertEqual(response.content, six.b(''))
2012-09-28 18:54:00 +04:00
ids = [obj.id for obj in self.objects.all()]
2013-02-28 01:15:00 +04:00
self.assertEqual(ids, [2, 3])
2012-09-28 19:41:35 +04:00
def test_options_instance_view(self):
"""
2012-10-03 12:26:15 +04:00
OPTIONS requests to RetrieveUpdateDestroyAPIView should return metadata
2012-09-28 19:41:35 +04:00
"""
2013-05-25 02:44:23 +04:00
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()
2012-09-28 19:41:35 +04:00
expected = {
'parses': [
'application/json',
'application/x-www-form-urlencoded',
'multipart/form-data'
],
'renders': [
'application/json',
'text/html'
],
'name': 'Instance',
'description': 'Example description for OPTIONS.',
2013-05-25 02:44:23 +04:00
'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',
},
}
}
2013-05-25 02:44:23 +04:00
}
2013-02-28 01:15:00 +04:00
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.
Regression test for #890.
"""
request = factory.get('/a')
with self.assertNumQueries(0):
response = self.view(request, pk='a').render()
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
def test_put_cannot_set_id(self):
"""
PUT requests to create a new object should not be able to set the id.
"""
2013-06-28 20:17:39 +04:00
data = {'id': 999, 'text': 'foobar'}
request = factory.put('/1', data, format='json')
with self.assertNumQueries(2):
2013-03-08 21:36:43 +04:00
response = self.view(request, pk=1).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
updated = self.objects.get(id=1)
2013-02-28 01:15:00 +04:00
self.assertEqual(updated.text, 'foobar')
2012-10-05 19:24:52 +04:00
def test_put_to_deleted_instance(self):
"""
PUT requests to RetrieveUpdateDestroyAPIView should create an object
if it does not currently exist.
"""
self.objects.get(id=1).delete()
2013-06-28 20:17:39 +04:00
data = {'text': 'foobar'}
request = factory.put('/1', data, format='json')
with self.assertNumQueries(3):
2013-03-08 21:36:43 +04:00
response = self.view(request, pk=1).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
2012-10-05 19:24:52 +04:00
updated = self.objects.get(id=1)
2013-02-28 01:15:00 +04:00
self.assertEqual(updated.text, 'foobar')
def test_put_to_filtered_out_instance(self):
"""
PUT requests to an URL of instance which is filtered out should not be
able to create new objects.
"""
data = {'text': 'foo'}
filtered_out_pk = BasicModel.objects.filter(text='filtered out')[0].pk
request = factory.put('/{0}'.format(filtered_out_pk), data, format='json')
response = self.view(request, pk=filtered_out_pk).render()
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
def test_put_as_create_on_id_based_url(self):
"""
PUT requests to RetrieveUpdateDestroyAPIView should create an object
at the requested url if it doesn't exist.
"""
2013-06-28 20:17:39 +04:00
data = {'text': 'foobar'}
2013-03-08 21:01:43 +04:00
# pk fields can not be created on demand, only the database can set the pk for a new object
2013-06-28 20:17:39 +04:00
request = factory.put('/5', data, format='json')
with self.assertNumQueries(3):
2013-03-08 21:36:43 +04:00
response = self.view(request, pk=5).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
2012-10-28 23:56:48 +04:00
new_obj = self.objects.get(pk=5)
2013-02-28 01:15:00 +04:00
self.assertEqual(new_obj.text, 'foobar')
def test_put_as_create_on_slug_based_url(self):
"""
PUT requests to RetrieveUpdateDestroyAPIView should create an object
at the requested url if possible, else return HTTP_403_FORBIDDEN error-response.
"""
2013-06-28 20:17:39 +04:00
data = {'text': 'foobar'}
request = factory.put('/test_slug', data, format='json')
2013-03-08 21:36:43 +04:00
with self.assertNumQueries(2):
response = self.slug_based_view(request, slug='test_slug').render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data, {'slug': 'test_slug', 'text': 'foobar'})
2012-10-29 21:20:06 +04:00
new_obj = SlugBasedModel.objects.get(slug='test_slug')
2013-02-28 01:15:00 +04:00
self.assertEqual(new_obj.text, 'foobar')
2012-10-08 15:52:56 +04:00
def test_patch_cannot_create_an_object(self):
"""
PATCH requests should not be able to create objects.
"""
data = {'text': 'foobar'}
request = factory.patch('/999', data, format='json')
with self.assertNumQueries(1):
response = self.view(request, pk=999).render()
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertFalse(self.objects.filter(id=999).exists())
class TestFKInstanceView(TestCase):
def setUp(self):
"""
Create 3 BasicModel instances.
"""
items = ['foo', 'bar', 'baz']
for item in items:
t = ForeignKeyTarget(name=item)
t.save()
ForeignKeySource(name='source_' + item, target=t).save()
self.objects = ForeignKeySource.objects
self.data = [
{'id': obj.id, 'name': obj.name}
for obj in self.objects.all()
]
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,
2014-03-30 14:06:03 +04:00
'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):
"""
Test cases for a RetrieveUpdateDestroyAPIView that does NOT use the
queryset/model mechanism but instead overrides get_object()
"""
def setUp(self):
"""
Create 3 BasicModel intances.
"""
items = ['foo', 'bar', 'baz']
for item in items:
BasicModel(text=item).save()
self.objects = BasicModel.objects
self.data = [
{'id': obj.id, 'text': obj.text}
for obj in self.objects.all()
]
class OverriddenGetObjectView(generics.RetrieveUpdateDestroyAPIView):
"""
Example detail view for override of get_object().
"""
model = BasicModel
def get_object(self):
pk = int(self.kwargs['pk'])
return get_object_or_404(BasicModel.objects.all(), id=pk)
self.view = OverriddenGetObjectView.as_view()
def test_overridden_get_object_view(self):
"""
GET requests to RetrieveUpdateDestroyAPIView should return a single object.
"""
request = factory.get('/1')
with self.assertNumQueries(1):
response = self.view(request, pk=1).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, self.data[0])
2012-10-08 15:52:56 +04:00
# Regression test for #285
class CommentSerializer(serializers.ModelSerializer):
class Meta:
model = Comment
exclude = ('created',)
class CommentView(generics.ListCreateAPIView):
serializer_class = CommentSerializer
model = Comment
class TestCreateModelWithAutoNowAddField(TestCase):
def setUp(self):
self.objects = Comment.objects
self.view = CommentView.as_view()
def test_create_model_with_auto_now_add_field(self):
"""
Regression test for #285
https://github.com/tomchristie/django-rest-framework/issues/285
"""
2013-06-28 20:17:39 +04:00
data = {'email': 'foobar@example.com', 'content': 'foobar'}
request = factory.post('/', data, format='json')
2012-10-08 15:52:56 +04:00
response = self.view(request).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
2012-10-08 15:52:56 +04:00
created = self.objects.get(id=1)
2013-02-28 01:15:00 +04:00
self.assertEqual(created.content, 'foobar')
2012-12-18 01:59:51 +04:00
# Test for particularly ugly regression with m2m in browsable API
2012-12-18 01:59:51 +04:00
class ClassB(models.Model):
name = models.CharField(max_length=255)
class ClassA(models.Model):
name = models.CharField(max_length=255)
childs = models.ManyToManyField(ClassB, blank=True, null=True)
class ClassASerializer(serializers.ModelSerializer):
2013-02-07 13:14:58 +04:00
childs = serializers.PrimaryKeyRelatedField(many=True, source='childs')
2012-12-18 01:59:51 +04:00
class Meta:
model = ClassA
class ExampleView(generics.ListCreateAPIView):
serializer_class = ClassASerializer
model = ClassA
class TestM2MBrowseableAPI(TestCase):
def test_m2m_in_browseable_api(self):
"""
Test for particularly ugly regression with m2m in browsable API
2012-12-18 01:59:51 +04:00
"""
request = factory.get('/', HTTP_ACCEPT='text/html')
view = ExampleView().as_view()
response = view(request).render()
2013-02-28 01:15:00 +04:00
self.assertEqual(response.status_code, status.HTTP_200_OK)
class InclusiveFilterBackend(object):
def filter_queryset(self, request, queryset, view):
return queryset.filter(text='foo')
class ExclusiveFilterBackend(object):
def filter_queryset(self, request, queryset, view):
return queryset.filter(text='other')
class TwoFieldModel(models.Model):
field_a = models.CharField(max_length=100)
field_b = models.CharField(max_length=100)
class DynamicSerializerView(generics.ListCreateAPIView):
model = TwoFieldModel
renderer_classes = (renderers.BrowsableAPIRenderer, renderers.JSONRenderer)
def get_serializer_class(self):
if self.request.method == 'POST':
class DynamicSerializer(serializers.ModelSerializer):
class Meta:
model = TwoFieldModel
fields = ('field_b',)
return DynamicSerializer
return super(DynamicSerializerView, self).get_serializer_class()
class TestFilterBackendAppliedToViews(TestCase):
def setUp(self):
"""
Create 3 BasicModel instances to filter on.
"""
items = ['foo', 'bar', 'baz']
for item in items:
BasicModel(text=item).save()
self.objects = BasicModel.objects
self.data = [
{'id': obj.id, 'text': obj.text}
for obj in self.objects.all()
]
def test_get_root_view_filters_by_name_with_filter_backend(self):
"""
GET requests to ListCreateAPIView should return filtered list.
"""
root_view = RootView.as_view(filter_backends=(InclusiveFilterBackend,))
request = factory.get('/')
response = root_view(request).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data, [{'id': 1, 'text': 'foo'}])
def test_get_root_view_filters_out_all_models_with_exclusive_filter_backend(self):
"""
GET requests to ListCreateAPIView should return empty list when all models are filtered out.
"""
root_view = RootView.as_view(filter_backends=(ExclusiveFilterBackend,))
request = factory.get('/')
response = root_view(request).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, [])
def test_get_instance_view_filters_out_name_with_filter_backend(self):
"""
GET requests to RetrieveUpdateDestroyAPIView should raise 404 when model filtered out.
"""
instance_view = InstanceView.as_view(filter_backends=(ExclusiveFilterBackend,))
request = factory.get('/1')
response = instance_view(request, pk=1).render()
self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
self.assertEqual(response.data, {'detail': 'Not found'})
def test_get_instance_view_will_return_single_object_when_filter_does_not_exclude_it(self):
"""
GET requests to RetrieveUpdateDestroyAPIView should return a single object when not excluded
"""
instance_view = InstanceView.as_view(filter_backends=(InclusiveFilterBackend,))
request = factory.get('/1')
response = instance_view(request, pk=1).render()
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data, {'id': 1, 'text': 'foo'})
def test_dynamic_serializer_form_in_browsable_api(self):
"""
GET requests to ListCreateAPIView should return filtered list.
"""
view = DynamicSerializerView.as_view()
request = factory.get('/')
response = view(request).render()
self.assertContains(response, 'field_b')
self.assertNotContains(response, 'field_a')