              def post(self, request, *args, **kwargs):
                  return Response({'FILE_NAME': self.CONTENT['file'].name,
                          'FILE_CONTENT': self.CONTENT['file'].read()})
  
          file = StringIO.StringIO('stuff')
          file.name = 'stuff.txt'
          request = self.factory.post('/', {'file': file})
          view = MockView.as_view()
          response = view(request)
          self.assertEquals(response.raw_content, {"FILE_CONTENT": "stuff", "FILE_NAME": "stuff.txt"})
  
 
</s> remove             def post(self, request, *args, **kwargs):
                return Response({'FILE_NAME': self.CONTENT['file'].name,
                        'FILE_CONTENT': self.CONTENT['file'].read()})
 </s> add #         class MockView(View):
#             permissions = ()
#             form = FileForm </s> remove         class MockView(View):
            permissions = ()
            form = FileForm
 </s> add #         class FileForm(forms.Form):
#             file = forms.FileField() </s> remove 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 import forms
from django.db import models
from django.utils import simplejson as json

from djangorestframework.resources import ModelResource
from djangorestframework.views import (
    View,
    ListOrCreateModelView,
    InstanceModelView
)


class MockView(View):
    """This is a basic mock view"""
    pass


class MockViewFinal(View):
    """View with final() override"""

    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"""

    class MockForm(forms.Form):
        foo = forms.BooleanField(required=False)
        bar = forms.IntegerField(help_text='Must be an integer.')
        baz = forms.CharField(max_length=32)

    form = MockForm


class MockResource(ModelResource):
    """This is a mock model-based resource"""

    class MockResourceModel(models.Model):
        foo = models.BooleanField()
        bar = models.IntegerField(help_text='Must be an integer.')
        baz = models.CharField(max_length=32, help_text='Free text.  Max length 32 chars.')

    model = MockResourceModel
    fields = ('foo', 'bar', 'baz')

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'

    def test_view_call_final(self):
        response = self.client.options('/mock/final/')
        self.assertEqual(response['Content-Type'].split(';')[0], "application/json")
        data = json.loads(response.content)
        self.assertEqual(data['test'], 'passed')

    def test_options_method_simple_view(self):
        response = self.client.options('/mock/')
        self._verify_options_response(response,
                                      name='Mock',
                                      description='This is a basic mock view')

    def test_options_method_resource_view(self):
        response = self.client.options('/resourcemock/')
        self._verify_options_response(response,
                                      name='Resource Mock',
                                      description='This is a resource-based mock view',
                                      fields={'foo': 'BooleanField',
                                              'bar': 'IntegerField',
                                              'baz': 'CharField',
                                              })

    def test_options_method_model_resource_list_view(self):
        response = self.client.options('/model/')
        self._verify_options_response(response,
                                      name='Mock List',
                                      description='This is a mock model-based resource',
                                      fields={'foo': 'BooleanField',
                                              'bar': 'IntegerField',
                                              'baz': 'CharField',
                                              })

    def test_options_method_model_resource_detail_view(self):
        response = self.client.options('/model/0/')
        self._verify_options_response(response,
                                      name='Mock Instance',
                                      description='This is a mock model-based resource',
                                      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)
        data = json.loads(response.content)
        self.assertTrue('application/json' in data['renders'])
        self.assertEqual(name, data['name'])
        self.assertEqual(description, data['description'])
        if fields is None:
            self.assertFalse(hasattr(data, 'fields'))
        else:
            self.assertEqual(data['fields'], fields)


class ExtraViewsTests(TestCase):
    """Test the extra views djangorestframework provides"""
    urls = 'djangorestframework.tests.views'

    def test_login_view(self):
        """Ensure the login view exists"""
        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(reverse('djangorestframework:logout'))
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response['Content-Type'].split(';')[0], 'text/html')
 </s> add # 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.utils import simplejson as json

# from djangorestframework.views import View


# class MockView(View):
#     """This is a basic mock view"""
#     pass


# class MockViewFinal(View):
#     """View with final() override"""

#     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"""

# #     class MockForm(forms.Form):
# #         foo = forms.BooleanField(required=False)
# #         bar = forms.IntegerField(help_text='Must be an integer.')
# #         baz = forms.CharField(max_length=32)

# #     form = MockForm


# # class MockResource(ModelResource):
# #     """This is a mock model-based resource"""

# #     class MockResourceModel(models.Model):
# #         foo = models.BooleanField()
# #         bar = models.IntegerField(help_text='Must be an integer.')
# #         baz = models.CharField(max_length=32, help_text='Free text.  Max length 32 chars.')

# #     model = MockResourceModel
# #     fields = ('foo', 'bar', 'baz')

# 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'

#     def test_view_call_final(self):
#         response = self.client.options('/mock/final/')
#         self.assertEqual(response['Content-Type'].split(';')[0], "application/json")
#         data = json.loads(response.content)
#         self.assertEqual(data['test'], 'passed')

