From 7eefcf7e53f2bc37733a601041f23d354c7729f5 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Mon, 25 Mar 2013 20:26:34 +0000
Subject: Bulk update, allow_add_remove flag

---
 rest_framework/tests/serializer_bulk_update.py | 34 ++++++++++++++++++++++----
 1 file changed, 29 insertions(+), 5 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/serializer_bulk_update.py b/rest_framework/tests/serializer_bulk_update.py
index afc1a1a9..8b0ded1a 100644
--- a/rest_framework/tests/serializer_bulk_update.py
+++ b/rest_framework/tests/serializer_bulk_update.py
@@ -98,7 +98,7 @@ class BulkCreateSerializerTests(TestCase):
         serializer = self.BookSerializer(data=data, many=True)
         self.assertEqual(serializer.is_valid(), False)
 
-        expected_errors = {'non_field_errors': ['Expected a list of items']}
+        expected_errors = {'non_field_errors': ['Expected a list of items.']}
 
         self.assertEqual(serializer.errors, expected_errors)
 
@@ -115,7 +115,7 @@ class BulkCreateSerializerTests(TestCase):
         serializer = self.BookSerializer(data=data, many=True)
         self.assertEqual(serializer.is_valid(), False)
 
-        expected_errors = {'non_field_errors': ['Expected a list of items']}
+        expected_errors = {'non_field_errors': ['Expected a list of items.']}
 
         self.assertEqual(serializer.errors, expected_errors)
 
@@ -201,11 +201,12 @@ class BulkUpdateSerializerTests(TestCase):
                 'author': 'Haruki Murakami'
             }
         ]
-        serializer = self.BookSerializer(self.books(), data=data, many=True, allow_delete=True)
+        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):
@@ -223,13 +224,36 @@ class BulkUpdateSerializerTests(TestCase):
                 'author': 'Haruki Murakami'
             }
         ]
-        serializer = self.BookSerializer(self.books(), data=data, many=True, allow_delete=True)
+        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.
@@ -249,6 +273,6 @@ class BulkUpdateSerializerTests(TestCase):
             {},
             {'id': ['Enter a whole number.']}
         ]
-        serializer = self.BookSerializer(self.books(), data=data, many=True, allow_delete=True)
+        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)
-- 
cgit v1.2.3


