refactoring resource specfic stuff into ResourceMixin - validators now defunct

4 files changed, 33 insertions, 25 deletions

diff --git a/djangorestframework/tests/content.py b/djangorestframework/tests/content.py
index e566ea00..a99981fd 100644
--- a/djangorestframework/tests/content.py
+++ b/djangorestframework/tests/content.py
@@ -14,14 +14,14 @@ class TestContentParsing(TestCase):
     def ensure_determines_no_content_GET(self, view):
         """Ensure view.RAW_CONTENT returns None for GET request with no content."""
         view.request = self.req.get('/')
-        self.assertEqual(view.RAW_CONTENT, None)
+        self.assertEqual(view.DATA, None)
 
     def ensure_determines_form_content_POST(self, view):
         """Ensure view.RAW_CONTENT 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.RAW_CONTENT, form_data)
+        self.assertEqual(view.DATA, form_data)
 
     def ensure_determines_non_form_content_POST(self, view):
         """Ensure view.RAW_CONTENT returns content for POST request with non-form content."""
@@ -29,14 +29,14 @@ class TestContentParsing(TestCase):
         content_type = 'text/plain'
         view.parsers = (PlainTextParser,)
         view.request = self.req.post('/', content, content_type=content_type)
-        self.assertEqual(view.RAW_CONTENT, content)
+        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.RAW_CONTENT, form_data)
+        self.assertEqual(view.DATA, form_data)
 
     def ensure_determines_non_form_content_PUT(self, view):
         """Ensure view.RAW_CONTENT returns content for PUT request with non-form content."""
@@ -44,36 +44,36 @@ class TestContentParsing(TestCase):
         content_type = 'text/plain'
         view.parsers = (PlainTextParser,)
         view.request = self.req.post('/', content, content_type=content_type)
-        self.assertEqual(view.RAW_CONTENT, content)
+        self.assertEqual(view.DATA, content)
 
     def test_standard_behaviour_determines_no_content_GET(self):
-        """Ensure view.RAW_CONTENT returns None for GET request with no content."""
+        """Ensure view.DATA returns None for GET request with no content."""
         self.ensure_determines_no_content_GET(RequestMixin())
 
     def test_standard_behaviour_determines_form_content_POST(self):
-        """Ensure view.RAW_CONTENT returns content for POST request with form content."""
+        """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.RAW_CONTENT returns content for POST request with non-form content."""
+        """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.RAW_CONTENT returns content for PUT request with form content."""
+        """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.RAW_CONTENT returns content for PUT request with non-form content."""
+        """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.RAW_CONTENT returns content for overloaded POST request"""
+        """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}
+        form_data = {view._CONTENT_PARAM: content,
+                     view._CONTENTTYPE_PARAM: content_type}
         view.request = self.req.post('/', form_data)
         view.parsers = (PlainTextParser,)
-        view.perform_form_overloading()
-        self.assertEqual(view.RAW_CONTENT, content)
+        view._perform_form_overloading()
+        self.assertEqual(view.DATA, content)
diff --git a/djangorestframework/tests/files.py b/djangorestframework/tests/files.py
index f0321cb3..fc82fd83 100644
--- a/djangorestframework/tests/files.py
+++ b/djangorestframework/tests/files.py
@@ -2,6 +2,7 @@ from django.test import TestCase
 from django import forms
 from djangorestframework.compat import RequestFactory
 from djangorestframework.views import BaseView
+from djangorestframework.resource import FormResource
 import StringIO
 
 class UploadFilesTests(TestCase):
@@ -15,9 +16,12 @@ class UploadFilesTests(TestCase):
         class FileForm(forms.Form):
             file = forms.FileField
 
+        class MockResource(FormResource):
+            form = FileForm
+
         class MockView(BaseView):
             permissions = ()