#     def test_options_method_simple_view(self):
#         response = self.client.options('/mock/')
#         self._verify_options_response(response,
#                                       name='Mock',
#                                       description='This is a basic mock view')

#     def test_options_method_resource_view(self):
#         response = self.client.options('/resourcemock/')
#         self._verify_options_response(response,
#                                       name='Resource Mock',
#                                       description='This is a resource-based mock view',
#                                       fields={'foo': 'BooleanField',
#                                               'bar': 'IntegerField',
#                                               'baz': 'CharField',
#                                               })

#     def test_options_method_model_resource_list_view(self):
#         response = self.client.options('/model/')
#         self._verify_options_response(response,
#                                       name='Mock List',
#                                       description='This is a mock model-based resource',
#                                       fields={'foo': 'BooleanField',
#                                               'bar': 'IntegerField',
#                                               'baz': 'CharField',
#                                               })

#     def test_options_method_model_resource_detail_view(self):
#         response = self.client.options('/model/0/')
#         self._verify_options_response(response,
#                                       name='Mock Instance',
#                                       description='This is a mock model-based resource',
#                                       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)
#         data = json.loads(response.content)
#         self.assertTrue('application/json' in data['renders'])
#         self.assertEqual(name, data['name'])
#         self.assertEqual(description, data['description'])
#         if fields is None:
#             self.assertFalse(hasattr(data, 'fields'))
#         else:
#             self.assertEqual(data['fields'], fields)


# class ExtraViewsTests(TestCase):
#     """Test the extra views djangorestframework provides"""
#     urls = 'djangorestframework.tests.views'

#     def test_login_view(self):
#         """Ensure the login view exists"""
#         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(reverse('djangorestframework:logout'))
#         self.assertEqual(response.status_code, 200)
#         self.assertEqual(response['Content-Type'].split(';')[0], 'text/html') </s> remove         form_data = {'username': 'bar1', 'groups': [group.id]}
        request = self.req.post('/groups', data=form_data)
        cleaned_data = dict(form_data)
        cleaned_data['groups'] = [group]
        mixin = CreateModelMixin()
        mixin.resource = UserResource
        mixin.CONTENT = cleaned_data

        response = mixin.post(request)
        self.assertEquals(2, CustomUser.objects.count())
        self.assertEquals(1, response.raw_content.groups.count())
        self.assertEquals('foo1', response.raw_content.groups.all()[0].name)

        group2 = Group(name='foo2')
        group2.save()

        form_data = {'username': 'bar2', 'groups': [group.id, group2.id]}
        request = self.req.post('/groups', data=form_data)
        cleaned_data = dict(form_data)
        cleaned_data['groups'] = [group, group2]
        mixin = CreateModelMixin()
        mixin.resource = UserResource
        mixin.CONTENT = cleaned_data

        response = mixin.post(request)
        self.assertEquals(3, CustomUser.objects.count())
        self.assertEquals(2, response.raw_content.groups.count())
        self.assertEquals('foo1', response.raw_content.groups.all()[0].name)
        self.assertEquals('foo2', response.raw_content.groups.all()[1].name)


class MockPaginatorView(PaginatorMixin, View):
    total = 60

    def get(self, request):
        return Response(range(0, self.total))

    def post(self, request):
        return Response({'status': 'OK'}, status=status.HTTP_201_CREATED)


