cleaned a bit Response/ResponseMixin code, added some documentation + renamed ErrorResponse to ImmediateResponse

5 files changed, 62 insertions, 42 deletions

diff --git a/djangorestframework/tests/accept.py b/djangorestframework/tests/accept.py
index 2a02e04d..e7dfc303 100644
--- a/djangorestframework/tests/accept.py
+++ b/djangorestframework/tests/accept.py
@@ -23,9 +23,10 @@ class UserAgentMungingTest(TestCase):
 
         class MockView(View):
             permissions = ()
+            response_class = Response
 
             def get(self, request):
-                return Response({'a':1, 'b':2, 'c':3})
+                return self.response_class({'a':1, 'b':2, 'c':3})
 
         self.req = RequestFactory()
         self.MockView = MockView
diff --git a/djangorestframework/tests/mixins.py b/djangorestframework/tests/mixins.py
index 7a1d2769..187ce719 100644
--- a/djangorestframework/tests/mixins.py
+++ b/djangorestframework/tests/mixins.py
@@ -6,7 +6,7 @@ from djangorestframework.compat import RequestFactory
 from django.contrib.auth.models import Group, User
 from djangorestframework.mixins import CreateModelMixin, PaginatorMixin, ReadModelMixin
 from djangorestframework.resources import ModelResource
-from djangorestframework.response import Response, ErrorResponse
+from djangorestframework.response import Response, ImmediateResponse
 from djangorestframework.tests.models import CustomUser
 from djangorestframework.tests.testcases import TestModelsTestCase
 from djangorestframework.views import View
@@ -41,7 +41,7 @@ class TestModelRead(TestModelsTestCase):
         mixin = ReadModelMixin()
         mixin.resource = GroupResource
 
-        self.assertRaises(ErrorResponse, mixin.get, request, id=12345)
+        self.assertRaises(ImmediateResponse, mixin.get, request, id=12345)
 
 
 class TestModelCreation(TestModelsTestCase):
diff --git a/djangorestframework/tests/renderers.py b/djangorestframework/tests/renderers.py
index 461bc877..cc211dce 100644
--- a/djangorestframework/tests/renderers.py
+++ b/djangorestframework/tests/renderers.py
@@ -73,8 +73,8 @@ class MockGETView(View):
 
 
 urlpatterns = patterns('',
-    url(r'^jsonp/jsonrenderer$', MockGETView.as_view(renderers=[JSONRenderer, JSONPRenderer])),
-    url(r'^jsonp/nojsonrenderer$', MockGETView.as_view(renderers=[JSONPRenderer])),
+    url(r'^jsonp/jsonrenderer$', MockGETView.as_view(renderer_classes=[JSONRenderer, JSONPRenderer])),
+    url(r'^jsonp/nojsonrenderer$', MockGETView.as_view(renderer_classes=[JSONPRenderer])),
 )
 
 
diff --git a/djangorestframework/tests/response.py b/djangorestframework/tests/response.py
index 5a01e356..b8cc5c1b 100644
--- a/djangorestframework/tests/response.py
+++ b/djangorestframework/tests/response.py
@@ -1,9 +1,10 @@
 import json
+import unittest
 
 from django.conf.urls.defaults import patterns, url
 from django.test import TestCase
 
-from djangorestframework.response import Response, ErrorResponse
+from djangorestframework.response import Response, ImmediateResponse
 from djangorestframework.mixins import ResponseMixin
 from djangorestframework.views import View
 from djangorestframework.compat import View as DjangoView
@@ -17,13 +18,16 @@ from djangorestframework.renderers import BaseRenderer, JSONRenderer, YAMLRender
 class TestResponseDetermineRenderer(TestCase):
 
     def get_response(self, url='', accept_list=[], renderers=[]):
-        request = RequestFactory().get(url, HTTP_ACCEPT=','.join(accept_list))
+        kwargs = {}
+        if accept_list is not None:
+            kwargs['HTTP_ACCEPT'] = HTTP_ACCEPT=','.join(accept_list)
+        request = RequestFactory().get(url, **kwargs)
         return Response(request=request, renderers=renderers)
 
     def get_renderer_mock(self, media_type):
         return type('RendererMock', (BaseRenderer,), {
             'media_type': media_type,
-        })
+        })()
 
     def test_determine_accept_list_accept_header(self):
         """
@@ -32,6 +36,13 @@ class TestResponseDetermineRenderer(TestCase):
         accept_list = ['application/pickle', 'application/json']
         response = self.get_response(accept_list=accept_list)
         self.assertEqual(response._determine_accept_list(), accept_list)
+
+    def test_determine_accept_list_default(self):
+        """
+        Test that determine_accept_list takes the default renderer if Accept is not specified.
+        """
+        response = self.get_response(accept_list=None)
+        self.assertEqual(response._determine_accept_list(), ['*/*'])
         
     def test_determine_accept_list_overriden_header(self):
         """
