Merge git://github.com/sebpiq/django-rest-framework into develop

djangorestframework/authentication.py

@@ -87,7 +87,7 @@ class UserLoggedInAuthentication(BaseAuthentication):
         Returns a :obj:`User` if the request session currently has a logged in user.
         Otherwise returns :const:`None`.
         """
-        self.view.DATA  # Make sure our generic parsing runs first
+        request.DATA  # Make sure our generic parsing runs first
 
         if getattr(request, 'user', None) and request.user.is_active:
             # Enforce CSRF validation for session based authentication.

djangorestframework/mixins.py

@@ -6,17 +6,14 @@ classes that can be added to a `View`.
 from django.contrib.auth.models import AnonymousUser
 from django.core.paginator import Paginator
 from django.db.models.fields.related import ForeignKey
-from django.http import HttpResponse
 from urlobject import URLObject
 
 from djangorestframework import status
 from djangorestframework.renderers import BaseRenderer
 from djangorestframework.resources import Resource, FormResource, ModelResource
-from djangorestframework.response import Response, ErrorResponse
+from djangorestframework.response import Response, ImmediateResponse
-from djangorestframework.utils import as_tuple, MSIE_USER_AGENT_REGEX
+from djangorestframework.request import Request
-from djangorestframework.utils.mediatypes import is_form_media_type, order_by_precedence
+from djangorestframework.utils import as_tuple, allowed_methods
-
-from StringIO import StringIO
 
 
 __all__ = (
@@ -40,281 +37,102 @@ __all__ = (
 
 class RequestMixin(object):
     """
-    `Mixin` class to provide request parsing behavior.
+    `Mixin` class enabling the use of :class:`request.Request` in your views.
     """
 
-    _USE_FORM_OVERLOADING = True
+    parser_classes = ()
-    _METHOD_PARAM = '_method'
-    _CONTENTTYPE_PARAM = '_content_type'
-    _CONTENT_PARAM = '_content'
-
-    parsers = ()
     """
-    The set of request parsers that the view can handle.
+    The set of parsers that the view can handle.
-
     Should be a tuple/list of classes as described in the :mod:`parsers` module.
     """
 
-    @property
+    request_class = Request
-    def method(self):
+    """
+    The class to use as a wrapper for the original request object.
+    """
+
+    def get_parsers(self):
         """
-        Returns the HTTP method.
+        Instantiates and returns the list of parsers the request will use.
-
-        This should be used instead of just reading :const:`request.method`, as it allows the `method`
-        to be overridden by using a hidden `form` field on a form POST request.
         """
-        if not hasattr(self, '_method'):
+        return [p(self) for p in self.parser_classes]
-            self._load_method_and_content_type()
-        return self._method
 
-    @property
+    def create_request(self, request):
-    def content_type(self):
         """
-        Returns the content type header.
+        Creates and returns an instance of :class:`request.Request`.
-
+        This new instance wraps the `request` passed as a parameter, and use the 
-        This should be used instead of ``request.META.get('HTTP_CONTENT_TYPE')``,
+        parsers set on the view.
-        as it allows the content type to be overridden by using a hidden form
-        field on a form POST request.
         """
-        if not hasattr(self, '_content_type'):
+        parsers = self.get_parsers()
-            self._load_method_and_content_type()
+        return self.request_class(request, parsers=parsers)
-        return self._content_type
-
-    @property
-    def DATA(self):
-        """
-        Parses the request body and returns the data.
-
-        Similar to ``request.POST``, except that it handles arbitrary parsers,
-        and also works on methods other than POST (eg PUT).
-        """
-        if not hasattr(self, '_data'):
-            self._load_data_and_files()
-        return self._data
-
-    @property
-    def FILES(self):
-        """
-        Parses the request body and returns the files.
-        Similar to ``request.FILES``, except that it handles arbitrary parsers,
-        and also works on methods other than POST (eg PUT).
-        """
-        if not hasattr(self, '_files'):
-            self._load_data_and_files()
-        return self._files
-
-    def _load_data_and_files(self):
-        """
-        Parse the request content into self.DATA and self.FILES.
-        """
-        if not hasattr(self, '_content_type'):
-            self._load_method_and_content_type()
-
-        if not hasattr(self, '_data'):
-            (self._data, self._files) = self._parse(self._get_stream(), self._content_type)
-
-    def _load_method_and_content_type(self):
-        """
-        Set the method and content_type, and then check if they've been overridden.
-        """
-        self._method = self.request.method
-        self._content_type = self.request.META.get('HTTP_CONTENT_TYPE', self.request.META.get('CONTENT_TYPE', ''))
-        self._perform_form_overloading()
-
-    def _get_stream(self):
-        """
-        Returns an object that may be used to stream the request content.
-        """
-        request = self.request
-
-        try:
-            content_length = int(request.META.get('CONTENT_LENGTH', request.META.get('HTTP_CONTENT_LENGTH')))
-        except (ValueError, TypeError):
-            content_length = 0
-
-        # TODO: Add 1.3's LimitedStream to compat and use that.
-        # NOTE: Currently only supports parsing request body as a stream with 1.3
-        if content_length == 0:
-            return None
-        elif hasattr(request, 'read'):
-            return request
-        return StringIO(request.raw_post_data)
-
-    def _perform_form_overloading(self):
-        """
-        If this is a form POST request, then we need to check if the method and content/content_type have been
-        overridden by setting them in hidden form fields or not.
-        """
-
-        # We only need to use form overloading on form POST requests.
-        if not self._USE_FORM_OVERLOADING or self._method != 'POST' or not is_form_media_type(self._content_type):
-            return
-
-        # At this point we're committed to parsing the request as form data.
-        self._data = data = self.request.POST.copy()
-        self._files = self.request.FILES
-
-        # Method overloading - change the method and remove the param from the content.
-        if self._METHOD_PARAM in data:
-            # NOTE: unlike `get`, `pop` on a `QueryDict` seems to return a list of values.
-            self._method = self._data.pop(self._METHOD_PARAM)[0].upper()
-
-        # Content overloading - modify the content type, and re-parse.
-        if self._CONTENT_PARAM in data and self._CONTENTTYPE_PARAM in data:
-            self._content_type = self._data.pop(self._CONTENTTYPE_PARAM)[0]
-            stream = StringIO(self._data.pop(self._CONTENT_PARAM)[0])
-            (self._data, self._files) = self._parse(stream, self._content_type)
-
-    def _parse(self, stream, content_type):
-        """
-        Parse the request content.
-
-        May raise a 415 ErrorResponse (Unsupported Media Type), or a 400 ErrorResponse (Bad Request).
-        """
-        if stream is None or content_type is None:
-            return (None, None)
-
-        parsers = as_tuple(self.parsers)
-
-        for parser_cls in parsers:
-            parser = parser_cls(self)
-            if parser.can_handle_request(content_type):
-                return parser.parse(stream)
-
-        raise ErrorResponse(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
-                            {'error': 'Unsupported media type in request \'%s\'.' %
-                            content_type})
 
     @property
     def _parsed_media_types(self):
         """
-        Return a list of all the media types that this view can parse.
+        Returns a list of all the media types that this view can parse.
         """
-        return [parser.media_type for parser in self.parsers]
+        return [p.media_type for p in self.parser_classes]
-
+        
-    @property
-    def _default_parser(self):
-        """
-        Return the view's default parser class.
-        """
-        return self.parsers[0]
-
 
 ########## ResponseMixin ##########
 
 class ResponseMixin(object):
     """
-    Adds behavior for pluggable `Renderers` to a :class:`views.View` class.
+    `Mixin` class enabling the use of :class:`response.Response` in your views.
-
-    Default behavior is to use standard HTTP Accept header content negotiation.
-    Also supports overriding the content type by specifying an ``_accept=`` parameter in the URL.
-    Ignores Accept headers from Internet Explorer user agents and uses a sensible browser Accept header instead.
     """
 
-    _ACCEPT_QUERY_PARAM = '_accept'        # Allow override of Accept header in URL query params
+    renderer_classes = ()
-    _IGNORE_IE_ACCEPT_HEADER = True
-
-    renderers = ()
     """
     The set of response renderers that the view can handle.
-
     Should be a tuple/list of classes as described in the :mod:`renderers` module.
     """
 
-    # TODO: wrap this behavior around dispatch(), ensuring it works
+    def get_renderers(self):
-    # out of the box with existing Django classes that use render_to_response.
-    def render(self, response):
         """
-        Takes a :obj:`Response` object and returns an :obj:`HttpResponse`.
+        Instantiates and returns the list of renderers the response will use.
         """
-        self.response = response
+        return [r(self) for r in self.renderer_classes]
 
-        try:
+    def prepare_response(self, response):
-            renderer, media_type = self._determine_renderer(self.request)
-        except ErrorResponse, exc:
-            renderer = self._default_renderer(self)
-            media_type = renderer.media_type
-            response = exc.response
-
-        # Set the media type of the response
-        # Note that the renderer *could* override it in .render() if required.
-        response.media_type = renderer.media_type
-
-        # Serialize the response content
-        if response.has_content_body:
-            content = renderer.render(response.cleaned_content, media_type)
-        else:
-            content = renderer.render()
-
-        # Build the HTTP Response
-        resp = HttpResponse(content, mimetype=response.media_type, status=response.status)
-        for (key, val) in response.headers.items():
-            resp[key] = val
-
-        return resp
-
-    def _determine_renderer(self, request):
         """
-        Determines the appropriate renderer for the output, given the client's 'Accept' header,
+        Prepares and returns `response`.
-        and the :attr:`renderers` set on this class.
+        This has no effect if the response is not an instance of :class:`response.Response`.
-
-        Returns a 2-tuple of `(renderer, media_type)`
-
-        See: RFC 2616, Section 14 - http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
         """
+        if hasattr(response, 'request') and response.request is None:
+            response.request = self.request
 
-        if self._ACCEPT_QUERY_PARAM and request.GET.get(self._ACCEPT_QUERY_PARAM, None):
+        # set all the cached headers
-            # Use _accept parameter override
+        for name, value in self.headers.items():
-            accept_list = [request.GET.get(self._ACCEPT_QUERY_PARAM)]
+            response[name] = value
-        elif (self._IGNORE_IE_ACCEPT_HEADER and
-              'HTTP_USER_AGENT' in request.META and
-              MSIE_USER_AGENT_REGEX.match(request.META['HTTP_USER_AGENT'])):
-            # Ignore MSIE's broken accept behavior and do something sensible instead
-            accept_list = ['text/html', '*/*']
-        elif 'HTTP_ACCEPT' in request.META:
-            # Use standard HTTP Accept negotiation
-            accept_list = [token.strip() for token in request.META['HTTP_ACCEPT'].split(',')]
-        else:
-            # No accept header specified
-            accept_list = ['*/*']
 
-        # Check the acceptable media types against each renderer,
+        # set the views renderers on the response
-        # attempting more specific media types first
+        response.renderers = self.get_renderers()
-        # NB. The inner loop here isn't as bad as it first looks :)
+        return response
-        #     Worst case is we're looping over len(accept_list) * len(self.renderers)
-        renderers = [renderer_cls(self) for renderer_cls in self.renderers]
 
-        for accepted_media_type_lst in order_by_precedence(accept_list):
+    @property
-            for renderer in renderers:
+    def headers(self):
-                for accepted_media_type in accepted_media_type_lst:
+        """
-                    if renderer.can_handle_response(accepted_media_type):
+        Dictionary of headers to set on the response.
-                        return renderer, accepted_media_type
+        This is useful when the response doesn't exist yet, but you
-
+        want to memorize some headers to set on it when it will exist.
-        # No acceptable renderers were found
+        """
-        raise ErrorResponse(status.HTTP_406_NOT_ACCEPTABLE,
+        if not hasattr(self, '_headers'):
-                                {'detail': 'Could not satisfy the client\'s Accept header',
+            self._headers = {}
-                                 'available_types': self._rendered_media_types})
+        return self._headers
 
     @property
     def _rendered_media_types(self):
         """
         Return an list of all the media types that this view can render.
         """
-        return [renderer.media_type for renderer in self.renderers]
+        return [renderer.media_type for renderer in self.get_renderers()]
 
     @property
     def _rendered_formats(self):
         """
         Return a list of all the formats that this view can render.
         """
-        return [renderer.format for renderer in self.renderers]
+        return [renderer.format for renderer in self.get_renderers()]
-
-    @property
-    def _default_renderer(self):
-        """
-        Return the view's default renderer class.
-        """
-        return self.renderers[0]
 
 
 ########## Auth Mixin ##########
@@ -363,7 +181,7 @@ class AuthMixin(object):
     # TODO: wrap this behavior around dispatch()
     def _check_permissions(self):
         """
-        Check user permissions and either raise an ``ErrorResponse`` or return.
+        Check user permissions and either raise an ``ImmediateResponse`` or return.
         """
         user = self.user
         for permission_cls in self.permissions:
@@ -391,10 +209,10 @@ class ResourceMixin(object):
         """
         Returns the cleaned, validated request content.
 
-        May raise an :class:`response.ErrorResponse` with status code 400 (Bad Request).
+        May raise an :class:`response.ImmediateResponse` with status code 400 (Bad Request).
         """
         if not hasattr(self, '_content'):
-            self._content = self.validate_request(self.DATA, self.FILES)
+            self._content = self.validate_request(self.request.DATA, self.request.FILES)
         return self._content
 
     @property
@@ -402,7 +220,7 @@ class ResourceMixin(object):
         """
         Returns the cleaned, validated query parameters.
 