From f1b8fee4f1e0ea2503d4e0453bdc3049edaa2598 Mon Sep 17 00:00:00 2001
From: Fernando Rocha
Date: Wed, 27 Mar 2013 14:05:46 -0300
Subject: client credentials should be optional (fix #759)

client credentials should only be required on token
request

Signed-off-by: Fernando Rocha <fernandogrd@gmail.com>
---
 rest_framework/tests/authentication.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/authentication.py b/rest_framework/tests/authentication.py
index b663ca48..375b19bd 100644
--- a/rest_framework/tests/authentication.py
+++ b/rest_framework/tests/authentication.py
@@ -516,6 +516,18 @@ class OAuth2Tests(TestCase):
         response = self.csrf_client.get('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 200)
 
+    @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
+    def test_get_form_passing_auth_without_client_params(self):
+        """
+        Ensure GETing form over OAuth without client credentials
+
+        Regression test for issue #759:
+        https://github.com/tomchristie/django-rest-framework/issues/759
+        """
+        auth = self._create_authorization_header()
+        response = self.csrf_client.get('/oauth2-test/', HTTP_AUTHORIZATION=auth)
+        self.assertEqual(response.status_code, 200)
+
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
     def test_post_form_passing_auth(self):
         """Ensure POSTing form over OAuth with correct credentials passes and does not require CSRF"""
-- 
cgit v1.2.3


From b2cea84fae4f721e8eb6432b3d1bab1309e21a00 Mon Sep 17 00:00:00 2001
From: Fernando Rocha
Date: Wed, 27 Mar 2013 19:00:36 -0300
Subject: Complete remove of client checks from oauth2

Signed-off-by: Fernando Rocha <fernandogrd@gmail.com>
---
 rest_framework/tests/authentication.py | 9 ---------
 1 file changed, 9 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/authentication.py b/rest_framework/tests/authentication.py
index 375b19bd..629db422 100644
--- a/rest_framework/tests/authentication.py
+++ b/rest_framework/tests/authentication.py
@@ -499,15 +499,6 @@ class OAuth2Tests(TestCase):
         response = self.csrf_client.get('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 401)
 
-    @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
-    def test_get_form_with_wrong_client_data_failing_auth(self):
-        """Ensure GETing form over OAuth with incorrect client credentials fails"""
-        auth = self._create_authorization_header()
-        params = self._client_credentials_params()
-        params['client_id'] += 'a'
-        response = self.csrf_client.get('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
-        self.assertEqual(response.status_code, 401)
-
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
     def test_get_form_passing_auth(self):
         """Ensure GETing form over OAuth with correct client credentials succeed"""
-- 
cgit v1.2.3


From 8ec60a22e1c14792b7021ff9b4e940e16528788a Mon Sep 17 00:00:00 2001
From: Pierre Dulac
Date: Thu, 28 Mar 2013 00:57:23 +0100
Subject: Remove client credentials from all OAuth 2 tests

---
 rest_framework/tests/authentication.py | 45 ++++++++--------------------------
 1 file changed, 10 insertions(+), 35 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/authentication.py b/rest_framework/tests/authentication.py
index 629db422..8e6d3e51 100644
--- a/rest_framework/tests/authentication.py
+++ b/rest_framework/tests/authentication.py
@@ -466,17 +466,13 @@ class OAuth2Tests(TestCase):
     def _create_authorization_header(self, token=None):
         return "Bearer {0}".format(token or self.access_token.token)
 
-    def _client_credentials_params(self):
-        return {'client_id': self.CLIENT_ID, 'client_secret': self.CLIENT_SECRET}
-
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
     def test_get_form_with_wrong_authorization_header_token_type_failing(self):
         """Ensure that a wrong token type lead to the correct HTTP error status code"""
         auth = "Wrong token-type-obsviously"
         response = self.csrf_client.get('/oauth2-test/', {}, HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 401)
-        params = self._client_credentials_params()
-        response = self.csrf_client.get('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.get('/oauth2-test/', HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 401)
 
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
@@ -485,8 +481,7 @@ class OAuth2Tests(TestCase):
         auth = "Bearer wrong token format"
         response = self.csrf_client.get('/oauth2-test/', {}, HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 401)
-        params = self._client_credentials_params()
-        response = self.csrf_client.get('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.get('/oauth2-test/', HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 401)
 
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
@@ -495,27 +490,13 @@ class OAuth2Tests(TestCase):
         auth = "Bearer wrong-token"
         response = self.csrf_client.get('/oauth2-test/', {}, HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 401)
-        params = self._client_credentials_params()
-        response = self.csrf_client.get('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.get('/oauth2-test/', HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 401)
 
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
     def test_get_form_passing_auth(self):
         """Ensure GETing form over OAuth with correct client credentials succeed"""
         auth = self._create_authorization_header()
-        params = self._client_credentials_params()
-        response = self.csrf_client.get('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
-        self.assertEqual(response.status_code, 200)
-
-    @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
-    def test_get_form_passing_auth_without_client_params(self):
-        """
-        Ensure GETing form over OAuth without client credentials
-
-        Regression test for issue #759:
-        https://github.com/tomchristie/django-rest-framework/issues/759
-        """
-        auth = self._create_authorization_header()
         response = self.csrf_client.get('/oauth2-test/', HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 200)
 
@@ -523,8 +504,7 @@ class OAuth2Tests(TestCase):
     def test_post_form_passing_auth(self):
         """Ensure POSTing form over OAuth with correct credentials passes and does not require CSRF"""
         auth = self._create_authorization_header()
-        params = self._client_credentials_params()
-        response = self.csrf_client.post('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.post('/oauth2-test/', HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 200)
 
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
@@ -532,16 +512,14 @@ class OAuth2Tests(TestCase):
         """Ensure POSTing when there is no OAuth access token in db fails"""
         self.access_token.delete()
         auth = self._create_authorization_header()
-        params = self._client_credentials_params()
-        response = self.csrf_client.post('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.post('/oauth2-test/', HTTP_AUTHORIZATION=auth)
         self.assertIn(response.status_code, (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN))
 
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
     def test_post_form_with_refresh_token_failing_auth(self):
         """Ensure POSTing with refresh token instead of access token fails"""
         auth = self._create_authorization_header(token=self.refresh_token.token)
-        params = self._client_credentials_params()
-        response = self.csrf_client.post('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.post('/oauth2-test/', HTTP_AUTHORIZATION=auth)
         self.assertIn(response.status_code, (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN))
 
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
@@ -550,8 +528,7 @@ class OAuth2Tests(TestCase):
         self.access_token.expires = datetime.datetime.now() - datetime.timedelta(seconds=10)  # 10 seconds late
         self.access_token.save()
         auth = self._create_authorization_header()
-        params = self._client_credentials_params()
-        response = self.csrf_client.post('/oauth2-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.post('/oauth2-test/', HTTP_AUTHORIZATION=auth)
         self.assertIn(response.status_code, (status.HTTP_401_UNAUTHORIZED, status.HTTP_403_FORBIDDEN))
         self.assertIn('Invalid token', response.content)
 
@@ -562,10 +539,9 @@ class OAuth2Tests(TestCase):
         read_only_access_token.scope = oauth2_provider_scope.SCOPE_NAME_DICT['read']
         read_only_access_token.save()
         auth = self._create_authorization_header(token=read_only_access_token.token)
-        params = self._client_credentials_params()
-        response = self.csrf_client.get('/oauth2-with-scope-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.get('/oauth2-with-scope-test/', HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 200)
-        response = self.csrf_client.post('/oauth2-with-scope-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.post('/oauth2-with-scope-test/', HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
 
     @unittest.skipUnless(oauth2_provider, 'django-oauth2-provider not installed')
@@ -575,6 +551,5 @@ class OAuth2Tests(TestCase):
         read_write_access_token.scope = oauth2_provider_scope.SCOPE_NAME_DICT['write']
         read_write_access_token.save()
         auth = self._create_authorization_header(token=read_write_access_token.token)
-        params = self._client_credentials_params()
-        response = self.csrf_client.post('/oauth2-with-scope-test/', params, HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.post('/oauth2-with-scope-test/', HTTP_AUTHORIZATION=auth)
         self.assertEqual(response.status_code, 200)
-- 
cgit v1.2.3


From d4df617f8c1980c1d5f1b91a6b9928185c4c4dce Mon Sep 17 00:00:00 2001
From: Kevin Stone
Date: Wed, 27 Mar 2013 18:29:50 -0700
Subject: Added unit test for failing DjangoFilterBackend on SingleObjectMixin
 that was resolved in b10663e02408404844aca4b362aa24df816aca98

Signed-off-by: Kevin Stone <kevinastone@gmail.com>
---
 rest_framework/tests/filterset.py | 75 +++++++++++++++++++++++++++++++++++----
 1 file changed, 69 insertions(+), 6 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filterset.py b/rest_framework/tests/filterset.py
index 238da56e..1a71558c 100644
--- a/rest_framework/tests/filterset.py
+++ b/rest_framework/tests/filterset.py
@@ -1,11 +1,12 @@
 from __future__ import unicode_literals
 import datetime
 from decimal import Decimal
+from django.core.urlresolvers import reverse
 from django.test import TestCase
 from django.test.client import RequestFactory
 from django.utils import unittest
 from rest_framework import generics, status, filters
-from rest_framework.compat import django_filters
+from rest_framework.compat import django_filters, patterns, url
 from rest_framework.tests.models import FilterableItem, BasicModel
 
 factory = RequestFactory()
@@ -46,12 +47,21 @@ if django_filters:
         filter_class = MisconfiguredFilter
         filter_backend = filters.DjangoFilterBackend
 
+    class FilterClassDetailView(generics.RetrieveAPIView):
+        model = FilterableItem
+        filter_class = SeveralFieldsFilter
+        filter_backend = filters.DjangoFilterBackend
+
+    urlpatterns = patterns('',
+        url(r'^(?P<pk>\d+)/$', FilterClassDetailView.as_view(), name='detail-view'),
+        url(r'^$', FilterClassRootView.as_view(), name='root-view'),
+    )
 
-class IntegrationTestFiltering(TestCase):
-    """
-    Integration tests for filtered list views.
-    """
 
+class CommonFilteringTestCase(TestCase):
+    def _serialize_object(self, obj):
+        return {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}
+    
     def setUp(self):
         """
         Create 10 FilterableItem instances.
@@ -65,10 +75,16 @@ class IntegrationTestFiltering(TestCase):
 
         self.objects = FilterableItem.objects
         self.data = [
-            {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}
+            self._serialize_object(obj)
             for obj in self.objects.all()
         ]
 
+
+class IntegrationTestFiltering(CommonFilteringTestCase):
+    """
+    Integration tests for filtered list views.
+    """
+
     @unittest.skipUnless(django_filters, 'django-filters not installed')
     def test_get_filtered_fields_root_view(self):
         """
@@ -167,3 +183,50 @@ class IntegrationTestFiltering(TestCase):
         request = factory.get('/?integer=%s' % search_integer)
         response = view(request).render()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+
+class IntegrationTestDetailFiltering(CommonFilteringTestCase):
+    """
+    Integration tests for filtered detail views.
+    """
+    urls = 'rest_framework.tests.filterset'
+    
+    def _get_url(self, item):
+        return reverse('detail-view', kwargs=dict(pk=item.pk))
+
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_get_filtered_detail_view(self):
+        """
+        GET requests to filtered RetrieveAPIView that have a filter_class set
+        should return filtered results.
+        """
+        item = self.objects.all()[0]
+        data = self._serialize_object(item)
+
+        # Basic test with no filter.
+        response = self.client.get(self._get_url(item))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, data)
+
+        # Tests that the decimal filter set that should fail.
+        search_decimal = Decimal('4.25')
+        high_item = self.objects.filter(decimal__gt=search_decimal)[0]
+        response = self.client.get('{url}?decimal={param}'.format(url=self._get_url(high_item), param=search_decimal))
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+        # Tests that the decimal filter set that should succeed.
+        search_decimal = Decimal('4.25')
+        low_item = self.objects.filter(decimal__lt=search_decimal)[0]
+        low_item_data = self._serialize_object(low_item)
+        response = self.client.get('{url}?decimal={param}'.format(url=self._get_url(low_item), param=search_decimal))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, low_item_data)
+        
+        # Tests that multiple filters works.
+        search_decimal = Decimal('5.25')
+        search_date = datetime.date(2012, 10, 2)
+        valid_item = self.objects.filter(decimal__lt=search_decimal, date__gt=search_date)[0]
+        valid_item_data = self._serialize_object(valid_item)
+        response = self.client.get('{url}?decimal={decimal}&date={date}'.format(url=self._get_url(valid_item), decimal=search_decimal, date=search_date))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, valid_item_data)
-- 
cgit v1.2.3


From 4531ded061831a9cf402c6c5d84e42f31bc025ad Mon Sep 17 00:00:00 2001
From: Kevin Stone
Date: Thu, 28 Mar 2013 18:48:48 -0700
Subject: Removed pagination regression special case for Django<1.4.   Having
 DjangoFilterBackend return an actual query set fixes this issue.

Signed-off-by: Kevin Stone <kevinastone@gmail.com>
---
 rest_framework/tests/pagination.py | 10 ----------
 1 file changed, 10 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/pagination.py b/rest_framework/tests/pagination.py
index d2c9b051..6b8ef02f 100644
--- a/rest_framework/tests/pagination.py
+++ b/rest_framework/tests/pagination.py
@@ -129,16 +129,6 @@ class IntegrationTestPaginationAndFiltering(TestCase):
         view = FilterFieldsRootView.as_view()
 
         EXPECTED_NUM_QUERIES = 2
-        if django.VERSION < (1, 4):
-            # On Django 1.3 we need to use django-filter 0.5.4
-            #
-            # The filter objects there don't expose a `.count()` method,
-            # which means we only make a single query *but* it's a single
-            # query across *all* of the queryset, instead of a COUNT and then
-            # a SELECT with a LIMIT.
-            #
-            # Although this is fewer queries, it's actually a regression.
-            EXPECTED_NUM_QUERIES = 1
 
         request = factory.get('/?decimal=15.20')
         with self.assertNumQueries(EXPECTED_NUM_QUERIES):
-- 
cgit v1.2.3


From fd3f538e9f9ef5d4d929c107b9619e0735e426f1 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Thu, 4 Apr 2013 21:48:23 +0100
Subject: Fix up view name/description tests

---
 rest_framework/tests/description.py | 63 ++++++++++++++-----------------------
 1 file changed, 23 insertions(+), 40 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/description.py b/rest_framework/tests/description.py
index 5b3315bc..52c1a34c 100644
--- a/rest_framework/tests/description.py
+++ b/rest_framework/tests/description.py
@@ -4,6 +4,7 @@ from __future__ import unicode_literals
 from django.test import TestCase
 from rest_framework.views import APIView
 from rest_framework.compat import apply_markdown
+from rest_framework.utils.formatting import get_view_name, get_view_description
 
 # We check that docstrings get nicely un-indented.
 DESCRIPTION = """an example docstring
@@ -49,22 +50,16 @@ MARKED_DOWN_gte_21 = """<h2 id="an-example-docstring">an example docstring</h2>
 
 
 class TestViewNamesAndDescriptions(TestCase):
-    def test_resource_name_uses_classname_by_default(self):
-        """Ensure Resource names are based on the classname by default."""
+    def test_view_name_uses_class_name(self):
+        """
+        Ensure view names are based on the class name.
+        """
         class MockView(APIView):
             pass
-        self.assertEqual(MockView().get_name(), 'Mock')
+        self.assertEqual(get_view_name(MockView), 'Mock')
 
-    def test_resource_name_can_be_set_explicitly(self):
-        """Ensure Resource names can be set using the 'get_name' method."""
-        example = 'Some Other Name'
-        class MockView(APIView):
-            def get_name(self):
-                return example
-        self.assertEqual(MockView().get_name(), example)
-
-    def test_resource_description_uses_docstring_by_default(self):
-        """Ensure Resource names are based on the docstring by default."""
+    def test_view_description_uses_docstring(self):
+        """Ensure view descriptions are based on the docstring."""
         class MockView(APIView):
             """an example docstring
             ====================
@@ -81,44 +76,32 @@ class TestViewNamesAndDescriptions(TestCase):
 
             # hash style header #"""
 
-        self.assertEqual(MockView().get_description(), DESCRIPTION)
-
-    def test_resource_description_can_be_set_explicitly(self):
-        """Ensure Resource descriptions can be set using the 'get_description' method."""
-        example = 'Some other description'
-
-        class MockView(APIView):
-            """docstring"""
-            def get_description(self):
-                return example
-        self.assertEqual(MockView().get_description(), example)
+        self.assertEqual(get_view_description(MockView), DESCRIPTION)
 
-    def test_resource_description_supports_unicode(self):
+    def test_view_description_supports_unicode(self):
+        """
+        Unicode in docstrings should be respected.
+        """
 
         class MockView(APIView):
             """Проверка"""
             pass
 
-        self.assertEqual(MockView().get_description(), "Проверка")
-
-
-    def test_resource_description_does_not_require_docstring(self):
-        """Ensure that empty docstrings do not affect the Resource's description if it has been set using the 'get_description' method."""
-        example = 'Some other description'
-
-        class MockView(APIView):
-            def get_description(self):
-                return example
-        self.assertEqual(MockView().get_description(), example)
+        self.assertEqual(get_view_description(MockView), "Проверка")
 
-    def test_resource_description_can_be_empty(self):
-        """Ensure that if a resource has no doctring or 'description' class attribute, then it's description is the empty string."""
+    def test_view_description_can_be_empty(self):
+        """
+        Ensure that if a view has no docstring,
+        then it's description is the empty string.
+        """
         class MockView(APIView):
             pass
-        self.assertEqual(MockView().get_description(), '')
+        self.assertEqual(get_view_description(MockView), '')
 
     def test_markdown(self):
-        """Ensure markdown to HTML works as expected"""
+        """
+        Ensure markdown to HTML works as expected.
+        """
         if apply_markdown:
             gte_21_match = apply_markdown(DESCRIPTION) == MARKED_DOWN_gte_21
             lt_21_match = apply_markdown(DESCRIPTION) == MARKED_DOWN_lt_21
-- 
cgit v1.2.3


From dc45bc7bfad64a17f3e5ed0f5a487bccc379aac2 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 9 Apr 2013 19:01:01 +0100
Subject: Add lookup_kwarg

---
 rest_framework/tests/filterset.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filterset.py b/rest_framework/tests/filterset.py
index 1a71558c..1e53a5cd 100644
--- a/rest_framework/tests/filterset.py
+++ b/rest_framework/tests/filterset.py
@@ -61,7 +61,7 @@ if django_filters:
 class CommonFilteringTestCase(TestCase):
     def _serialize_object(self, obj):
         return {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}
-    
+
     def setUp(self):
         """
         Create 10 FilterableItem instances.
@@ -190,7 +190,7 @@ class IntegrationTestDetailFiltering(CommonFilteringTestCase):
     Integration tests for filtered detail views.
     """
     urls = 'rest_framework.tests.filterset'
-    
+
     def _get_url(self, item):
         return reverse('detail-view', kwargs=dict(pk=item.pk))
 
@@ -221,7 +221,7 @@ class IntegrationTestDetailFiltering(CommonFilteringTestCase):
         response = self.client.get('{url}?decimal={param}'.format(url=self._get_url(low_item), param=search_decimal))
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.data, low_item_data)
-        
+
         # Tests that multiple filters works.
         search_decimal = Decimal('5.25')
         search_date = datetime.date(2012, 10, 2)
-- 
cgit v1.2.3


From 76e039d70e8fc7f1d5c65180cb544abab81e600e Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 10 Apr 2013 22:38:02 +0100
Subject: First pass on automatically including reverse relationship

---
 rest_framework/tests/serializer.py | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 05217f35..3a94fad5 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -738,6 +738,43 @@ class ManyRelatedTests(TestCase):
 
         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")
-- 
cgit v1.2.3


From 750451f5b4de61684f4a4e69dd5776bd84ac054c Mon Sep 17 00:00:00 2001
From: Johannes Spielmann
Date: Sun, 14 Apr 2013 18:30:44 +0200
Subject: adding test case for generic view with overriden get_object()

---
 rest_framework/tests/generics.py | 173 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 173 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py
index f564890c..b40b0102 100644
--- a/rest_framework/tests/generics.py
+++ b/rest_framework/tests/generics.py
@@ -24,6 +24,28 @@ class InstanceView(generics.RetrieveUpdateDestroyAPIView):
     model = BasicModel
 
 
+class InstanceDetailView(generics.RetrieveUpdateDestroyAPIView):
+    """
+    Example detail view for override of get_object().
+    """
+
+    # we have to implement this too, otherwise we can't be sure that get_object
+    # will be called
+    def get_serializer(self, instance=None, data=None, files=None, partial=None):
+        class InstanceDetailSerializer(serializers.ModelSerializer):
+            class Meta:
+                model = BasicModel
+        return InstanceDetailSerializer(instance=instance, data=data, files=files, partial=partial)
+    
+    def get_object(self):
+        try:
+            pk = int(self.kwargs['pk'])
+            self.object = BasicModel.objects.get(id=pk)
+            return self.object
+        except BasicModel.DoesNotExist:
+            return self.permission_denied(self.request)
+
+
 class SlugSerializer(serializers.ModelSerializer):
     slug = serializers.Field()  # read only
 
@@ -301,6 +323,157 @@ class TestInstanceView(TestCase):
         new_obj = SlugBasedModel.objects.get(slug='test_slug')
         self.assertEqual(new_obj.text, 'foobar')
 
+class TestInstanceDetailView(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()
+        ]
+        self.view_class = InstanceDetailView
+        self.view = InstanceDetailView.as_view()
+
+    def test_get_instance_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])    
+
+    def test_post_instance_view(self):
+        """
+        POST requests to RetrieveUpdateDestroyAPIView should not be allowed
+        """
+        content = {'text': 'foobar'}
+        request = factory.post('/', json.dumps(content),
+                               content_type='application/json')
+        with self.assertNumQueries(0):
+            response = self.view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
+        self.assertEqual(response.data, {"detail": "Method 'POST' not allowed."})
+
+    def test_put_instance_view(self):
+        """
+        PUT requests to RetrieveUpdateDestroyAPIView should update an object.
+        """
+        content = {'text': 'foobar'}
+        request = factory.put('/1', json.dumps(content),
+                              content_type='application/json')
+        with self.assertNumQueries(2):
+            response = self.view(request, pk='1').render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
+        updated = self.objects.get(id=1)
+        self.assertEqual(updated.text, 'foobar')
+
+    def test_patch_instance_view(self):
+        """
+        PATCH requests to RetrieveUpdateDestroyAPIView should update an object.
+        """
+        content = {'text': 'foobar'}
+        request = factory.patch('/1', json.dumps(content),
+                              content_type='application/json')
+
+        with self.assertNumQueries(2):
+            response = self.view(request, pk=1).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
+        updated = self.objects.get(id=1)
+        self.assertEqual(updated.text, 'foobar')
+
+    def test_delete_instance_view(self):
+        """
+        DELETE requests to RetrieveUpdateDestroyAPIView should delete an object.
+        """
+        request = factory.delete('/1')
+        with self.assertNumQueries(2):
+            response = self.view(request, pk=1).render()
+        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
+        self.assertEqual(response.content, six.b(''))
+        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('/')
+        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': 'Instance Detail',
+            'description': 'Example detail view for override of get_object().'
+        }
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, expected)
+
+    def test_put_cannot_set_id(self):
+        """
+        PUT requests to create a new object should not be able to set the id.
+        """
+        content = {'id': 999, 'text': 'foobar'}
+        request = factory.put('/1', json.dumps(content),
+                              content_type='application/json')
+        with self.assertNumQueries(2):
+            response = self.view(request, pk=1).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
+        updated = self.objects.get(id=1)
+        self.assertEqual(updated.text, 'foobar')
+
+    def test_put_to_deleted_instance(self):
+        """
+        PUT requests to RetrieveUpdateDestroyAPIView should create an object
+        if it does not currently exist. In our DetailView, however,
+        we cannot access any other id's than those that already exist.
+        See the InstanceView for the normal behaviour.
+        """
+        self.objects.get(id=1).delete()
+        content = {'text': 'foobar'}
+        request = factory.put('/1', json.dumps(content),
+                              content_type='application/json')
+        with self.assertNumQueries(1):
+            response = self.view(request, pk=5).render()
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+    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. In our DetailView, however,
+        we cannot access any other id's than those that already exist.
+        See the InstanceView for the normal behaviour.
+        """
+        content = {'text': 'foobar'}
+        # pk fields can not be created on demand, only the database can set the pk for a new object
+        request = factory.put('/5', json.dumps(content),
+                              content_type='application/json')
+        with self.assertNumQueries(1):
+            response = self.view(request, pk=5).render()
+        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+
 
 # Regression test for #285
 
-- 
cgit v1.2.3


From ad436d966fa9ee2f5817aa5c26612c82558c4262 Mon Sep 17 00:00:00 2001
From: Stephan Groß
Date: Mon, 15 Apr 2013 12:40:18 +0200
Subject: Add DecimalField support

---
 rest_framework/tests/fields.py | 165 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 165 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/fields.py b/rest_framework/tests/fields.py
index 19c663d8..f833aa32 100644
--- a/rest_framework/tests/fields.py
+++ b/rest_framework/tests/fields.py
@@ -3,12 +3,14 @@ General serializer field tests.
 """
 from __future__ import unicode_literals
 import datetime
+from decimal import Decimal
 
 from django.db import models
 from django.test import TestCase
 from django.core import validators
 
 from rest_framework import serializers
+from rest_framework.serializers import Serializer
 
 
 class TimestampedModel(models.Model):
@@ -481,3 +483,166 @@ class TimeFieldTest(TestCase):
         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('9000', result_1)
+        self.assertEqual('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(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(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': [u'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(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': [u'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(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': [u'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(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': [u'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(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': [u'Ensure that there are no more than 4 digits in total.']})
\ No newline at end of file
-- 
cgit v1.2.3


From 37f7d8bc0f00feb1a4d23c0e163eab8b47faaec3 Mon Sep 17 00:00:00 2001
From: Stephan Groß
Date: Mon, 15 Apr 2013 12:55:29 +0200
Subject: Fix unicodes

---
 rest_framework/tests/fields.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/fields.py b/rest_framework/tests/fields.py
index f833aa32..597180b4 100644
--- a/rest_framework/tests/fields.py
+++ b/rest_framework/tests/fields.py
@@ -597,7 +597,7 @@ class DecimalFieldTest(TestCase):
         s = DecimalSerializer(data={'decimal_field': '123'})
 
         self.assertFalse(s.is_valid())
-        self.assertEqual(s.errors,  {'decimal_field': [u'Ensure this value is less than or equal to 100.']})
+        self.assertEqual(s.errors,  {'decimal_field': ['Ensure this value is less than or equal to 100.']})
 
     def test_raise_min_value(self):
         """
@@ -609,7 +609,7 @@ class DecimalFieldTest(TestCase):
         s = DecimalSerializer(data={'decimal_field': '99'})
 
         self.assertFalse(s.is_valid())
-        self.assertEqual(s.errors,  {'decimal_field': [u'Ensure this value is greater than or equal to 100.']})
+        self.assertEqual(s.errors,  {'decimal_field': ['Ensure this value is greater than or equal to 100.']})
 
     def test_raise_max_digits(self):
         """
@@ -621,7 +621,7 @@ class DecimalFieldTest(TestCase):
         s = DecimalSerializer(data={'decimal_field': '123.456'})
 
         self.assertFalse(s.is_valid())
-        self.assertEqual(s.errors,  {'decimal_field': [u'Ensure that there are no more than 5 digits in total.']})
+        self.assertEqual(s.errors,  {'decimal_field': ['Ensure that there are no more than 5 digits in total.']})
 
     def test_raise_max_decimal_places(self):
         """
@@ -633,7 +633,7 @@ class DecimalFieldTest(TestCase):
         s = DecimalSerializer(data={'decimal_field': '123.4567'})
 
         self.assertFalse(s.is_valid())
-        self.assertEqual(s.errors,  {'decimal_field': [u'Ensure that there are no more than 3 decimal places.']})
+        self.assertEqual(s.errors,  {'decimal_field': ['Ensure that there are no more than 3 decimal places.']})
 
     def test_raise_max_whole_digits(self):
         """
@@ -645,4 +645,4 @@ class DecimalFieldTest(TestCase):
         s = DecimalSerializer(data={'decimal_field': '12345.6'})
 
         self.assertFalse(s.is_valid())
-        self.assertEqual(s.errors,  {'decimal_field': [u'Ensure that there are no more than 4 digits in total.']})
\ No newline at end of file
+        self.assertEqual(s.errors,  {'decimal_field': ['Ensure that there are no more than 4 digits in total.']})
\ No newline at end of file
-- 
cgit v1.2.3


From cac669702596cdf768971267e6355fb9223a69e8 Mon Sep 17 00:00:00 2001
From: Stephan Groß
Date: Mon, 15 Apr 2013 15:24:14 +0200
Subject: Return Decimal instance instead of string

---
 rest_framework/tests/fields.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/fields.py b/rest_framework/tests/fields.py
index 597180b4..3cdfa0f6 100644
--- a/rest_framework/tests/fields.py
+++ b/rest_framework/tests/fields.py
@@ -559,8 +559,8 @@ class DecimalFieldTest(TestCase):
         result_1 = f.to_native(Decimal('9000'))
         result_2 = f.to_native(Decimal('1.00000001'))
 
-        self.assertEqual('9000', result_1)
-        self.assertEqual('1.00000001', result_2)
+        self.assertEqual(Decimal('9000'), result_1)
+        self.assertEqual(Decimal('1.00000001'), result_2)
 
     def test_to_native_none(self):
         """
-- 
cgit v1.2.3


From 37fe0bf0de25d28d792a291d5a84987ab71c4cb6 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 17 Apr 2013 09:03:24 +0100
Subject: Remove unneccessary tests from #789, and bit of cleanup.

---
 rest_framework/tests/generics.py | 165 ++++-----------------------------------
 1 file changed, 17 insertions(+), 148 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py
index b40b0102..4a13389a 100644
--- a/rest_framework/tests/generics.py
+++ b/rest_framework/tests/generics.py
@@ -1,5 +1,6 @@
 from __future__ import unicode_literals
 from django.db import models
+from django.shortcuts import get_object_or_404
 from django.test import TestCase
 from rest_framework import generics, serializers, status
 from rest_framework.tests.utils import RequestFactory
@@ -24,28 +25,6 @@ class InstanceView(generics.RetrieveUpdateDestroyAPIView):
     model = BasicModel
 
 
-class InstanceDetailView(generics.RetrieveUpdateDestroyAPIView):
-    """
-    Example detail view for override of get_object().
-    """
-
-    # we have to implement this too, otherwise we can't be sure that get_object
-    # will be called
-    def get_serializer(self, instance=None, data=None, files=None, partial=None):
-        class InstanceDetailSerializer(serializers.ModelSerializer):
-            class Meta:
-                model = BasicModel
-        return InstanceDetailSerializer(instance=instance, data=data, files=files, partial=partial)
-    
-    def get_object(self):
-        try:
-            pk = int(self.kwargs['pk'])
-            self.object = BasicModel.objects.get(id=pk)
-            return self.object
-        except BasicModel.DoesNotExist:
-            return self.permission_denied(self.request)
-
-
 class SlugSerializer(serializers.ModelSerializer):
     slug = serializers.Field()  # read only
 
@@ -323,7 +302,8 @@ class TestInstanceView(TestCase):
         new_obj = SlugBasedModel.objects.get(slug='test_slug')
         self.assertEqual(new_obj.text, 'foobar')
 
-class TestInstanceDetailView(TestCase):
+
+class TestOverriddenGetObject(TestCase):
     """
     Test cases for a RetrieveUpdateDestroyAPIView that does NOT use the
     queryset/model mechanism but instead overrides get_object()
@@ -340,139 +320,28 @@ class TestInstanceDetailView(TestCase):
             {'id': obj.id, 'text': obj.text}
             for obj in self.objects.all()
         ]
-        self.view_class = InstanceDetailView
-        self.view = InstanceDetailView.as_view()
 
-    def test_get_instance_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])    
+        class OverriddenGetObjectView(generics.RetrieveUpdateDestroyAPIView):
+            """
+            Example detail view for override of get_object().
+            """
+            model = BasicModel
 
-    def test_post_instance_view(self):
-        """
-        POST requests to RetrieveUpdateDestroyAPIView should not be allowed
-        """
-        content = {'text': 'foobar'}
-        request = factory.post('/', json.dumps(content),
-                               content_type='application/json')
-        with self.assertNumQueries(0):
-            response = self.view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
-        self.assertEqual(response.data, {"detail": "Method 'POST' not allowed."})
-
-    def test_put_instance_view(self):
-        """
-        PUT requests to RetrieveUpdateDestroyAPIView should update an object.
-        """
-        content = {'text': 'foobar'}
-        request = factory.put('/1', json.dumps(content),
-                              content_type='application/json')
-        with self.assertNumQueries(2):
-            response = self.view(request, pk='1').render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
-        updated = self.objects.get(id=1)
-        self.assertEqual(updated.text, 'foobar')
-
-    def test_patch_instance_view(self):
-        """
-        PATCH requests to RetrieveUpdateDestroyAPIView should update an object.
-        """
-        content = {'text': 'foobar'}
-        request = factory.patch('/1', json.dumps(content),
-                              content_type='application/json')
-
-        with self.assertNumQueries(2):
-            response = self.view(request, pk=1).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data, {'id': 1, 'text': 'foobar'})
-        updated = self.objects.get(id=1)
-        self.assertEqual(updated.text, 'foobar')
-
-    def test_delete_instance_view(self):
-        """
-        DELETE requests to RetrieveUpdateDestroyAPIView should delete an object.
-        """
-        request = factory.delete('/1')
-        with self.assertNumQueries(2):
-            response = self.view(request, pk=1).render()
-        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(response.content, six.b(''))
-        ids = [obj.id for obj in self.objects.all()]
-        self.assertEqual(ids, [2, 3])
+            def get_object(self):
+                pk = int(self.kwargs['pk'])
+                return get_object_or_404(BasicModel.objects.all(), id=pk)
 
-    def test_options_instance_view(self):
-        """
-        OPTIONS requests to RetrieveUpdateDestroyAPIView 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': 'Instance Detail',
-            'description': 'Example detail view for override of get_object().'
-        }
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data, expected)
+        self.view = OverriddenGetObjectView.as_view()
 
-    def test_put_cannot_set_id(self):
+    def test_overridden_get_object_view(self):
         """
-        PUT requests to create a new object should not be able to set the id.
+        GET requests to RetrieveUpdateDestroyAPIView should return a single object.
         """
-        content = {'id': 999, 'text': 'foobar'}
-        request = factory.put('/1', json.dumps(content),
-                              content_type='application/json')
-        with self.assertNumQueries(2):
+        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, {'id': 1, 'text': 'foobar'})
-        updated = self.objects.get(id=1)
-        self.assertEqual(updated.text, 'foobar')
-
-    def test_put_to_deleted_instance(self):
-        """
-        PUT requests to RetrieveUpdateDestroyAPIView should create an object
-        if it does not currently exist. In our DetailView, however,
-        we cannot access any other id's than those that already exist.
-        See the InstanceView for the normal behaviour.
-        """
-        self.objects.get(id=1).delete()
-        content = {'text': 'foobar'}
-        request = factory.put('/1', json.dumps(content),
-                              content_type='application/json')
-        with self.assertNumQueries(1):
-            response = self.view(request, pk=5).render()
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-
-    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. In our DetailView, however,
-        we cannot access any other id's than those that already exist.
-        See the InstanceView for the normal behaviour.
-        """
-        content = {'text': 'foobar'}
-        # pk fields can not be created on demand, only the database can set the pk for a new object
-        request = factory.put('/5', json.dumps(content),
-                              content_type='application/json')
-        with self.assertNumQueries(1):
-            response = self.view(request, pk=5).render()
-        self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
-
+        self.assertEqual(response.data, self.data[0])
 
 
 # Regression test for #285
-- 
cgit v1.2.3


From 4bf1a09baeb885863e6028b97c2d51b26fb18534 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 23 Apr 2013 11:31:38 +0100
Subject: Ensure implementation of reverse relations in 'fields' is backwards
 compatible

---
 rest_framework/tests/relations_hyperlink.py | 16 +++++++++-------
 rest_framework/tests/relations_nested.py    | 24 ++++++++----------------
 rest_framework/tests/relations_pk.py        | 17 ++++++++++-------
 3 files changed, 27 insertions(+), 30 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/relations_hyperlink.py b/rest_framework/tests/relations_hyperlink.py
index b5702a48..b1eed9a7 100644
--- a/rest_framework/tests/relations_hyperlink.py
+++ b/rest_framework/tests/relations_hyperlink.py
@@ -26,42 +26,44 @@ urlpatterns = patterns('',
 )
 
 
+# ManyToMany
 class ManyToManyTargetSerializer(serializers.HyperlinkedModelSerializer):
-    sources = serializers.HyperlinkedRelatedField(many=True, view_name='manytomanysource-detail')
-
     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):
-    sources = serializers.HyperlinkedRelatedField(many=True, view_name='foreignkeysource-detail')
-
     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')
 
 
-# OneToOne
+# Nullable OneToOne
 class NullableOneToOneTargetSerializer(serializers.HyperlinkedModelSerializer):
-    nullable_source = serializers.HyperlinkedRelatedField(view_name='nullableonetoonesource-detail')
-
     class Meta:
         model = OneToOneTarget
+        fields = ('url', 'name', 'nullable_source')
 
 
 # TODO: Add test that .data cannot be accessed prior to .is_valid
diff --git a/rest_framework/tests/relations_nested.py b/rest_framework/tests/relations_nested.py
index a125ba65..f6d006b3 100644
--- a/rest_framework/tests/relations_nested.py
+++ b/rest_framework/tests/relations_nested.py
@@ -5,39 +5,31 @@ from rest_framework.tests.models import ForeignKeyTarget, ForeignKeySource, Null
 
 
 class ForeignKeySourceSerializer(serializers.ModelSerializer):
-    class Meta:
-        depth = 1
-        model = ForeignKeySource
-
-
-class FlatForeignKeySourceSerializer(serializers.ModelSerializer):
     class Meta:
         model = ForeignKeySource
+        fields = ('id', 'name', 'target')
+        depth = 1
 
 
 class ForeignKeyTargetSerializer(serializers.ModelSerializer):
-    sources = FlatForeignKeySourceSerializer(many=True)
-
     class Meta:
         model = ForeignKeyTarget
+        fields = ('id', 'name', 'sources')
+        depth = 1
 
 
 class NullableForeignKeySourceSerializer(serializers.ModelSerializer):
     class Meta:
-        depth = 1
         model = NullableForeignKeySource
-
-
-class NullableOneToOneSourceSerializer(serializers.ModelSerializer):
-    class Meta:
-        model = NullableOneToOneSource
+        fields = ('id', 'name', 'target')
+        depth = 1
 
 
 class NullableOneToOneTargetSerializer(serializers.ModelSerializer):
-    nullable_source = NullableOneToOneSourceSerializer()
-
     class Meta:
         model = OneToOneTarget
+        fields = ('id', 'name', 'nullable_source')
+        depth = 1
 
 
 class ReverseForeignKeyTests(TestCase):
diff --git a/rest_framework/tests/relations_pk.py b/rest_framework/tests/relations_pk.py
index f08e1808..5ce8b567 100644
--- a/rest_framework/tests/relations_pk.py
+++ b/rest_framework/tests/relations_pk.py
@@ -5,41 +5,44 @@ from rest_framework.tests.models import ManyToManyTarget, ManyToManySource, Fore
 from rest_framework.compat import six
 
 
+# ManyToMany
 class ManyToManyTargetSerializer(serializers.ModelSerializer):
-    sources = serializers.PrimaryKeyRelatedField(many=True)
-
     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):
-    sources = serializers.PrimaryKeyRelatedField(many=True)
-
     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')
 
 
-# OneToOne
+# Nullable OneToOne
 class NullableOneToOneTargetSerializer(serializers.ModelSerializer):
-    nullable_source = serializers.PrimaryKeyRelatedField()
-
     class Meta:
         model = OneToOneTarget
+        fields = ('id', 'name', 'nullable_source')
 
 
 # TODO: Add test that .data cannot be accessed prior to .is_valid
-- 
cgit v1.2.3


From 3b0fa3ebaa9d42723d970bb88be0dfe2586d1a5e Mon Sep 17 00:00:00 2001
From: JC
Date: Sat, 27 Apr 2013 13:10:39 -0700
Subject: Changed DepthTest to have depth=2

---
 rest_framework/tests/serializer.py | 31 +++++++++++++++++++------------
 1 file changed, 19 insertions(+), 12 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 05217f35..bd874253 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -3,7 +3,7 @@ from django.utils.datastructures import MultiValueDict
 from django.test import TestCase
 from rest_framework import serializers
 from rest_framework.tests.models import (HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel,
-    BlankFieldModel, BlogPost, Book, CallableDefaultValueModel, DefaultValueModel,
+    BlankFieldModel, BlogPost, BlogPostComment, Book, CallableDefaultValueModel, DefaultValueModel,
     ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo)
 import datetime
 import pickle
@@ -767,8 +767,6 @@ class RelatedTraversalTest(TestCase):
         post = BlogPost.objects.create(title="Test blog post", writer=user)
         post.blogpostcomment_set.create(text="I love this blog post")
 
-        from rest_framework.tests.models import BlogPostComment
-
         class PersonSerializer(serializers.ModelSerializer):
             class Meta:
                 model = Person
@@ -968,23 +966,26 @@ class SerializerPickleTests(TestCase):
 
 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 BlogPostSerializer(serializers.ModelSerializer):
+        class BlogPostCommentSerializer(serializers.ModelSerializer):
             class Meta:
-                model = BlogPost
-                depth = 1
+                model = BlogPostComment
+                depth = 2
 
-        serializer = BlogPostSerializer(instance=post)
-        expected = {'id': 1, 'title': 'Test blog post',
-                    'writer': {'id': 1, 'name': 'django', 'age': 1}}
+        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:
@@ -996,9 +997,15 @@ class DepthTest(TestCase):
             class Meta:
                 model = BlogPost
 
-        serializer = BlogPostSerializer(instance=post)
-        expected = {'id': 1, 'title': 'Test blog post',
-                    'writer': {'id': 1, 'name': 'django', 'age': 1}}
+        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)
 
-- 
cgit v1.2.3


From dc7b1d643020cac5d585aac42f98962cc7aa6bf7 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Mon, 29 Apr 2013 12:45:00 +0100
Subject: 2.2's PendingDeprecationWarnings now become DeprecationWarnings. 
 2.3's PendingDeprecationWarnings added.

---
 rest_framework/tests/serializer.py        | 5 ++---
 rest_framework/tests/serializer_nested.py | 4 ++--
 2 files changed, 4 insertions(+), 5 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 3a94fad5..ae8d09dc 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -357,7 +357,6 @@ class CustomValidationTests(TestCase):
 
         def validate_email(self, attrs, source):
             value = attrs[source]
-
             return attrs
 
         def validate_content(self, attrs, source):
@@ -1103,7 +1102,7 @@ class DeserializeListTestCase(TestCase):
 
     def test_no_errors(self):
         data = [self.data.copy() for x in range(0, 3)]
-        serializer = CommentSerializer(data=data)
+        serializer = CommentSerializer(data=data, many=True)
         self.assertTrue(serializer.is_valid())
         self.assertTrue(isinstance(serializer.object, list))
         self.assertTrue(
@@ -1115,7 +1114,7 @@ class DeserializeListTestCase(TestCase):
         invalid_item['email'] = ''
         data = [self.data.copy(), invalid_item, self.data.copy()]
 
-        serializer = CommentSerializer(data=data)
+        serializer = CommentSerializer(data=data, many=True)
         self.assertFalse(serializer.is_valid())
         expected = [{}, {'email': ['This field is required.']}, {}]
         self.assertEqual(serializer.errors, expected)
diff --git a/rest_framework/tests/serializer_nested.py b/rest_framework/tests/serializer_nested.py
index 6a29c652..71d0e24b 100644
--- a/rest_framework/tests/serializer_nested.py
+++ b/rest_framework/tests/serializer_nested.py
@@ -109,7 +109,7 @@ class WritableNestedSerializerBasicTests(TestCase):
             }
         ]
 
-        serializer = self.AlbumSerializer(data=data)
+        serializer = self.AlbumSerializer(data=data, many=True)
         self.assertEqual(serializer.is_valid(), False)
         self.assertEqual(serializer.errors, expected_errors)
 
@@ -241,6 +241,6 @@ class WritableNestedSerializerObjectTests(TestCase):
             )
         ]
 