class TestPagination(TestCase):
    def setUp(self):
        self.req = RequestFactory()

    def test_default_limit(self):
        """ Tests if pagination works without overwriting the limit """
        request = self.req.get('/paginator')
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(MockPaginatorView.total, content['total'])
        self.assertEqual(MockPaginatorView.limit, content['per_page'])

        self.assertEqual(range(0, MockPaginatorView.limit), content['results'])

    def test_overwriting_limit(self):
        """ Tests if the limit can be overwritten """
        limit = 10

        request = self.req.get('/paginator')
        response = MockPaginatorView.as_view(limit=limit)(request)
        content = response.raw_content

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(content['per_page'], limit)

        self.assertEqual(range(0, limit), content['results'])

    def test_limit_param(self):
        """ Tests if the client can set the limit """
        from math import ceil

        limit = 5
        num_pages = int(ceil(MockPaginatorView.total / float(limit)))

        request = self.req.get('/paginator/?limit=%d' % limit)
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(MockPaginatorView.total, content['total'])
        self.assertEqual(limit, content['per_page'])
        self.assertEqual(num_pages, content['pages'])

    def test_exceeding_limit(self):
        """ Makes sure the client cannot exceed the default limit """
        from math import ceil

        limit = MockPaginatorView.limit + 10
        num_pages = int(ceil(MockPaginatorView.total / float(limit)))

        request = self.req.get('/paginator/?limit=%d' % limit)
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(MockPaginatorView.total, content['total'])
        self.assertNotEqual(limit, content['per_page'])
        self.assertNotEqual(num_pages, content['pages'])
        self.assertEqual(MockPaginatorView.limit, content['per_page'])

    def test_only_works_for_get(self):
        """ Pagination should only work for GET requests """
        request = self.req.post('/paginator', data={'content': 'spam'})
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content

        self.assertEqual(response.status_code, status.HTTP_201_CREATED)
        self.assertEqual(None, content.get('per_page'))
        self.assertEqual('OK', content['status'])

    def test_non_int_page(self):
        """ Tests that it can handle invalid values """
        request = self.req.get('/paginator/?page=spam')
        response = MockPaginatorView.as_view()(request)

        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

    def test_page_range(self):
        """ Tests that the page range is handle correctly """
        request = self.req.get('/paginator/?page=0')
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

        request = self.req.get('/paginator/')
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(range(0, MockPaginatorView.limit), content['results'])

        num_pages = content['pages']

        request = self.req.get('/paginator/?page=%d' % num_pages)
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(range(MockPaginatorView.limit*(num_pages-1), MockPaginatorView.total), content['results'])

        request = self.req.get('/paginator/?page=%d' % (num_pages + 1,))
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

    def test_existing_query_parameters_are_preserved(self):
        """ Tests that existing query parameters are preserved when
        generating next/previous page links """
        request = self.req.get('/paginator/?foo=bar&another=something')
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertTrue('foo=bar' in content['next'])
        self.assertTrue('another=something' in content['next'])
        self.assertTrue('page=2' in content['next'])

    def test_duplicate_parameters_are_not_created(self):
        """ Regression: ensure duplicate "page" parameters are not added to
        paginated URLs. So page 1 should contain ?page=2, not ?page=1&page=2 """
        request = self.req.get('/paginator/?page=1')
        response = MockPaginatorView.as_view()(request)
        content = response.raw_content
        self.assertTrue('page=2' in content['next'])
        self.assertFalse('page=1' in content['next'])
 </s> add #         form_data = {'username': 'bar1', 'groups': [group.id]}
#         request = self.req.post('/groups', data=form_data)
#         cleaned_data = dict(form_data)
#         cleaned_data['groups'] = [group]
#         mixin = CreateModelMixin()
#         mixin.resource = UserResource
#         mixin.CONTENT = cleaned_data

#         response = mixin.post(request)
#         self.assertEquals(2, CustomUser.objects.count())
#         self.assertEquals(1, response.raw_content.groups.count())
#         self.assertEquals('foo1', response.raw_content.groups.all()[0].name)

#         group2 = Group(name='foo2')
#         group2.save()

#         form_data = {'username': 'bar2', 'groups': [group.id, group2.id]}
#         request = self.req.post('/groups', data=form_data)
#         cleaned_data = dict(form_data)
#         cleaned_data['groups'] = [group, group2]
#         mixin = CreateModelMixin()
#         mixin.resource = UserResource
#         mixin.CONTENT = cleaned_data

#         response = mixin.post(request)
#         self.assertEquals(3, CustomUser.objects.count())
#         self.assertEquals(2, response.raw_content.groups.count())
#         self.assertEquals('foo1', response.raw_content.groups.all()[0].name)
#         self.assertEquals('foo2', response.raw_content.groups.all()[1].name)


# class MockPaginatorView(PaginatorMixin, View):
#     total = 60

#     def get(self, request):
#         return Response(range(0, self.total))

#     def post(self, request):
#         return Response({'status': 'OK'}, status=status.HTTP_201_CREATED)


# class TestPagination(TestCase):
#     def setUp(self):
#         self.req = RequestFactory()

#     def test_default_limit(self):
#         """ Tests if pagination works without overwriting the limit """
#         request = self.req.get('/paginator')
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content

#         self.assertEqual(response.status_code, status.HTTP_200_OK)
#         self.assertEqual(MockPaginatorView.total, content['total'])
#         self.assertEqual(MockPaginatorView.limit, content['per_page'])

#         self.assertEqual(range(0, MockPaginatorView.limit), content['results'])

#     def test_overwriting_limit(self):
#         """ Tests if the limit can be overwritten """
#         limit = 10

#         request = self.req.get('/paginator')
#         response = MockPaginatorView.as_view(limit=limit)(request)
#         content = response.raw_content

#         self.assertEqual(response.status_code, status.HTTP_200_OK)
#         self.assertEqual(content['per_page'], limit)

#         self.assertEqual(range(0, limit), content['results'])

#     def test_limit_param(self):
#         """ Tests if the client can set the limit """
#         from math import ceil

#         limit = 5
#         num_pages = int(ceil(MockPaginatorView.total / float(limit)))