-        May raise an :class:`response.ErrorResponse` with status code 400 (Bad Request).
+        May raise an :class:`response.ImmediateResponse` with status code 400 (Bad Request).
         """
         return self.validate_request(self.request.GET)
 
@@ -414,14 +232,14 @@ class ResourceMixin(object):
             return ModelResource(self)
         elif getattr(self, 'form', None):
             return FormResource(self)
-        elif getattr(self, '%s_form' % self.method.lower(), None):
+        elif getattr(self, '%s_form' % self.request.method.lower(), None):
             return FormResource(self)
         return Resource(self)
 
     def validate_request(self, data, files=None):
         """
         Given the request *data* and optional *files*, return the cleaned, validated content.
-        May raise an :class:`response.ErrorResponse` with status code 400 (Bad Request) on failure.
+        May raise an :class:`response.ImmediateResponse` with status code 400 (Bad Request) on failure.
         """
         return self._resource.validate_request(data, files)
 
@@ -552,9 +370,9 @@ class ReadModelMixin(ModelMixin):
         try:
             self.model_instance = self.get_instance(**query_kwargs)
         except model.DoesNotExist:
-            raise ErrorResponse(status.HTTP_404_NOT_FOUND)
+            raise ImmediateResponse(status=status.HTTP_404_NOT_FOUND)
 
-        return self.model_instance
+        return Response(self.model_instance)
 
 
 class CreateModelMixin(ModelMixin):
@@ -591,10 +409,12 @@ class CreateModelMixin(ModelMixin):
                     data[m2m_data[fieldname][0]] = related_item
                     manager.through(**data).save()
 
-        headers = {}
+        response = Response(instance, status=status.HTTP_201_CREATED)
+
+        # Set headers
         if hasattr(instance, 'get_absolute_url'):
-            headers['Location'] = self.resource(self).url(instance)
+            response['Location'] = self.resource(self).url(instance)
-        return Response(status.HTTP_201_CREATED, instance, headers)
+        return response
 
 
 class UpdateModelMixin(ModelMixin):
@@ -615,7 +435,7 @@ class UpdateModelMixin(ModelMixin):
         except model.DoesNotExist:
             self.model_instance = model(**self.get_instance_data(model, self.CONTENT, *args, **kwargs))
         self.model_instance.save()
-        return self.model_instance
+        return Response(self.model_instance)
 
 
 class DeleteModelMixin(ModelMixin):
@@ -629,10 +449,10 @@ class DeleteModelMixin(ModelMixin):
         try:
             instance = self.get_instance(**query_kwargs)
         except model.DoesNotExist:
-            raise ErrorResponse(status.HTTP_404_NOT_FOUND, None, {})
+            raise ImmediateResponse(status=status.HTTP_404_NOT_FOUND)
 
         instance.delete()
-        return
+        return Response()
 
 
 class ListModelMixin(ModelMixin):
@@ -649,7 +469,7 @@ class ListModelMixin(ModelMixin):
         if ordering:
             queryset = queryset.order_by(*ordering)
 
-        return queryset
+        return Response(queryset)
 
 
 ########## Pagination Mixins ##########
@@ -728,7 +548,7 @@ class PaginatorMixin(object):
         """
 
         # We don't want to paginate responses for anything other than GET requests
-        if self.method.upper() != 'GET':
+        if self.request.method.upper() != 'GET':
             return self._resource.filter_response(obj)
 
         paginator = Paginator(obj, self.get_limit())
@@ -736,12 +556,14 @@ class PaginatorMixin(object):
         try:
             page_num = int(self.request.GET.get('page', '1'))
         except ValueError:
-            raise ErrorResponse(status.HTTP_404_NOT_FOUND,
+            raise ImmediateResponse(
-                                {'detail': 'That page contains no results'})
+                {'detail': 'That page contains no results'},
+                status=status.HTTP_404_NOT_FOUND)
 
         if page_num not in paginator.page_range:
-            raise ErrorResponse(status.HTTP_404_NOT_FOUND,
+            raise ImmediateResponse(
-                                {'detail': 'That page contains no results'})
+                {'detail': 'That page contains no results'},
+                status=status.HTTP_404_NOT_FOUND)
 
         page = paginator.page(page_num)
 

djangorestframework/parsers.py

@@ -17,7 +17,7 @@ from django.http.multipartparser import MultiPartParserError
 from django.utils import simplejson as json
 from djangorestframework import status
 from djangorestframework.compat import yaml
-from djangorestframework.response import ErrorResponse
+from djangorestframework.response import ImmediateResponse
 from djangorestframework.utils.mediatypes import media_type_matches
 from xml.etree import ElementTree as ET
 import datetime
@@ -43,7 +43,7 @@ class BaseParser(object):
 
     media_type = None
 
-    def __init__(self, view):
+    def __init__(self, view=None):
         """
         Initialize the parser with the ``View`` instance as state,
         in case the parser needs to access any metadata on the :obj:`View` object.
@@ -88,8 +88,9 @@ class JSONParser(BaseParser):
         try:
             return (json.load(stream), None)
         except ValueError, exc:
-            raise ErrorResponse(status.HTTP_400_BAD_REQUEST,
+            raise ImmediateResponse(
-                                {'detail': 'JSON parse error - %s' % unicode(exc)})
+                {'detail': 'JSON parse error - %s' % unicode(exc)},
+                status=status.HTTP_400_BAD_REQUEST)
 
 
 if yaml:
@@ -110,8 +111,9 @@ if yaml:
             try:
                 return (yaml.safe_load(stream), None)
             except ValueError, exc:
-                raise ErrorResponse(status.HTTP_400_BAD_REQUEST,
+                raise ImmediateResponse(
-                                    {'detail': 'YAML parse error - %s' % unicode(exc)})
+                    {'detail': 'YAML parse error - %s' % unicode(exc)},
+                    status=status.HTTP_400_BAD_REQUEST)
 else:
     YAMLParser = None
 
@@ -169,8 +171,9 @@ class MultiPartParser(BaseParser):
         try:
             django_parser = DjangoMultiPartParser(self.view.request.META, stream, upload_handlers)
         except MultiPartParserError, exc:
-            raise ErrorResponse(status.HTTP_400_BAD_REQUEST,
+            raise ImmediateResponse(
-                                {'detail': 'multipart parse error - %s' % unicode(exc)})
+                {'detail': 'multipart parse error - %s' % unicode(exc)},
+                status=status.HTTP_400_BAD_REQUEST)
         return django_parser.parse()
 
 

djangorestframework/permissions.py

@@ -6,7 +6,7 @@ class to your view by setting your View's :attr:`permissions` class attribute.
 
 from django.core.cache import cache
 from djangorestframework import status
-from djangorestframework.response import ErrorResponse
+from djangorestframework.response import ImmediateResponse
 import time
 
 __all__ = (
@@ -23,14 +23,14 @@ __all__ = (
 SAFE_METHODS = ['GET', 'HEAD', 'OPTIONS']
 
 
-_403_FORBIDDEN_RESPONSE = ErrorResponse(
+_403_FORBIDDEN_RESPONSE = ImmediateResponse(
-    status.HTTP_403_FORBIDDEN,
     {'detail': 'You do not have permission to access this resource. ' +
-               'You may need to login or otherwise authenticate the request.'})
+               'You may need to login or otherwise authenticate the request.'},
+    status=status.HTTP_403_FORBIDDEN)
 
-_503_SERVICE_UNAVAILABLE = ErrorResponse(
+_503_SERVICE_UNAVAILABLE = ImmediateResponse(
-    status.HTTP_503_SERVICE_UNAVAILABLE,
+    {'detail': 'request was throttled'},
-    {'detail': 'request was throttled'})
+    status=status.HTTP_503_SERVICE_UNAVAILABLE)
 
 
 class BasePermission(object):
@@ -45,7 +45,7 @@ class BasePermission(object):
 
     def check_permission(self, auth):
         """
-        Should simply return, or raise an :exc:`response.ErrorResponse`.
+        Should simply return, or raise an :exc:`response.ImmediateResponse`.
         """
         pass
 
@@ -164,7 +164,7 @@ class BaseThrottle(BasePermission):
     def check_permission(self, auth):
         """
         Check the throttling.
-        Return `None` or raise an :exc:`.ErrorResponse`.
+        Return `None` or raise an :exc:`.ImmediateResponse`.
         """
         num, period = getattr(self.view, self.attr_name, self.default).split('/')
         self.num_requests = int(num)
@@ -200,7 +200,7 @@ class BaseThrottle(BasePermission):
         self.history.insert(0, self.now)
         cache.set(self.key, self.history, self.duration)
         header = 'status=SUCCESS; next=%s sec' % self.next()
-        self.view.add_header('X-Throttle', header)
+        self.view.headers['X-Throttle'] = header
 
     def throttle_failure(self):
         """
@@ -208,7 +208,7 @@ class BaseThrottle(BasePermission):
         Raises a '503 service unavailable' response.
         """
         header = 'status=FAILURE; next=%s sec' % self.next()
-        self.view.add_header('X-Throttle', header)
+        self.view.headers['X-Throttle'] = header
         raise _503_SERVICE_UNAVAILABLE
 
     def next(self):

djangorestframework/renderers.py

@@ -13,7 +13,7 @@ from django.utils import simplejson as json
 
 
 from djangorestframework.compat import yaml
-from djangorestframework.utils import dict2xml, url_resolves
+from djangorestframework.utils import dict2xml, url_resolves, allowed_methods
 from djangorestframework.utils.breadcrumbs import get_breadcrumbs
 from djangorestframework.utils.mediatypes import get_media_type_params, add_media_type_param, media_type_matches
 from djangorestframework import VERSION
@@ -45,7 +45,7 @@ class BaseRenderer(object):
     media_type = None
     format = None
 
-    def __init__(self, view):
+    def __init__(self, view=None):
         self.view = view
 
     def can_handle_response(self, accept):
@@ -60,9 +60,13 @@ class BaseRenderer(object):
         This may be overridden to provide for other behavior, but typically you'll
         instead want to just set the :attr:`media_type` attribute on the class.
         """
-        format = self.view.kwargs.get(self._FORMAT_QUERY_PARAM, None)
+        # TODO: format overriding must go out of here
-        if format is None:
+        format = None
+        if self.view is not None:
+            format = self.view.kwargs.get(self._FORMAT_QUERY_PARAM, None)
+        if format is None and self.view is not None:
             format = self.view.request.GET.get(self._FORMAT_QUERY_PARAM, None)
+
         if format is not None:
             return format == self.format
         return media_type_matches(self.media_type, accept)