-        serializer = self.AlbumSerializer(data=data)
+        serializer = self.AlbumSerializer(data=data, many=True)
         self.assertEqual(serializer.is_valid(), True)
         self.assertEqual(serializer.object, expected_object)
-- 
cgit v1.2.3


From 53f9d4a380ee0066cbee8382ae265ea6005d8c88 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Mon, 29 Apr 2013 13:20:15 +0100
Subject: fields shortcut on views

---
 rest_framework/tests/generics.py | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py
index 4a13389a..12c9b677 100644
--- a/rest_framework/tests/generics.py
+++ b/rest_framework/tests/generics.py
@@ -344,6 +344,30 @@ class TestOverriddenGetObject(TestCase):
         self.assertEqual(response.data, self.data[0])
 
 
+class TestFieldsShortcut(TestCase):
+    """
+    Test cases for setting the `fields` attribute on a view.
+    """
+    def setUp(self):
+        class OverriddenFieldsView(generics.RetrieveUpdateDestroyAPIView):
+            model = BasicModel
+            fields = ('text',)
+
+        class RegularView(generics.RetrieveUpdateDestroyAPIView):
+            model = BasicModel
+
+        self.overridden_fields_view = OverriddenFieldsView()
+        self.regular_view = RegularView()
+
+    def test_overridden_fields_view(self):
+        Serializer = self.overridden_fields_view.get_serializer_class()
+        self.assertEqual(Serializer().fields.keys(), ['text'])
+
+    def test_not_overridden_fields_view(self):
+        Serializer = self.regular_view.get_serializer_class()
+        self.assertEqual(Serializer().fields.keys(), ['id', 'text'])
+
+
 # Regression test for #285
 
 class CommentSerializer(serializers.ModelSerializer):
