Massive merge

1 files changed, 131 insertions, 120 deletions

diff --git a/djangorestframework/tests/request.py b/djangorestframework/tests/request.py
index c92d3f5f..7e289536 100644
--- a/djangorestframework/tests/request.py
+++ b/djangorestframework/tests/request.py
@@ -4,205 +4,214 @@ 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 django.utils import simplejson as json
+
 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.utils import RequestFactory
+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)
-
+factory = RequestFactory()
 
-class TestMethodOverloading(RequestTestCase):
 
-    def test_standard_behaviour_determines_GET(self):
-        """GET requests identified"""
-        request = self.build_request('get', '/')
+class TestMethodOverloading(TestCase):
+    def test_GET_method(self):
+        """
+        GET requests identified.
+        """
+        request = factory.get('/')
         self.assertEqual(request.method, 'GET')
 
-    def test_standard_behaviour_determines_POST(self):
-        """POST requests identified"""
-        request = self.build_request('post', '/')
+    def test_POST_method(self):
+        """
+        POST requests identified.
+        """
+        request = factory.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', '/')
+    def test_HEAD_method(self):
+        """
+        HEAD requests identified.
+        """
+        request = factory.head('/')
         self.assertEqual(request.method, 'HEAD')
 
+    def test_overloaded_method(self):
+        """
+        POST requests can be overloaded to another method by setting a
+        reserved form field
+        """
+        request = factory.post('/', {Request._METHOD_PARAM: 'DELETE'})
+        self.assertEqual(request.method, 'DELETE')
 
-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
-    
+
+class TestContentParsing(TestCase):
     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', '/')
+        """
+        Ensure request.DATA returns None for GET request with no content.
+        """
+        request = factory.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', '/')
+        """
+        Ensure request.DATA returns None for HEAD request.
+        """
+        request = factory.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())
+        """
+        Ensure request.DATA returns content for POST request with form content.
+        """
+        data = {'qwerty': 'uiop'}
+        parsers = (FormParser, MultiPartParser)
+        request = factory.post('/', data, parser=parsers)
+        self.assertEqual(request.DATA.items(), data.items())
 
     def test_standard_behaviour_determines_non_form_content_POST(self):
-        """Ensure request.DATA returns content for POST request with non-form content."""
+        """
+        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)
+        parsers = (PlainTextParser,)
+        request = factory.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())
+        """
+        Ensure request.DATA returns content for PUT request with form content.
+        """
+        data = {'qwerty': 'uiop'}
+        parsers = (FormParser, MultiPartParser)
+        request = factory.put('/', data, parsers=parsers)
+        self.assertEqual(request.DATA.items(), data.items())
 
     def test_standard_behaviour_determines_non_form_content_PUT(self):
-        """Ensure request.DATA returns content for PUT request with non-form content."""
+        """
+        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)
+        parsers = (PlainTextParser, )
+        request = factory.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"""
+        """
+        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)
+        data = {
+            Request._CONTENT_PARAM: content,
+            Request._CONTENTTYPE_PARAM: content_type
+        }
+        parsers = (PlainTextParser, )
+        request = factory.post('/', 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())
+        """
+        Ensures request.POST can be accessed after request.DATA in
+        form request.
+        """
+        data = {'qwerty': 'uiop'}
+        request = factory.post('/', data=data)
+        self.assertEqual(request.DATA.items(), data.items())
+        self.assertEqual(request.POST.items(), 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
-
+        """
+        Ensures request.POST can be accessed after request.DATA in
+        json request.
+        """
         data = {'qwerty': 'uiop'}
         content = json.dumps(data)
         content_type = 'application/json'
-        parsers = (JSONParser(),)
+        parsers = (JSONParser, )
 
-        request = self.build_request('post', '/', content, content_type=content_type, parsers=parsers)
+        request = factory.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
-
+        """
+        Ensures request.POST can be accessed after request.DATA in overloaded
+        json request.
+        """
         data = {'qwerty': 'uiop'}
         content = json.dumps(data)
         content_type = 'application/json'
-        parsers = (JSONParser(),)
+        parsers = (JSONParser, )
         form_data = {Request._CONTENT_PARAM: content,
                      Request._CONTENTTYPE_PARAM: content_type}
 
-        request = self.build_request('post', '/', data=form_data, parsers=parsers)
+        request = factory.post('/', 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'}
+        """
+        Ensures request.DATA can be accessed after request.POST in
+        form request.
+        """
+        data = {'qwerty': 'uiop'}
         parsers = (FormParser, MultiPartParser)
-        request = self.build_request('post', '/', data=form_data, parsers=parsers)
+        request = factory.post('/', data, parsers=parsers)
 
-        self.assertEqual(request.POST.items(), form_data.items())
-        self.assertEqual(request.DATA.items(), form_data.items())
+        self.assertEqual(request.POST.items(), data.items())
+        self.assertEqual(request.DATA.items(), 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
-
+        """
+        Ensures request.DATA can be accessed after request.POST in
+        json request.
+        """
         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)
+        parsers = (JSONParser, )
+        request = factory.post('/', content, content_type=content_type,
+                               parsers=parsers)
+        self.assertEqual(request.POST.items(), [])
         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
-
+        """
+        Ensures request.DATA can be accessed after request.POST in overloaded
+        json request
+        """
         data = {'qwerty': 'uiop'}
         content = json.dumps(data)
         content_type = 'application/json'
-        parsers = (JSONParser(),)
+        parsers = (JSONParser, )
         form_data = {Request._CONTENT_PARAM: content,
                      Request._CONTENTTYPE_PARAM: content_type}
 
-        request = self.build_request('post', '/', data=form_data, parsers=parsers)
+        request = factory.post('/', 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)
@@ -223,17 +232,19 @@ class TestContentParsingWithAuthentication(TestCase):
         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"""
+    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")
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
 
         response = self.csrf_client.post('/', content)
-        self.assertEqual(status.HTTP_200_OK, response.status_code, "POST data is malformed")
+        self.assertEqual(status.HTTP_200_OK, response.status_code)
 
     # def test_user_logged_in_authentication_has_post_when_logged_in(self):
     #     """Ensures request.POST exists after UserLoggedInAuthentication when user does log in"""