@@ -214,7 +218,8 @@ class DocumentingTemplateRenderer(BaseRenderer):
         """
 
         # Find the first valid renderer and render the content. (Don't use another documenting renderer.)
-        renderers = [renderer for renderer in view.renderers if not issubclass(renderer, DocumentingTemplateRenderer)]
+        renderers = [renderer for renderer in view.renderer_classes 
+                if not issubclass(renderer, DocumentingTemplateRenderer)]
         if not renderers:
             return '[No renderers were found]'
 
@@ -268,32 +273,32 @@ class DocumentingTemplateRenderer(BaseRenderer):
 
         # If we're not using content overloading there's no point in supplying a generic form,
         # as the view won't treat the form's value as the content of the request.
-        if not getattr(view, '_USE_FORM_OVERLOADING', False):
+        if not getattr(view.request, '_USE_FORM_OVERLOADING', False):
             return None
 
         # NB. http://jacobian.org/writing/dynamic-form-generation/
         class GenericContentForm(forms.Form):
-            def __init__(self, view):
+            def __init__(self, request):
                 """We don't know the names of the fields we want to set until the point the form is instantiated,
                 as they are determined by the Resource the form is being created against.
                 Add the fields dynamically."""
                 super(GenericContentForm, self).__init__()
 
-                contenttype_choices = [(media_type, media_type) for media_type in view._parsed_media_types]
+                contenttype_choices = [(media_type, media_type) for media_type in request._parsed_media_types]
-                initial_contenttype = view._default_parser.media_type
+                initial_contenttype = request._default_parser.media_type
 
-                self.fields[view._CONTENTTYPE_PARAM] = forms.ChoiceField(label='Content Type',
+                self.fields[request._CONTENTTYPE_PARAM] = forms.ChoiceField(label='Content Type',
                                                                          choices=contenttype_choices,
                                                                          initial=initial_contenttype)
-                self.fields[view._CONTENT_PARAM] = forms.CharField(label='Content',
+                self.fields[request._CONTENT_PARAM] = forms.CharField(label='Content',
                                                                    widget=forms.Textarea)
 
         # If either of these reserved parameters are turned off then content tunneling is not possible
-        if self.view._CONTENTTYPE_PARAM is None or self.view._CONTENT_PARAM is None:
+        if self.view.request._CONTENTTYPE_PARAM is None or self.view.request._CONTENT_PARAM is None:
             return None
 
         # Okey doke, let's do it
-        return GenericContentForm(view)
+        return GenericContentForm(view.request)
 
     def get_name(self):
         try:
@@ -344,13 +349,14 @@ class DocumentingTemplateRenderer(BaseRenderer):
             'name': name,
             'version': VERSION,
             'breadcrumblist': breadcrumb_list,
+            'allowed_methods': allowed_methods(self.view),
             'available_formats': self.view._rendered_formats,
             'put_form': put_form_instance,
             'post_form': post_form_instance,
             'login_url': login_url,
             'logout_url': logout_url,
             'FORMAT_PARAM': self._FORMAT_QUERY_PARAM,
-            'METHOD_PARAM': getattr(self.view, '_METHOD_PARAM', None),
+            'METHOD_PARAM': getattr(self.view.request, '_METHOD_PARAM', None),
             'ADMIN_MEDIA_PREFIX': getattr(settings, 'ADMIN_MEDIA_PREFIX', None),
         })
 
@@ -359,8 +365,8 @@ class DocumentingTemplateRenderer(BaseRenderer):
         # Munge DELETE Response code to allow us to return content
         # (Do this *after* we've rendered the template so that we include
         # the normal deletion response code in the output)
-        if self.view.response.status == 204:
+        if self.view.response.status_code == 204:
-            self.view.response.status = 200
+            self.view.response.status_code = 200
 
         return ret
 

djangorestframework/request.py

@@ -0,0 +1,205 @@
+"""
+The :mod:`request` module provides a :class:`Request` class used to wrap the standard `request`
+object received in all the views.
+
+The wrapped request then offers a richer API, in particular :
+
+    - content automatically parsed according to `Content-Type` header, and available as :meth:`.DATA<Request.DATA>`
+    - full support of PUT method, including support for file uploads
+    - form overloading of HTTP method, content type and content
+"""
+
+from django.http import HttpRequest
+
+from djangorestframework.response import ImmediateResponse
+from djangorestframework import status
+from djangorestframework.utils.mediatypes import is_form_media_type, order_by_precedence
+from djangorestframework.utils import as_tuple
+
+from StringIO import StringIO
+
+
+__all__ = ('Request',)
+
+
+class Request(object):
+    """
+    Wrapper allowing to enhance a standard `HttpRequest` instance.
+
+    Kwargs:
+        - request(HttpRequest). The original request instance.
+        - parsers(list/tuple). The parsers to use for parsing the request content.
+    """
+
+    _USE_FORM_OVERLOADING = True
+    _METHOD_PARAM = '_method'
+    _CONTENTTYPE_PARAM = '_content_type'
+    _CONTENT_PARAM = '_content'
+
+    def __init__(self, request=None, parsers=None):
+        self.request = request
+        if parsers is not None:
+            self.parsers = parsers
+
+    @property
+    def method(self):
+        """
+        Returns the HTTP method.
+
+        This allows the `method` to be overridden by using a hidden `form` field
+        on a form POST request.
+        """
+        if not hasattr(self, '_method'):
+            self._load_method_and_content_type()
+        return self._method
+
+    @property
+    def content_type(self):
+        """
+        Returns the content type header.
+
+        This should be used instead of ``request.META.get('HTTP_CONTENT_TYPE')``,
+        as it allows the content type to be overridden by using a hidden form
+        field on a form POST request.
+        """
+        if not hasattr(self, '_content_type'):
+            self._load_method_and_content_type()
+        return self._content_type
+
+    @property
+    def DATA(self):
+        """
+        Parses the request body and returns the data.
+
+        Similar to ``request.POST``, except that it handles arbitrary parsers,
+        and also works on methods other than POST (eg PUT).
+        """
+        if not hasattr(self, '_data'):
+            self._load_data_and_files()
+        return self._data
+
+    @property
+    def FILES(self):
+        """
+        Parses the request body and returns the files.
+        Similar to ``request.FILES``, except that it handles arbitrary parsers,
+        and also works on methods other than POST (eg PUT).
+        """
+        if not hasattr(self, '_files'):
+            self._load_data_and_files()
+        return self._files
+
+    def _load_data_and_files(self):
+        """
+        Parses the request content into self.DATA and self.FILES.
+        """
+        if not hasattr(self, '_content_type'):
+            self._load_method_and_content_type()
+
+        if not hasattr(self, '_data'):
+            (self._data, self._files) = self._parse(self._get_stream(), self._content_type)
+
+    def _load_method_and_content_type(self):
+        """
+        Sets the method and content_type, and then check if they've been overridden.
+        """
+        self._content_type = self.META.get('HTTP_CONTENT_TYPE', self.META.get('CONTENT_TYPE', ''))
+        self._perform_form_overloading()
+        # if the HTTP method was not overloaded, we take the raw HTTP method 
+        if not hasattr(self, '_method'):
+            self._method = self.request.method
+
+    def _get_stream(self):
+        """
+        Returns an object that may be used to stream the request content.
+        """
+
+        try:
+            content_length = int(self.META.get('CONTENT_LENGTH', self.META.get('HTTP_CONTENT_LENGTH')))
+        except (ValueError, TypeError):
+            content_length = 0
+
+        # TODO: Add 1.3's LimitedStream to compat and use that.
+        # NOTE: Currently only supports parsing request body as a stream with 1.3
+        if content_length == 0:
+            return None
+        elif hasattr(self, 'read'):
+            return self
+        return StringIO(self.raw_post_data)
+
+    def _perform_form_overloading(self):
+        """
+        If this is a form POST request, then we need to check if the method and content/content_type have been
+        overridden by setting them in hidden form fields or not.
+        """
+
+        # We only need to use form overloading on form POST requests.
+        if (not self._USE_FORM_OVERLOADING or self.request.method != 'POST'
+                                or not is_form_media_type(self._content_type)):
+            return
+
+        # At this point we're committed to parsing the request as form data.
+        self._data = data = self.POST.copy()
+        self._files = self.FILES
+
+        # Method overloading - change the method and remove the param from the content.
+        if self._METHOD_PARAM in data:
+            # NOTE: unlike `get`, `pop` on a `QueryDict` seems to return a list of values.
+            self._method = self._data.pop(self._METHOD_PARAM)[0].upper()
+
+        # Content overloading - modify the content type, and re-parse.
+        if self._CONTENT_PARAM in data and self._CONTENTTYPE_PARAM in data:
+            self._content_type = self._data.pop(self._CONTENTTYPE_PARAM)[0]
+            stream = StringIO(self._data.pop(self._CONTENT_PARAM)[0])
+            (self._data, self._files) = self._parse(stream, self._content_type)
+
+    def _parse(self, stream, content_type):
+        """
+        Parse the request content.
+
+        May raise a 415 ImmediateResponse (Unsupported Media Type), or a 400 ImmediateResponse (Bad Request).
+        """
+        if stream is None or content_type is None:
+            return (None, None)
+
+        for parser in as_tuple(self.parsers):
+            if parser.can_handle_request(content_type):
+                return parser.parse(stream)
+
+        raise ImmediateResponse({
+                  'error': 'Unsupported media type in request \'%s\'.' % content_type},
+                  status=status.HTTP_415_UNSUPPORTED_MEDIA_TYPE)
+
+    @property
+    def _parsed_media_types(self):
+        """
+        Return a list of all the media types that this view can parse.
+        """
+        return [parser.media_type for parser in self.parsers]
+
+    @property
+    def _default_parser(self):
+        """
+        Return the view's default parser class.
+        """
+        return self.parsers[0]
+
+    def _get_parsers(self):
+        if hasattr(self, '_parsers'):
+            return self._parsers
+        return ()
+
+    def _set_parsers(self, value):
+        self._parsers = value
+
+    parsers = property(_get_parsers, _set_parsers)
+
+    def __getattr__(self, name):
+        """
+        When an attribute is not present on the calling instance, try to get it
+        from the original request.
+        """
+        if hasattr(self.request, name):
+            return getattr(self.request, name)
+        else:
+            return super(Request, self).__getattribute__(name)

djangorestframework/resources.py

@@ -2,7 +2,7 @@ from django import forms
 from django.core.urlresolvers import reverse, get_urlconf, get_resolver, NoReverseMatch
 from django.db import models
 
-from djangorestframework.response import ErrorResponse
+from djangorestframework.response import ImmediateResponse
 from djangorestframework.serializer import Serializer, _SkipField
 from djangorestframework.utils import as_tuple
 
@@ -22,7 +22,7 @@ class BaseResource(Serializer):
     def validate_request(self, data, files=None):
         """
         Given the request content return the cleaned, validated content.
-        Typically raises a :exc:`response.ErrorResponse` with status code 400 (Bad Request) on failure.
+        Typically raises a :exc:`response.ImmediateResponse` with status code 400 (Bad Request) on failure.
         """
         return data
 
@@ -73,19 +73,19 @@ class FormResource(Resource):
     """
     Flag to check for unknown fields when validating a form. If set to false and
     we receive request data that is not expected by the form it raises an
-    :exc:`response.ErrorResponse` with status code 400. If set to true, only
+    :exc:`response.ImmediateResponse` with status code 400. If set to true, only
     expected fields are validated.
     """
 
     def validate_request(self, data, files=None):
         """
         Given some content as input return some cleaned, validated content.
-        Raises a :exc:`response.ErrorResponse` with status code 400 (Bad Request) on failure.
+        Raises a :exc:`response.ImmediateResponse` with status code 400 (Bad Request) on failure.
 
         Validation is standard form validation, with an additional constraint that *no extra unknown fields* may be supplied
         if :attr:`self.allow_unknown_form_fields` is ``False``.
 
-        On failure the :exc:`response.ErrorResponse` content is a dict which may contain :obj:`'errors'` and :obj:`'field-errors'` keys.
+        On failure the :exc:`response.ImmediateResponse` content is a dict which may contain :obj:`'errors'` and :obj:`'field-errors'` keys.
         If the :obj:`'errors'` key exists it is a list of strings of non-field errors.
         If the :obj:`'field-errors'` key exists it is a dict of ``{'field name as string': ['errors as strings', ...]}``.
         """
@@ -174,7 +174,7 @@ class FormResource(Resource):
                 detail[u'field_errors'] = field_errors
 
         # Return HTTP 400 response (BAD REQUEST)
-        raise ErrorResponse(400, detail)
+        raise ImmediateResponse(detail, status=400)
 
     def get_form_class(self, method=None):
         """
@@ -273,14 +273,14 @@ class ModelResource(FormResource):
     def validate_request(self, data, files=None):
         """
         Given some content as input return some cleaned, validated content.
-        Raises a :exc:`response.ErrorResponse` with status code 400 (Bad Request) on failure.
+        Raises a :exc:`response.ImmediateResponse` with status code 400 (Bad Request) on failure.
 
         Validation is standard form or model form validation,
         with an additional constraint that no extra unknown fields may be supplied,
         and that all fields specified by the fields class attribute must be supplied,
         even if they are not validated by the form/model form.
 
-        On failure the ErrorResponse content is a dict which may contain :obj:`'errors'` and :obj:`'field-errors'` keys.
+        On failure the ImmediateResponse content is a dict which may contain :obj:`'errors'` and :obj:`'field-errors'` keys.
         If the :obj:`'errors'` key exists it is a list of strings of non-field errors.
         If the ''field-errors'` key exists it is a dict of {field name as string: list of errors as strings}.
         """

djangorestframework/response.py

@@ -1,44 +1,176 @@
 """
-The :mod:`response` module provides Response classes you can use in your
+The :mod:`response` module provides :class:`Response` and :class:`ImmediateResponse` classes.
-views to return a certain HTTP response. Typically a response is *rendered*
+
-into a HTTP response depending on what renderers are set on your view and
+`Response` is a subclass of `HttpResponse`, and can be similarly instantiated and returned
-als depending on the accept header of the request.
+from any view. It is a bit smarter than Django's `HttpResponse`, for it renders automatically
+its content to a serial format by using a list of :mod:`renderers`.
+
+To determine the content type to which it must render, default behaviour is to use standard
+HTTP Accept header content negotiation. But `Response` also supports overriding the content type 
+by specifying an ``_accept=`` parameter in the URL. Also, `Response` will ignore `Accept` headers
+from Internet Explorer user agents and use a sensible browser `Accept` header instead.
+
+
+`ImmediateResponse` is an exception that inherits from `Response`. It can be used
+to abort the request handling (i.e. ``View.get``, ``View.put``, ...), 
+and immediately returning a response.
 """
 
+from django.template.response import SimpleTemplateResponse
 from django.core.handlers.wsgi import STATUS_CODE_TEXT
 
-__all__ = ('Response', 'ErrorResponse')
+from djangorestframework.utils.mediatypes import order_by_precedence
-
+from djangorestframework.utils import MSIE_USER_AGENT_REGEX
-# TODO: remove raw_content/cleaned_content and just use content?
+from djangorestframework import status
 
 
-class Response(object):
+__all__ = ('Response', 'ImmediateResponse')
+
+
+class Response(SimpleTemplateResponse):
     """
     An HttpResponse that may include content that hasn't yet been serialized.
+
+    Kwargs: 
+        - content(object). The raw content, not yet serialized. This must be simple Python \
+        data that renderers can handle (e.g.: `dict`, `str`, ...)
+        - renderers(list/tuple). The renderers to use for rendering the response content.
     """
 
-    def __init__(self, status=200, content=None, headers=None):
+    _ACCEPT_QUERY_PARAM = '_accept'        # Allow override of Accept header in URL query params
-        self.status = status
+    _IGNORE_IE_ACCEPT_HEADER = True
-        self.media_type = None
+
+    def __init__(self, content=None, status=None, request=None, renderers=None):
+        # First argument taken by `SimpleTemplateResponse.__init__` is template_name,
+        # which we don't need
+        super(Response, self).__init__(None, status=status)
+
+        # We need to store our content in raw content to avoid overriding HttpResponse's
+        # `content` property
+        self.raw_content = content 
         self.has_content_body = content is not None
-        self.raw_content = content      # content prior to filtering
+        self.request = request
-        self.cleaned_content = content  # content after filtering
+        if renderers is not None:
-        self.headers = headers or {}
+            self.renderers = renderers
+
+    @property
+    def rendered_content(self):
+        """
+        The final rendered content. Accessing this attribute triggers the complete rendering cycle : 
+        selecting suitable renderer, setting response's actual content type, rendering data.
+        """
+        renderer, media_type = self._determine_renderer()
+
+        # Set the media type of the response
+        self['Content-Type'] = renderer.media_type
+
+        # Render the response content
+        if self.has_content_body:
+            return renderer.render(self.raw_content, media_type)
+        return renderer.render()
 
     @property
     def status_text(self):
         """
-        Return reason text corresponding to our HTTP response status code.
+        Returns reason text corresponding to our HTTP response status code.
         Provided for convenience.
         """