-- 
cgit v1.2.3


From 0c1ab584d3d0898d47e0bce6beb5d7c39a55dd52 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Mon, 29 Apr 2013 14:08:38 +0100
Subject: Tweaks for preferring .queryset over .model

---
 rest_framework/tests/generics.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py
index 12c9b677..63ff1fc3 100644
--- a/rest_framework/tests/generics.py
+++ b/rest_framework/tests/generics.py
@@ -350,11 +350,11 @@ class TestFieldsShortcut(TestCase):
     """
     def setUp(self):
         class OverriddenFieldsView(generics.RetrieveUpdateDestroyAPIView):
-            model = BasicModel
+            queryset = BasicModel.objects.all()
             fields = ('text',)
 
         class RegularView(generics.RetrieveUpdateDestroyAPIView):
-            model = BasicModel
+            queryset = BasicModel.objects.all()
 
         self.overridden_fields_view = OverriddenFieldsView()
         self.regular_view = RegularView()
@@ -362,10 +362,12 @@ class TestFieldsShortcut(TestCase):
     def test_overridden_fields_view(self):
         Serializer = self.overridden_fields_view.get_serializer_class()
         self.assertEqual(Serializer().fields.keys(), ['text'])
+        self.assertEqual(Serializer().opts.model, BasicModel)
 
     def test_not_overridden_fields_view(self):
         Serializer = self.regular_view.get_serializer_class()
         self.assertEqual(Serializer().fields.keys(), ['id', 'text'])
+        self.assertEqual(Serializer().opts.model, BasicModel)
 
 
 # Regression test for #285
-- 
cgit v1.2.3


From 21ae3a66917acf4ea57e8f7940ce1a6823a2ce92 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 30 Apr 2013 08:24:33 +0100
Subject: Drop out  attribute

---
 rest_framework/tests/generics.py | 26 --------------------------
 1 file changed, 26 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py
index 63ff1fc3..4a13389a 100644
--- a/rest_framework/tests/generics.py
+++ b/rest_framework/tests/generics.py
@@ -344,32 +344,6 @@ class TestOverriddenGetObject(TestCase):
         self.assertEqual(response.data, self.data[0])
 
 
-class TestFieldsShortcut(TestCase):
-    """
-    Test cases for setting the `fields` attribute on a view.
-    """
-    def setUp(self):
-        class OverriddenFieldsView(generics.RetrieveUpdateDestroyAPIView):
-            queryset = BasicModel.objects.all()
-            fields = ('text',)
-
-        class RegularView(generics.RetrieveUpdateDestroyAPIView):
-            queryset = BasicModel.objects.all()
-
-        self.overridden_fields_view = OverriddenFieldsView()
-        self.regular_view = RegularView()
-
-    def test_overridden_fields_view(self):
-        Serializer = self.overridden_fields_view.get_serializer_class()
-        self.assertEqual(Serializer().fields.keys(), ['text'])
-        self.assertEqual(Serializer().opts.model, BasicModel)
-
-    def test_not_overridden_fields_view(self):
-        Serializer = self.regular_view.get_serializer_class()
-        self.assertEqual(Serializer().fields.keys(), ['id', 'text'])
-        self.assertEqual(Serializer().opts.model, BasicModel)
-
-
 # Regression test for #285
 
 class CommentSerializer(serializers.ModelSerializer):
-- 
cgit v1.2.3


From 8cabae22c5330da2e0a15a6d61ef038a6447756a Mon Sep 17 00:00:00 2001
From: Victor Shih
Date: Wed, 1 May 2013 21:26:40 -0700
Subject: Example and spelling fixes. Change "browseable" to "browsable" for
 consistency.

---
 rest_framework/tests/generics.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py
index 4a13389a..eca50d82 100644
--- a/rest_framework/tests/generics.py
+++ b/rest_framework/tests/generics.py
@@ -377,7 +377,7 @@ class TestCreateModelWithAutoNowAddField(TestCase):
         self.assertEqual(created.content, 'foobar')
 
 
-# Test for particularly ugly regression with m2m in browseable API
+# Test for particularly ugly regression with m2m in browsable API
 class ClassB(models.Model):
     name = models.CharField(max_length=255)
 
@@ -402,7 +402,7 @@ class ExampleView(generics.ListCreateAPIView):
 class TestM2MBrowseableAPI(TestCase):
     def test_m2m_in_browseable_api(self):
         """
-        Test for particularly ugly regression with m2m in browseable API
+        Test for particularly ugly regression with m2m in browsable API
         """
         request = factory.get('/', HTTP_ACCEPT='text/html')
         view = ExampleView().as_view()
-- 
cgit v1.2.3


From 318fdaabe560c99de4983e0a3cdcb79756baaf01 Mon Sep 17 00:00:00 2001
From: Michael Elovskikh
Date: Fri, 3 May 2013 01:39:08 +0600
Subject: Tests for FileUploadParser

---
 rest_framework/tests/parsers.py | 27 ++++++++++++++++++++++++++-
 1 file changed, 26 insertions(+), 1 deletion(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/parsers.py b/rest_framework/tests/parsers.py
index 539c5b44..b18ecbf2 100644
--- a/rest_framework/tests/parsers.py
+++ b/rest_framework/tests/parsers.py
@@ -1,10 +1,11 @@
 from __future__ import unicode_literals
 from rest_framework.compat import StringIO
 from django import forms
+from django.core.files.uploadhandler import MemoryFileUploadHandler
 from django.test import TestCase
 from django.utils import unittest
 from rest_framework.compat import etree
-from rest_framework.parsers import FormParser
+from rest_framework.parsers import FormParser, FileUploadParser
 from rest_framework.parsers import XMLParser
 import datetime
 
@@ -82,3 +83,27 @@ class TestXMLParser(TestCase):
         parser = XMLParser()
         data = parser.parse(self._complex_data_input)
         self.assertEqual(data, self._complex_data)
+
+
+class TestFileUploadParser(TestCase):
+    def setUp(self):
+        class MockRequest(object):
+            pass
+        from io import BytesIO
+        self.stream = BytesIO(
+            "Test text file".encode('utf-8')
+        )
+        request = MockRequest()
+        request.upload_handlers = (MemoryFileUploadHandler(),)
+        request.META = {
+            'HTTP_CONTENT_DISPOSITION': 'Content-Disposition: inline; filename=file.txt'.encode('utf-8'),
+            'HTTP_CONTENT_LENGTH': 14,
+        }
+        self.parser_context = {'request': request}
+
+    def test_parse(self):
+        """ Make sure the `QueryDict` works OK """
+        parser = FileUploadParser()
+        data_and_files = parser.parse(self.stream, parser_context=self.parser_context)
+        file_obj = data_and_files.files['file']
+        self.assertEqual(file_obj._size, 14)
-- 
cgit v1.2.3


From e36e4f48ad481b4303e68ed524677add07b224f7 Mon Sep 17 00:00:00 2001
From: Michael Elovskikh
Date: Sat, 4 May 2013 14:58:21 +0600
Subject: Codebase improvements on FileUploadParser

* Added docstrings.
* Added `FileUploadParser.get_filename` to make it easier to override.
* Added url kwargs filename detection step.
* Updated tests corresponding to these changes.
---
 rest_framework/tests/parsers.py | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/parsers.py b/rest_framework/tests/parsers.py
index b18ecbf2..7699e10c 100644
--- a/rest_framework/tests/parsers.py
+++ b/rest_framework/tests/parsers.py
@@ -99,11 +99,17 @@ class TestFileUploadParser(TestCase):
             'HTTP_CONTENT_DISPOSITION': 'Content-Disposition: inline; filename=file.txt'.encode('utf-8'),
             'HTTP_CONTENT_LENGTH': 14,
         }
-        self.parser_context = {'request': request}
+        self.parser_context = {'request': request, 'kwargs': {}}
 
     def test_parse(self):
         """ Make sure the `QueryDict` works OK """
         parser = FileUploadParser()
-        data_and_files = parser.parse(self.stream, parser_context=self.parser_context)
+        self.stream.seek(0)
+        data_and_files = parser.parse(self.stream, None, self.parser_context)
         file_obj = data_and_files.files['file']
         self.assertEqual(file_obj._size, 14)
+
+    def test_get_filename(self):
+        parser = FileUploadParser()
+        filename = parser.get_filename(self.stream, None, self.parser_context)
+        self.assertEqual(filename, 'file.txt'.encode('utf-8'))
-- 
cgit v1.2.3


From de69a28b9e786b8c759cda4acedb0a1b8542298b Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 8 May 2013 20:18:01 +0100
Subject: Test and fix for #814.

---
 rest_framework/tests/filterset.py | 28 +++++++++++++++++++++++++++-
 1 file changed, 27 insertions(+), 1 deletion(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filterset.py b/rest_framework/tests/filterset.py
index 1e53a5cd..023bd016 100644
--- a/rest_framework/tests/filterset.py
+++ b/rest_framework/tests/filterset.py
@@ -5,7 +5,7 @@ from django.core.urlresolvers import reverse
 from django.test import TestCase
 from django.test.client import RequestFactory
 from django.utils import unittest
-from rest_framework import generics, status, filters
+from rest_framework import generics, serializers, status, filters
 from rest_framework.compat import django_filters, patterns, url
 from rest_framework.tests.models import FilterableItem, BasicModel
 
@@ -52,6 +52,17 @@ if django_filters:
         filter_class = SeveralFieldsFilter
         filter_backend = filters.DjangoFilterBackend
 
+    # Regression test for #814
+    class FilterableItemSerializer(serializers.ModelSerializer):
+        class Meta:
+            model = FilterableItem
+
+    class FilterFieldsQuerysetView(generics.ListCreateAPIView):
+        queryset = FilterableItem.objects.all()
+        serializer_class = FilterableItemSerializer
+        filter_fields = ['decimal', 'date']
+        filter_backend = filters.DjangoFilterBackend
+
     urlpatterns = patterns('',
         url(r'^(?P<pk>\d+)/$', FilterClassDetailView.as_view(), name='detail-view'),
         url(r'^$', FilterClassRootView.as_view(), name='root-view'),
@@ -114,6 +125,21 @@ class IntegrationTestFiltering(CommonFilteringTestCase):
         expected_data = [f for f in self.data if f['date'] == search_date]
         self.assertEqual(response.data, expected_data)
 
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_filter_with_queryset(self):
+        """
+        Regression test for #814.
+        """
+        view = FilterFieldsQuerysetView.as_view()
+
+        # Tests that the decimal filter works.
+        search_decimal = Decimal('2.25')
+        request = factory.get('/?decimal=%s' % search_decimal)
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        expected_data = [f for f in self.data if f['decimal'] == search_decimal]
+        self.assertEqual(response.data, expected_data)
+
     @unittest.skipUnless(django_filters, 'django-filters not installed')
     def test_get_filtered_class_root_view(self):
         """
-- 
cgit v1.2.3


From 773a92eab3ac4b635511483ef906b3b8de9dedc9 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 10 May 2013 21:57:05 +0100
Subject: Move models into test modules, out of models module

---
 rest_framework/tests/models.py     |  7 -------
 rest_framework/tests/pagination.py | 10 ++++++++--
 2 files changed, 8 insertions(+), 9 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/models.py b/rest_framework/tests/models.py
index f2117538..40e41a64 100644
--- a/rest_framework/tests/models.py
+++ b/rest_framework/tests/models.py
@@ -58,13 +58,6 @@ class ReadOnlyManyToManyModel(RESTFrameworkModel):
     rel = models.ManyToManyField(Anchor)
 
 
-# Model to test filtering.
-class FilterableItem(RESTFrameworkModel):
-    text = models.CharField(max_length=100)
-    decimal = models.DecimalField(max_digits=4, decimal_places=2)
-    date = models.DateField()
-
-
 # Model for regression test for #285
 
 class Comment(RESTFrameworkModel):
diff --git a/rest_framework/tests/pagination.py b/rest_framework/tests/pagination.py
index 6b8ef02f..894d53d6 100644
--- a/rest_framework/tests/pagination.py
+++ b/rest_framework/tests/pagination.py
@@ -1,18 +1,24 @@
 from __future__ import unicode_literals
 import datetime
 from decimal import Decimal
-import django
+from django.db import models
 from django.core.paginator import Paginator
 from django.test import TestCase
 from django.test.client import RequestFactory
 from django.utils import unittest
 from rest_framework import generics, status, pagination, filters, serializers
 from rest_framework.compat import django_filters
-from rest_framework.tests.models import BasicModel, FilterableItem
+from rest_framework.tests.models import BasicModel
 
 factory = RequestFactory()
 
 
