.DATA, .FILES, overloaded HTTP method, content type and content available directly on the request - see #128

4 files changed, 251 insertions, 266 deletions

diff --git a/djangorestframework/tests/content.py b/djangorestframework/tests/content.py
deleted file mode 100644
index 6bae8feb..00000000
--- a/djangorestframework/tests/content.py
+++ /dev/null
@@ -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")
diff --git a/djangorestframework/tests/methods.py b/djangorestframework/tests/methods.py
index 4b90a21f..e69de29b 100644
--- a/djangorestframework/tests/methods.py
+++ b/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')
diff --git a/djangorestframework/tests/renderers.py b/djangorestframework/tests/renderers.py
index 84e4390b..adb46f7f 100644
--- a/djangorestframework/tests/renderers.py
+++ b/djangorestframework/tests/renderers.py
@@ -172,7 +172,7 @@ class RendererIntegrationTests(TestCase):
         self.assertEquals(resp.status_code, DUMMYSTATUS)
 
 _flat_repr = '{"foo": ["bar", "baz"]}'
-_indented_repr = '{\n  "foo": [\n    "bar", \n    "baz"\n  ]\n}'
+_indented_repr = '{\n  "foo": [\n    "bar",\n    "baz"\n  ]\n}'
 
 
 class JSONRendererTests(TestCase):
diff --git a/djangorestframework/tests/request.py b/djangorestframework/tests/request.py
new file mode 100644
index 00000000..7f3a485e
--- /dev/null
+++ b/djangorestframework/tests/request.py
@@ -0,0 +1,250 @@
+"""
+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.request import Request
+from djangorestframework.views import View
+from djangorestframework.request import request_class_factory
+
+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()),
+)
+
+request_class = request_class_factory(RequestFactory().get('/'))
+
+
+class RequestTestCase(TestCase):
+
+    def tearDown(self):
+        request_class.parsers = ()
+
+    def build_request(self, method, *args, **kwargs):
+        factory = RequestFactory()
+        method = getattr(factory, method)
+        original_request = method(*args, **kwargs)
+        return request_class(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):
+    #TODO: is there any reason why many test cases documented as testing a PUT,
+    # in fact use a POST !?
+
+    def tearDown(self):
+        request_class.parsers = ()
+
+    def build_request(self, method, *args, **kwargs):
+        factory = RequestFactory()
+        method = getattr(factory, method)
+        original_request = method(*args, **kwargs)
+        return request_class(original_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'}
+        request_class.parsers = (FormParser, MultiPartParser)
+        request = self.build_request('post', '/', data=form_data)
+        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'
+        request_class.parsers = (PlainTextParser,)
+        request = self.build_request('post', '/', content, content_type=content_type)
+        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'}
+        request_class.parsers = (FormParser, MultiPartParser)
+        request = self.build_request('put', '/', data=form_data)
+        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'
+        request_class.parsers = (PlainTextParser,)
+        request = self.build_request('post', '/', content, content_type=content_type)
+        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}
+        request_class.parsers = (PlainTextParser,)
+        request = self.build_request('post', '/', form_data)
+        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'}
+        request_class.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'
+
+        request_class.parsers = (JSONParser,)
+
+        request = self.build_request('post', '/', content, content_type=content_type)
+
+        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'
+
+        request_class.parsers = (JSONParser,)
+
+        form_data = {Request._CONTENT_PARAM: content,
+                     Request._CONTENTTYPE_PARAM: content_type}
+
+        request = self.build_request('post', '/', data=form_data)
+
+        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'}
+        request_class.parsers = (FormParser, MultiPartParser)
+        request = self.build_request('post', '/', data=form_data)
+
+        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'
+
+        request_class.parsers = (JSONParser,)
+
+        request = self.build_request('post', '/', content, content_type=content_type)
+
+        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'
+
+        request_class.parsers = (JSONParser,)
+
+        form_data = {Request._CONTENT_PARAM: content,
+                     Request._CONTENTTYPE_PARAM: content_type}
+
+        request = self.build_request('post', '/', data=form_data)
+        self.assertEqual(request.POST.items(), form_data.items())
+        self.assertEqual(request.DATA.items(), data.items())
+
+
+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")