-        return STATUS_CODE_TEXT.get(self.status, '')
+        return STATUS_CODE_TEXT.get(self.status_code, '')
+
+    def _determine_accept_list(self):
+        """
+        Returns a list of accepted media types. This list is determined from :
+        
+            1. overload with `_ACCEPT_QUERY_PARAM`
+            2. `Accept` header of the request 
+
+        If those are useless, a default value is returned instead.
+        """
+        request = self.request
+        if request is None:
+            return ['*/*']
+
+        if self._ACCEPT_QUERY_PARAM and request.GET.get(self._ACCEPT_QUERY_PARAM, None):
+            # Use _accept parameter override
+            return [request.GET.get(self._ACCEPT_QUERY_PARAM)]
+        elif (self._IGNORE_IE_ACCEPT_HEADER and
+              'HTTP_USER_AGENT' in request.META and
+              MSIE_USER_AGENT_REGEX.match(request.META['HTTP_USER_AGENT'])):
+            # Ignore MSIE's broken accept behavior and do something sensible instead
+            return ['text/html', '*/*']
+        elif 'HTTP_ACCEPT' in request.META:
+            # Use standard HTTP Accept negotiation
+            return [token.strip() for token in request.META['HTTP_ACCEPT'].split(',')]
+        else:
+            # No accept header specified
+            return ['*/*']
+
+    def _determine_renderer(self):
+        """
+        Determines the appropriate renderer for the output, given the list of accepted media types,
+        and the :attr:`renderers` set on this class.
+
+        Returns a 2-tuple of `(renderer, media_type)`
+
+        See: RFC 2616, Section 14 - http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+        """
+        # Check the acceptable media types against each renderer,
+        # attempting more specific media types first
+        # NB. The inner loop here isn't as bad as it first looks :)
+        #     Worst case is we're looping over len(accept_list) * len(self.renderers)
+        for media_type_list in order_by_precedence(self._determine_accept_list()):
+            for renderer in self.renderers:
+                for media_type in media_type_list:
+                    if renderer.can_handle_response(media_type):
+                        return renderer, media_type
+
+        # No acceptable renderers were found
+        raise ImmediateResponse({'detail': 'Could not satisfy the client\'s Accept header',
+                                 'available_types': self._rendered_media_types},
+                        status=status.HTTP_406_NOT_ACCEPTABLE,
+                        renderers=self.renderers)
+
+    def _get_renderers(self):
+        if hasattr(self, '_renderers'):
+            return self._renderers
+        return ()
+
+    def _set_renderers(self, value):
+        self._renderers = value
+
+    renderers = property(_get_renderers, _set_renderers)
+
+    @property
+    def _rendered_media_types(self):
+        """
+        Return an list of all the media types that this response can render.
+        """
+        return [renderer.media_type for renderer in self.renderers]
+
+    @property
+    def _rendered_formats(self):
+        """
+        Return a list of all the formats that this response can render.
+        """
+        return [renderer.format for renderer in self.renderers]
+
+    @property
+    def _default_renderer(self):
+        """
+        Return the response's default renderer class.
+        """
+        return self.renderers[0]
 
 
-class ErrorResponse(Exception):
+class ImmediateResponse(Response, Exception):
     """
-    An exception representing an Response that should be returned immediately.
+    A subclass of :class:`Response` used to abort the current request handling.
-    Any content should be serialized as-is, without being filtered.
     """
 
-    def __init__(self, status, content=None, headers={}):
+    def __str__(self):
-        self.response = Response(status, content=content, headers=headers)
+        """
+        Since this class is also an exception it has to provide a sensible
+        representation for the cases when it is treated as an exception.
+        """
+        return ('%s must be caught in try/except block, '
+                'and returned as a normal HttpResponse' % self.__class__.__name__)

djangorestframework/templates/renderer.html

@@ -29,7 +29,7 @@
 
     <div id="content" class="{% block coltype %}colM{% endblock %}">
 
-		{% if 'OPTIONS' in view.allowed_methods %}
+		{% if 'OPTIONS' in allowed_methods %}
 				<form action="{{ request.get_full_path }}" method="post">
 				    {% csrf_token %}
 					<input type="hidden" name="{{ METHOD_PARAM }}" value="OPTIONS" />
@@ -41,12 +41,12 @@
 	    <h1>{{ name }}</h1>
 	    <p>{{ description }}</p>
 	    <div class='module'>
-	    <pre><b>{{ response.status }} {{ response.status_text }}</b>{% autoescape off %}
+	    <pre><b>{{ response.status_code }} {{ response.status_text }}</b>{% autoescape off %}
-{% for key, val in response.headers.items %}<b>{{ key }}:</b> {{ val|urlize_quoted_links }}
+{% for key, val in response.items %}<b>{{ key }}:</b> {{ val|urlize_quoted_links }}
 {% endfor %}
 {{ content|urlize_quoted_links }}</pre>{% endautoescape %}</div>
 
-	{% if 'GET' in view.allowed_methods %}
+	{% if 'GET' in allowed_methods %}
 			<form>
 				<fieldset class='module aligned'>
 				<h2>GET {{ name }}</h2>
@@ -63,9 +63,9 @@
 	{% endif %}
 
 	{# Only display the POST/PUT/DELETE forms if method tunneling via POST forms is enabled and the user has permissions on this view. #}
-	{% if METHOD_PARAM and response.status != 403 %}
+	{% if METHOD_PARAM and response.status_code != 403 %}
 
-		{% if 'POST' in view.allowed_methods %}
+		{% if 'POST' in allowed_methods %}
 				<form action="{{ request.get_full_path }}" method="post" {% if post_form.is_multipart %}enctype="multipart/form-data"{% endif %}>
 				<fieldset class='module aligned'>
 					<h2>POST {{ name }}</h2>
@@ -86,7 +86,7 @@
 				</form>
 		{% endif %}
 
-		{% if 'PUT' in view.allowed_methods %}
+		{% if 'PUT' in allowed_methods %}
 				<form action="{{ request.get_full_path }}" method="post" {% if put_form.is_multipart %}enctype="multipart/form-data"{% endif %}>
 				<fieldset class='module aligned'>
 					<h2>PUT {{ name }}</h2>
@@ -108,7 +108,7 @@
 				</form>
 		{% endif %}
 
-		{% if 'DELETE' in view.allowed_methods %}
+		{% if 'DELETE' in allowed_methods %}
 				<form action="{{ request.get_full_path }}" method="post">
 				<fieldset class='module aligned'>
 					<h2>DELETE {{ name }}</h2>

djangorestframework/tests/accept.py

@@ -1,6 +1,8 @@
 from django.test import TestCase
+
 from djangorestframework.compat import RequestFactory
 from djangorestframework.views import View
+from djangorestframework.response import Response
 
 
 # See: http://www.useragentstring.com/
@@ -21,9 +23,10 @@ class UserAgentMungingTest(TestCase):
 
         class MockView(View):
             permissions = ()
+            response_class = Response
 
             def get(self, request):
-                return {'a':1, 'b':2, 'c':3}
+                return self.response_class({'a':1, 'b':2, 'c':3})
 
         self.req = RequestFactory()
         self.MockView = MockView
@@ -37,18 +40,22 @@ class UserAgentMungingTest(TestCase):
                            MSIE_7_USER_AGENT):
             req = self.req.get('/', HTTP_ACCEPT='*/*', HTTP_USER_AGENT=user_agent)
             resp = self.view(req)
+            resp.render()
             self.assertEqual(resp['Content-Type'], 'text/html')
-
+    
     def test_dont_rewrite_msie_accept_header(self):
         """Turn off _IGNORE_IE_ACCEPT_HEADER, send MSIE user agent strings and ensure
         that we get a JSON response if we set a */* accept header."""
-        view = self.MockView.as_view(_IGNORE_IE_ACCEPT_HEADER=False)
+        class IgnoreIEAcceptResponse(Response):
+            _IGNORE_IE_ACCEPT_HEADER=False
+        view = self.MockView.as_view(response_class=IgnoreIEAcceptResponse)
 
         for user_agent in (MSIE_9_USER_AGENT,
                            MSIE_8_USER_AGENT,
                            MSIE_7_USER_AGENT):
             req = self.req.get('/', HTTP_ACCEPT='*/*', HTTP_USER_AGENT=user_agent)
             resp = view(req)
+            resp.render()
             self.assertEqual(resp['Content-Type'], 'application/json')
 
     def test_dont_munge_nice_browsers_accept_header(self):
@@ -61,5 +68,6 @@ class UserAgentMungingTest(TestCase):
                            OPERA_11_0_OPERA_USER_AGENT):
             req = self.req.get('/', HTTP_ACCEPT='*/*', HTTP_USER_AGENT=user_agent)
             resp = self.view(req)
+            resp.render()
             self.assertEqual(resp['Content-Type'], 'application/json')
 

djangorestframework/tests/authentication.py

@@ -3,6 +3,7 @@ from django.contrib.auth.models import User
 from django.test import Client, TestCase
 
 from django.utils import simplejson as json
+from django.http import HttpResponse
 
 from djangorestframework.views import View
 from djangorestframework import permissions
@@ -14,10 +15,10 @@ class MockView(View):
     permissions = (permissions.IsAuthenticated,)
 
     def post(self, request):
-        return {'a': 1, 'b': 2, 'c': 3}
+        return HttpResponse({'a': 1, 'b': 2, 'c': 3})
 
     def put(self, request):