@@ -47,38 +58,46 @@ class TestResponseDetermineRenderer(TestCase):
         Test that right renderer is chosen, in the order of Accept list.
         """
         accept_list = ['application/pickle', 'application/json']
-        PRenderer = self.get_renderer_mock('application/pickle')
-        JRenderer = self.get_renderer_mock('application/json')
+        prenderer = self.get_renderer_mock('application/pickle')
+        jrenderer = self.get_renderer_mock('application/json')
 
-        renderers = (PRenderer, JRenderer)
-        response = self.get_response(accept_list=accept_list, renderers=renderers)
+        response = self.get_response(accept_list=accept_list, renderers=(prenderer, jrenderer))
         renderer, media_type = response._determine_renderer()
         self.assertEqual(media_type, 'application/pickle')
-        self.assertTrue(isinstance(renderer, PRenderer))
+        self.assertTrue(renderer, prenderer)
 
-        renderers = (JRenderer,)
-        response = self.get_response(accept_list=accept_list, renderers=renderers)
+        response = self.get_response(accept_list=accept_list, renderers=(jrenderer,))
         renderer, media_type = response._determine_renderer()
         self.assertEqual(media_type, 'application/json')
-        self.assertTrue(isinstance(renderer, JRenderer))
+        self.assertTrue(renderer, jrenderer)
+
+    def test_determine_renderer_default(self):
+        """
+        Test determine renderer when Accept was not specified.
+        """
+        prenderer = self.get_renderer_mock('application/pickle')
+
+        response = self.get_response(accept_list=None, renderers=(prenderer,))
+        renderer, media_type = response._determine_renderer()
+        self.assertEqual(media_type, '*/*')
+        self.assertTrue(renderer, prenderer)
         
     def test_determine_renderer_no_renderer(self):
         """
         Test determine renderer when no renderer can satisfy the Accept list.
         """
         accept_list = ['application/json']
-        PRenderer = self.get_renderer_mock('application/pickle')
+        prenderer = self.get_renderer_mock('application/pickle')
 
-        renderers = (PRenderer,)
-        response = self.get_response(accept_list=accept_list, renderers=renderers)
-        self.assertRaises(ErrorResponse, response._determine_renderer)
+        response = self.get_response(accept_list=accept_list, renderers=(prenderer,))
+        self.assertRaises(ImmediateResponse, response._determine_renderer)
 
 
 class TestResponseRenderContent(TestCase):
     
     def get_response(self, url='', accept_list=[], content=None):
         request = RequestFactory().get(url, HTTP_ACCEPT=','.join(accept_list))
-        return Response(request=request, content=content, renderers=DEFAULT_RENDERERS)
+        return Response(request=request, content=content, renderers=[r() for r in DEFAULT_RENDERERS])
 
     def test_render(self):
         """
@@ -116,7 +135,7 @@ class RendererB(BaseRenderer):
 
 
 class MockView(ResponseMixin, DjangoView):
-    renderers = (RendererA, RendererB)
+    renderer_classes = (RendererA, RendererB)
 
     def get(self, request, **kwargs):
         response = Response(DUMMYCONTENT, status=DUMMYSTATUS)
@@ -124,22 +143,22 @@ class MockView(ResponseMixin, DjangoView):
 
 
 class HTMLView(View):
-    renderers = (DocumentingHTMLRenderer, )
+    renderer_classes = (DocumentingHTMLRenderer, )
 
     def get(self, request, **kwargs):
         return Response('text')
 
 
 class HTMLView1(View):
-    renderers = (DocumentingHTMLRenderer, JSONRenderer)
+    renderer_classes = (DocumentingHTMLRenderer, JSONRenderer)
 
     def get(self, request, **kwargs):
         return Response('text') 
 
 
 urlpatterns = patterns('',
-    url(r'^.*\.(?P<format>.+)$', MockView.as_view(renderers=[RendererA, RendererB])),
-    url(r'^$', MockView.as_view(renderers=[RendererA, RendererB])),
+    url(r'^.*\.(?P<format>.+)$', MockView.as_view(renderer_classes=[RendererA, RendererB])),
+    url(r'^$', MockView.as_view(renderer_classes=[RendererA, RendererB])),
     url(r'^html$', HTMLView.as_view()),
     url(r'^html1$', HTMLView1.as_view()),
 )
@@ -197,11 +216,11 @@ class RendererIntegrationTests(TestCase):
         self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
         self.assertEquals(resp.status_code, DUMMYSTATUS)
 
