Massive merge

1 files changed, 176 insertions, 32 deletions

diff --git a/djangorestframework/tests/renderers.py b/djangorestframework/tests/renderers.py
index cc211dce..8eb78b74 100644
--- a/djangorestframework/tests/renderers.py
+++ b/djangorestframework/tests/renderers.py
@@ -1,21 +1,180 @@
 import re
 
+from django.conf.urls.defaults import patterns, url, include
 from django.test import TestCase
 
-from django.conf.urls.defaults import patterns, url
-from django.test import TestCase
-
+from djangorestframework import status
+from djangorestframework.compat import View as DjangoView
 from djangorestframework.response import Response
+from djangorestframework.mixins import ResponseMixin
 from djangorestframework.views import View
 from djangorestframework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer, \
     XMLRenderer, JSONPRenderer, DocumentingHTMLRenderer
-from djangorestframework.parsers import JSONParser, YAMLParser, XMLParser
+from djangorestframework.parsers import YAMLParser, XMLParser
 
 from StringIO import StringIO
 import datetime
 from decimal import Decimal
 
 
+DUMMYSTATUS = status.HTTP_200_OK
+DUMMYCONTENT = 'dummycontent'
+
+RENDERER_A_SERIALIZER = lambda x: 'Renderer A: %s' % x
+RENDERER_B_SERIALIZER = lambda x: 'Renderer B: %s' % x
+
+
+class RendererA(BaseRenderer):
+    media_type = 'mock/renderera'
+    format = "formata"
+
+    def render(self, obj=None, media_type=None):
+        return RENDERER_A_SERIALIZER(obj)
+
+
+class RendererB(BaseRenderer):
+    media_type = 'mock/rendererb'
+    format = "formatb"
+
+    def render(self, obj=None, media_type=None):
+        return RENDERER_B_SERIALIZER(obj)
+
+
+class MockView(ResponseMixin, DjangoView):
+    renderers = (RendererA, RendererB)
+
+    def get(self, request, **kwargs):
+        response = Response(DUMMYSTATUS, DUMMYCONTENT)
+        return self.render(response)
+
+
+class MockGETView(View):
+
+    def get(self, request, **kwargs):
+        return {'foo': ['bar', 'baz']}
+
+
+class HTMLView(View):
+    renderers = (DocumentingHTMLRenderer, )
+
+    def get(self, request, **kwargs):
+        return 'text'
+
+
+class HTMLView1(View):
+    renderers = (DocumentingHTMLRenderer, JSONRenderer)
+
+    def get(self, request, **kwargs):
+        return 'text'
+
+urlpatterns = patterns('',
+    url(r'^.*\.(?P<format>.+)$', MockView.as_view(renderers=[RendererA, RendererB])),
+    url(r'^$', MockView.as_view(renderers=[RendererA, RendererB])),
+    url(r'^jsonp/jsonrenderer$', MockGETView.as_view(renderers=[JSONRenderer, JSONPRenderer])),
+    url(r'^jsonp/nojsonrenderer$', MockGETView.as_view(renderers=[JSONPRenderer])),
+    url(r'^html$', HTMLView.as_view()),
+    url(r'^html1$', HTMLView1.as_view()),
+    url(r'^api', include('djangorestframework.urls', namespace='djangorestframework'))
+)
+
+
+class RendererIntegrationTests(TestCase):
+    """
+    End-to-end testing of renderers using an RendererMixin on a generic view.
+    """
+
+    urls = 'djangorestframework.tests.renderers'
+
+    def test_default_renderer_serializes_content(self):
+        """If the Accept header is not set the default renderer should serialize the response."""
+        resp = self.client.get('/')
+        self.assertEquals(resp['Content-Type'], RendererA.media_type)
+        self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    def test_head_method_serializes_no_content(self):
+        """No response must be included in HEAD requests."""
+        resp = self.client.head('/')
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+        self.assertEquals(resp['Content-Type'], RendererA.media_type)
+        self.assertEquals(resp.content, '')
+
+    def test_default_renderer_serializes_content_on_accept_any(self):
+        """If the Accept header is set to */* the default renderer should serialize the response."""
+        resp = self.client.get('/', HTTP_ACCEPT='*/*')
+        self.assertEquals(resp['Content-Type'], RendererA.media_type)
+        self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    def test_specified_renderer_serializes_content_default_case(self):
+        """If the Accept header is set the specified renderer should serialize the response.
+        (In this case we check that works for the default renderer)"""
+        resp = self.client.get('/', HTTP_ACCEPT=RendererA.media_type)
+        self.assertEquals(resp['Content-Type'], RendererA.media_type)
+        self.assertEquals(resp.content, RENDERER_A_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    def test_specified_renderer_serializes_content_non_default_case(self):
+        """If the Accept header is set the specified renderer should serialize the response.
+        (In this case we check that works for a non-default renderer)"""
+        resp = self.client.get('/', HTTP_ACCEPT=RendererB.media_type)
+        self.assertEquals(resp['Content-Type'], RendererB.media_type)
+        self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    def test_specified_renderer_serializes_content_on_accept_query(self):
+        """The '_accept' query string should behave in the same way as the Accept header."""
+        resp = self.client.get('/?_accept=%s' % RendererB.media_type)
+        self.assertEquals(resp['Content-Type'], RendererB.media_type)
+        self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    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
+        format attribute should serialize the response."""
+        resp = self.client.get('/?format=%s' % RendererB.format)
+        self.assertEquals(resp['Content-Type'], RendererB.media_type)
+        self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    def test_specified_renderer_serializes_content_on_format_kwargs(self):
+        """If a 'format' keyword arg is specified, the renderer with the matching
+        format attribute should serialize the response."""
+        resp = self.client.get('/something.formatb')
+        self.assertEquals(resp['Content-Type'], RendererB.media_type)
+        self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    def test_specified_renderer_is_used_on_format_query_with_matching_accept(self):
+        """If both a 'format' query and a matching Accept header specified,
+        the renderer with the matching format attribute should serialize the response."""
+        resp = self.client.get('/?format=%s' % RendererB.format,
+                               HTTP_ACCEPT=RendererB.media_type)
+        self.assertEquals(resp['Content-Type'], RendererB.media_type)
+        self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    def test_conflicting_format_query_and_accept_ignores_accept(self):
+        """If a 'format' query is specified that does not match the Accept
+        header, we should only honor the 'format' query string."""
+        resp = self.client.get('/?format=%s' % RendererB.format,
+                               HTTP_ACCEPT='dummy')
+        self.assertEquals(resp['Content-Type'], RendererB.media_type)
+        self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
+    def test_bla(self):  # What the f***?
+        resp = self.client.get('/?format=formatb',
+            HTTP_ACCEPT='text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8')
+        self.assertEquals(resp['Content-Type'], RendererB.media_type)
+        self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
+        self.assertEquals(resp.status_code, DUMMYSTATUS)
+
 _flat_repr = '{"foo": ["bar", "baz"]}'
 _indented_repr = '{\n  "foo": [\n    "bar",\n    "baz"\n  ]\n}'
 
@@ -27,6 +186,7 @@ def strip_trailing_whitespace(content):
     """
     return re.sub(' +\n', '\n', content)
 
+
 class JSONRendererTests(TestCase):
     """
     Tests specific to the JSON Renderer
@@ -51,30 +211,16 @@ class JSONRendererTests(TestCase):
         content = renderer.render(obj, 'application/json; indent=2')
         self.assertEquals(strip_trailing_whitespace(content), _indented_repr)
 
-    def test_render_and_parse(self):
-        """
-        Test rendering and then parsing returns the original object.
-        IE obj -> render -> parse -> obj.
-        """
-        obj = {'foo': ['bar', 'baz']}
-
-        renderer = JSONRenderer(None)
-        parser = JSONParser(None)
-
-        content = renderer.render(obj, 'application/json')
-        (data, files) = parser.parse(StringIO(content))
-        self.assertEquals(obj, data)
-
 
 class MockGETView(View):
 
-    def get(self, request, **kwargs):
+    def get(self, request, *args, **kwargs):
         return Response({'foo': ['bar', 'baz']})
 
 
 urlpatterns = patterns('',
-    url(r'^jsonp/jsonrenderer$', MockGETView.as_view(renderer_classes=[JSONRenderer, JSONPRenderer])),
-    url(r'^jsonp/nojsonrenderer$', MockGETView.as_view(renderer_classes=[JSONPRenderer])),
+    url(r'^jsonp/jsonrenderer$', MockGETView.as_view(renderers=[JSONRenderer, JSONPRenderer])),
+    url(r'^jsonp/nojsonrenderer$', MockGETView.as_view(renderers=[JSONPRenderer])),
 )
 
 
@@ -149,22 +295,21 @@ if YAMLRenderer:
             self.assertEquals(obj, data)
 
 
-
 class XMLRendererTestCase(TestCase):
     """
     Tests specific to the XML Renderer
     """
 
     _complex_data = {
-        "creation_date": datetime.datetime(2011, 12, 25, 12, 45, 00), 
-        "name": "name", 
+        "creation_date": datetime.datetime(2011, 12, 25, 12, 45, 00),
+        "name": "name",
         "sub_data_list": [
             {
-                "sub_id": 1, 
+                "sub_id": 1,
                 "sub_name": "first"
-            }, 
+            },
             {
-                "sub_id": 2, 
+                "sub_id": 2,
                 "sub_name": "second"
             }
         ]
@@ -219,12 +364,12 @@ class XMLRendererTestCase(TestCase):
         renderer = XMLRenderer(None)
         content = renderer.render({'field': None}, 'application/xml')
         self.assertXMLContains(content, '<field></field>')
-        
+
     def test_render_complex_data(self):
         """
         Test XML rendering.
         """
-        renderer = XMLRenderer(None)            
+        renderer = XMLRenderer(None)
         content = renderer.render(self._complex_data, 'application/xml')
         self.assertXMLContains(content, '<sub_name>first</sub_name>')
         self.assertXMLContains(content, '<sub_name>second</sub_name>')
@@ -233,9 +378,9 @@ class XMLRendererTestCase(TestCase):
         """
         Test XML rendering.
         """
-        renderer = XMLRenderer(None)            
+        renderer = XMLRenderer(None)
         content = StringIO(renderer.render(self._complex_data, 'application/xml'))
-        
+
         parser = XMLParser(None)
         complex_data_out, dummy = parser.parse(content)
         error_msg = "complex data differs!IN:\n %s \n\n OUT:\n %s" % (repr(self._complex_data), repr(complex_data_out))
@@ -245,4 +390,3 @@ class XMLRendererTestCase(TestCase):
         self.assertTrue(xml.startswith('<?xml version="1.0" encoding="utf-8"?>\n<root>'))
         self.assertTrue(xml.endswith('</root>'))
         self.assertTrue(string in xml, '%r not in %r' % (string, xml))
-