-        return {'a': 1, 'b': 2, 'c': 3}
+        return HttpResponse({'a': 1, 'b': 2, 'c': 3})
 
 urlpatterns = patterns('',
     (r'^$', MockView.as_view()),

djangorestframework/tests/content.py

@@ -1,233 +0,0 @@
-"""
-Tests for content parsing, and form-overloaded content parsing.
-"""
-from django.conf.urls.defaults import patterns
-from django.contrib.auth.models import User
-from django.test import TestCase, Client
-from djangorestframework import status
-from djangorestframework.authentication import UserLoggedInAuthentication
-from djangorestframework.compat import RequestFactory, unittest
-from djangorestframework.mixins import RequestMixin
-from djangorestframework.parsers import FormParser, MultiPartParser, \
-    PlainTextParser, JSONParser
-from djangorestframework.response import Response
-from djangorestframework.views import View
-
-class MockView(View):
-    authentication = (UserLoggedInAuthentication,)
-    def post(self, request):
-        if request.POST.get('example') is not None:
-            return Response(status.HTTP_200_OK)
-
-        return Response(status.INTERNAL_SERVER_ERROR)
-
-urlpatterns = patterns('',
-    (r'^$', MockView.as_view()),
-)
-
-class TestContentParsing(TestCase):
-    def setUp(self):
-        self.req = RequestFactory()
-
-    def ensure_determines_no_content_GET(self, view):
-        """Ensure view.DATA returns None for GET request with no content."""
-        view.request = self.req.get('/')
-        self.assertEqual(view.DATA, None)
-
-    def ensure_determines_no_content_HEAD(self, view):
-        """Ensure view.DATA returns None for HEAD request."""
-        view.request = self.req.head('/')
-        self.assertEqual(view.DATA, None)
-
-    def ensure_determines_form_content_POST(self, view):
-        """Ensure view.DATA returns content for POST request with form content."""
-        form_data = {'qwerty': 'uiop'}
-        view.parsers = (FormParser, MultiPartParser)
-        view.request = self.req.post('/', data=form_data)
-        self.assertEqual(view.DATA.items(), form_data.items())
-
-    def ensure_determines_non_form_content_POST(self, view):
-        """Ensure view.RAW_CONTENT returns content for POST request with non-form content."""
-        content = 'qwerty'
-        content_type = 'text/plain'
-        view.parsers = (PlainTextParser,)
-        view.request = self.req.post('/', content, content_type=content_type)
-        self.assertEqual(view.DATA, content)
-
-    def ensure_determines_form_content_PUT(self, view):
-        """Ensure view.RAW_CONTENT returns content for PUT request with form content."""
-        form_data = {'qwerty': 'uiop'}
-        view.parsers = (FormParser, MultiPartParser)
-        view.request = self.req.put('/', data=form_data)
-        self.assertEqual(view.DATA.items(), form_data.items())
-
-    def ensure_determines_non_form_content_PUT(self, view):
-        """Ensure view.RAW_CONTENT returns content for PUT request with non-form content."""
-        content = 'qwerty'
-        content_type = 'text/plain'
-        view.parsers = (PlainTextParser,)
-        view.request = self.req.post('/', content, content_type=content_type)
-        self.assertEqual(view.DATA, content)
-
-    def test_standard_behaviour_determines_no_content_GET(self):
-        """Ensure view.DATA returns None for GET request with no content."""
-        self.ensure_determines_no_content_GET(RequestMixin())
-
-    def test_standard_behaviour_determines_no_content_HEAD(self):
-        """Ensure view.DATA returns None for HEAD request."""
-        self.ensure_determines_no_content_HEAD(RequestMixin())
-
-    def test_standard_behaviour_determines_form_content_POST(self):
-        """Ensure view.DATA returns content for POST request with form content."""
-        self.ensure_determines_form_content_POST(RequestMixin())
-
-    def test_standard_behaviour_determines_non_form_content_POST(self):
-        """Ensure view.DATA returns content for POST request with non-form content."""
-        self.ensure_determines_non_form_content_POST(RequestMixin())
-
-    def test_standard_behaviour_determines_form_content_PUT(self):
-        """Ensure view.DATA returns content for PUT request with form content."""
-        self.ensure_determines_form_content_PUT(RequestMixin())
-
-    def test_standard_behaviour_determines_non_form_content_PUT(self):
-        """Ensure view.DATA returns content for PUT request with non-form content."""
-        self.ensure_determines_non_form_content_PUT(RequestMixin())
-
-    def test_overloaded_behaviour_allows_content_tunnelling(self):
-        """Ensure request.DATA returns content for overloaded POST request"""
-        content = 'qwerty'
-        content_type = 'text/plain'
-        view = RequestMixin()
-        form_data = {view._CONTENT_PARAM: content,
-                     view._CONTENTTYPE_PARAM: content_type}
-        view.request = self.req.post('/', form_data)
-        view.parsers = (PlainTextParser,)
-        self.assertEqual(view.DATA, content)
-
-    def test_accessing_post_after_data_form(self):
-        """Ensures request.POST can be accessed after request.DATA in form request"""
-        form_data = {'qwerty': 'uiop'}
-        view = RequestMixin()
-        view.parsers = (FormParser, MultiPartParser)
-        view.request = self.req.post('/', data=form_data)
-
-        self.assertEqual(view.DATA.items(), form_data.items())
-        self.assertEqual(view.request.POST.items(), form_data.items())
-
-    @unittest.skip('This test was disabled some time ago for some reason')
-    def test_accessing_post_after_data_for_json(self):
-        """Ensures request.POST can be accessed after request.DATA in json request"""
-        from django.utils import simplejson as json
-
-        data = {'qwerty': 'uiop'}
-        content = json.dumps(data)
-        content_type = 'application/json'
-
-        view = RequestMixin()
-        view.parsers = (JSONParser,)
-
-        view.request = self.req.post('/', content, content_type=content_type)
-
-        self.assertEqual(view.DATA.items(), data.items())
-        self.assertEqual(view.request.POST.items(), [])
-
-    def test_accessing_post_after_data_for_overloaded_json(self):
-        """Ensures request.POST can be accessed after request.DATA in overloaded json request"""
-        from django.utils import simplejson as json
-
-        data = {'qwerty': 'uiop'}
-        content = json.dumps(data)
-        content_type = 'application/json'
-
-        view = RequestMixin()
-        view.parsers = (JSONParser,)
-
-        form_data = {view._CONTENT_PARAM: content,
-                     view._CONTENTTYPE_PARAM: content_type}
-
-        view.request = self.req.post('/', data=form_data)
-
-        self.assertEqual(view.DATA.items(), data.items())
-        self.assertEqual(view.request.POST.items(), form_data.items())
-
-    def test_accessing_data_after_post_form(self):
-        """Ensures request.DATA can be accessed after request.POST in form request"""
-        form_data = {'qwerty': 'uiop'}
-        view = RequestMixin()
-        view.parsers = (FormParser, MultiPartParser)
-        view.request = self.req.post('/', data=form_data)
-
-        self.assertEqual(view.request.POST.items(), form_data.items())
-        self.assertEqual(view.DATA.items(), form_data.items())
-
-    def test_accessing_data_after_post_for_json(self):
-        """Ensures request.DATA can be accessed after request.POST in json request"""
-        from django.utils import simplejson as json
-
-        data = {'qwerty': 'uiop'}
-        content = json.dumps(data)
-        content_type = 'application/json'
-
-        view = RequestMixin()
-        view.parsers = (JSONParser,)
-
-        view.request = self.req.post('/', content, content_type=content_type)
-
-        post_items = view.request.POST.items()
-
-        self.assertEqual(len(post_items), 1)
-        self.assertEqual(len(post_items[0]), 2)
-        self.assertEqual(post_items[0][0], content)
-        self.assertEqual(view.DATA.items(), data.items())
-
-    def test_accessing_data_after_post_for_overloaded_json(self):
-        """Ensures request.DATA can be accessed after request.POST in overloaded json request"""
-        from django.utils import simplejson as json
-
-        data = {'qwerty': 'uiop'}
-        content = json.dumps(data)
-        content_type = 'application/json'
-
-        view = RequestMixin()
-        view.parsers = (JSONParser,)
-
-        form_data = {view._CONTENT_PARAM: content,
-                     view._CONTENTTYPE_PARAM: content_type}
-
-        view.request = self.req.post('/', data=form_data)
-
-        self.assertEqual(view.request.POST.items(), form_data.items())
-        self.assertEqual(view.DATA.items(), data.items())
-
-class TestContentParsingWithAuthentication(TestCase):
-    urls = 'djangorestframework.tests.content'
-
-    def setUp(self):
-        self.csrf_client = Client(enforce_csrf_checks=True)
-        self.username = 'john'
-        self.email = 'lennon@thebeatles.com'
-        self.password = 'password'
-        self.user = User.objects.create_user(self.username, self.email, self.password)
-        self.req = RequestFactory()
-
-    def test_user_logged_in_authentication_has_post_when_not_logged_in(self):
-        """Ensures request.POST exists after UserLoggedInAuthentication when user doesn't log in"""
-        content = {'example': 'example'}
-
-        response = self.client.post('/', content)
-        self.assertEqual(status.HTTP_200_OK, response.status_code, "POST data is malformed")
-
-        response = self.csrf_client.post('/', content)
-        self.assertEqual(status.HTTP_200_OK, response.status_code, "POST data is malformed")
-
-    # def test_user_logged_in_authentication_has_post_when_logged_in(self):
-    #     """Ensures request.POST exists after UserLoggedInAuthentication when user does log in"""
-    #     self.client.login(username='john', password='password')
-    #     self.csrf_client.login(username='john', password='password')
-    #     content = {'example': 'example'}
-
-    #     response = self.client.post('/', content)
-    #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")
-
-    #     response = self.csrf_client.post('/', content)
-    #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")

djangorestframework/tests/files.py

@@ -1,8 +1,11 @@
 from django.test import TestCase
 from django import forms
+
 from djangorestframework.compat import RequestFactory
 from djangorestframework.views import View
 from djangorestframework.resources import FormResource
+from djangorestframework.response import Response
+
 import StringIO
 
 class UploadFilesTests(TestCase):
@@ -20,13 +23,13 @@ class UploadFilesTests(TestCase):
             form = FileForm
 
             def post(self, request, *args, **kwargs):
-                return {'FILE_NAME': self.CONTENT['file'].name,
+                return Response({'FILE_NAME': self.CONTENT['file'].name,
-                        'FILE_CONTENT': self.CONTENT['file'].read()}
+                        'FILE_CONTENT': self.CONTENT['file'].read()})
 
         file = StringIO.StringIO('stuff')
         file.name = 'stuff.txt'
         request = self.factory.post('/', {'file': file})
         view = MockView.as_view()
         response = view(request)
-        self.assertEquals(response.content, '{"FILE_CONTENT": "stuff", "FILE_NAME": "stuff.txt"}')
+        self.assertEquals(response.raw_content, {"FILE_CONTENT": "stuff", "FILE_NAME": "stuff.txt"})
 

djangorestframework/tests/methods.py

@@ -1,32 +0,0 @@
-from django.test import TestCase
-from djangorestframework.compat import RequestFactory
-from djangorestframework.mixins import RequestMixin
-
-
-class TestMethodOverloading(TestCase):
-    def setUp(self):
-        self.req = RequestFactory()
-
-    def test_standard_behaviour_determines_GET(self):
-        """GET requests identified"""
-        view = RequestMixin()
-        view.request = self.req.get('/')
-        self.assertEqual(view.method, 'GET')
-
-    def test_standard_behaviour_determines_POST(self):
-        """POST requests identified"""
-        view = RequestMixin()
-        view.request = self.req.post('/')
-        self.assertEqual(view.method, 'POST')
-
-    def test_overloaded_POST_behaviour_determines_overloaded_method(self):
-        """POST requests can be overloaded to another method by setting a reserved form field"""
-        view = RequestMixin()
-        view.request = self.req.post('/', {view._METHOD_PARAM: 'DELETE'})
-        self.assertEqual(view.method, 'DELETE')
-
-    def test_HEAD_is_a_valid_method(self):
-        """HEAD requests identified"""
-        view = RequestMixin()
-        view.request = self.req.head('/')
-        self.assertEqual(view.method, 'HEAD')

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
@@ -31,7 +31,7 @@ class TestModelRead(TestModelsTestCase):
         mixin.resource = GroupResource
 
         response = mixin.get(request, id=group.id)
-        self.assertEquals(group.name, response.name)
+        self.assertEquals(group.name, response.raw_content.name)
 
     def test_read_404(self):
         class GroupResource(ModelResource):
@@ -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):
@@ -65,7 +65,7 @@ class TestModelCreation(TestModelsTestCase):
 
         response = mixin.post(request)
         self.assertEquals(1, Group.objects.count())
-        self.assertEquals('foo', response.cleaned_content.name)
+        self.assertEquals('foo', response.raw_content.name)
 
     def test_creation_with_m2m_relation(self):
         class UserResource(ModelResource):
@@ -91,8 +91,8 @@ class TestModelCreation(TestModelsTestCase):
 
         response = mixin.post(request)
         self.assertEquals(1, User.objects.count())
-        self.assertEquals(1, response.cleaned_content.groups.count())
+        self.assertEquals(1, response.raw_content.groups.count())
-        self.assertEquals('foo', response.cleaned_content.groups.all()[0].name)
+        self.assertEquals('foo', response.raw_content.groups.all()[0].name)
 
     def test_creation_with_m2m_relation_through(self):
         """
@@ -114,7 +114,7 @@ class TestModelCreation(TestModelsTestCase):
 
         response = mixin.post(request)
         self.assertEquals(1, CustomUser.objects.count())
-        self.assertEquals(0, response.cleaned_content.groups.count())
+        self.assertEquals(0, response.raw_content.groups.count())
 
         group = Group(name='foo1')
         group.save()
@@ -129,8 +129,8 @@ class TestModelCreation(TestModelsTestCase):
 
         response = mixin.post(request)
         self.assertEquals(2, CustomUser.objects.count())
-        self.assertEquals(1, response.cleaned_content.groups.count())
+        self.assertEquals(1, response.raw_content.groups.count())
-        self.assertEquals('foo1', response.cleaned_content.groups.all()[0].name)
+        self.assertEquals('foo1', response.raw_content.groups.all()[0].name)
 
         group2 = Group(name='foo2')
         group2.save()
@@ -145,19 +145,19 @@ class TestModelCreation(TestModelsTestCase):
 
         response = mixin.post(request)
         self.assertEquals(3, CustomUser.objects.count())
-        self.assertEquals(2, response.cleaned_content.groups.count())
+        self.assertEquals(2, response.raw_content.groups.count())
-        self.assertEquals('foo1', response.cleaned_content.groups.all()[0].name)
+        self.assertEquals('foo1', response.raw_content.groups.all()[0].name)
-        self.assertEquals('foo2', response.cleaned_content.groups.all()[1].name)
+        self.assertEquals('foo2', response.raw_content.groups.all()[1].name)
 
 
 class MockPaginatorView(PaginatorMixin, View):
     total = 60
 
     def get(self, request):
-        return range(0, self.total)
+        return Response(range(0, self.total))
 
     def post(self, request):
-        return Response(status.HTTP_201_CREATED, {'status': 'OK'})
+        return Response({'status': 'OK'}, status=status.HTTP_201_CREATED)
 
 
 class TestPagination(TestCase):
@@ -168,8 +168,7 @@ class TestPagination(TestCase):
         """ Tests if pagination works without overwriting the limit """
         request = self.req.get('/paginator')
         response = MockPaginatorView.as_view()(request)
-
+        content = response.raw_content
-        content = json.loads(response.content)
 
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(MockPaginatorView.total, content['total'])
@@ -183,8 +182,7 @@ class TestPagination(TestCase):
 
         request = self.req.get('/paginator')
         response = MockPaginatorView.as_view(limit=limit)(request)
-
+        content = response.raw_content
-        content = json.loads(response.content)
 
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(content['per_page'], limit)
@@ -200,8 +198,7 @@ class TestPagination(TestCase):
 
         request = self.req.get('/paginator/?limit=%d' % limit)
         response = MockPaginatorView.as_view()(request)
-
+        content = response.raw_content
-        content = json.loads(response.content)
 
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(MockPaginatorView.total, content['total'])
@@ -217,8 +214,7 @@ class TestPagination(TestCase):
 
         request = self.req.get('/paginator/?limit=%d' % limit)
         response = MockPaginatorView.as_view()(request)
-
+        content = response.raw_content
-        content = json.loads(response.content)
 
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(MockPaginatorView.total, content['total'])
@@ -230,8 +226,7 @@ class TestPagination(TestCase):
         """ Pagination should only work for GET requests """
         request = self.req.post('/paginator', data={'content': 'spam'})
         response = MockPaginatorView.as_view()(request)
-
+        content = response.raw_content
-        content = json.loads(response.content)
 
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
         self.assertEqual(None, content.get('per_page'))
@@ -248,12 +243,12 @@ class TestPagination(TestCase):
         """ Tests that the page range is handle correctly """
         request = self.req.get('/paginator/?page=0')
         response = MockPaginatorView.as_view()(request)
-        content = json.loads(response.content)
+        content = response.raw_content
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
 
         request = self.req.get('/paginator/')
         response = MockPaginatorView.as_view()(request)
-        content = json.loads(response.content)
+        content = response.raw_content
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(range(0, MockPaginatorView.limit), content['results'])
 
@@ -261,13 +256,13 @@ class TestPagination(TestCase):
 
         request = self.req.get('/paginator/?page=%d' % num_pages)
         response = MockPaginatorView.as_view()(request)
-        content = json.loads(response.content)
+        content = response.raw_content
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertEqual(range(MockPaginatorView.limit*(num_pages-1), MockPaginatorView.total), content['results'])
 
         request = self.req.get('/paginator/?page=%d' % (num_pages + 1,))
         response = MockPaginatorView.as_view()(request)
-        content = json.loads(response.content)
+        content = response.raw_content
         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)
 
     def test_existing_query_parameters_are_preserved(self):
@@ -275,7 +270,7 @@ class TestPagination(TestCase):
         generating next/previous page links """
         request = self.req.get('/paginator/?foo=bar&another=something')
         response = MockPaginatorView.as_view()(request)
