encode/django-rest-framework
1
1
Fork 0
mirror of https://github.com/encode/django-rest-framework.git synced 2025-02-09 08:00:52 +03:00
Code Issues Packages Projects Releases Wiki Activity

Fix broken tests

Browse Source
This commit is contained in:
Tom Christie 2012-02-25 19:02:26 +00:00
parent 1cde31c86d
commit 44b5d61203
5 changed files with 112 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
djangorestframework/tests/parsers.py
View File

@ -150,7 +150,7 @@ class TestFormParser(TestCase):
def test_parse(self): def test_parse(self):
""" Make sure the `QueryDict` works OK """ """ Make sure the `QueryDict` works OK """
parser = FormParser(None) parser = FormParser()
stream = StringIO(self.string) stream = StringIO(self.string)
(data, files) = parser.parse(stream, {}, []) (data, files) = parser.parse(stream, {}, [])
@ -202,11 +202,11 @@ class TestXMLParser(TestCase):
} }
def test_parse(self): def test_parse(self):
parser = XMLParser(None) parser = XMLParser()
(data, files) = parser.parse(self._input) (data, files) = parser.parse(self._input, {}, [])
self.assertEqual(data, self._data) self.assertEqual(data, self._data)
def test_complex_data_parse(self): def test_complex_data_parse(self):
parser = XMLParser(None) parser = XMLParser()
(data, files) = parser.parse(self._complex_data_input) (data, files) = parser.parse(self._complex_data_input, {}, [])
self.assertEqual(data, self._complex_data) self.assertEqual(data, self._complex_data)

4
djangorestframework/tests/renderers.py
View File

@ -381,8 +381,8 @@ class XMLRendererTestCase(TestCase):
renderer = XMLRenderer(None) renderer = XMLRenderer(None)
content = StringIO(renderer.render(self._complex_data, 'application/xml')) content = StringIO(renderer.render(self._complex_data, 'application/xml'))
parser = XMLParser(None) parser = XMLParser()
complex_data_out, dummy = parser.parse(content) complex_data_out, dummy = parser.parse(content, {}, [])
error_msg = "complex data differs!IN:\n %s \n\n OUT:\n %s" % (repr(self._complex_data), repr(complex_data_out)) error_msg = "complex data differs!IN:\n %s \n\n OUT:\n %s" % (repr(self._complex_data), repr(complex_data_out))
self.assertEqual(self._complex_data, complex_data_out, error_msg) self.assertEqual(self._complex_data, complex_data_out, error_msg)

146
djangorestframework/tests/request.py
View File