-            form = FileForm
+            resource = MockResource
 
             def post(self, request, *args, **kwargs):
                 return {'FILE_NAME': self.CONTENT['file'].name,
diff --git a/djangorestframework/tests/methods.py b/djangorestframework/tests/methods.py
index 0e74dc94..961d518b 100644
--- a/djangorestframework/tests/methods.py
+++ b/djangorestframework/tests/methods.py
@@ -22,6 +22,6 @@ class TestMethodOverloading(TestCase):
     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'})
-        view.perform_form_overloading()
+        view.request = self.req.post('/', {view._METHOD_PARAM: 'DELETE'})
+        view._perform_form_overloading()
         self.assertEqual(view.method, 'DELETE')
diff --git a/djangorestframework/tests/parsers.py b/djangorestframework/tests/parsers.py
index 88aad880..2720f4c7 100644
--- a/djangorestframework/tests/parsers.py
+++ b/djangorestframework/tests/parsers.py
@@ -24,7 +24,8 @@ Here is some example data, which would eventually be sent along with a post requ
 
 Default behaviour for :class:`parsers.FormParser`, is to return a single value for each parameter :
 
-    >>> FormParser(some_view).parse(StringIO(inpt)) == {'key1': 'bla1', 'key2': 'blo1'}
+    >>> (data, files) = FormParser(some_view).parse(StringIO(inpt))
+    >>> data == {'key1': 'bla1', 'key2': 'blo1'}
     True
 
 However, you can customize this behaviour by subclassing :class:`parsers.FormParser`, and overriding :meth:`parsers.FormParser.is_a_list` :
@@ -36,7 +37,8 @@ However, you can customize this behaviour by subclassing :class:`parsers.FormPar
 
 This new parser only flattens the lists of parameters that contain a single value.
 
-    >>> MyFormParser(some_view).parse(StringIO(inpt)) == {'key1': 'bla1', 'key2': ['blo1', 'blo2']}
+    >>> (data, files) = MyFormParser(some_view).parse(StringIO(inpt))
+    >>> data == {'key1': 'bla1', 'key2': ['blo1', 'blo2']}
     True
 
 .. note:: The same functionality is available for :class:`parsers.MultiPartParser`.
@@ -61,7 +63,8 @@ The browsers usually strip the parameter completely. A hack to avoid this, and t
 
 :class:`parsers.FormParser` strips the values ``_empty`` from all the lists.
 
-    >>> MyFormParser(some_view).parse(StringIO(inpt)) == {'key1': 'blo1'}
+    >>> (data, files) = MyFormParser(some_view).parse(StringIO(inpt))
+    >>> data == {'key1': 'blo1'}
     True
 
 Oh ... but wait a second, the parameter ``key2`` isn't even supposed to be a list, so the parser just stripped it.
@@ -71,7 +74,8 @@ Oh ... but wait a second, the parameter ``key2`` isn't even supposed to be a lis
     ...     def is_a_list(self, key, val_list):
     ...         return key == 'key2'
     ... 
-    >>> MyFormParser(some_view).parse(StringIO(inpt)) == {'key1': 'blo1', 'key2': []}
+    >>> (data, files) = MyFormParser(some_view).parse(StringIO(inpt))
+    >>> data == {'key1': 'blo1', 'key2': []}
     True
 
 Better like that. Note that you can configure something else than ``_empty`` for the empty value by setting :attr:`parsers.FormParser.EMPTY_VALUE`.
@@ -123,7 +127,7 @@ class TestMultiPartParser(TestCase):
         post_req = RequestFactory().post('/', self.body, content_type=self.content_type)
         view = BaseView()
         view.request = post_req
-        parsed = MultiPartParser(view).parse(StringIO(self.body))
-        self.assertEqual(parsed['key1'], 'val1')
-        self.assertEqual(parsed.FILES['file1'].read(), 'blablabla')
+        (data, files) = MultiPartParser(view).parse(StringIO(self.body))
+        self.assertEqual(data['key1'], 'val1')
+        self.assertEqual(files['file1'].read(), 'blablabla')