-        content = json.loads(response.content)
+        content = response.raw_content
         self.assertEqual(response.status_code, status.HTTP_200_OK)
         self.assertTrue('foo=bar' in content['next'])
         self.assertTrue('another=something' in content['next'])

djangorestframework/tests/renderers.py

@@ -1,177 +1,20 @@
 import re
 
+from django.test import TestCase
+
 from django.conf.urls.defaults import patterns, url
 from django.test import TestCase
 
-from djangorestframework import status
+from djangorestframework.response import Response
 from djangorestframework.views import View
-from djangorestframework.compat import View as DjangoView
 from djangorestframework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer, \
     XMLRenderer, JSONPRenderer, DocumentingHTMLRenderer
 from djangorestframework.parsers import JSONParser, YAMLParser, XMLParser
-from djangorestframework.mixins import ResponseMixin
-from djangorestframework.response import Response
 
 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()),
-)
-
-
-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):
-        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}'
@@ -223,6 +66,18 @@ class JSONRendererTests(TestCase):
         self.assertEquals(obj, data)
 
 
+class MockGETView(View):
+
+    def get(self, request, **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])),
+)
+
+
 class JSONPRendererTests(TestCase):
     """
     Tests specific to the JSONP Renderer
@@ -391,21 +246,3 @@ class XMLRendererTestCase(TestCase):
         self.assertTrue(xml.endswith('</root>'))
         self.assertTrue(string in xml, '%r not in %r' % (string, xml))
 
-
-class Issue122Tests(TestCase):
-    """
-    Tests that covers #122.
-    """
-    urls = 'djangorestframework.tests.renderers'
-
-    def test_only_html_renderer(self):
-        """
-        Test if no infinite recursion occurs.
-        """
-        resp = self.client.get('/html')
-        
-    def test_html_renderer_is_first(self):
-        """
-        Test if no infinite recursion occurs.
-        """
-        resp = self.client.get('/html1')

djangorestframework/tests/request.py

@@ -0,0 +1,248 @@
+"""
+Tests for content parsing, and form-overloaded content parsing.
+"""
+from django.conf.urls.defaults import patterns
+from django.contrib.auth.models import User
+from django.test import TestCase, Client
+from djangorestframework import status
+from djangorestframework.authentication import UserLoggedInAuthentication
+from djangorestframework.compat import RequestFactory
+from djangorestframework.mixins import RequestMixin
+from djangorestframework.parsers import FormParser, MultiPartParser, \
+    PlainTextParser, JSONParser
+from djangorestframework.request import Request
+from djangorestframework.response import Response
+from djangorestframework.request import Request
+from djangorestframework.views import View
+
+
+class RequestTestCase(TestCase):
+
+    def build_request(self, method, *args, **kwargs):
+        factory = RequestFactory()
+        method = getattr(factory, method)
+        original_request = method(*args, **kwargs)
+        return Request(original_request)
+
+
+class TestMethodOverloading(RequestTestCase):
+
+    def test_standard_behaviour_determines_GET(self):
+        """GET requests identified"""
+        request = self.build_request('get', '/')
+        self.assertEqual(request.method, 'GET')
+
+    def test_standard_behaviour_determines_POST(self):
+        """POST requests identified"""
+        request = self.build_request('post', '/')
+        self.assertEqual(request.method, 'POST')
+
+    def test_overloaded_POST_behaviour_determines_overloaded_method(self):
+        """POST requests can be overloaded to another method by setting a reserved form field"""
+        request = self.build_request('post', '/', {Request._METHOD_PARAM: 'DELETE'})
+        self.assertEqual(request.method, 'DELETE')
+
+    def test_HEAD_is_a_valid_method(self):
+        """HEAD requests identified"""
+        request = request = self.build_request('head', '/')
+        self.assertEqual(request.method, 'HEAD')
+
+
+class TestContentParsing(RequestTestCase):
+
+    def build_request(self, method, *args, **kwargs):
+        factory = RequestFactory()
+        parsers = kwargs.pop('parsers', None)
+        method = getattr(factory, method)
+        original_request = method(*args, **kwargs)
+        rkwargs = {}
+        if parsers is not None:
+            rkwargs['parsers'] = parsers
+        request = Request(original_request, **rkwargs)
+        # TODO: Just a hack because the parsers need a view. This will be fixed in the future
+        class Obj(object): pass
+        obj = Obj()
+        obj.request = request
+        for p in request.parsers:
+            p.view = obj
+        return request
+    
+    def test_standard_behaviour_determines_no_content_GET(self):
+        """Ensure request.DATA returns None for GET request with no content."""
+        request = self.build_request('get', '/')
+        self.assertEqual(request.DATA, None)
+
+    def test_standard_behaviour_determines_no_content_HEAD(self):
+        """Ensure request.DATA returns None for HEAD request."""
+        request = self.build_request('head', '/')
+        self.assertEqual(request.DATA, None)
+
+    def test_standard_behaviour_determines_form_content_POST(self):
+        """Ensure request.DATA returns content for POST request with form content."""
+        form_data = {'qwerty': 'uiop'}
+        parsers = (FormParser(), MultiPartParser())
+
+        request = self.build_request('post', '/', data=form_data, parsers=parsers)
+        self.assertEqual(request.DATA.items(), form_data.items())
+
+    def test_standard_behaviour_determines_non_form_content_POST(self):
+        """Ensure request.DATA returns content for POST request with non-form content."""
+        content = 'qwerty'
+        content_type = 'text/plain'
+        parsers = (PlainTextParser(),)
+
+        request = self.build_request('post', '/', content, content_type=content_type, parsers=parsers)
+        self.assertEqual(request.DATA, content)
+
+    def test_standard_behaviour_determines_form_content_PUT(self):
+        """Ensure request.DATA returns content for PUT request with form content."""
+        form_data = {'qwerty': 'uiop'}
+        parsers = (FormParser(), MultiPartParser())
+
+        request = self.build_request('put', '/', data=form_data, parsers=parsers)
+        self.assertEqual(request.DATA.items(), form_data.items())
+
+    def test_standard_behaviour_determines_non_form_content_PUT(self):
+        """Ensure request.DATA returns content for PUT request with non-form content."""
+        content = 'qwerty'
+        content_type = 'text/plain'
+        parsers = (PlainTextParser(),)
+
+        request = self.build_request('put', '/', content, content_type=content_type, parsers=parsers)
+        self.assertEqual(request.DATA, content)
+
+    def test_overloaded_behaviour_allows_content_tunnelling(self):
+        """Ensure request.DATA returns content for overloaded POST request"""
+        content = 'qwerty'
+        content_type = 'text/plain'
+        form_data = {Request._CONTENT_PARAM: content,
+                     Request._CONTENTTYPE_PARAM: content_type}
+        parsers = (PlainTextParser(),)
+
+        request = self.build_request('post', '/', form_data, parsers=parsers)
+        self.assertEqual(request.DATA, content)
+
+    def test_accessing_post_after_data_form(self):
+        """Ensures request.POST can be accessed after request.DATA in form request"""
+        form_data = {'qwerty': 'uiop'}
+        parsers = (FormParser(), MultiPartParser())
+
+        request = self.build_request('post', '/', data=form_data)
+        self.assertEqual(request.DATA.items(), form_data.items())
+        self.assertEqual(request.POST.items(), form_data.items())
+
+    def test_accessing_post_after_data_for_json(self):
+        """Ensures request.POST can be accessed after request.DATA in json request"""
+        from django.utils import simplejson as json
+
+        data = {'qwerty': 'uiop'}
+        content = json.dumps(data)
+        content_type = 'application/json'
+        parsers = (JSONParser(),)
+
+        request = self.build_request('post', '/', content, content_type=content_type, parsers=parsers)
+        self.assertEqual(request.DATA.items(), data.items())
+        self.assertEqual(request.POST.items(), [])
+
+    def test_accessing_post_after_data_for_overloaded_json(self):
+        """Ensures request.POST can be accessed after request.DATA in overloaded json request"""
+        from django.utils import simplejson as json
+
+        data = {'qwerty': 'uiop'}
+        content = json.dumps(data)
+        content_type = 'application/json'
+        parsers = (JSONParser(),)
+        form_data = {Request._CONTENT_PARAM: content,
+                     Request._CONTENTTYPE_PARAM: content_type}
+
+        request = self.build_request('post', '/', data=form_data, parsers=parsers)
+        self.assertEqual(request.DATA.items(), data.items())
+        self.assertEqual(request.POST.items(), form_data.items())
+
+    def test_accessing_data_after_post_form(self):
+        """Ensures request.DATA can be accessed after request.POST in form request"""
+        form_data = {'qwerty': 'uiop'}
+        parsers = (FormParser, MultiPartParser)
+        request = self.build_request('post', '/', data=form_data, parsers=parsers)
+
+        self.assertEqual(request.POST.items(), form_data.items())
+        self.assertEqual(request.DATA.items(), form_data.items())
+
+    def test_accessing_data_after_post_for_json(self):
+        """Ensures request.DATA can be accessed after request.POST in json request"""
+        from django.utils import simplejson as json
+
+        data = {'qwerty': 'uiop'}
+        content = json.dumps(data)
+        content_type = 'application/json'
+        parsers = (JSONParser(),)
+
+        request = self.build_request('post', '/', content, content_type=content_type, parsers=parsers)
+        post_items = request.POST.items()
+
+        self.assertEqual(len(post_items), 1)
+        self.assertEqual(len(post_items[0]), 2)
+        self.assertEqual(post_items[0][0], content)
+        self.assertEqual(request.DATA.items(), data.items())
+
+    def test_accessing_data_after_post_for_overloaded_json(self):
+        """Ensures request.DATA can be accessed after request.POST in overloaded json request"""
+        from django.utils import simplejson as json
+
+        data = {'qwerty': 'uiop'}
+        content = json.dumps(data)
+        content_type = 'application/json'
+        parsers = (JSONParser(),)
+        form_data = {Request._CONTENT_PARAM: content,
+                     Request._CONTENTTYPE_PARAM: content_type}
+
+        request = self.build_request('post', '/', data=form_data, parsers=parsers)
+        self.assertEqual(request.POST.items(), form_data.items())
+        self.assertEqual(request.DATA.items(), data.items())
+
+
+class MockView(View):
+    authentication = (UserLoggedInAuthentication,)
+    def post(self, request):
+        if request.POST.get('example') is not None:
+            return Response(status=status.HTTP_200_OK)
+
+        return Response(status=status.INTERNAL_SERVER_ERROR)
+
+urlpatterns = patterns('',
+    (r'^$', MockView.as_view()),
+)
+
+
+class TestContentParsingWithAuthentication(TestCase):
+    urls = 'djangorestframework.tests.request'
+
+    def setUp(self):
+        self.csrf_client = Client(enforce_csrf_checks=True)
+        self.username = 'john'
+        self.email = 'lennon@thebeatles.com'
+        self.password = 'password'
+        self.user = User.objects.create_user(self.username, self.email, self.password)
+        self.req = RequestFactory()
+
+    def test_user_logged_in_authentication_has_post_when_not_logged_in(self):
+        """Ensures request.POST exists after UserLoggedInAuthentication when user doesn't log in"""
+        content = {'example': 'example'}
+
+        response = self.client.post('/', content)
+        self.assertEqual(status.HTTP_200_OK, response.status_code, "POST data is malformed")
+
+        response = self.csrf_client.post('/', content)
+        self.assertEqual(status.HTTP_200_OK, response.status_code, "POST data is malformed")
+
+    # def test_user_logged_in_authentication_has_post_when_logged_in(self):
+    #     """Ensures request.POST exists after UserLoggedInAuthentication when user does log in"""
+    #     self.client.login(username='john', password='password')
+    #     self.csrf_client.login(username='john', password='password')
+    #     content = {'example': 'example'}
+
+    #     response = self.client.post('/', content)
+    #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")
+
+    #     response = self.csrf_client.post('/', content)
+    #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")

djangorestframework/tests/response.py

@@ -1,19 +1,284 @@
-# Right now we expect this test to fail - I'm just going to leave it commented out.
+import json
-# Looking forward to actually being able to raise ExpectedFailure sometime!
+import unittest
-#
-#from django.test import TestCase
-#from djangorestframework.response import Response
-#
-#
-#class TestResponse(TestCase):
-#
-#    # Interface tests
-#
-#    # This is mainly to remind myself that the Response interface needs to change slightly
-#    def test_response_interface(self):
-#        """Ensure the Response interface is as expected."""
-#        response = Response()
-#        getattr(response, 'status')
-#        getattr(response, 'content')
-#        getattr(response, 'headers')
 