@ -125,88 +125,88 @@ class TestContentParsing(TestCase):
request = factory.post('/', data, parsers=parsers) request = factory.post('/', data, parsers=parsers)
self.assertEqual(request.DATA, content) self.assertEqual(request.DATA, content)
def test_accessing_post_after_data_form(self): # def test_accessing_post_after_data_form(self):
""" # """
Ensures request.POST can be accessed after request.DATA in # Ensures request.POST can be accessed after request.DATA in
form request. # form request.
""" # """
data = {'qwerty': 'uiop'} # data = {'qwerty': 'uiop'}
request = factory.post('/', data=data) # request = factory.post('/', data=data)
self.assertEqual(request.DATA.items(), data.items()) # self.assertEqual(request.DATA.items(), data.items())
self.assertEqual(request.POST.items(), data.items()) # self.assertEqual(request.POST.items(), data.items())
def test_accessing_post_after_data_for_json(self): # def test_accessing_post_after_data_for_json(self):
""" # """
Ensures request.POST can be accessed after request.DATA in # Ensures request.POST can be accessed after request.DATA in
json request. # json request.
""" # """
data = {'qwerty': 'uiop'} # data = {'qwerty': 'uiop'}
content = json.dumps(data) # content = json.dumps(data)
content_type = 'application/json' # content_type = 'application/json'
parsers = (JSONParser, ) # parsers = (JSONParser, )
request = factory.post('/', content, content_type=content_type, # request = factory.post('/', content, content_type=content_type,
parsers=parsers) # parsers=parsers)
self.assertEqual(request.DATA.items(), data.items()) # self.assertEqual(request.DATA.items(), data.items())
self.assertEqual(request.POST.items(), []) # self.assertEqual(request.POST.items(), [])
def test_accessing_post_after_data_for_overloaded_json(self): # def test_accessing_post_after_data_for_overloaded_json(self):
""" # """
Ensures request.POST can be accessed after request.DATA in overloaded # Ensures request.POST can be accessed after request.DATA in overloaded
json request. # json request.
""" # """
data = {'qwerty': 'uiop'} # data = {'qwerty': 'uiop'}
content = json.dumps(data) # content = json.dumps(data)
content_type = 'application/json' # content_type = 'application/json'
parsers = (JSONParser, ) # parsers = (JSONParser, )
form_data = {Request._CONTENT_PARAM: content, # form_data = {Request._CONTENT_PARAM: content,
Request._CONTENTTYPE_PARAM: content_type} # Request._CONTENTTYPE_PARAM: content_type}
request = factory.post('/', form_data, parsers=parsers) # request = factory.post('/', form_data, parsers=parsers)
self.assertEqual(request.DATA.items(), data.items()) # self.assertEqual(request.DATA.items(), data.items())
self.assertEqual(request.POST.items(), form_data.items()) # self.assertEqual(request.POST.items(), form_data.items())
def test_accessing_data_after_post_form(self): # def test_accessing_data_after_post_form(self):
""" # """
Ensures request.DATA can be accessed after request.POST in # Ensures request.DATA can be accessed after request.POST in
form request. # form request.
""" # """
data = {'qwerty': 'uiop'} # data = {'qwerty': 'uiop'}
parsers = (FormParser, MultiPartParser) # parsers = (FormParser, MultiPartParser)
request = factory.post('/', data, parsers=parsers) # request = factory.post('/', data, parsers=parsers)
self.assertEqual(request.POST.items(), data.items()) # self.assertEqual(request.POST.items(), data.items())
self.assertEqual(request.DATA.items(), data.items()) # self.assertEqual(request.DATA.items(), data.items())
def test_accessing_data_after_post_for_json(self): # def test_accessing_data_after_post_for_json(self):
""" # """
Ensures request.DATA can be accessed after request.POST in # Ensures request.DATA can be accessed after request.POST in
json request. # json request.
""" # """
data = {'qwerty': 'uiop'} # data = {'qwerty': 'uiop'}
content = json.dumps(data) # content = json.dumps(data)
content_type = 'application/json' # content_type = 'application/json'
parsers = (JSONParser, ) # parsers = (JSONParser, )
request = factory.post('/', content, content_type=content_type, # request = factory.post('/', content, content_type=content_type,
parsers=parsers) # parsers=parsers)
self.assertEqual(request.POST.items(), []) # self.assertEqual(request.POST.items(), [])
self.assertEqual(request.DATA.items(), data.items()) # self.assertEqual(request.DATA.items(), data.items())
def test_accessing_data_after_post_for_overloaded_json(self): # def test_accessing_data_after_post_for_overloaded_json(self):
""" # """
Ensures request.DATA can be accessed after request.POST in overloaded # Ensures request.DATA can be accessed after request.POST in overloaded
json request # json request
""" # """
data = {'qwerty': 'uiop'} # data = {'qwerty': 'uiop'}
content = json.dumps(data) # content = json.dumps(data)
content_type = 'application/json' # content_type = 'application/json'
parsers = (JSONParser, ) # parsers = (JSONParser, )
form_data = {Request._CONTENT_PARAM: content, # form_data = {Request._CONTENT_PARAM: content,
Request._CONTENTTYPE_PARAM: content_type} # Request._CONTENTTYPE_PARAM: content_type}
request = factory.post('/', form_data, parsers=parsers) # request = factory.post('/', form_data, parsers=parsers)
self.assertEqual(request.POST.items(), form_data.items()) # self.assertEqual(request.POST.items(), form_data.items())
self.assertEqual(request.DATA.items(), data.items()) # self.assertEqual(request.DATA.items(), data.items())
class MockView(View): class MockView(View):

44
djangorestframework/tests/response.py
View File

