diff options
Diffstat (limited to 'djangorestframework/tests')
| -rw-r--r-- | djangorestframework/tests/__init__.py | 1 | ||||
| -rw-r--r-- | djangorestframework/tests/accept.py | 15 | ||||
| -rw-r--r-- | djangorestframework/tests/modelviews.py | 5 | ||||
| -rw-r--r-- | djangorestframework/tests/oauthentication.py | 2 | ||||
| -rw-r--r-- | djangorestframework/tests/parsers.py | 28 | ||||
| -rw-r--r-- | djangorestframework/tests/renderers.py | 208 | ||||
| -rw-r--r-- | djangorestframework/tests/request.py | 251 | ||||
| -rw-r--r-- | djangorestframework/tests/response.py | 55 | ||||
| -rw-r--r-- | djangorestframework/tests/reverse.py | 3 | ||||
| -rw-r--r-- | djangorestframework/tests/views.py | 54 |
10 files changed, 392 insertions, 230 deletions
diff --git a/djangorestframework/tests/__init__.py b/djangorestframework/tests/__init__.py index f664c5c1..641b0277 100644 --- a/djangorestframework/tests/__init__.py +++ b/djangorestframework/tests/__init__.py @@ -10,4 +10,3 @@ for module in modules: exec("from djangorestframework.tests.%s import __doc__ as module_doc" % module) exec("from djangorestframework.tests.%s import *" % module) __test__[module] = module_doc or "" - diff --git a/djangorestframework/tests/accept.py b/djangorestframework/tests/accept.py index e7dfc303..93385493 100644 --- a/djangorestframework/tests/accept.py +++ b/djangorestframework/tests/accept.py @@ -1,3 +1,4 @@ +from django.conf.urls.defaults import patterns, url, include from django.test import TestCase from djangorestframework.compat import RequestFactory @@ -15,9 +16,19 @@ SAFARI_5_0_USER_AGENT = 'Mozilla/5.0 (X11; U; Linux x86_64; en-ca) AppleWebKit/5 OPERA_11_0_MSIE_USER_AGENT = 'Mozilla/4.0 (compatible; MSIE 8.0; X11; Linux x86_64; pl) Opera 11.00' OPERA_11_0_OPERA_USER_AGENT = 'Opera/9.80 (X11; Linux x86_64; U; pl) Presto/2.7.62 Version/11.00' + +urlpatterns = patterns('', + url(r'^api', include('djangorestframework.urls', namespace='djangorestframework')) +) + + class UserAgentMungingTest(TestCase): - """We need to fake up the accept headers when we deal with MSIE. Blergh. - http://www.gethifi.com/blog/browser-rest-http-accept-headers""" + """ + We need to fake up the accept headers when we deal with MSIE. Blergh. + http://www.gethifi.com/blog/browser-rest-http-accept-headers + """ + + urls = 'djangorestframework.tests.accept' def setUp(self): diff --git a/djangorestframework/tests/modelviews.py b/djangorestframework/tests/modelviews.py index 031e65c5..ccd8513f 100644 --- a/djangorestframework/tests/modelviews.py +++ b/djangorestframework/tests/modelviews.py @@ -1,5 +1,4 @@ from django.conf.urls.defaults import patterns, url -from django.test import TestCase from django.forms import ModelForm from django.contrib.auth.models import Group, User from djangorestframework.resources import ModelResource @@ -7,18 +6,22 @@ from djangorestframework.views import ListOrCreateModelView, InstanceModelView from djangorestframework.tests.models import CustomUser from djangorestframework.tests.testcases import TestModelsTestCase + class GroupResource(ModelResource): model = Group + class UserForm(ModelForm): class Meta: model = User exclude = ('last_login', 'date_joined') + class UserResource(ModelResource): model = User form = UserForm + class CustomUserResource(ModelResource): model = CustomUser diff --git a/djangorestframework/tests/oauthentication.py b/djangorestframework/tests/oauthentication.py index b4bcf2fa..29f2c44e 100644 --- a/djangorestframework/tests/oauthentication.py +++ b/djangorestframework/tests/oauthentication.py @@ -27,7 +27,7 @@ else: urlpatterns = patterns('', url(r'^$', oauth_required(ClientView.as_view())), url(r'^oauth/', include('oauth_provider.urls')), - url(r'^accounts/login/$', 'djangorestframework.utils.staticviews.api_login'), + url(r'^restframework/', include('djangorestframework.urls', namespace='djangorestframework')), ) diff --git a/djangorestframework/tests/parsers.py b/djangorestframework/tests/parsers.py index 1ecc1760..0f36cece 100644 --- a/djangorestframework/tests/parsers.py +++ b/djangorestframework/tests/parsers.py @@ -132,17 +132,18 @@ # self.assertEqual(files['file1'].read(), 'blablabla') from StringIO import StringIO -from cgi import parse_qs from django import forms from django.test import TestCase from djangorestframework.parsers import FormParser from djangorestframework.parsers import XMLParser import datetime + class Form(forms.Form): field1 = forms.CharField(max_length=3) field2 = forms.CharField() + class TestFormParser(TestCase): def setUp(self): self.string = "field1=abc&field2=defghijk" @@ -152,10 +153,11 @@ class TestFormParser(TestCase): parser = FormParser(None) stream = StringIO(self.string) - (data, files) = parser.parse(stream) + (data, files) = parser.parse(stream, {}, []) self.assertEqual(Form(data).is_valid(), True) + class TestXMLParser(TestCase): def setUp(self): self._input = StringIO( @@ -163,13 +165,13 @@ class TestXMLParser(TestCase): '<root>' '<field_a>121.0</field_a>' '<field_b>dasd</field_b>' - '<field_c></field_c>' + '<field_c></field_c>' '<field_d>2011-12-25 12:45:00</field_d>' '</root>' - ) - self._data = { + ) + self._data = { 'field_a': 121, - 'field_b': 'dasd', + 'field_b': 'dasd', 'field_c': None, 'field_d': datetime.datetime(2011, 12, 25, 12, 45, 00) } @@ -183,21 +185,21 @@ class TestXMLParser(TestCase): '</sub_data_list>' '<name>name</name>' '</root>' - ) + ) self._complex_data = { - "creation_date": datetime.datetime(2011, 12, 25, 12, 45, 00), - "name": "name", + "creation_date": datetime.datetime(2011, 12, 25, 12, 45, 00), + "name": "name", "sub_data_list": [ { - "sub_id": 1, + "sub_id": 1, "sub_name": "first" - }, + }, { - "sub_id": 2, + "sub_id": 2, "sub_name": "second" } ] - } + } def test_parse(self): parser = XMLParser(None) diff --git a/djangorestframework/tests/renderers.py b/djangorestframework/tests/renderers.py index cc211dce..8eb78b74 100644 --- a/djangorestframework/tests/renderers.py +++ b/djangorestframework/tests/renderers.py @@ -1,21 +1,180 @@ import re +from django.conf.urls.defaults import patterns, url, include from django.test import TestCase -from django.conf.urls.defaults import patterns, url -from django.test import TestCase - +from djangorestframework import status +from djangorestframework.compat import View as DjangoView from djangorestframework.response import Response +from djangorestframework.mixins import ResponseMixin from djangorestframework.views import View from djangorestframework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer, \ XMLRenderer, JSONPRenderer, DocumentingHTMLRenderer -from djangorestframework.parsers import JSONParser, YAMLParser, XMLParser +from djangorestframework.parsers import YAMLParser, XMLParser 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()), + url(r'^api', include('djangorestframework.urls', namespace='djangorestframework')) +) + + +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): # What the f***? + 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}' @@ -27,6 +186,7 @@ def strip_trailing_whitespace(content): """ return re.sub(' +\n', '\n', content) + class JSONRendererTests(TestCase): """ Tests specific to the JSON Renderer @@ -51,30 +211,16 @@ class JSONRendererTests(TestCase): content = renderer.render(obj, 'application/json; indent=2') self.assertEquals(strip_trailing_whitespace(content), _indented_repr) - def test_render_and_parse(self): - """ - Test rendering and then parsing returns the original object. - IE obj -> render -> parse -> obj. - """ - obj = {'foo': ['bar', 'baz']} - - renderer = JSONRenderer(None) - parser = JSONParser(None) - - content = renderer.render(obj, 'application/json') - (data, files) = parser.parse(StringIO(content)) - self.assertEquals(obj, data) - class MockGETView(View): - def get(self, request, **kwargs): + def get(self, request, *args, **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])), + url(r'^jsonp/jsonrenderer$', MockGETView.as_view(renderers=[JSONRenderer, JSONPRenderer])), + url(r'^jsonp/nojsonrenderer$', MockGETView.as_view(renderers=[JSONPRenderer])), ) @@ -149,22 +295,21 @@ if YAMLRenderer: self.assertEquals(obj, data) - class XMLRendererTestCase(TestCase): """ Tests specific to the XML Renderer """ _complex_data = { - "creation_date": datetime.datetime(2011, 12, 25, 12, 45, 00), - "name": "name", + "creation_date": datetime.datetime(2011, 12, 25, 12, 45, 00), + "name": "name", "sub_data_list": [ { - "sub_id": 1, + "sub_id": 1, "sub_name": "first" - }, + }, { - "sub_id": 2, + "sub_id": 2, "sub_name": "second" } ] @@ -219,12 +364,12 @@ class XMLRendererTestCase(TestCase): renderer = XMLRenderer(None) content = renderer.render({'field': None}, 'application/xml') self.assertXMLContains(content, '<field></field>') - + def test_render_complex_data(self): """ Test XML rendering. """ - renderer = XMLRenderer(None) + renderer = XMLRenderer(None) content = renderer.render(self._complex_data, 'application/xml') self.assertXMLContains(content, '<sub_name>first</sub_name>') self.assertXMLContains(content, '<sub_name>second</sub_name>') @@ -233,9 +378,9 @@ class XMLRendererTestCase(TestCase): """ Test XML rendering. """ - renderer = XMLRenderer(None) + renderer = XMLRenderer(None) content = StringIO(renderer.render(self._complex_data, 'application/xml')) - + parser = XMLParser(None) 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)) @@ -245,4 +390,3 @@ class XMLRendererTestCase(TestCase): self.assertTrue(xml.startswith('<?xml version="1.0" encoding="utf-8"?>\n<root>')) self.assertTrue(xml.endswith('</root>')) self.assertTrue(string in xml, '%r not in %r' % (string, xml)) - 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""" diff --git a/djangorestframework/tests/response.py b/djangorestframework/tests/response.py index 95603680..4cd000bd 100644 --- a/djangorestframework/tests/response.py +++ b/djangorestframework/tests/response.py @@ -1,18 +1,19 @@ import json import unittest -from django.conf.urls.defaults import patterns, url +from django.conf.urls.defaults import patterns, url, include 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 +from djangorestframework.renderers import ( + BaseRenderer, + JSONRenderer, + DocumentingHTMLRenderer, + DEFAULT_RENDERERS +) class TestResponseDetermineRenderer(TestCase): @@ -20,7 +21,7 @@ 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) + kwargs['HTTP_ACCEPT'] = ','.join(accept_list) request = RequestFactory().get(url, **kwargs) return Response(request=request, renderers=renderers) @@ -43,7 +44,7 @@ class TestResponseDetermineRenderer(TestCase): """ 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. @@ -81,7 +82,7 @@ class TestResponseDetermineRenderer(TestCase): 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. @@ -94,14 +95,14 @@ class TestResponseDetermineRenderer(TestCase): 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. + Test rendering simple data to json. """ content = {'a': 1, 'b': [1, 2, 3]} content_type = 'application/json' @@ -134,34 +135,33 @@ class RendererB(BaseRenderer): return RENDERER_B_SERIALIZER(obj) -class MockView(ResponseMixin, DjangoView): - renderer_classes = (RendererA, RendererB) +class MockView(View): + renderers = (RendererA, RendererB) def get(self, request, **kwargs): - response = Response(DUMMYCONTENT, status=DUMMYSTATUS) - self.response = self.prepare_response(response) - return self.response + return Response(DUMMYCONTENT, status=DUMMYSTATUS) class HTMLView(View): - renderer_classes = (DocumentingHTMLRenderer, ) + renderers = (DocumentingHTMLRenderer, ) def get(self, request, **kwargs): return Response('text') class HTMLView1(View): - renderer_classes = (DocumentingHTMLRenderer, JSONRenderer) + renderers = (DocumentingHTMLRenderer, JSONRenderer) def get(self, request, **kwargs): - return Response('text') + 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'^.*\.(?P<format>.+)$', MockView.as_view(renderers=[RendererA, RendererB])), + url(r'^$', MockView.as_view(renderers=[RendererA, RendererB])), url(r'^html$', HTMLView.as_view()), url(r'^html1$', HTMLView1.as_view()), + url(r'^restframework', include('djangorestframework.urls', namespace='djangorestframework')) ) @@ -257,13 +257,6 @@ class RendererIntegrationTests(TestCase): 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): """ @@ -275,10 +268,10 @@ class Issue122Tests(TestCase): """ Test if no infinite recursion occurs. """ - resp = self.client.get('/html') - + self.client.get('/html') + def test_html_renderer_is_first(self): """ Test if no infinite recursion occurs. """ - resp = self.client.get('/html1') + self.client.get('/html1') diff --git a/djangorestframework/tests/reverse.py b/djangorestframework/tests/reverse.py index c2388d62..8d467513 100644 --- a/djangorestframework/tests/reverse.py +++ b/djangorestframework/tests/reverse.py @@ -16,7 +16,8 @@ class MyView(View): renderers = (JSONRenderer, ) def get(self, request): - return Response(reverse('another', request)) + return Response(reverse('myview', request=request)) + urlpatterns = patterns('', url(r'^myview$', MyView.as_view(), name='myview'), diff --git a/djangorestframework/tests/views.py b/djangorestframework/tests/views.py index d4189087..00bce002 100644 --- a/djangorestframework/tests/views.py +++ b/djangorestframework/tests/views.py @@ -1,16 +1,17 @@ -from django.conf.urls.defaults import patterns, url +from django.core.urlresolvers import reverse +from django.conf.urls.defaults import patterns, url, include from django.http import HttpResponse from django.test import TestCase -from django.test import Client from django import forms from django.db import models +from django.utils import simplejson as json -from djangorestframework.views import View -from djangorestframework.parsers import JSONParser from djangorestframework.resources import ModelResource -from djangorestframework.views import ListOrCreateModelView, InstanceModelView - -from StringIO import StringIO +from djangorestframework.views import ( + View, + ListOrCreateModelView, + InstanceModelView +) class MockView(View): @@ -24,6 +25,7 @@ class MockViewFinal(View): def final(self, request, response, *args, **kwargs): return HttpResponse('{"test": "passed"}', content_type="application/json") + class ResourceMockView(View): """This is a resource-based mock view""" @@ -34,6 +36,7 @@ class ResourceMockView(View): form = MockForm + class MockResource(ModelResource): """This is a mock model-based resource""" @@ -45,16 +48,16 @@ class MockResource(ModelResource): model = MockResourceModel fields = ('foo', 'bar', 'baz') -urlpatterns = patterns('djangorestframework.utils.staticviews', - url(r'^accounts/login$', 'api_login'), - url(r'^accounts/logout$', 'api_logout'), +urlpatterns = patterns('', url(r'^mock/$', MockView.as_view()), url(r'^mock/final/$', MockViewFinal.as_view()), url(r'^resourcemock/$', ResourceMockView.as_view()), url(r'^model/$', ListOrCreateModelView.as_view(resource=MockResource)), url(r'^model/(?P<pk>[^/]+)/$', InstanceModelView.as_view(resource=MockResource)), + url(r'^restframework/', include('djangorestframework.urls', namespace='djangorestframework')), ) + class BaseViewTests(TestCase): """Test the base view class of djangorestframework""" urls = 'djangorestframework.tests.views' @@ -62,8 +65,7 @@ class BaseViewTests(TestCase): def test_view_call_final(self): response = self.client.options('/mock/final/') self.assertEqual(response['Content-Type'].split(';')[0], "application/json") - parser = JSONParser(None) - (data, files) = parser.parse(StringIO(response.content)) + data = json.loads(response.content) self.assertEqual(data['test'], 'passed') def test_options_method_simple_view(self): @@ -77,9 +79,9 @@ class BaseViewTests(TestCase): self._verify_options_response(response, name='Resource Mock', description='This is a resource-based mock view', - fields={'foo':'BooleanField', - 'bar':'IntegerField', - 'baz':'CharField', + fields={'foo': 'BooleanField', + 'bar': 'IntegerField', + 'baz': 'CharField', }) def test_options_method_model_resource_list_view(self): @@ -87,9 +89,9 @@ class BaseViewTests(TestCase): self._verify_options_response(response, name='Mock List', description='This is a mock model-based resource', - fields={'foo':'BooleanField', - 'bar':'IntegerField', - 'baz':'CharField', + fields={'foo': 'BooleanField', + 'bar': 'IntegerField', + 'baz': 'CharField', }) def test_options_method_model_resource_detail_view(self): @@ -97,17 +99,16 @@ class BaseViewTests(TestCase): self._verify_options_response(response, name='Mock Instance', description='This is a mock model-based resource', - fields={'foo':'BooleanField', - 'bar':'IntegerField', - 'baz':'CharField', + fields={'foo': 'BooleanField', + 'bar': 'IntegerField', + 'baz': 'CharField', }) def _verify_options_response(self, response, name, description, fields=None, status=200, mime_type='application/json'): self.assertEqual(response.status_code, status) self.assertEqual(response['Content-Type'].split(';')[0], mime_type) - parser = JSONParser(None) - (data, files) = parser.parse(StringIO(response.content)) + data = json.loads(response.content) self.assertTrue('application/json' in data['renders']) self.assertEqual(name, data['name']) self.assertEqual(description, data['description']) @@ -123,15 +124,12 @@ class ExtraViewsTests(TestCase): def test_login_view(self): """Ensure the login view exists""" - response = self.client.get('/accounts/login') + response = self.client.get(reverse('djangorestframework:login')) self.assertEqual(response.status_code, 200) self.assertEqual(response['Content-Type'].split(';')[0], 'text/html') def test_logout_view(self): """Ensure the logout view exists""" - response = self.client.get('/accounts/logout') + response = self.client.get(reverse('djangorestframework:logout')) self.assertEqual(response.status_code, 200) self.assertEqual(response['Content-Type'].split(';')[0], 'text/html') - - # TODO: Add login/logout behaviour tests - |