+from django.conf.urls.defaults import patterns, url
+from django.test import TestCase
+
+from djangorestframework.response import Response, ImmediateResponse
+from djangorestframework.mixins import ResponseMixin
+from djangorestframework.views import View
+from djangorestframework.compat import View as DjangoView
+from djangorestframework.renderers import BaseRenderer, DEFAULT_RENDERERS
+from djangorestframework.compat import RequestFactory
+from djangorestframework import status
+from djangorestframework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer, \
+    XMLRenderer, JSONPRenderer, DocumentingHTMLRenderer
+
+
+class TestResponseDetermineRenderer(TestCase):
+
+    def get_response(self, url='', accept_list=[], renderers=[]):
+        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):
+        """
+        Test that determine_accept_list takes the Accept header.
+        """
+        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):
+        """
+        Test Accept header overriding.
+        """
+        accept_list = ['application/pickle', 'application/json']
+        response = self.get_response(url='?_accept=application/x-www-form-urlencoded',
+            accept_list=accept_list)
+        self.assertEqual(response._determine_accept_list(), ['application/x-www-form-urlencoded'])
+
+    def test_determine_renderer(self):
+        """
+        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')
+
+        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(renderer, prenderer)
+
+        response = self.get_response(accept_list=accept_list, renderers=(jrenderer,))
+        renderer, media_type = response._determine_renderer()
+        self.assertEqual(media_type, 'application/json')
+        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')
+
+        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=[r() for r in DEFAULT_RENDERERS])
+
+    def test_render(self):
+        """
+        Test rendering simple data to json.  
+        """
+        content = {'a': 1, 'b': [1, 2, 3]}
+        content_type = 'application/json'
+        response = self.get_response(accept_list=[content_type], content=content)
+        response.render()
+        self.assertEqual(json.loads(response.content), content)
+        self.assertEqual(response['Content-Type'], content_type)
+
+
+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):
+    renderer_classes = (RendererA, RendererB)
+
+    def get(self, request, **kwargs):
+        response = Response(DUMMYCONTENT, status=DUMMYSTATUS)
+        self.response = self.prepare_response(response)
+        return self.response
+
+
+class HTMLView(View):
+    renderer_classes = (DocumentingHTMLRenderer, )
+
+    def get(self, request, **kwargs):
+        return Response('text')
+
+
+class HTMLView1(View):
+    renderer_classes = (DocumentingHTMLRenderer, JSONRenderer)
+
+    def get(self, request, **kwargs):
+        return Response('text') 
+
+
+urlpatterns = patterns('',
+    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()),
+)
+
+
+# TODO: Clean tests bellow - remove duplicates with above, better unit testing, ...
+class RendererIntegrationTests(TestCase):
+    """
+    End-to-end testing of renderers using an ResponseMixin on a generic view.
+    """
+
+    urls = 'djangorestframework.tests.response'
+
+    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)
+
+    @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
+        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):
+        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)
+
+
+class Issue122Tests(TestCase):
+    """
+    Tests that covers #122.
+    """
+    urls = 'djangorestframework.tests.response'
+
+    def test_only_html_renderer(self):
+        """
+        Test if no infinite recursion occurs.
+        """
+        resp = self.client.get('/html')
+        
+    def test_html_renderer_is_first(self):
+        """
+        Test if no infinite recursion occurs.
+        """
+        resp = self.client.get('/html1')

djangorestframework/tests/reverse.py

@@ -4,6 +4,7 @@ from django.test import TestCase
 from django.utils import simplejson as json
 
 from djangorestframework.views import View
+from djangorestframework.response import Response
 
 
 class MockView(View):
@@ -11,7 +12,7 @@ class MockView(View):
     permissions = ()
 
     def get(self, request):
-        return reverse('another')
+        return Response(reverse('another'))
 
 urlpatterns = patterns('',
     url(r'^$', MockView.as_view()),

djangorestframework/tests/throttling.py

@@ -10,13 +10,14 @@ from djangorestframework.compat import RequestFactory
 from djangorestframework.views import View
 from djangorestframework.permissions import PerUserThrottling, PerViewThrottling, PerResourceThrottling
 from djangorestframework.resources import FormResource
+from djangorestframework.response import Response
 
 class MockView(View):
     permissions = ( PerUserThrottling, )
     throttle = '3/sec'
 
     def get(self, request):
-        return 'foo'
+        return Response('foo')
 
 class MockView_PerViewThrottling(MockView):
     permissions = ( PerViewThrottling, )

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, exc:
+        except ImmediateResponse, response:
-            self.assertEqual(exc.response.raw_content, {'errors': [MockForm.ERROR_TEXT]})
+            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,8 +154,8 @@ class TestFormValidation(TestCase):
         content = {}
         try:
             validator.validate_request(content, None)
-        except ErrorResponse, exc:
+        except ImmediateResponse, response:
-            self.assertEqual(exc.response.raw_content, {'field_errors': {'qwerty': ['This field is required.']}})
+            self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.']}})
         else:
             self.fail('ResourceException was not raised')
 
@@ -164,8 +164,8 @@ class TestFormValidation(TestCase):
         content = {'qwerty': ''}
         try:
             validator.validate_request(content, None)
-        except ErrorResponse, exc:
+        except ImmediateResponse, response:
-            self.assertEqual(exc.response.raw_content, {'field_errors': {'qwerty': ['This field is required.']}})
+            self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.']}})
         else:
             self.fail('ResourceException was not raised')
 
@@ -174,8 +174,8 @@ class TestFormValidation(TestCase):
         content = {'qwerty': 'uiop', 'extra': 'extra'}
         try:
             validator.validate_request(content, None)
-        except ErrorResponse, exc:
+        except ImmediateResponse, response:
-            self.assertEqual(exc.response.raw_content, {'field_errors': {'extra': ['This field does not exist.']}})
+            self.assertEqual(response.raw_content, {'field_errors': {'extra': ['This field does not exist.']}})
         else:
             self.fail('ResourceException was not raised')
 
@@ -184,8 +184,8 @@ class TestFormValidation(TestCase):
         content = {'qwerty': '', 'extra': 'extra'}
         try:
             validator.validate_request(content, None)
-        except ErrorResponse, exc:
+        except ImmediateResponse, response:
-            self.assertEqual(exc.response.raw_content, {'field_errors': {'qwerty': ['This field is required.'],
+            self.assertEqual(response.raw_content, {'field_errors': {'qwerty': ['This field is required.'],
                                                                          'extra': ['This field does not exist.']}})
         else:
             self.fail('ResourceException was not raised')
@@ -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."""

djangorestframework/utils/__init__.py

@@ -48,6 +48,13 @@ def url_resolves(url):
     return True
 
 
+def allowed_methods(view):
+    """
+    Return the list of uppercased allowed HTTP methods on `view`.
+    """
+    return [method.upper() for method in view.http_method_names if hasattr(view, method)]
+
+
 # From http://www.koders.com/python/fidB6E125C586A6F49EAC38992CF3AFDAAE35651975.aspx?s=mdef:xml
 #class object_dict(dict):
 #    """object view of dict, you can

djangorestframework/views.py

@@ -13,8 +13,9 @@ from django.utils.safestring import mark_safe
 from django.views.decorators.csrf import csrf_exempt
 
 from djangorestframework.compat import View as DjangoView, apply_markdown
-from djangorestframework.response import Response, ErrorResponse
+from djangorestframework.response import Response, ImmediateResponse
 from djangorestframework.mixins import *
+from djangorestframework.utils import allowed_methods
 from djangorestframework import resources, renderers, parsers, authentication, permissions, status
 
 
@@ -81,14 +82,14 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView):
     or `None` to use default behaviour.
     """
 
-    renderers = renderers.DEFAULT_RENDERERS
+    renderer_classes = renderers.DEFAULT_RENDERERS
     """
-    List of renderers the resource can serialize the response with, ordered by preference.
+    List of renderer classes the resource can serialize the response with, ordered by preference.
     """
 
-    parsers = parsers.DEFAULT_PARSERS
+    parser_classes = parsers.DEFAULT_PARSERS
     """
-    List of parsers the resource can parse the request with.
+    List of parser classes the resource can parse the request with.
     """
 
     authentication = (authentication.UserLoggedInAuthentication,
@@ -118,7 +119,7 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView):
         """
         Return the list of allowed HTTP methods, uppercased.
         """
-        return [method.upper() for method in self.http_method_names if hasattr(self, method)]
+        return allowed_methods(self)
 
     def get_name(self):
         """
@@ -172,12 +173,14 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView):
         """
         Return an HTTP 405 error if an operation is called which does not have a handler method.
         """
-        raise ErrorResponse(status.HTTP_405_METHOD_NOT_ALLOWED,
+        raise ImmediateResponse(
-                            {'detail': 'Method \'%s\' not allowed on this resource.' % self.method})
+                {'detail': 'Method \'%s\' not allowed on this resource.' % request.method},
+            status=status.HTTP_405_METHOD_NOT_ALLOWED)
 
     def initial(self, request, *args, **kargs):
         """
-        Hook for any code that needs to run prior to anything else.
+        Returns an `HttpRequest`. This method is a hook for any code that needs to run
+        prior to anything else.
         Required if you want to do things like set `request.upload_handlers` before
         the authentication and dispatch handling is run.
         """
@@ -187,28 +190,22 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView):
         if not (self.orig_prefix.startswith('http:') or self.orig_prefix.startswith('https:')):
             prefix = '%s://%s' % (request.is_secure() and 'https' or 'http', request.get_host())
             set_script_prefix(prefix + self.orig_prefix)
+        return request
 
     def final(self, request, response, *args, **kargs):
         """
-        Hook for any code that needs to run after everything else in the view.
+        Returns an `HttpResponse`. This method is a hook for any code that needs to run
+        after everything else in the view.
         """
         # Restore script_prefix.
         set_script_prefix(self.orig_prefix)
 
         # Always add these headers.
-        response.headers['Allow'] = ', '.join(self.allowed_methods)
+        response['Allow'] = ', '.join(allowed_methods(self))
         # sample to allow caching using Vary http header
-        response.headers['Vary'] = 'Authenticate, Accept'
+        response['Vary'] = 'Authenticate, Accept'
 
-        # merge with headers possibly set at some point in the view
+        return response
-        response.headers.update(self.headers)
-        return self.render(response)
-
-    def add_header(self, field, value):
-        """
-        Add *field* and *value* to the :attr:`headers` attribute of the :class:`View` class.
-        """
-        self.headers[field] = value
 
     # Note: session based authentication is explicitly CSRF validated,
     # all other authentication is CSRF exempt.
@@ -217,42 +214,47 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView):
         self.request = request
         self.args = args
         self.kwargs = kwargs
-        self.headers = {}
 
         try:
-            self.initial(request, *args, **kwargs)
+            # Get a custom request, built form the original request instance
+            self.request = request = self.create_request(request)
+
+            # `initial` is the opportunity to temper with the request, 
+            # even completely replace it.
+            self.request = request = self.initial(request, *args, **kwargs)
 
             # Authenticate and check request has the relevant permissions
             self._check_permissions()
 
             # Get the appropriate handler method
-            if self.method.lower() in self.http_method_names:
+            if request.method.lower() in self.http_method_names:
-                handler = getattr(self, self.method.lower(), self.http_method_not_allowed)
+                handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
             else:
                 handler = self.http_method_not_allowed
+ 
+            # TODO: should we enforce HttpResponse, like Django does ?
+            response = handler(request, *args, **kwargs)
 
-            response_obj = handler(request, *args, **kwargs)
+            # Prepare response for the response cycle.
-
+            self.response = response = self.prepare_response(response)
-            # Allow return value to be either HttpResponse, Response, or an object, or None
-            if isinstance(response_obj, HttpResponse):
-                return response_obj
-            elif isinstance(response_obj, Response):
-                response = response_obj
-            elif response_obj is not None:
-                response = Response(status.HTTP_200_OK, response_obj)
-            else:
-                response = Response(status.HTTP_204_NO_CONTENT)
 
             # Pre-serialize filtering (eg filter complex objects into natively serializable types)
-            response.cleaned_content = self.filter_response(response.raw_content)
+            # TODO: ugly hack to handle both HttpResponse and Response. 
+            if hasattr(response, 'raw_content'):
+                response.raw_content = self.filter_response(response.raw_content)
+            else:
+                response.content = self.filter_response(response.content)
 
-        except ErrorResponse, exc:
+        except ImmediateResponse, response:
-            response = exc.response
+            # Prepare response for the response cycle.
+            self.response = response = self.prepare_response(response)
 
+        # `final` is the last opportunity to temper with the response, or even
+        # completely replace it.
         return self.final(request, response, *args, **kwargs)
 
     def options(self, request, *args, **kwargs):