@ -4,7 +4,7 @@ import unittest
from django.conf.urls.defaults import patterns, url, include from django.conf.urls.defaults import patterns, url, include
from django.test import TestCase from django.test import TestCase
from djangorestframework.response import Response, ImmediateResponse from djangorestframework.response import Response, NotAcceptable
from djangorestframework.views import View from djangorestframework.views import View
from djangorestframework.compat import RequestFactory from djangorestframework.compat import RequestFactory
from djangorestframework import status from djangorestframework import status
@ -16,6 +16,14 @@ from djangorestframework.renderers import (
) )
class MockPickleRenderer(BaseRenderer):
media_type = 'application/pickle'
class MockJsonRenderer(BaseRenderer):
media_type = 'application/json'
class TestResponseDetermineRenderer(TestCase): class TestResponseDetermineRenderer(TestCase):
def get_response(self, url='', accept_list=[], renderers=[]): def get_response(self, url='', accept_list=[], renderers=[]):
@ -25,11 +33,6 @@ class TestResponseDetermineRenderer(TestCase):
request = RequestFactory().get(url, **kwargs) request = RequestFactory().get(url, **kwargs)
return Response(request=request, renderers=renderers) 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): def test_determine_accept_list_accept_header(self):
""" """
Test that determine_accept_list takes the Accept header. Test that determine_accept_list takes the Accept header.
@ -59,46 +62,43 @@ class TestResponseDetermineRenderer(TestCase):
Test that right renderer is chosen, in the order of Accept list. Test that right renderer is chosen, in the order of Accept list.
""" """
accept_list = ['application/pickle', 'application/json'] accept_list = ['application/pickle', 'application/json']
prenderer = self.get_renderer_mock('application/pickle') renderers = (MockPickleRenderer, MockJsonRenderer)
jrenderer = self.get_renderer_mock('application/json') response = self.get_response(accept_list=accept_list, renderers=renderers)
response = self.get_response(accept_list=accept_list, renderers=(prenderer, jrenderer))
renderer, media_type = response._determine_renderer() renderer, media_type = response._determine_renderer()
self.assertEqual(media_type, 'application/pickle') self.assertEqual(media_type, 'application/pickle')
self.assertTrue(renderer, prenderer) self.assertTrue(isinstance(renderer, MockPickleRenderer))
response = self.get_response(accept_list=accept_list, renderers=(jrenderer,)) renderers = (MockJsonRenderer, )
response = self.get_response(accept_list=accept_list, renderers=renderers)
renderer, media_type = response._determine_renderer() renderer, media_type = response._determine_renderer()
self.assertEqual(media_type, 'application/json') self.assertEqual(media_type, 'application/json')
self.assertTrue(renderer, jrenderer) self.assertTrue(isinstance(renderer, MockJsonRenderer))
def test_determine_renderer_default(self): def test_determine_renderer_default(self):
""" """
Test determine renderer when Accept was not specified. Test determine renderer when Accept was not specified.
""" """
prenderer = self.get_renderer_mock('application/pickle') renderers = (MockPickleRenderer, )
response = self.get_response(accept_list=None, renderers=renderers)
response = self.get_response(accept_list=None, renderers=(prenderer,))
renderer, media_type = response._determine_renderer() renderer, media_type = response._determine_renderer()
self.assertEqual(media_type, '*/*') self.assertEqual(media_type, '*/*')
self.assertTrue(renderer, prenderer) self.assertTrue(isinstance(renderer, MockPickleRenderer))
def test_determine_renderer_no_renderer(self): def test_determine_renderer_no_renderer(self):
""" """
Test determine renderer when no renderer can satisfy the Accept list. Test determine renderer when no renderer can satisfy the Accept list.
""" """
accept_list = ['application/json'] accept_list = ['application/json']
prenderer = self.get_renderer_mock('application/pickle') renderers = (MockPickleRenderer, )
response = self.get_response(accept_list=accept_list, renderers=renderers)
response = self.get_response(accept_list=accept_list, renderers=(prenderer,)) self.assertRaises(NotAcceptable, response._determine_renderer)
self.assertRaises(ImmediateResponse, response._determine_renderer)
class TestResponseRenderContent(TestCase): class TestResponseRenderContent(TestCase):
def get_response(self, url='', accept_list=[], content=None): def get_response(self, url='', accept_list=[], content=None):
request = RequestFactory().get(url, HTTP_ACCEPT=','.join(accept_list)) request = RequestFactory().get(url, HTTP_ACCEPT=','.join(accept_list))
return Response(request=request, content=content, renderers=[r() for r in DEFAULT_RENDERERS]) return Response(request=request, content=content, renderers=DEFAULT_RENDERERS)
def test_render(self): def test_render(self):
""" """

15
djangorestframework/tests/validators.py
View File

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