aboutsummaryrefslogtreecommitdiffstats
path: root/djangorestframework/tests/request.py
diff options
context:
space:
mode:
Diffstat (limited to 'djangorestframework/tests/request.py')
-rw-r--r--djangorestframework/tests/request.py251
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"""
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-06 15:01:48 +0000