-        response_obj = {
+        content = {
             'name': self.get_name(),
             'description': self.get_description(),
             'renders': self._rendered_media_types,
@@ -263,11 +265,8 @@ class View(ResourceMixin, RequestMixin, ResponseMixin, AuthMixin, DjangoView):
             field_name_types = {}
             for name, field in form.fields.iteritems():
                 field_name_types[name] = field.__class__.__name__
-            response_obj['fields'] = field_name_types
+            content['fields'] = field_name_types
-        # Note 'ErrorResponse' is misleading, it's just any response
+        raise ImmediateResponse(content, status=status.HTTP_200_OK)
-        # that should be rendered and returned immediately, without any
-        # response filtering.
-        raise ErrorResponse(status.HTTP_200_OK, response_obj)
 
 
 class ModelView(View):

docs/howto/requestmixin.rst

@@ -0,0 +1,75 @@
+Using the enhanced request in all your views
+==============================================
+
+This example shows how you can use Django REST framework's enhanced `request` - :class:`request.Request` - in your own views, without having to use the full-blown :class:`views.View` class.
+
+What can it do for you ? Mostly, it will take care of parsing the request's content, and handling equally all HTTP methods ... 
+
+Before
+--------
+
+In order to support `JSON` or other serial formats, you might have parsed manually the request's content with something like : ::
+
+    class MyView(View):
+
+        def put(self, request, *args, **kwargs):
+            content_type = request.META['CONTENT_TYPE']
+            if (content_type == 'application/json'):
+                raw_data = request.read()
+                parsed_data = json.loads(raw_data)
+
+            # PLUS as many `elif` as formats you wish to support ...
+
+            # then do stuff with your data :
+            self.do_stuff(parsed_data['bla'], parsed_data['hoho'])
+
+            # and finally respond something
+
+... and you were unhappy because this looks hackish.
+
+Also, you might have tried uploading files with a PUT request - *and given up* since that's complicated to achieve even with Django 1.3.
+
+
+After
+------
+
+All the dirty `Content-type` checking and content reading and parsing is done for you, and you only need to do the following : ::
+
+    class MyView(MyBaseViewUsingEnhancedRequest):
+
+        def put(self, request, *args, **kwargs):
+            self.do_stuff(request.DATA['bla'], request.DATA['hoho'])
+            # and finally respond something
+
+So the parsed content is magically available as `.DATA` on the `request` object.
+
+Also, if you uploaded files, they are available as `.FILES`, like with a normal POST request.
+
+.. note:: Note that all the above is also valid for a POST request.
+
+
+How to add it to your custom views ?
+--------------------------------------
+
+Now that you're convinced you need to use the enhanced request object, here is how you can add it to all your custom views : ::
+
+    from django.views.generic.base import View
+
+    from djangorestframework.mixins import RequestMixin
+    from djangorestframework import parsers
+
+
+    class MyBaseViewUsingEnhancedRequest(RequestMixin, View):
+        """
+        Base view enabling the usage of enhanced requests with user defined views.
+        """
+
+        parser_classes = parsers.DEFAULT_PARSERS
+
+        def dispatch(self, request, *args, **kwargs):
+            request = self.prepare_request(request)
+            return super(MyBaseViewUsingEnhancedRequest, self).dispatch(request, *args, **kwargs)
+
+And then, use this class as a base for all your custom views.
+
+.. note:: you can see this live in the examples. 

docs/library/request.rst

@@ -0,0 +1,5 @@
+:mod:`request`
+=====================
+
+.. automodule:: request
+   :members:

examples/mixin/urls.py

@@ -10,12 +10,13 @@ from django.core.urlresolvers import reverse
 class ExampleView(ResponseMixin, View):
     """An example view using Django 1.3's class based views.
     Uses djangorestframework's RendererMixin to provide support for multiple output formats."""
-    renderers = DEFAULT_RENDERERS
+    renderer_classes = DEFAULT_RENDERERS
 
     def get(self, request):
-        response = Response(200, {'description': 'Some example content',
+        response = Response({'description': 'Some example content',
-                                  'url': reverse('mixin-view')})
+                                  'url': reverse('mixin-view')}, status=200)
-        return self.render(response)
+        self.response = self.prepare_response(response)
+        return self.response
 
 
 urlpatterns = patterns('',

examples/objectstore/views.py

@@ -41,7 +41,7 @@ class ObjectStoreRoot(View):
         filepaths = [os.path.join(OBJECT_STORE_DIR, file) for file in os.listdir(OBJECT_STORE_DIR) if not file.startswith('.')]
         ctime_sorted_basenames = [item[0] for item in sorted([(os.path.basename(path), os.path.getctime(path)) for path in filepaths],
                                                              key=operator.itemgetter(1), reverse=True)]
-        return [reverse('stored-object', kwargs={'key':key}) for key in ctime_sorted_basenames]
+        return Response([reverse('stored-object', kwargs={'key':key}) for key in ctime_sorted_basenames])
 
     def post(self, request):
         """
@@ -51,7 +51,8 @@ class ObjectStoreRoot(View):
         pathname = os.path.join(OBJECT_STORE_DIR, key)
         pickle.dump(self.CONTENT, open(pathname, 'wb'))
         remove_oldest_files(OBJECT_STORE_DIR, MAX_FILES)
-        return Response(status.HTTP_201_CREATED, self.CONTENT, {'Location': reverse('stored-object', kwargs={'key':key})})
+        self.headers['Location'] = reverse('stored-object', kwargs={'key':key})
+        return Response(self.CONTENT, status=status.HTTP_201_CREATED)
 
 
 class StoredObject(View):
@@ -66,8 +67,8 @@ class StoredObject(View):
         """
         pathname = os.path.join(OBJECT_STORE_DIR, key)
         if not os.path.exists(pathname):
-            return Response(status.HTTP_404_NOT_FOUND)
+            return Response(status=status.HTTP_404_NOT_FOUND)
-        return pickle.load(open(pathname, 'rb'))
+        return Response(pickle.load(open(pathname, 'rb')))
 
     def put(self, request, key):
         """
@@ -75,7 +76,7 @@ class StoredObject(View):
         """
         pathname = os.path.join(OBJECT_STORE_DIR, key)
         pickle.dump(self.CONTENT, open(pathname, 'wb'))
-        return self.CONTENT
+        return Response(self.CONTENT)
 
     def delete(self, request, key):
         """
@@ -83,5 +84,6 @@ class StoredObject(View):
         """
         pathname = os.path.join(OBJECT_STORE_DIR, key)
         if not os.path.exists(pathname):
-            return Response(status.HTTP_404_NOT_FOUND)
+            return Response(status=status.HTTP_404_NOT_FOUND)
         os.remove(pathname)
+        return Response()

examples/permissionsexample/views.py

@@ -1,4 +1,5 @@
 from djangorestframework.views import View
+from djangorestframework.response import Response
 from djangorestframework.permissions import PerUserThrottling, IsAuthenticated
 from django.core.urlresolvers import reverse
 
@@ -9,7 +10,7 @@ class PermissionsExampleView(View):
     """
 
     def get(self, request):
-        return [
+        return Response([
             {
                 'name': 'Throttling Example',
                 'url': reverse('throttled-resource')
@@ -18,7 +19,7 @@ class PermissionsExampleView(View):
                 'name': 'Logged in example',
                 'url': reverse('loggedin-resource')
             },
-        ]
+        ])
 
 
 class ThrottlingExampleView(View):
@@ -36,7 +37,7 @@ class ThrottlingExampleView(View):
         """
         Handle GET requests.
         """
-        return "Successful response to GET request because throttle is not yet active."
+        return Response("Successful response to GET request because throttle is not yet active.")
 
 
 class LoggedInExampleView(View):
@@ -49,4 +50,4 @@ class LoggedInExampleView(View):
     permissions = (IsAuthenticated, )
 
     def get(self, request):
-        return 'You have permission to view this resource'
+        return Response('You have permission to view this resource')

examples/pygments_api/views.py

@@ -61,7 +61,7 @@ class PygmentsRoot(View):
         Return a list of all currently existing snippets.
         """
         unique_ids = [os.path.split(f)[1] for f in list_dir_sorted_by_ctime(HIGHLIGHTED_CODE_DIR)]
-        return [reverse('pygments-instance', args=[unique_id]) for unique_id in unique_ids]
+        return Response([reverse('pygments-instance', args=[unique_id]) for unique_id in unique_ids])
 
     def post(self, request):
         """
@@ -81,7 +81,8 @@ class PygmentsRoot(View):
 
         remove_oldest_files(HIGHLIGHTED_CODE_DIR, MAX_FILES)
 
-        return Response(status.HTTP_201_CREATED, headers={'Location': reverse('pygments-instance', args=[unique_id])})
+        self.headers['Location'] = reverse('pygments-instance', args=[unique_id])
+        return Response(status=status.HTTP_201_CREATED)
 
 
 class PygmentsInstance(View):
@@ -89,7 +90,7 @@ class PygmentsInstance(View):
     Simply return the stored highlighted HTML file with the correct mime type.
     This Resource only renders HTML and uses a standard HTML renderer rather than the renderers.DocumentingHTMLRenderer class.
     """
-    renderers = (HTMLRenderer,)
+    renderer_classes = (HTMLRenderer,)
 
     def get(self, request, unique_id):
         """
@@ -98,7 +99,7 @@ class PygmentsInstance(View):
         pathname = os.path.join(HIGHLIGHTED_CODE_DIR, unique_id)
         if not os.path.exists(pathname):
             return Response(status.HTTP_404_NOT_FOUND)
-        return open(pathname, 'r').read()
+        return Response(open(pathname, 'r').read())
 
     def delete(self, request, unique_id):
         """
@@ -107,5 +108,5 @@ class PygmentsInstance(View):
         pathname = os.path.join(HIGHLIGHTED_CODE_DIR, unique_id)
         if not os.path.exists(pathname):
             return Response(status.HTTP_404_NOT_FOUND)
-        return os.remove(pathname)
+        return Response(os.remove(pathname))
 

examples/requestexample/models.py

@@ -0,0 +1,3 @@
+from django.db import models
+
+# Create your models here.

examples/requestexample/urls.py

@@ -0,0 +1,9 @@
+from django.conf.urls.defaults import patterns, url
+from requestexample.views import RequestExampleView, EchoRequestContentView
+from examples.views import ProxyView
+
+
+urlpatterns = patterns('',
+    url(r'^$', RequestExampleView.as_view(), name='request-example'),
+    url(r'^content$', ProxyView.as_view(view_class=EchoRequestContentView), name='request-content'),
+)

examples/requestexample/views.py

@@ -0,0 +1,44 @@
+from djangorestframework.compat import View
+from django.http import HttpResponse
+from django.core.urlresolvers import reverse
+
+from djangorestframework.mixins import RequestMixin
+from djangorestframework.views import View as DRFView
+from djangorestframework import parsers
+from djangorestframework.response import Response
+
+
+class RequestExampleView(DRFView):
+    """
+    A container view for request examples.
+    """
+
+    def get(self, request):
+        return Response([{'name': 'request.DATA Example', 'url': reverse('request-content')},])
+
+
+class MyBaseViewUsingEnhancedRequest(RequestMixin, View):
+    """
+    Base view enabling the usage of enhanced requests with user defined views.
+    """
+
+    parser_classes = parsers.DEFAULT_PARSERS
+
+    def dispatch(self, request, *args, **kwargs):
+        self.request = request = self.create_request(request)
+        return super(MyBaseViewUsingEnhancedRequest, self).dispatch(request, *args, **kwargs)
+
+
+class EchoRequestContentView(MyBaseViewUsingEnhancedRequest):
+    """
+    A view that just reads the items in `request.DATA` and echoes them back.
+    """
+
+    def post(self, request, *args, **kwargs):
+        return HttpResponse(("Found %s in request.DATA, content : %s" %
+            (type(request.DATA), request.DATA)))
+
+    def put(self, request, *args, **kwargs):
+        return HttpResponse(("Found %s in request.DATA, content : %s" %
+            (type(request.DATA), request.DATA)))
+

examples/resourceexample/views.py

@@ -16,12 +16,12 @@ class ExampleView(View):
         """
         Handle GET requests, returning a list of URLs pointing to 3 other views.
         """
-        return {"Some other resources": [reverse('another-example', kwargs={'num':num}) for num in range(3)]}
+        return Response({"Some other resources": [reverse('another-example', kwargs={'num':num}) for num in range(3)]})
 
 
 class AnotherExampleView(View):
     """
-    A basic view, that can be handle GET and POST requests.
+    A basic view, that can handle GET and POST requests.
     Applies some simple form validation on POST requests.
     """
     form = MyForm
@@ -33,7 +33,7 @@ class AnotherExampleView(View):
         """
         if int(num) > 2:
             return Response(status.HTTP_404_NOT_FOUND)
-        return "GET request to AnotherExampleResource %s" % num
+        return Response("GET request to AnotherExampleResource %s" % num)
 
     def post(self, request, num):
         """
@@ -42,4 +42,4 @@ class AnotherExampleView(View):
         """
         if int(num) > 2:
             return Response(status.HTTP_404_NOT_FOUND)
-        return "POST request to AnotherExampleResource %s, with content: %s" % (num, repr(self.CONTENT))
+        return Response("POST request to AnotherExampleResource %s, with content: %s" % (num, repr(self.CONTENT)))

examples/sandbox/views.py

@@ -2,6 +2,7 @@
 
 from django.core.urlresolvers import reverse
 from djangorestframework.views import View
+from djangorestframework.response import Response
 
 
 class Sandbox(View):
@@ -23,15 +24,17 @@ class Sandbox(View):
     5. A code highlighting API.
     6. A blog posts and comments API.
     7. A basic example using permissions.
+    8. A basic example using enhanced request.
 
     Please feel free to browse, create, edit and delete the resources in these examples."""
 
     def get(self, request):
-        return [{'name': 'Simple Resource example', 'url': reverse('example-resource')},
+        return Response([{'name': 'Simple Resource example', 'url': reverse('example-resource')},
                 {'name': 'Simple ModelResource example', 'url': reverse('model-resource-root')},
                 {'name': 'Simple Mixin-only example', 'url': reverse('mixin-view')},
                 {'name': 'Object store API', 'url': reverse('object-store-root')},
                 {'name': 'Code highlighting API', 'url': reverse('pygments-root')},
                 {'name': 'Blog posts API', 'url': reverse('blog-posts-root')},
-                {'name': 'Permissions example', 'url': reverse('permissions-example')}
+                {'name': 'Permissions example', 'url': reverse('permissions-example')},
-                ]
+                {'name': 'Simple request mixin example', 'url': reverse('request-example')}
+                ])

examples/settings.py

@@ -106,6 +106,7 @@ INSTALLED_APPS = (
     'pygments_api',
     'blogpost',
     'permissionsexample',
+    'requestexample',
 )
 
 import os

examples/urls.py

@@ -15,6 +15,7 @@ urlpatterns = patterns('',
     (r'^pygments/', include('pygments_api.urls')),
     (r'^blog-post/', include('blogpost.urls')),
     (r'^permissions-example/', include('permissionsexample.urls')),
+    (r'^request-example/', include('requestexample.urls')),
 
     (r'^', include('djangorestframework.urls')),
 )

examples/views.py

@@ -0,0 +1,32 @@
+from djangorestframework.views import View
+from djangorestframework.response import Response
+
+
+class ProxyView(View):
+    """
+    A view that just acts as a proxy to call non-djangorestframework views, while still
+    displaying the browsable API interface.
+    """
+
+    view_class = None
+
+    def dispatch(self, request, *args, **kwargs):
+        self.request = request = self.create_request(request)
+        if request.method in ['PUT', 'POST']:
+            self.response = self.view_class.as_view()(request, *args, **kwargs)
+        return super(ProxyView, self).dispatch(request, *args, **kwargs)
+
+    def get(self, request, *args, **kwargs):
+        return Response()
+
+    def put(self, request, *args, **kwargs):
+        return Response(self.response.content)
+
+    def post(self, request, *args, **kwargs):
+        return Response(self.response.content)
+
+    def get_name(self):    
+        return self.view_class.__name__
+
+    def get_description(self, html):
+        return self.view_class.__doc__