+class FilterableItem(models.Model):
+    text = models.CharField(max_length=100)
+    decimal = models.DecimalField(max_digits=4, decimal_places=2)
+    date = models.DateField()
+
+
 class RootView(generics.ListCreateAPIView):
     """
     Example description for OPTIONS.
-- 
cgit v1.2.3


From 8ce36d2bf1a899683208dc7de425a238ab27d0b3 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 10 May 2013 21:57:20 +0100
Subject: SearchFilter and tests

---
 rest_framework/tests/filterset.py | 81 ++++++++++++++++++++++++++++++++++++++-
 1 file changed, 80 insertions(+), 1 deletion(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filterset.py b/rest_framework/tests/filterset.py
index 023bd016..7865fedd 100644
--- a/rest_framework/tests/filterset.py
+++ b/rest_framework/tests/filterset.py
@@ -1,17 +1,24 @@
 from __future__ import unicode_literals
 import datetime
 from decimal import Decimal
+from django.db import models
 from django.core.urlresolvers import reverse
 from django.test import TestCase
 from django.test.client import RequestFactory
 from django.utils import unittest
 from rest_framework import generics, serializers, status, filters
 from rest_framework.compat import django_filters, patterns, url
-from rest_framework.tests.models import FilterableItem, BasicModel
+from rest_framework.tests.models import BasicModel
 
 factory = RequestFactory()
 
 
+class FilterableItem(models.Model):
+    text = models.CharField(max_length=100)
+    decimal = models.DecimalField(max_digits=4, decimal_places=2)
+    date = models.DateField()
+
+
 if django_filters:
     # Basic filter on a list view.
     class FilterFieldsRootView(generics.ListCreateAPIView):
@@ -256,3 +263,75 @@ class IntegrationTestDetailFiltering(CommonFilteringTestCase):
         response = self.client.get('{url}?decimal={decimal}&date={date}'.format(url=self._get_url(valid_item), decimal=search_decimal, date=search_date))
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.data, valid_item_data)
+
+
+class SearchFilterModel(models.Model):
+    title = models.CharField(max_length=20)
+    text = models.CharField(max_length=100)
+
+
+class SearchFilterTests(TestCase):
+    def setUp(self):
+        # Sequence of title/text is:
+        #
+        # z   abc
+        # zz  bcd
+        # zzz cde
+        # ...
+        for idx in range(10):
+            title = 'z' * (idx + 1)
+            text = (
+                chr(idx + ord('a')) +
+                chr(idx + ord('b')) +
+                chr(idx + ord('c'))
+            )
+            SearchFilterModel(title=title, text=text).save()
+
+    def test_search(self):
+        class SearchListView(generics.ListAPIView):
+            model = SearchFilterModel
+            filter_backends = (filters.SearchFilter,)
+            search_fields = ('title', 'text')
+
+        view = SearchListView.as_view()
+        request = factory.get('?search=b')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {u'id': 1, 'title': u'z', 'text': u'abc'},
+                {u'id': 2, 'title': u'zz', 'text': u'bcd'}
+            ]
+        )
+
+    def test_exact_search(self):
+        class SearchListView(generics.ListAPIView):
+            model = SearchFilterModel
+            filter_backends = (filters.SearchFilter,)
+            search_fields = ('=title', 'text')
+
+        view = SearchListView.as_view()
+        request = factory.get('?search=zzz')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {u'id': 3, 'title': u'zzz', 'text': u'cde'}
+            ]
+        )
+
+    def test_startswith_search(self):
+        class SearchListView(generics.ListAPIView):
+            model = SearchFilterModel
+            filter_backends = (filters.SearchFilter,)
+            search_fields = ('title', '^text')
+
+        view = SearchListView.as_view()
+        request = factory.get('?search=b')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {u'id': 2, 'title': u'zz', 'text': u'bcd'}
+            ]
+        )
-- 
cgit v1.2.3


From dd51d369c8228f3add37cc639702097b0df9cd90 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 10 May 2013 23:02:24 +0100
Subject: Unicode string fix

---
 rest_framework/tests/filterset.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filterset.py b/rest_framework/tests/filterset.py
index 7865fedd..e5414232 100644
--- a/rest_framework/tests/filterset.py
+++ b/rest_framework/tests/filterset.py
@@ -299,8 +299,8 @@ class SearchFilterTests(TestCase):
         self.assertEqual(
             response.data,
             [
-                {u'id': 1, 'title': u'z', 'text': u'abc'},
-                {u'id': 2, 'title': u'zz', 'text': u'bcd'}
+                {'id': 1, 'title': 'z', 'text': 'abc'},
+                {'id': 2, 'title': 'zz', 'text': 'bcd'}
             ]
         )
 
@@ -316,7 +316,7 @@ class SearchFilterTests(TestCase):
         self.assertEqual(
             response.data,
             [
-                {u'id': 3, 'title': u'zzz', 'text': u'cde'}
+                {'id': 3, 'title': 'zzz', 'text': 'cde'}
             ]
         )
 
@@ -332,6 +332,6 @@ class SearchFilterTests(TestCase):
         self.assertEqual(
             response.data,
             [
-                {u'id': 2, 'title': u'zz', 'text': u'bcd'}
+                {'id': 2, 'title': 'zz', 'text': 'bcd'}
             ]
         )
-- 
cgit v1.2.3


From 9d2580dccfe23e113221c7e150bddebb95d98214 Mon Sep 17 00:00:00 2001
From: Marlon Bailey
Date: Sat, 11 May 2013 22:26:34 -0400
Subject: added support for multiple @action and @link decorators on a viewset,
 along with a router testcase illustrating the failure against the master code
 base

---
 rest_framework/tests/routers.py | 46 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 rest_framework/tests/routers.py

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/routers.py b/rest_framework/tests/routers.py
new file mode 100644
index 00000000..138d13d7
--- /dev/null
+++ b/rest_framework/tests/routers.py
@@ -0,0 +1,46 @@
+from __future__ import unicode_literals
+from django.test import TestCase
+from django.test.client import RequestFactory
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework import viewsets
+from rest_framework.decorators import link, action
+from rest_framework.routers import SimpleRouter
+import copy
+
+factory = RequestFactory()
+
+
+class BasicViewSet(viewsets.ViewSet):
+    def list(self, request, *args, **kwargs):
+        return Response({'method': 'list'})
+
+    @action()
+    def action1(self, request, *args, **kwargs):
+        return Response({'method': 'action1'})
+
+    @action()
+    def action2(self, request, *args, **kwargs):
+        return Response({'method': 'action2'})
+
+    @link()
+    def link1(self, request, *args, **kwargs):
+        return Response({'method': 'link1'})
+
+    @link()
+    def link2(self, request, *args, **kwargs):
+        return Response({'method': 'link2'})
+
+
+class TestSimpleRouter(TestCase):
+    def setUp(self):
+        self.router = SimpleRouter()
+
+    def test_link_and_action_decorator(self):
+        routes = self.router.get_routes(BasicViewSet)
+        # Should be 2 by default, and then four from the @action and @link combined
+        #self.assertEqual(len(routes), 6)
+        #
+        decorator_routes = routes[2:]
+        for i, method in enumerate(['action1', 'action2', 'link1', 'link2']):
+            self.assertEqual(decorator_routes[i].mapping.values()[0], method)
-- 
cgit v1.2.3


From 5e2d8052d4bf87c81cc9807c96c933ca975cc483 Mon Sep 17 00:00:00 2001
From: Marlon Bailey
Date: Sun, 12 May 2013 09:22:14 -0400
Subject: fix test case to work with Python 3 and make it more explicit

---
 rest_framework/tests/routers.py | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/routers.py b/rest_framework/tests/routers.py
index 138d13d7..4e4765cb 100644
--- a/rest_framework/tests/routers.py
+++ b/rest_framework/tests/routers.py
@@ -38,9 +38,18 @@ class TestSimpleRouter(TestCase):
 
     def test_link_and_action_decorator(self):
         routes = self.router.get_routes(BasicViewSet)
-        # Should be 2 by default, and then four from the @action and @link combined
-        #self.assertEqual(len(routes), 6)
-        #
         decorator_routes = routes[2:]
-        for i, method in enumerate(['action1', 'action2', 'link1', 'link2']):
-            self.assertEqual(decorator_routes[i].mapping.values()[0], method)
+        # Make sure all these endpoints exist and none have been clobbered
+        for i, endpoint in enumerate(['action1', 'action2', 'link1', 'link2']):
+            route = decorator_routes[i]
+            # check url listing
+            self.assertEqual(route.url,
+                             '^{{prefix}}/{{lookup}}/{0}/$'.format(endpoint))
+            # check method to function mapping
+            if endpoint.startswith('action'):
+                method_map = 'post'
+            else:
+                method_map = 'get'
+            self.assertEqual(route.mapping[method_map], endpoint)
+
+
-- 
cgit v1.2.3


From 24c9c455feaa47487196a2c9343746d7d5bdd962 Mon Sep 17 00:00:00 2001
From: Brian Zambrano
Date: Mon, 13 May 2013 10:51:51 -0700
Subject: Allow for missing non-required nested objects.

Serializer fields which are themselves serializers should not be required.
Specifically, if a nested object is set to "required=False", it should be
possible to serialize the main object and have the sub-object set to None/null.
---
 rest_framework/tests/serializer.py | 47 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 84e1ee4e..6e732327 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -43,6 +43,17 @@ class CommentSerializer(serializers.Serializer):
         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'})
 
@@ -141,6 +152,42 @@ class BasicTests(TestCase):
         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
-- 
cgit v1.2.3


From 08bc97626960f108f01657e4ad12b7fd62e6183d Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 14 May 2013 10:16:46 +0100
Subject: Rename filter tests

---
 rest_framework/tests/filters.py   | 337 ++++++++++++++++++++++++++++++++++++++
 rest_framework/tests/filterset.py | 337 --------------------------------------
 2 files changed, 337 insertions(+), 337 deletions(-)
 create mode 100644 rest_framework/tests/filters.py
 delete mode 100644 rest_framework/tests/filterset.py

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filters.py b/rest_framework/tests/filters.py
new file mode 100644
index 00000000..e5414232
--- /dev/null
+++ b/rest_framework/tests/filters.py
@@ -0,0 +1,337 @@
+from __future__ import unicode_literals
+import datetime
+from decimal import Decimal
+from django.db import models
+from django.core.urlresolvers import reverse
+from django.test import TestCase
+from django.test.client import RequestFactory
+from django.utils import unittest
+from rest_framework import generics, serializers, status, filters
+from rest_framework.compat import django_filters, patterns, url
+from rest_framework.tests.models import BasicModel
+
+factory = RequestFactory()
+
+
+class FilterableItem(models.Model):
+    text = models.CharField(max_length=100)
+    decimal = models.DecimalField(max_digits=4, decimal_places=2)
+    date = models.DateField()
+
+
+if django_filters:
+    # Basic filter on a list view.
+    class FilterFieldsRootView(generics.ListCreateAPIView):
+        model = FilterableItem
+        filter_fields = ['decimal', 'date']
+        filter_backend = filters.DjangoFilterBackend
+
+    # These class are used to test a filter class.
+    class SeveralFieldsFilter(django_filters.FilterSet):
+        text = django_filters.CharFilter(lookup_type='icontains')
+        decimal = django_filters.NumberFilter(lookup_type='lt')
+        date = django_filters.DateFilter(lookup_type='gt')
+
+        class Meta:
+            model = FilterableItem
+            fields = ['text', 'decimal', 'date']
+
+    class FilterClassRootView(generics.ListCreateAPIView):
+        model = FilterableItem
+        filter_class = SeveralFieldsFilter
+        filter_backend = filters.DjangoFilterBackend
+
+    # These classes are used to test a misconfigured filter class.
+    class MisconfiguredFilter(django_filters.FilterSet):
+        text = django_filters.CharFilter(lookup_type='icontains')
+
+        class Meta:
+            model = BasicModel
+            fields = ['text']
+
+    class IncorrectlyConfiguredRootView(generics.ListCreateAPIView):
+        model = FilterableItem
+        filter_class = MisconfiguredFilter
+        filter_backend = filters.DjangoFilterBackend
+
+    class FilterClassDetailView(generics.RetrieveAPIView):
+        model = FilterableItem
+        filter_class = SeveralFieldsFilter
+        filter_backend = filters.DjangoFilterBackend
+
+    # Regression test for #814
+    class FilterableItemSerializer(serializers.ModelSerializer):
+        class Meta:
+            model = FilterableItem
+
+    class FilterFieldsQuerysetView(generics.ListCreateAPIView):
+        queryset = FilterableItem.objects.all()
+        serializer_class = FilterableItemSerializer
+        filter_fields = ['decimal', 'date']
+        filter_backend = filters.DjangoFilterBackend
+
+    urlpatterns = patterns('',
+        url(r'^(?P<pk>\d+)/$', FilterClassDetailView.as_view(), name='detail-view'),
+        url(r'^$', FilterClassRootView.as_view(), name='root-view'),
+    )
+
+
+class CommonFilteringTestCase(TestCase):
+    def _serialize_object(self, obj):
+        return {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}
+
+    def setUp(self):
+        """
+        Create 10 FilterableItem instances.
+        """
+        base_data = ('a', Decimal('0.25'), datetime.date(2012, 10, 8))
+        for i in range(10):
+            text = chr(i + ord(base_data[0])) * 3  # Produces string 'aaa', 'bbb', etc.
+            decimal = base_data[1] + i
+            date = base_data[2] - datetime.timedelta(days=i * 2)
+            FilterableItem(text=text, decimal=decimal, date=date).save()
+
+        self.objects = FilterableItem.objects
+        self.data = [
+            self._serialize_object(obj)
+            for obj in self.objects.all()
+        ]
+
+
+class IntegrationTestFiltering(CommonFilteringTestCase):
+    """
+    Integration tests for filtered list views.
+    """
+
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_get_filtered_fields_root_view(self):
+        """
+        GET requests to paginated ListCreateAPIView should return paginated results.
+        """
+        view = FilterFieldsRootView.as_view()
+
+        # Basic test with no filter.
+        request = factory.get('/')
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, self.data)
+
+        # Tests that the decimal filter works.
+        search_decimal = Decimal('2.25')
+        request = factory.get('/?decimal=%s' % search_decimal)
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        expected_data = [f for f in self.data if f['decimal'] == search_decimal]
+        self.assertEqual(response.data, expected_data)
+
+        # Tests that the date filter works.
+        search_date = datetime.date(2012, 9, 22)
+        request = factory.get('/?date=%s' % search_date)  # search_date str: '2012-09-22'
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        expected_data = [f for f in self.data if f['date'] == search_date]
+        self.assertEqual(response.data, expected_data)
+
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_filter_with_queryset(self):
+        """
+        Regression test for #814.
+        """
+        view = FilterFieldsQuerysetView.as_view()
+
+        # Tests that the decimal filter works.
+        search_decimal = Decimal('2.25')
+        request = factory.get('/?decimal=%s' % search_decimal)
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        expected_data = [f for f in self.data if f['decimal'] == search_decimal]
+        self.assertEqual(response.data, expected_data)
+
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_get_filtered_class_root_view(self):
+        """
+        GET requests to filtered ListCreateAPIView that have a filter_class set
+        should return filtered results.
+        """
+        view = FilterClassRootView.as_view()
+
+        # Basic test with no filter.
+        request = factory.get('/')
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, self.data)
+
+        # Tests that the decimal filter set with 'lt' in the filter class works.
+        search_decimal = Decimal('4.25')
+        request = factory.get('/?decimal=%s' % search_decimal)
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        expected_data = [f for f in self.data if f['decimal'] < search_decimal]
+        self.assertEqual(response.data, expected_data)
+
+        # Tests that the date filter set with 'gt' in the filter class works.
+        search_date = datetime.date(2012, 10, 2)
+        request = factory.get('/?date=%s' % search_date)  # search_date str: '2012-10-02'
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        expected_data = [f for f in self.data if f['date'] > search_date]
+        self.assertEqual(response.data, expected_data)
+
+        # Tests that the text filter set with 'icontains' in the filter class works.
+        search_text = 'ff'
+        request = factory.get('/?text=%s' % search_text)
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        expected_data = [f for f in self.data if search_text in f['text'].lower()]
+        self.assertEqual(response.data, expected_data)
+
+        # Tests that multiple filters works.
+        search_decimal = Decimal('5.25')
+        search_date = datetime.date(2012, 10, 2)
+        request = factory.get('/?decimal=%s&date=%s' % (search_decimal, search_date))
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        expected_data = [f for f in self.data if f['date'] > search_date and
+                         f['decimal'] < search_decimal]
+        self.assertEqual(response.data, expected_data)
+
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_incorrectly_configured_filter(self):
+        """
+        An error should be displayed when the filter class is misconfigured.
+        """
+        view = IncorrectlyConfiguredRootView.as_view()
+
+        request = factory.get('/')
+        self.assertRaises(AssertionError, view, request)
+
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_unknown_filter(self):
+        """
+        GET requests with filters that aren't configured should return 200.
+        """
+        view = FilterFieldsRootView.as_view()
+
+        search_integer = 10
+        request = factory.get('/?integer=%s' % search_integer)
+        response = view(request).render()
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+
+
+class IntegrationTestDetailFiltering(CommonFilteringTestCase):
+    """
+    Integration tests for filtered detail views.
+    """
+    urls = 'rest_framework.tests.filterset'
+
+    def _get_url(self, item):
+        return reverse('detail-view', kwargs=dict(pk=item.pk))
+
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_get_filtered_detail_view(self):
+        """
+        GET requests to filtered RetrieveAPIView that have a filter_class set
+        should return filtered results.
+        """
+        item = self.objects.all()[0]
+        data = self._serialize_object(item)
+
+        # Basic test with no filter.
+        response = self.client.get(self._get_url(item))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, data)
+
+        # Tests that the decimal filter set that should fail.
+        search_decimal = Decimal('4.25')
+        high_item = self.objects.filter(decimal__gt=search_decimal)[0]
+        response = self.client.get('{url}?decimal={param}'.format(url=self._get_url(high_item), param=search_decimal))
+        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
+
+        # Tests that the decimal filter set that should succeed.
+        search_decimal = Decimal('4.25')
+        low_item = self.objects.filter(decimal__lt=search_decimal)[0]
+        low_item_data = self._serialize_object(low_item)
+        response = self.client.get('{url}?decimal={param}'.format(url=self._get_url(low_item), param=search_decimal))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, low_item_data)
+
+        # Tests that multiple filters works.
+        search_decimal = Decimal('5.25')
+        search_date = datetime.date(2012, 10, 2)
+        valid_item = self.objects.filter(decimal__lt=search_decimal, date__gt=search_date)[0]
+        valid_item_data = self._serialize_object(valid_item)
+        response = self.client.get('{url}?decimal={decimal}&date={date}'.format(url=self._get_url(valid_item), decimal=search_decimal, date=search_date))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(response.data, valid_item_data)
+
+
+class SearchFilterModel(models.Model):
+    title = models.CharField(max_length=20)
+    text = models.CharField(max_length=100)
+
+
+class SearchFilterTests(TestCase):
+    def setUp(self):
+        # Sequence of title/text is:
+        #
+        # z   abc
+        # zz  bcd
+        # zzz cde
+        # ...
+        for idx in range(10):
+            title = 'z' * (idx + 1)
+            text = (
+                chr(idx + ord('a')) +
+                chr(idx + ord('b')) +
+                chr(idx + ord('c'))
+            )
+            SearchFilterModel(title=title, text=text).save()
+
+    def test_search(self):
+        class SearchListView(generics.ListAPIView):
+            model = SearchFilterModel
+            filter_backends = (filters.SearchFilter,)
+            search_fields = ('title', 'text')
+
+        view = SearchListView.as_view()
+        request = factory.get('?search=b')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {'id': 1, 'title': 'z', 'text': 'abc'},
+                {'id': 2, 'title': 'zz', 'text': 'bcd'}
+            ]
+        )
+
+    def test_exact_search(self):
+        class SearchListView(generics.ListAPIView):
+            model = SearchFilterModel
+            filter_backends = (filters.SearchFilter,)
+            search_fields = ('=title', 'text')
+
+        view = SearchListView.as_view()
+        request = factory.get('?search=zzz')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {'id': 3, 'title': 'zzz', 'text': 'cde'}
+            ]
+        )
+
+    def test_startswith_search(self):
+        class SearchListView(generics.ListAPIView):
+            model = SearchFilterModel
+            filter_backends = (filters.SearchFilter,)
+            search_fields = ('title', '^text')
+
+        view = SearchListView.as_view()
+        request = factory.get('?search=b')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {'id': 2, 'title': 'zz', 'text': 'bcd'}
+            ]
+        )
diff --git a/rest_framework/tests/filterset.py b/rest_framework/tests/filterset.py
deleted file mode 100644
index e5414232..00000000
--- a/rest_framework/tests/filterset.py
+++ /dev/null
@@ -1,337 +0,0 @@
-from __future__ import unicode_literals
-import datetime
-from decimal import Decimal
-from django.db import models
-from django.core.urlresolvers import reverse
-from django.test import TestCase
-from django.test.client import RequestFactory
-from django.utils import unittest
-from rest_framework import generics, serializers, status, filters
-from rest_framework.compat import django_filters, patterns, url
-from rest_framework.tests.models import BasicModel
-
-factory = RequestFactory()
-
-
-class FilterableItem(models.Model):
-    text = models.CharField(max_length=100)
-    decimal = models.DecimalField(max_digits=4, decimal_places=2)
-    date = models.DateField()
-
-
-if django_filters:
-    # Basic filter on a list view.
-    class FilterFieldsRootView(generics.ListCreateAPIView):
-        model = FilterableItem
-        filter_fields = ['decimal', 'date']
-        filter_backend = filters.DjangoFilterBackend
-
-    # These class are used to test a filter class.
-    class SeveralFieldsFilter(django_filters.FilterSet):
-        text = django_filters.CharFilter(lookup_type='icontains')
-        decimal = django_filters.NumberFilter(lookup_type='lt')
-        date = django_filters.DateFilter(lookup_type='gt')
-
-        class Meta:
-            model = FilterableItem
-            fields = ['text', 'decimal', 'date']
-
-    class FilterClassRootView(generics.ListCreateAPIView):
-        model = FilterableItem
-        filter_class = SeveralFieldsFilter
-        filter_backend = filters.DjangoFilterBackend
-
-    # These classes are used to test a misconfigured filter class.
-    class MisconfiguredFilter(django_filters.FilterSet):
-        text = django_filters.CharFilter(lookup_type='icontains')
-
-        class Meta:
-            model = BasicModel
-            fields = ['text']
-
-    class IncorrectlyConfiguredRootView(generics.ListCreateAPIView):
-        model = FilterableItem
-        filter_class = MisconfiguredFilter
-        filter_backend = filters.DjangoFilterBackend
-
-    class FilterClassDetailView(generics.RetrieveAPIView):
-        model = FilterableItem
-        filter_class = SeveralFieldsFilter
-        filter_backend = filters.DjangoFilterBackend
-
-    # Regression test for #814
-    class FilterableItemSerializer(serializers.ModelSerializer):
-        class Meta:
-            model = FilterableItem
-
-    class FilterFieldsQuerysetView(generics.ListCreateAPIView):
-        queryset = FilterableItem.objects.all()
-        serializer_class = FilterableItemSerializer
-        filter_fields = ['decimal', 'date']
-        filter_backend = filters.DjangoFilterBackend
-
-    urlpatterns = patterns('',
-        url(r'^(?P<pk>\d+)/$', FilterClassDetailView.as_view(), name='detail-view'),
-        url(r'^$', FilterClassRootView.as_view(), name='root-view'),
-    )
-
-
-class CommonFilteringTestCase(TestCase):
-    def _serialize_object(self, obj):
-        return {'id': obj.id, 'text': obj.text, 'decimal': obj.decimal, 'date': obj.date}
-
-    def setUp(self):
-        """
-        Create 10 FilterableItem instances.
-        """
-        base_data = ('a', Decimal('0.25'), datetime.date(2012, 10, 8))
-        for i in range(10):
-            text = chr(i + ord(base_data[0])) * 3  # Produces string 'aaa', 'bbb', etc.
-            decimal = base_data[1] + i
-            date = base_data[2] - datetime.timedelta(days=i * 2)
-            FilterableItem(text=text, decimal=decimal, date=date).save()
-
-        self.objects = FilterableItem.objects
-        self.data = [
-            self._serialize_object(obj)
-            for obj in self.objects.all()
-        ]
-
-
-class IntegrationTestFiltering(CommonFilteringTestCase):
-    """
-    Integration tests for filtered list views.
-    """
-
-    @unittest.skipUnless(django_filters, 'django-filters not installed')
-    def test_get_filtered_fields_root_view(self):
-        """
-        GET requests to paginated ListCreateAPIView should return paginated results.
-        """
-        view = FilterFieldsRootView.as_view()
-
-        # Basic test with no filter.
-        request = factory.get('/')
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data, self.data)
-
-        # Tests that the decimal filter works.
-        search_decimal = Decimal('2.25')
-        request = factory.get('/?decimal=%s' % search_decimal)
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if f['decimal'] == search_decimal]
-        self.assertEqual(response.data, expected_data)
-
-        # Tests that the date filter works.
-        search_date = datetime.date(2012, 9, 22)
-        request = factory.get('/?date=%s' % search_date)  # search_date str: '2012-09-22'
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if f['date'] == search_date]
-        self.assertEqual(response.data, expected_data)
-
-    @unittest.skipUnless(django_filters, 'django-filters not installed')
-    def test_filter_with_queryset(self):
-        """
-        Regression test for #814.
-        """
-        view = FilterFieldsQuerysetView.as_view()
-
-        # Tests that the decimal filter works.
-        search_decimal = Decimal('2.25')
-        request = factory.get('/?decimal=%s' % search_decimal)
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if f['decimal'] == search_decimal]
-        self.assertEqual(response.data, expected_data)
-
-    @unittest.skipUnless(django_filters, 'django-filters not installed')
-    def test_get_filtered_class_root_view(self):
-        """
-        GET requests to filtered ListCreateAPIView that have a filter_class set
-        should return filtered results.
-        """
-        view = FilterClassRootView.as_view()
-
-        # Basic test with no filter.
-        request = factory.get('/')
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data, self.data)
-
-        # Tests that the decimal filter set with 'lt' in the filter class works.
-        search_decimal = Decimal('4.25')
-        request = factory.get('/?decimal=%s' % search_decimal)
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if f['decimal'] < search_decimal]
-        self.assertEqual(response.data, expected_data)
-
-        # Tests that the date filter set with 'gt' in the filter class works.
-        search_date = datetime.date(2012, 10, 2)
-        request = factory.get('/?date=%s' % search_date)  # search_date str: '2012-10-02'
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if f['date'] > search_date]
-        self.assertEqual(response.data, expected_data)
-
-        # Tests that the text filter set with 'icontains' in the filter class works.
-        search_text = 'ff'
-        request = factory.get('/?text=%s' % search_text)
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if search_text in f['text'].lower()]
-        self.assertEqual(response.data, expected_data)
-
-        # Tests that multiple filters works.
-        search_decimal = Decimal('5.25')
-        search_date = datetime.date(2012, 10, 2)
-        request = factory.get('/?decimal=%s&date=%s' % (search_decimal, search_date))
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        expected_data = [f for f in self.data if f['date'] > search_date and
-                         f['decimal'] < search_decimal]
-        self.assertEqual(response.data, expected_data)
-
-    @unittest.skipUnless(django_filters, 'django-filters not installed')
-    def test_incorrectly_configured_filter(self):
-        """
-        An error should be displayed when the filter class is misconfigured.
-        """
-        view = IncorrectlyConfiguredRootView.as_view()
-
-        request = factory.get('/')
-        self.assertRaises(AssertionError, view, request)
-
-    @unittest.skipUnless(django_filters, 'django-filters not installed')
-    def test_unknown_filter(self):
-        """
-        GET requests with filters that aren't configured should return 200.
-        """
-        view = FilterFieldsRootView.as_view()
-
-        search_integer = 10
-        request = factory.get('/?integer=%s' % search_integer)
-        response = view(request).render()
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-
-
-class IntegrationTestDetailFiltering(CommonFilteringTestCase):
-    """
-    Integration tests for filtered detail views.
-    """
-    urls = 'rest_framework.tests.filterset'
-
-    def _get_url(self, item):
-        return reverse('detail-view', kwargs=dict(pk=item.pk))
-
-    @unittest.skipUnless(django_filters, 'django-filters not installed')
-    def test_get_filtered_detail_view(self):
-        """
-        GET requests to filtered RetrieveAPIView that have a filter_class set
-        should return filtered results.
-        """
-        item = self.objects.all()[0]
-        data = self._serialize_object(item)
-
-        # Basic test with no filter.
-        response = self.client.get(self._get_url(item))
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data, data)
-
-        # Tests that the decimal filter set that should fail.
-        search_decimal = Decimal('4.25')
-        high_item = self.objects.filter(decimal__gt=search_decimal)[0]
-        response = self.client.get('{url}?decimal={param}'.format(url=self._get_url(high_item), param=search_decimal))
-        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
-
-        # Tests that the decimal filter set that should succeed.
-        search_decimal = Decimal('4.25')
-        low_item = self.objects.filter(decimal__lt=search_decimal)[0]
-        low_item_data = self._serialize_object(low_item)
-        response = self.client.get('{url}?decimal={param}'.format(url=self._get_url(low_item), param=search_decimal))
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data, low_item_data)
-
-        # Tests that multiple filters works.
-        search_decimal = Decimal('5.25')
-        search_date = datetime.date(2012, 10, 2)
-        valid_item = self.objects.filter(decimal__lt=search_decimal, date__gt=search_date)[0]
-        valid_item_data = self._serialize_object(valid_item)
-        response = self.client.get('{url}?decimal={decimal}&date={date}'.format(url=self._get_url(valid_item), decimal=search_decimal, date=search_date))
-        self.assertEqual(response.status_code, status.HTTP_200_OK)
-        self.assertEqual(response.data, valid_item_data)
-
-
-class SearchFilterModel(models.Model):
-    title = models.CharField(max_length=20)
-    text = models.CharField(max_length=100)
-
-
-class SearchFilterTests(TestCase):
-    def setUp(self):
-        # Sequence of title/text is:
-        #
-        # z   abc
-        # zz  bcd
-        # zzz cde
-        # ...
-        for idx in range(10):
-            title = 'z' * (idx + 1)
-            text = (
-                chr(idx + ord('a')) +
-                chr(idx + ord('b')) +
-                chr(idx + ord('c'))
-            )
-            SearchFilterModel(title=title, text=text).save()
-
-    def test_search(self):
-        class SearchListView(generics.ListAPIView):
-            model = SearchFilterModel
-            filter_backends = (filters.SearchFilter,)
-            search_fields = ('title', 'text')
-
-        view = SearchListView.as_view()
-        request = factory.get('?search=b')
-        response = view(request)
-        self.assertEqual(
-            response.data,
-            [
-                {'id': 1, 'title': 'z', 'text': 'abc'},
-                {'id': 2, 'title': 'zz', 'text': 'bcd'}
-            ]
-        )
-
-    def test_exact_search(self):
-        class SearchListView(generics.ListAPIView):
-            model = SearchFilterModel
-            filter_backends = (filters.SearchFilter,)
-            search_fields = ('=title', 'text')
-
-        view = SearchListView.as_view()
-        request = factory.get('?search=zzz')
-        response = view(request)
-        self.assertEqual(
-            response.data,
-            [
-                {'id': 3, 'title': 'zzz', 'text': 'cde'}
-            ]
-        )
-
-    def test_startswith_search(self):
-        class SearchListView(generics.ListAPIView):
-            model = SearchFilterModel
-            filter_backends = (filters.SearchFilter,)
-            search_fields = ('title', '^text')
-
-        view = SearchListView.as_view()
-        request = factory.get('?search=b')
-        response = view(request)
-        self.assertEqual(
-            response.data,
-            [
-                {'id': 2, 'title': 'zz', 'text': 'bcd'}
-            ]
-        )
-- 
cgit v1.2.3


From 6a037f63edf33e7a76f56828cf68bfae4ccb4f80 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 14 May 2013 11:27:03 +0100
Subject: Added OrderingFilter

---
 rest_framework/tests/filters.py | 116 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 116 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filters.py b/rest_framework/tests/filters.py
index e5414232..6b604deb 100644
--- a/rest_framework/tests/filters.py
+++ b/rest_framework/tests/filters.py
@@ -335,3 +335,119 @@ class SearchFilterTests(TestCase):
                 {'id': 2, 'title': 'zz', 'text': 'bcd'}
             ]
         )
+
+
+class OrdringFilterModel(models.Model):
+    title = models.CharField(max_length=20)
+    text = models.CharField(max_length=100)
+
+
+class OrderingFilterTests(TestCase):
+    def setUp(self):
+        # Sequence of title/text is:
+        #
+        # zyx abc
+        # yxw bcd
+        # xwv cde
+        for idx in range(3):
+            title = (
+                chr(ord('z') - idx) +
+                chr(ord('y') - idx) +
+                chr(ord('x') - idx)
+            )
+            text = (
+                chr(idx + ord('a')) +
+                chr(idx + ord('b')) +
+                chr(idx + ord('c'))
+            )
+            OrdringFilterModel(title=title, text=text).save()
+
+    def test_ordering(self):
+        class OrderingListView(generics.ListAPIView):
+            model = OrdringFilterModel
+            filter_backends = (filters.OrderingFilter,)
+            ordering = ('title',)
+
+        view = OrderingListView.as_view()
+        request = factory.get('?order=text')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {'id': 1, 'title': 'zyx', 'text': 'abc'},
+                {'id': 2, 'title': 'yxw', 'text': 'bcd'},
+                {'id': 3, 'title': 'xwv', 'text': 'cde'},
+            ]
+        )
+
+    def test_reverse_ordering(self):
+        class OrderingListView(generics.ListAPIView):
+            model = OrdringFilterModel
+            filter_backends = (filters.OrderingFilter,)
+            ordering = ('title',)
+
+        view = OrderingListView.as_view()
+        request = factory.get('?order=-text')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {'id': 3, 'title': 'xwv', 'text': 'cde'},
+                {'id': 2, 'title': 'yxw', 'text': 'bcd'},
+                {'id': 1, 'title': 'zyx', 'text': 'abc'},
+            ]
+        )
+
+    def test_incorrectfield_ordering(self):
+        class OrderingListView(generics.ListAPIView):
+            model = OrdringFilterModel
+            filter_backends = (filters.OrderingFilter,)
+            ordering = ('title',)
+
+        view = OrderingListView.as_view()
+        request = factory.get('?order=foobar')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {'id': 3, 'title': 'xwv', 'text': 'cde'},
+                {'id': 2, 'title': 'yxw', 'text': 'bcd'},
+                {'id': 1, 'title': 'zyx', 'text': 'abc'},
+            ]
+        )
+
+    def test_default_ordering(self):
+        class OrderingListView(generics.ListAPIView):
+            model = OrdringFilterModel
+            filter_backends = (filters.OrderingFilter,)
+            ordering = ('title',)
+
+        view = OrderingListView.as_view()
+        request = factory.get('')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {'id': 3, 'title': 'xwv', 'text': 'cde'},
+                {'id': 2, 'title': 'yxw', 'text': 'bcd'},
+                {'id': 1, 'title': 'zyx', 'text': 'abc'},
+            ]
+        )
+
+    def test_default_ordering_using_string(self):
+        class OrderingListView(generics.ListAPIView):
+            model = OrdringFilterModel
+            filter_backends = (filters.OrderingFilter,)
+            ordering = 'title'
+
+        view = OrderingListView.as_view()
+        request = factory.get('')
+        response = view(request)
+        self.assertEqual(
+            response.data,
+            [
+                {'id': 3, 'title': 'xwv', 'text': 'cde'},
+                {'id': 2, 'title': 'yxw', 'text': 'bcd'},
+                {'id': 1, 'title': 'zyx', 'text': 'abc'},
+            ]
+        )
-- 
cgit v1.2.3


From 2cff6e69dbe3828eca56d0ce60ffdfc80fed045c Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 14 May 2013 11:27:08 +0100
Subject: Added OrderingFilter

---
 rest_framework/tests/filters.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filters.py b/rest_framework/tests/filters.py
index 6b604deb..b20d5980 100644
--- a/rest_framework/tests/filters.py
+++ b/rest_framework/tests/filters.py
@@ -369,7 +369,7 @@ class OrderingFilterTests(TestCase):
             ordering = ('title',)
 
         view = OrderingListView.as_view()
-        request = factory.get('?order=text')
+        request = factory.get('?ordering=text')
         response = view(request)
         self.assertEqual(
             response.data,
@@ -387,7 +387,7 @@ class OrderingFilterTests(TestCase):
             ordering = ('title',)
 
         view = OrderingListView.as_view()
-        request = factory.get('?order=-text')
+        request = factory.get('?ordering=-text')
         response = view(request)
         self.assertEqual(
             response.data,
@@ -405,7 +405,7 @@ class OrderingFilterTests(TestCase):
             ordering = ('title',)
 
         view = OrderingListView.as_view()
-        request = factory.get('?order=foobar')
+        request = factory.get('?ordering=foobar')
         response = view(request)
         self.assertEqual(
             response.data,
-- 
cgit v1.2.3


From a303d0f38c4758fc3aad412529922203e5785e29 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 14 May 2013 11:37:59 +0100
Subject: Fix filter test renaming

---
 rest_framework/tests/filters.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filters.py b/rest_framework/tests/filters.py
index b20d5980..18972c84 100644
--- a/rest_framework/tests/filters.py
+++ b/rest_framework/tests/filters.py
@@ -222,7 +222,7 @@ class IntegrationTestDetailFiltering(CommonFilteringTestCase):
     """
     Integration tests for filtered detail views.
     """
-    urls = 'rest_framework.tests.filterset'
+    urls = 'rest_framework.tests.filters'
 
     def _get_url(self, item):
         return reverse('detail-view', kwargs=dict(pk=item.pk))
-- 
cgit v1.2.3


From e939e1755a94b50c87a82c0f777645e28fe91bf0 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Tue, 14 May 2013 21:40:55 +0100
Subject: Base automatic filterset model on the queryset model.  Fixes #834.

---
 rest_framework/tests/filters.py | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filters.py b/rest_framework/tests/filters.py
index 18972c84..a58c66ae 100644
--- a/rest_framework/tests/filters.py
+++ b/rest_framework/tests/filters.py
@@ -70,9 +70,19 @@ if django_filters:
         filter_fields = ['decimal', 'date']
         filter_backend = filters.DjangoFilterBackend
 
+    class GetQuerysetView(generics.ListCreateAPIView):
+        serializer_class = FilterableItemSerializer
+        filter_class = SeveralFieldsFilter
+        filter_backend = filters.DjangoFilterBackend
+
+        def get_queryset(self):
+            return FilterableItem.objects.all()
+
     urlpatterns = patterns('',
         url(r'^(?P<pk>\d+)/$', FilterClassDetailView.as_view(), name='detail-view'),
         url(r'^$', FilterClassRootView.as_view(), name='root-view'),
+        url(r'^get-queryset/$', GetQuerysetView.as_view(),
+            name='get-queryset-view'),
     )
 
 
@@ -147,6 +157,17 @@ class IntegrationTestFiltering(CommonFilteringTestCase):
         expected_data = [f for f in self.data if f['decimal'] == search_decimal]
         self.assertEqual(response.data, expected_data)
 
+    @unittest.skipUnless(django_filters, 'django-filters not installed')
+    def test_filter_with_get_queryset_only(self):
+        """
+        Regression test for #834.
+        """
+        view = GetQuerysetView.as_view()
+        request = factory.get('/get-queryset/')
+        view(request).render()
+        # Used to raise "issubclass() arg 2 must be a class or tuple of classes"
+        # here when neither `model' nor `queryset' was specified.
+
     @unittest.skipUnless(django_filters, 'django-filters not installed')
     def test_get_filtered_class_root_view(self):
         """