-# TODO: can't pass because view is a simple Django view and response is an ErrorResponse
-#    def test_unsatisfiable_accept_header_on_request_returns_406_status(self):
-#        """If the Accept header is unsatisfiable we should return a 406 Not Acceptable response."""
-#        resp = self.client.get('/', HTTP_ACCEPT='foo/bar')
-#        self.assertEquals(resp.status_code, status.HTTP_406_NOT_ACCEPTABLE)
+    @unittest.skip('can\'t pass because view is a simple Django view and response is an ImmediateResponse')
+    def test_unsatisfiable_accept_header_on_request_returns_406_status(self):
+        """If the Accept header is unsatisfiable we should return a 406 Not Acceptable response."""
+        resp = self.client.get('/', HTTP_ACCEPT='foo/bar')
+        self.assertEquals(resp.status_code, status.HTTP_406_NOT_ACCEPTABLE)
 
     def test_specified_renderer_serializes_content_on_format_query(self):
         """If a 'format' query is specified, the renderer with the matching
diff --git a/djangorestframework/tests/validators.py b/djangorestframework/tests/validators.py
index 1f384b4c..771b3125 100644
--- a/djangorestframework/tests/validators.py
+++ b/djangorestframework/tests/validators.py
@@ -2,7 +2,7 @@ from django import forms
 from django.db import models
 from django.test import TestCase
 from djangorestframework.resources import FormResource, ModelResource
-from djangorestframework.response import ErrorResponse
+from djangorestframework.response import ImmediateResponse
 from djangorestframework.views import View
 
 
@@ -81,10 +81,10 @@ class TestNonFieldErrors(TestCase):
         content = {'field1': 'example1', 'field2': 'example2'}
         try:
             MockResource(view).validate_request(content, None)
-        except ErrorResponse, response:
+        except ImmediateResponse, response:
             self.assertEqual(response.raw_content, {'errors': [MockForm.ERROR_TEXT]})
         else:
-            self.fail('ErrorResponse was not raised')
+            self.fail('ImmediateResponse was not raised')
 
 
 class TestFormValidation(TestCase):
@@ -120,14 +120,14 @@ class TestFormValidation(TestCase):
     def validation_failure_raises_response_exception(self, validator):
         """If form validation fails a ResourceException 400 (Bad Request) should be raised."""
         content = {}
-        self.assertRaises(ErrorResponse, validator.validate_request, content, None)
+        self.assertRaises(ImmediateResponse, validator.validate_request, content, None)
 
     def validation_does_not_allow_extra_fields_by_default(self, validator):
         """If some (otherwise valid) content includes fields that are not in the form then validation should fail.
         It might be okay on normal form submission, but for Web APIs we oughta get strict, as it'll help show up
         broken clients more easily (eg submitting content with a misnamed field)"""
         content = {'qwerty': 'uiop', 'extra': 'extra'}
-        self.assertRaises(ErrorResponse, validator.validate_request, content, None)
+        self.assertRaises(ImmediateResponse, validator.validate_request, content, None)
 
     def validation_allows_extra_fields_if_explicitly_set(self, validator):
         """If we include an allowed_extra_fields paramater on _validate, then allow fields with those names."""
@@ -154,7 +154,7 @@ class TestFormValidation(TestCase):
         content = {}
         try:
             validator.validate_request(content, None)
-        except ErrorResponse, response:
+        except ImmediateResponse, response:
             self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.']}})
         else:
             self.fail('ResourceException was not raised')
@@ -164,7 +164,7 @@ class TestFormValidation(TestCase):
         content = {'qwerty': ''}
         try:
             validator.validate_request(content, None)
-        except ErrorResponse, response:
+        except ImmediateResponse, response:
             self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.']}})
         else:
             self.fail('ResourceException was not raised')
@@ -174,7 +174,7 @@ class TestFormValidation(TestCase):
         content = {'qwerty': 'uiop', 'extra': 'extra'}
         try:
             validator.validate_request(content, None)
-        except ErrorResponse, response:
+        except ImmediateResponse, response:
             self.assertEqual(response.raw_content, {'field_errors': {'extra': ['This field does not exist.']}})
         else:
             self.fail('ResourceException was not raised')
@@ -184,7 +184,7 @@ class TestFormValidation(TestCase):
         content = {'qwerty': '', 'extra': 'extra'}
         try:
             validator.validate_request(content, None)
-        except ErrorResponse, response:
+        except ImmediateResponse, response:
             self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.'],
                                                                          'extra': ['This field does not exist.']}})
         else:
@@ -307,14 +307,14 @@ class TestModelFormValidator(TestCase):
         It might be okay on normal form submission, but for Web APIs we oughta get strict, as it'll help show up
         broken clients more easily (eg submitting content with a misnamed field)"""
         content = {'qwerty': 'example', 'uiop': 'example', 'readonly': 'read only', 'extra': 'extra'}
-        self.assertRaises(ErrorResponse, self.validator.validate_request, content, None)
+        self.assertRaises(ImmediateResponse, self.validator.validate_request, content, None)
 
     def test_validate_requires_fields_on_model_forms(self):
         """If some (otherwise valid) content includes fields that are not in the form then validation should fail.
         It might be okay on normal form submission, but for Web APIs we oughta get strict, as it'll help show up
         broken clients more easily (eg submitting content with a misnamed field)"""
         content = {'readonly': 'read only'}
-        self.assertRaises(ErrorResponse, self.validator.validate_request, content, None)
+        self.assertRaises(ImmediateResponse, self.validator.validate_request, content, None)
 
     def test_validate_does_not_require_blankable_fields_on_model_forms(self):
         """Test standard ModelForm validation behaviour - fields with blank=True are not required."""