#         request = self.req.get('/paginator/?limit=%d' % limit)
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content

#         self.assertEqual(response.status_code, status.HTTP_200_OK)
#         self.assertEqual(MockPaginatorView.total, content['total'])
#         self.assertEqual(limit, content['per_page'])
#         self.assertEqual(num_pages, content['pages'])

#     def test_exceeding_limit(self):
#         """ Makes sure the client cannot exceed the default limit """
#         from math import ceil

#         limit = MockPaginatorView.limit + 10
#         num_pages = int(ceil(MockPaginatorView.total / float(limit)))

#         request = self.req.get('/paginator/?limit=%d' % limit)
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content

#         self.assertEqual(response.status_code, status.HTTP_200_OK)
#         self.assertEqual(MockPaginatorView.total, content['total'])
#         self.assertNotEqual(limit, content['per_page'])
#         self.assertNotEqual(num_pages, content['pages'])
#         self.assertEqual(MockPaginatorView.limit, content['per_page'])

#     def test_only_works_for_get(self):
#         """ Pagination should only work for GET requests """
#         request = self.req.post('/paginator', data={'content': 'spam'})
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content

#         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
#         self.assertEqual(None, content.get('per_page'))
#         self.assertEqual('OK', content['status'])

#     def test_non_int_page(self):
#         """ Tests that it can handle invalid values """
#         request = self.req.get('/paginator/?page=spam')
#         response = MockPaginatorView.as_view()(request)

#         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

#     def test_page_range(self):
#         """ Tests that the page range is handle correctly """
#         request = self.req.get('/paginator/?page=0')
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content
#         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

#         request = self.req.get('/paginator/')
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content
#         self.assertEqual(response.status_code, status.HTTP_200_OK)
#         self.assertEqual(range(0, MockPaginatorView.limit), content['results'])

#         num_pages = content['pages']

#         request = self.req.get('/paginator/?page=%d' % num_pages)
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content
#         self.assertEqual(response.status_code, status.HTTP_200_OK)
#         self.assertEqual(range(MockPaginatorView.limit*(num_pages-1), MockPaginatorView.total), content['results'])

#         request = self.req.get('/paginator/?page=%d' % (num_pages + 1,))
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content
#         self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

#     def test_existing_query_parameters_are_preserved(self):
#         """ Tests that existing query parameters are preserved when
#         generating next/previous page links """
#         request = self.req.get('/paginator/?foo=bar&another=something')
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content
#         self.assertEqual(response.status_code, status.HTTP_200_OK)
#         self.assertTrue('foo=bar' in content['next'])
#         self.assertTrue('another=something' in content['next'])
#         self.assertTrue('page=2' in content['next'])

#     def test_duplicate_parameters_are_not_created(self):
#         """ Regression: ensure duplicate "page" parameters are not added to
#         paginated URLs. So page 1 should contain ?page=2, not ?page=1&page=2 """
#         request = self.req.get('/paginator/?page=1')
#         response = MockPaginatorView.as_view()(request)
#         content = response.raw_content
#         self.assertTrue('page=2' in content['next'])
#         self.assertFalse('page=1' in content['next'])
#             def post(self, request, *args, **kwargs):
#                 return Response({'FILE_NAME': self.CONTENT['file'].name,
#                         'FILE_CONTENT': self.CONTENT['file'].read()})
              def post(self, request, *args, **kwargs):
                  return Response({'FILE_NAME': self.CONTENT['file'].name,
                          'FILE_CONTENT': self.CONTENT['file'].read()})
  
#             def post(self, request, *args, **kwargs):
#                 return Response({'FILE_NAME': self.CONTENT['file'].name,
#                         'FILE_CONTENT': self.CONTENT['file'].read()})
#             def post(self, request, *args, **kwargs):
#                 return Response({'FILE_NAME': self.CONTENT['file'].name,
#                         'FILE_CONTENT': self.CONTENT['file'].read()})
#             def post(self, request, *args, **kwargs):
#                 return Response({'FILE_NAME': self.CONTENT['file'].name,
#                         'FILE_CONTENT': self.CONTENT['file'].read()})
#             def post(self, request, *args, **kwargs):
#                 return Response({'FILE_NAME': self.CONTENT['file'].name,
#                         'FILE_CONTENT': self.CONTENT['file'].read()})
#             def post(self, request, *args, **kwargs):
#                 return Response({'FILE_NAME': self.CONTENT['file'].name,
#                         'FILE_CONTENT': self.CONTENT['file'].read()})
#             def post(self, request, *args, **kwargs):
#                 return Response({'FILE_NAME': self.CONTENT['file'].name,
#                         'FILE_CONTENT': self.CONTENT['file'].read()})
  
keep keep keep keep replace replace replace replace replace replace keep
 Drop out resources & mixins 
djangorestframework/tests/files.py