-- 
cgit v1.2.3


From af88a5b1751da32018e8408eac01a91a5f63f8ce Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Wed, 15 May 2013 14:25:25 +0100
Subject: Test and fix which closes #652.

---
 rest_framework/tests/serializer.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 84e1ee4e..db3881f9 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -78,6 +78,18 @@ class PersonSerializer(serializers.ModelSerializer):
         read_only_fields = ('age',)
 
 
+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:
@@ -189,6 +201,12 @@ class BasicTests(TestCase):
         # 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, [])
+
 
 class DictStyleSerializer(serializers.Serializer):
     """
-- 
cgit v1.2.3


From abe207b869c771187523efd3d189ffc0beba51c3 Mon Sep 17 00:00:00 2001
From: Andy Freeland
Date: Thu, 16 May 2013 11:24:11 -0400
Subject: HyperlinkedIdentityField uses `lookup_field` kwarg.

According to the [Serializers API Guide][1], `HyperlinkedIdentityField`
takes `lookup_field` as a kwarg like the other related fields and the
generic views. However, this was not actually implemented.

[1]: http://django-rest-framework.org/api-guide/serializers.html#hyperlinkedmodelserializer
---
 rest_framework/tests/hyperlinkedserializers.py | 40 ++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/hyperlinkedserializers.py b/rest_framework/tests/hyperlinkedserializers.py
index 9a61f299..8fc6ba77 100644
--- a/rest_framework/tests/hyperlinkedserializers.py
+++ b/rest_framework/tests/hyperlinkedserializers.py
@@ -27,6 +27,14 @@ class PhotoSerializer(serializers.Serializer):
         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 BasicList(generics.ListCreateAPIView):
     model = BasicModel
     model_serializer_class = serializers.HyperlinkedModelSerializer
@@ -73,6 +81,8 @@ class PhotoListCreate(generics.ListCreateAPIView):
 
 class AlbumDetail(generics.RetrieveAPIView):
     model = Album
+    serializer_class = AlbumSerializer
+    lookup_field = 'title'
 
 
 class OptionalRelationDetail(generics.RetrieveUpdateDestroyAPIView):
@@ -180,6 +190,36 @@ class TestManyToManyHyperlinkedView(TestCase):
         self.assertEqual(response.data, self.data[0])
 
 
+class TestHyperlinkedIdentityFieldLookup(TestCase):
+    urls = 'rest_framework.tests.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 = 'rest_framework.tests.hyperlinkedserializers'
 
-- 
cgit v1.2.3


From b6fb377c2b4b747597bc3291dadd52b633b135b4 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Fri, 17 May 2013 21:57:11 +0100
Subject: Fix PendingDeprecation warnings in tests

---
 rest_framework/tests/filters.py    | 12 ++++++------
 rest_framework/tests/generics.py   | 25 +++++++++----------------
 rest_framework/tests/pagination.py |  4 ++--
 3 files changed, 17 insertions(+), 24 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/filters.py b/rest_framework/tests/filters.py
index a58c66ae..8ae6d530 100644
--- a/rest_framework/tests/filters.py
+++ b/rest_framework/tests/filters.py
@@ -24,7 +24,7 @@ if django_filters:
     class FilterFieldsRootView(generics.ListCreateAPIView):
         model = FilterableItem
         filter_fields = ['decimal', 'date']
-        filter_backend = filters.DjangoFilterBackend
+        filter_backends = (filters.DjangoFilterBackend,)
 
     # These class are used to test a filter class.
     class SeveralFieldsFilter(django_filters.FilterSet):
@@ -39,7 +39,7 @@ if django_filters:
     class FilterClassRootView(generics.ListCreateAPIView):
         model = FilterableItem
         filter_class = SeveralFieldsFilter
-        filter_backend = filters.DjangoFilterBackend
+        filter_backends = (filters.DjangoFilterBackend,)
 
     # These classes are used to test a misconfigured filter class.
     class MisconfiguredFilter(django_filters.FilterSet):
@@ -52,12 +52,12 @@ if django_filters:
     class IncorrectlyConfiguredRootView(generics.ListCreateAPIView):
         model = FilterableItem
         filter_class = MisconfiguredFilter
-        filter_backend = filters.DjangoFilterBackend
+        filter_backends = (filters.DjangoFilterBackend,)
 
     class FilterClassDetailView(generics.RetrieveAPIView):
         model = FilterableItem
         filter_class = SeveralFieldsFilter
-        filter_backend = filters.DjangoFilterBackend
+        filter_backends = (filters.DjangoFilterBackend,)
 
     # Regression test for #814
     class FilterableItemSerializer(serializers.ModelSerializer):
@@ -68,12 +68,12 @@ if django_filters:
         queryset = FilterableItem.objects.all()
         serializer_class = FilterableItemSerializer
         filter_fields = ['decimal', 'date']
-        filter_backend = filters.DjangoFilterBackend
+        filter_backends = (filters.DjangoFilterBackend,)
 
     class GetQuerysetView(generics.ListCreateAPIView):
         serializer_class = FilterableItemSerializer
         filter_class = SeveralFieldsFilter
-        filter_backend = filters.DjangoFilterBackend
+        filter_backends = (filters.DjangoFilterBackend,)
 
         def get_queryset(self):
             return FilterableItem.objects.all()
diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py
index eca50d82..2799d143 100644
--- a/rest_framework/tests/generics.py
+++ b/rest_framework/tests/generics.py
@@ -39,6 +39,7 @@ class SlugBasedInstanceView(InstanceView):
     """
     model = SlugBasedModel
     serializer_class = SlugSerializer
+    lookup_field = 'slug'
 
 
 class TestRootView(TestCase):
@@ -434,22 +435,14 @@ class TestFilterBackendAppliedToViews(TestCase):
             {'id': obj.id, 'text': obj.text}
             for obj in self.objects.all()
         ]
-        self.root_view = RootView.as_view()
-        self.instance_view = InstanceView.as_view()
-        self.original_root_backend = getattr(RootView, 'filter_backend')
-        self.original_instance_backend = getattr(InstanceView, 'filter_backend')
-
-    def tearDown(self):
-        setattr(RootView, 'filter_backend', self.original_root_backend)
-        setattr(InstanceView, 'filter_backend', self.original_instance_backend)
 
     def test_get_root_view_filters_by_name_with_filter_backend(self):
         """
         GET requests to ListCreateAPIView should return filtered list.
         """
-        setattr(RootView, 'filter_backend', InclusiveFilterBackend)
+        root_view = RootView.as_view(filter_backends=(InclusiveFilterBackend,))
         request = factory.get('/')
-        response = self.root_view(request).render()
+        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'}])
@@ -458,9 +451,9 @@ class TestFilterBackendAppliedToViews(TestCase):
         """
         GET requests to ListCreateAPIView should return empty list when all models are filtered out.
         """
-        setattr(RootView, 'filter_backend', ExclusiveFilterBackend)
+        root_view = RootView.as_view(filter_backends=(ExclusiveFilterBackend,))
         request = factory.get('/')
-        response = self.root_view(request).render()
+        response = root_view(request).render()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.data, [])
 
@@ -468,9 +461,9 @@ class TestFilterBackendAppliedToViews(TestCase):
         """
         GET requests to RetrieveUpdateDestroyAPIView should raise 404 when model filtered out.
         """
-        setattr(InstanceView, 'filter_backend', ExclusiveFilterBackend)
+        instance_view = InstanceView.as_view(filter_backends=(ExclusiveFilterBackend,))
         request = factory.get('/1')
-        response = self.instance_view(request, pk=1).render()
+        response = instance_view(request, pk=1).render()
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
         self.assertEqual(response.data, {'detail': 'Not found'})
 
@@ -478,8 +471,8 @@ class TestFilterBackendAppliedToViews(TestCase):
         """
         GET requests to RetrieveUpdateDestroyAPIView should return a single object when not excluded
         """
-        setattr(InstanceView, 'filter_backend', InclusiveFilterBackend)
+        instance_view = InstanceView.as_view(filter_backends=(InclusiveFilterBackend,))
         request = factory.get('/1')
-        response = self.instance_view(request, pk=1).render()
+        response = instance_view(request, pk=1).render()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.data, {'id': 1, 'text': 'foo'})
diff --git a/rest_framework/tests/pagination.py b/rest_framework/tests/pagination.py
index 894d53d6..e538a78e 100644
--- a/rest_framework/tests/pagination.py
+++ b/rest_framework/tests/pagination.py
@@ -130,7 +130,7 @@ class IntegrationTestPaginationAndFiltering(TestCase):
             model = FilterableItem
             paginate_by = 10
             filter_class = DecimalFilter
-            filter_backend = filters.DjangoFilterBackend
+            filter_backends = (filters.DjangoFilterBackend,)
 
         view = FilterFieldsRootView.as_view()
 
@@ -177,7 +177,7 @@ class IntegrationTestPaginationAndFiltering(TestCase):
         class BasicFilterFieldsRootView(generics.ListCreateAPIView):
             model = FilterableItem
             paginate_by = 10
-            filter_backend = DecimalFilterBackend
+            filter_backends = (DecimalFilterBackend,)
 
         view = BasicFilterFieldsRootView.as_view()
 
-- 
cgit v1.2.3


From aea040161ae29ec4b5335be5164aa8e5ada506e3 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Sat, 18 May 2013 09:36:09 +0100
Subject: Forms in Broseable API support dynamic serializers based on request
 method

---
 rest_framework/tests/generics.py | 34 +++++++++++++++++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/generics.py b/rest_framework/tests/generics.py
index 2799d143..15d87e86 100644
--- a/rest_framework/tests/generics.py
+++ b/rest_framework/tests/generics.py
@@ -2,7 +2,7 @@ from __future__ import unicode_literals
 from django.db import models
 from django.shortcuts import get_object_or_404
 from django.test import TestCase
-from rest_framework import generics, serializers, status
+from rest_framework import generics, renderers, serializers, status
 from rest_framework.tests.utils import RequestFactory
 from rest_framework.tests.models import BasicModel, Comment, SlugBasedModel
 from rest_framework.compat import six
@@ -476,3 +476,35 @@ class TestFilterBackendAppliedToViews(TestCase):
         response = instance_view(request, pk=1).render()
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(response.data, {'id': 1, 'text': 'foo'})
+
+
+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 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')
-- 
cgit v1.2.3


From 0cd7c80e6eaf3ca17d0fb8f8878054ce570e3932 Mon Sep 17 00:00:00 2001
From: Craig de Stigter
Date: Sat, 18 May 2013 12:16:30 +0200
Subject: add tests for related field source for RelatedField and
 PrimaryKeyRelatedField. #694

---
 rest_framework/tests/relations.py    | 37 +++++++++++++++++++++++++++++++++-
 rest_framework/tests/relations_pk.py | 39 +++++++++++++++++++++++++++++++++++-
 rest_framework/tests/serializer.py   | 17 ----------------
 3 files changed, 74 insertions(+), 19 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/relations.py b/rest_framework/tests/relations.py
index cbf93c65..f28f0de9 100644
--- a/rest_framework/tests/relations.py
+++ b/rest_framework/tests/relations.py
@@ -5,6 +5,7 @@ from __future__ import unicode_literals
 from django.db import models
 from django.test import TestCase
 from rest_framework import serializers
+from rest_framework.tests.models import BlogPost
 
 
 class NullModel(models.Model):
@@ -33,7 +34,7 @@ class FieldTests(TestCase):
         self.assertRaises(serializers.ValidationError, field.from_native, [])
 
 
-class TestManyRelateMixin(TestCase):
+class TestManyRelatedMixin(TestCase):
     def test_missing_many_to_many_related_field(self):
         '''
         Regression test for #632
@@ -45,3 +46,37 @@ class TestManyRelateMixin(TestCase):
         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'])
diff --git a/rest_framework/tests/relations_pk.py b/rest_framework/tests/relations_pk.py
index 5ce8b567..51fe59e9 100644
--- a/rest_framework/tests/relations_pk.py
+++ b/rest_framework/tests/relations_pk.py
@@ -1,7 +1,10 @@
 from __future__ import unicode_literals
 from django.test import TestCase
 from rest_framework import serializers
-from rest_framework.tests.models import ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource, NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource
+from rest_framework.tests.models import (
+    BlogPost, ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource,
+    NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource,
+)
 from rest_framework.compat import six
 
 
@@ -421,3 +424,37 @@ class PKNullableOneToOneTests(TestCase):
             {'id': 2, 'name': 'target-2', 'nullable_source': 1},
         ]
         self.assertEqual(serializer.data, expected)
+
+
+# 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])
diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index db3881f9..34acbaab 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -871,23 +871,6 @@ class RelatedTraversalTest(TestCase):
 
         self.assertEqual(serializer.data, expected)
 
-    def test_queryset_nested_traversal(self):
-        """
-        Relational fields should be able to use methods as their source.
-        """
-        BlogPost.objects.create(title='blah')
-
-        class QuerysetMethodSerializer(serializers.Serializer):
-            blogposts = serializers.RelatedField(many=True, source='get_all_blogposts')
-
-        class ClassWithQuerysetMethod(object):
-            def get_all_blogposts(self):
-                return BlogPost.objects
-
-        obj = ClassWithQuerysetMethod()
-        serializer = QuerysetMethodSerializer(obj)
-        self.assertEqual(serializer.data, {'blogposts': ['BlogPost object']})
-
 
 class SerializerMethodFieldTests(TestCase):
     def setUp(self):
-- 
cgit v1.2.3


From 930bd4d0e1f9a74ee56a57ef36c93b1c1d124f91 Mon Sep 17 00:00:00 2001
From: Craig de Stigter
Date: Sat, 18 May 2013 12:23:12 +0200
Subject: add tests for related field source for HyperlinkedRelatedField. #694

---
 rest_framework/tests/relations_hyperlink.py | 48 +++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/relations_hyperlink.py b/rest_framework/tests/relations_hyperlink.py
index b1eed9a7..8fb4687f 100644
--- a/rest_framework/tests/relations_hyperlink.py
+++ b/rest_framework/tests/relations_hyperlink.py
@@ -4,6 +4,7 @@ from django.test.client import RequestFactory
 from rest_framework import serializers
 from rest_framework.compat import patterns, url
 from rest_framework.tests.models import (
+    BlogPost,
     ManyToManyTarget, ManyToManySource, ForeignKeyTarget, ForeignKeySource,
     NullableForeignKeySource, OneToOneTarget, NullableOneToOneSource
 )
@@ -16,6 +17,7 @@ def dummy_view(request, pk):
     pass
 
 urlpatterns = patterns('',
+    url(r'^dummyurl/(?P<pk>[0-9]+)/$', dummy_view, name='dummy-url'),
     url(r'^manytomanysource/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanysource-detail'),
     url(r'^manytomanytarget/(?P<pk>[0-9]+)/$', dummy_view, name='manytomanytarget-detail'),
     url(r'^foreignkeysource/(?P<pk>[0-9]+)/$', dummy_view, name='foreignkeysource-detail'),
@@ -451,3 +453,49 @@ 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 = 'rest_framework.tests.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/'])
-- 
cgit v1.2.3


From a73c16b85f79aeb9139734a64623b49bc169fce9 Mon Sep 17 00:00:00 2001
From: Tom Christie
Date: Sat, 18 May 2013 11:27:48 +0100
Subject: serializers.Field respects ordering on dicts if it exists.  Closes
 #832

---
 rest_framework/tests/fields.py | 19 ++++++++++++++++---
 1 file changed, 16 insertions(+), 3 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/fields.py b/rest_framework/tests/fields.py
index 3cdfa0f6..5b5ce835 100644
--- a/rest_framework/tests/fields.py
+++ b/rest_framework/tests/fields.py
@@ -2,13 +2,12 @@
 General serializer field tests.
 """
 from __future__ import unicode_literals
+from django.utils.datastructures import SortedDict
 import datetime
 from decimal import Decimal
-
 from django.db import models
 from django.test import TestCase
 from django.core import validators
-
 from rest_framework import serializers
 from rest_framework.serializers import Serializer
 
@@ -63,6 +62,20 @@ class BasicFieldTests(TestCase):
         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'])
+
 
 class DateFieldTest(TestCase):
     """
@@ -645,4 +658,4 @@ class DecimalFieldTest(TestCase):
         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.']})
\ No newline at end of file
+        self.assertEqual(s.errors,  {'decimal_field': ['Ensure that there are no more than 4 digits in total.']})
-- 
cgit v1.2.3


From c992b600f7b0aefb156cddb5e27b438ccc316b39 Mon Sep 17 00:00:00 2001
From: Craig de Stigter
Date: Sat, 18 May 2013 12:32:48 +0200
Subject: add tests for dotted lookup in RelatedField, PrimaryKeyRelatedField,
 and HyperlinkedRelatedField. #694

---
 rest_framework/tests/relations.py           | 18 ++++++++++++++++++
 rest_framework/tests/relations_hyperlink.py | 23 +++++++++++++++++++++++
 rest_framework/tests/relations_pk.py        | 18 ++++++++++++++++++
 3 files changed, 59 insertions(+)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/relations.py b/rest_framework/tests/relations.py
index f28f0de9..d19219c9 100644
--- a/rest_framework/tests/relations.py
+++ b/rest_framework/tests/relations.py
@@ -80,3 +80,21 @@ class RelatedFieldSourceTests(TestCase):
         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'])
diff --git a/rest_framework/tests/relations_hyperlink.py b/rest_framework/tests/relations_hyperlink.py
index 8fb4687f..b3efbf52 100644
--- a/rest_framework/tests/relations_hyperlink.py
+++ b/rest_framework/tests/relations_hyperlink.py
@@ -499,3 +499,26 @@ class HyperlinkedRelatedFieldSourceTests(TestCase):
         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/rest_framework/tests/relations_pk.py b/rest_framework/tests/relations_pk.py
index 51fe59e9..0f8c5247 100644
--- a/rest_framework/tests/relations_pk.py
+++ b/rest_framework/tests/relations_pk.py
@@ -458,3 +458,21 @@ class PrimaryKeyRelatedFieldSourceTests(TestCase):
         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])
-- 
cgit v1.2.3


From ab8bd566f9db327a4c463317011818d421bbf89c Mon Sep 17 00:00:00 2001
From: Pablo Recio
Date: Sat, 18 May 2013 12:40:25 +0200
Subject: Adding `BLANK_CHOICE_DASH` as a choice if the model's field isn't
 required

---
 rest_framework/tests/fields.py     | 28 +++++++++++++++++++++++-
 rest_framework/tests/models.py     | 26 ++++++++++++++++++++++
 rest_framework/tests/serializer.py | 45 +++++++++++++++++++++++++++++++++++++-
 3 files changed, 97 insertions(+), 2 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/fields.py b/rest_framework/tests/fields.py
index 3cdfa0f6..f313ba60 100644
--- a/rest_framework/tests/fields.py
+++ b/rest_framework/tests/fields.py
@@ -645,4 +645,30 @@ class DecimalFieldTest(TestCase):
         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.']})
\ No newline at end of file
+        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
+    """
+
+    SAMPLE_CHOICES = [
+        ('red', 'Red'),
+        ('green', 'Green'),
+        ('blue', 'Blue'),
+    ]
+
+    def test_choices_required(self):
+        """
+        Make sure proper choices are rendered if field is required
+        """
+        f = serializers.ChoiceField(required=True, choices=self.SAMPLE_CHOICES)
+        self.assertEqual(f.choices, self.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=self.SAMPLE_CHOICES)
+        self.assertEqual(f.choices, models.fields.BLANK_CHOICE_DASH + self.SAMPLE_CHOICES)
diff --git a/rest_framework/tests/models.py b/rest_framework/tests/models.py
index 40e41a64..5d98b04b 100644
--- a/rest_framework/tests/models.py
+++ b/rest_framework/tests/models.py
@@ -117,6 +117,32 @@ class OptionalRelationModel(RESTFrameworkModel):
     other = models.ForeignKey('OptionalRelationModel', blank=True, null=True)
 
 
+# Model for issue #725
+class SeveralChoicesModel(RESTFrameworkModel):
+    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'
+    )
+
+
 # Model for RegexField
 class Book(RESTFrameworkModel):
     isbn = models.CharField(max_length=13)
diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index db3881f9..3f39308d 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -1,10 +1,11 @@
 from __future__ import unicode_literals
+from django.db.models.fields import BLANK_CHOICE_DASH
 from django.utils.datastructures import MultiValueDict
 from django.test import TestCase
 from rest_framework import serializers
 from rest_framework.tests.models import (HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel,
     BlankFieldModel, BlogPost, BlogPostComment, Book, CallableDefaultValueModel, DefaultValueModel,
-    ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo)
+    ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo, SeveralChoicesModel)
 import datetime
 import pickle
 
@@ -1018,6 +1019,48 @@ class SerializerPickleTests(TestCase):
         repr(pickle.loads(pickle.dumps(data, 0)))
 
 
+# test for issue #725
+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')]
+        )
+
+
 class DepthTest(TestCase):
     def test_implicit_nesting(self):
 
-- 
cgit v1.2.3


From 8fe43236a22e56d1741b49b92f0c53e01cd9e5f6 Mon Sep 17 00:00:00 2001
From: Pablo Recio
Date: Sat, 18 May 2013 13:23:38 +0200
Subject: Moved test model into closer to the testcase

---
 rest_framework/tests/models.py     | 26 --------------------------
 rest_framework/tests/serializer.py | 28 +++++++++++++++++++++++++++-
 2 files changed, 27 insertions(+), 27 deletions(-)

(limited to 'rest_framework/tests')

diff --git a/rest_framework/tests/models.py b/rest_framework/tests/models.py
index 5d98b04b..40e41a64 100644
--- a/rest_framework/tests/models.py
+++ b/rest_framework/tests/models.py
@@ -117,32 +117,6 @@ class OptionalRelationModel(RESTFrameworkModel):
     other = models.ForeignKey('OptionalRelationModel', blank=True, null=True)
 
 
-# Model for issue #725
-class SeveralChoicesModel(RESTFrameworkModel):
-    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'
-    )
-
-
 # Model for RegexField
 class Book(RESTFrameworkModel):
     isbn = models.CharField(max_length=13)
diff --git a/rest_framework/tests/serializer.py b/rest_framework/tests/serializer.py
index 85b95283..c043f417 100644
--- a/rest_framework/tests/serializer.py
+++ b/rest_framework/tests/serializer.py
@@ -1,11 +1,12 @@
 from __future__ import unicode_literals
+from django.db import models
 from django.db.models.fields import BLANK_CHOICE_DASH
 from django.utils.datastructures import MultiValueDict
 from django.test import TestCase
 from rest_framework import serializers
 from rest_framework.tests.models import (HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel,
     BlankFieldModel, BlogPost, BlogPostComment, Book, CallableDefaultValueModel, DefaultValueModel,
-    ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo, SeveralChoicesModel)
+    ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo)
 import datetime
 import pickle
 
@@ -1003,6 +1004,31 @@ class SerializerPickleTests(TestCase):
 
 
 # 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):
-- 
cgit v1.2.3