Tests now run with django-discover-runner instead of a custom suite.

development.txt

@@ -0,0 +1 @@
+django-discover-runner>=0.2.2

rest_framework/runtests/runcoverage.py

@@ -11,10 +11,12 @@ import sys
 
 # fix sys path so we don't need to setup PYTHONPATH
 sys.path.append(os.path.join(os.path.dirname(__file__), "../.."))
-os.environ['DJANGO_SETTINGS_MODULE'] = 'rest_framework.runtests.settings'
+os.environ['DJANGO_SETTINGS_MODULE'] = 'rest_framework.tests.settings'
-
-from coverage import coverage
 
+try:
+    from coverage import coverage
+except ImportError:
+    print("Coverage is not installed. Aborting...")
 
 def main():
     """Run the tests for rest_framework and generate a coverage report."""
@@ -25,12 +27,14 @@ def main():
 
     from django.conf import settings
     from django.test.utils import get_runner
+
     TestRunner = get_runner(settings)
 
     if hasattr(TestRunner, 'func_name'):
         # Pre 1.2 test runners were just functions,
         # and did not support the 'failfast' option.
         import warnings
+
         warnings.warn(
             'Function-based test runners are deprecated. Test runners should be classes with a run_tests() method.',
             DeprecationWarning

rest_framework/runtests/runtests.py

@@ -1,43 +1,11 @@
 #!/usr/bin/env python
-
-# http://ericholscher.com/blog/2009/jun/29/enable-setuppy-test-your-django-apps/
-# http://www.travisswicegood.com/2010/01/17/django-virtualenv-pip-and-fabric/
-# http://code.djangoproject.com/svn/django/trunk/tests/runtests.py
 import os
 import sys
 
-# fix sys path so we don't need to setup PYTHONPATH
 sys.path.append(os.path.join(os.path.dirname(__file__), "../.."))
-os.environ['DJANGO_SETTINGS_MODULE'] = 'rest_framework.runtests.settings'
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "rest_framework.tests.settings")
 
-from django.conf import settings
+from django.core.management import execute_from_command_line
-from django.test.utils import get_runner
 
-
+sys.argv.append('test')
-def usage():
+execute_from_command_line(sys.argv)
-    return """
-    Usage: python runtests.py [UnitTestClass].[method]
-
-    You can pass the Class name of the `UnitTestClass` you want to test.
-
-    Append a method name if you only want to test a specific method of that class.
-    """
-
-
-def main():
-    TestRunner = get_runner(settings)
-
-    test_runner = TestRunner()
-    if len(sys.argv) == 2:
-        test_case = '.' + sys.argv[1]
-    elif len(sys.argv) == 1:
-        test_case = ''
-    else:
-        print usage()
-        sys.exit(1)
-    failures = test_runner.run_tests(['tests' + test_case])
-
-    sys.exit(failures)
-
-if __name__ == '__main__':
-    main()

rest_framework/runtests/settings.py

@@ -1,117 +0,0 @@
-# Django settings for testproject project.
-
-DEBUG = True
-TEMPLATE_DEBUG = DEBUG
-DEBUG_PROPAGATE_EXCEPTIONS = True
-
-ADMINS = (
-    # ('Your Name', 'your_email@domain.com'),
-)
-
-MANAGERS = ADMINS
-
-DATABASES = {
-    'default': {
-        'ENGINE': 'django.db.backends.sqlite3',  # Add 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' or 'oracle'.
-        'NAME': 'sqlite.db',                     # Or path to database file if using sqlite3.
-        'USER': '',                      # Not used with sqlite3.
-        'PASSWORD': '',                  # Not used with sqlite3.
-        'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
-        'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
-    }
-}
-
-CACHES = {
-    'default': {
-        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
-    }
-}
-
-# Local time zone for this installation. Choices can be found here:
-# http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
-# although not all choices may be available on all operating systems.
-# On Unix systems, a value of None will cause Django to use the same
-# timezone as the operating system.
-# If running in a Windows environment this must be set to the same as your
-# system time zone.
-TIME_ZONE = 'Europe/London'
-
-# Language code for this installation. All choices can be found here:
-# http://www.i18nguy.com/unicode/language-identifiers.html
-LANGUAGE_CODE = 'en-uk'
-
-SITE_ID = 1
-
-# If you set this to False, Django will make some optimizations so as not
-# to load the internationalization machinery.
-USE_I18N = True
-
-# If you set this to False, Django will not format dates, numbers and
-# calendars according to the current locale
-USE_L10N = True
-
-# Absolute filesystem path to the directory that will hold user-uploaded files.
-# Example: "/home/media/media.lawrence.com/"
-MEDIA_ROOT = ''
-
-# URL that handles the media served from MEDIA_ROOT. Make sure to use a
-# trailing slash if there is a path component (optional in other cases).
-# Examples: "http://media.lawrence.com", "http://example.com/media/"
-MEDIA_URL = ''
-
-# Make this unique, and don't share it with anybody.
-SECRET_KEY = 'u@x-aj9(hoh#rb-^ymf#g2jx_hp0vj7u5#b@ag1n^seu9e!%cy'
-
-# List of callables that know how to import templates from various sources.
-TEMPLATE_LOADERS = (
-    'django.template.loaders.filesystem.Loader',
-    'django.template.loaders.app_directories.Loader',
-#     'django.template.loaders.eggs.Loader',
-)
-
-MIDDLEWARE_CLASSES = (
-    'django.middleware.common.CommonMiddleware',
-    'django.contrib.sessions.middleware.SessionMiddleware',
-    'django.middleware.csrf.CsrfViewMiddleware',
-    'django.contrib.auth.middleware.AuthenticationMiddleware',
-    'django.contrib.messages.middleware.MessageMiddleware',
-)
-
-ROOT_URLCONF = 'urls'
-
-TEMPLATE_DIRS = (
-    # Put strings here, like "/home/html/django_templates" or "C:/www/django/templates".
-    # Always use forward slashes, even on Windows.
-    # Don't forget to use absolute paths, not relative paths.
-)
-
-INSTALLED_APPS = (
-    'django.contrib.auth',
-    'django.contrib.contenttypes',
-    'django.contrib.sessions',
-    'django.contrib.sites',
-    'django.contrib.messages',
-    # Uncomment the next line to enable the admin:
-    # 'django.contrib.admin',
-    # Uncomment the next line to enable admin documentation:
-    # 'django.contrib.admindocs',
-    'rest_framework',
-    'rest_framework.authtoken',
-    'rest_framework.tests'
-)
-
-STATIC_URL = '/static/'
-
-import django
-
-if django.VERSION < (1, 3):
-    INSTALLED_APPS += ('staticfiles',)
-
-
-# If we're running on the Jenkins server we want to archive the coverage reports as XML.
-import os
-if os.environ.get('HUDSON_URL', None):
-    TEST_RUNNER = 'xmlrunner.extra.djangotestrunner.XMLTestRunner'
-    TEST_OUTPUT_VERBOSE = True
-    TEST_OUTPUT_DESCRIPTIONS = True
-    TEST_OUTPUT_DIR = 'xmlrunner'

rest_framework/tests/test_authentication.py

@@ -11,6 +11,7 @@ from rest_framework.views import APIView
 import json
 import base64
 
+import sure
 
 class MockView(APIView):
     permission_classes = (permissions.IsAuthenticated,)
@@ -31,7 +32,7 @@ urlpatterns = patterns('',
 
 class BasicAuthTests(TestCase):
     """Basic authentication"""
-    urls = 'rest_framework.tests.authentication'
+    urls = 'rest_framework.tests.test_authentication'
 
     def setUp(self):
         self.csrf_client = Client(enforce_csrf_checks=True)
@@ -44,29 +45,30 @@ class BasicAuthTests(TestCase):
         """Ensure POSTing json over basic auth with correct credentials passes and does not require CSRF"""
         auth = 'Basic %s' % base64.encodestring('%s:%s' % (self.username, self.password)).strip()
         response = self.csrf_client.post('/basic/', {'example': 'example'}, HTTP_AUTHORIZATION=auth)
-        self.assertEqual(response.status_code, 200)
+        response.status_code.should.equal(200)
 
     def test_post_json_passing_basic_auth(self):
         """Ensure POSTing form over basic auth with correct credentials passes and does not require CSRF"""
         auth = 'Basic %s' % base64.encodestring('%s:%s' % (self.username, self.password)).strip()
-        response = self.csrf_client.post('/basic/', json.dumps({'example': 'example'}), 'application/json', HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.post('/basic/', json.dumps({'example': 'example'}), 'application/json',
-        self.assertEqual(response.status_code, 200)
+            HTTP_AUTHORIZATION=auth)
+        response.status_code.should.equal(200)
 
     def test_post_form_failing_basic_auth(self):
         """Ensure POSTing form over basic auth without correct credentials fails"""
         response = self.csrf_client.post('/basic/', {'example': 'example'})
-        self.assertEqual(response.status_code, 401)
+        response.status_code.should.equal(401)
 
     def test_post_json_failing_basic_auth(self):
         """Ensure POSTing json over basic auth without correct credentials fails"""
         response = self.csrf_client.post('/basic/', json.dumps({'example': 'example'}), 'application/json')
-        self.assertEqual(response.status_code, 401)
+        response.status_code.should.equal(401)
-        self.assertEqual(response['WWW-Authenticate'], 'Basic realm="api"')
+        response['WWW-Authenticate'].should.equal('Basic realm="api"')
 
 
 class SessionAuthTests(TestCase):
     """User session authentication"""
-    urls = 'rest_framework.tests.authentication'
+    urls = 'rest_framework.tests.test_authentication'
 
     def setUp(self):
         self.csrf_client = Client(enforce_csrf_checks=True)
@@ -85,7 +87,7 @@ class SessionAuthTests(TestCase):
         """
         self.csrf_client.login(username=self.username, password=self.password)
         response = self.csrf_client.post('/session/', {'example': 'example'})
-        self.assertEqual(response.status_code, 403)
+        response.status_code.should.equal(403)
 
     def test_post_form_session_auth_passing(self):
         """
@@ -93,7 +95,7 @@ class SessionAuthTests(TestCase):
         """
         self.non_csrf_client.login(username=self.username, password=self.password)
         response = self.non_csrf_client.post('/session/', {'example': 'example'})
-        self.assertEqual(response.status_code, 200)
+        response.status_code.should.equal(200)
 
     def test_put_form_session_auth_passing(self):
         """
@@ -101,19 +103,19 @@ class SessionAuthTests(TestCase):
         """
         self.non_csrf_client.login(username=self.username, password=self.password)
         response = self.non_csrf_client.put('/session/', {'example': 'example'})
-        self.assertEqual(response.status_code, 200)
+        response.status_code.should.equal(200)
 
     def test_post_form_session_auth_failing(self):
         """
         Ensure POSTing form over session authentication without logged in user fails.
         """
         response = self.csrf_client.post('/session/', {'example': 'example'})
-        self.assertEqual(response.status_code, 403)
+        response.status_code.should.equal(403)
 
 
 class TokenAuthTests(TestCase):
     """Token authentication"""
-    urls = 'rest_framework.tests.authentication'
+    urls = 'rest_framework.tests.test_authentication'
 
     def setUp(self):
         self.csrf_client = Client(enforce_csrf_checks=True)
@@ -129,35 +131,36 @@ class TokenAuthTests(TestCase):
         """Ensure POSTing json over token auth with correct credentials passes and does not require CSRF"""
         auth = "Token " + self.key
         response = self.csrf_client.post('/token/', {'example': 'example'}, HTTP_AUTHORIZATION=auth)
-        self.assertEqual(response.status_code, 200)
+        response.status_code.should.equal(200)
 
     def test_post_json_passing_token_auth(self):
         """Ensure POSTing form over token auth with correct credentials passes and does not require CSRF"""
         auth = "Token " + self.key
-        response = self.csrf_client.post('/token/', json.dumps({'example': 'example'}), 'application/json', HTTP_AUTHORIZATION=auth)
+        response = self.csrf_client.post('/token/', json.dumps({'example': 'example'}), 'application/json',
-        self.assertEqual(response.status_code, 200)
+            HTTP_AUTHORIZATION=auth)
+        response.status_code.should.equal(200)
 
     def test_post_form_failing_token_auth(self):
         """Ensure POSTing form over token auth without correct credentials fails"""
         response = self.csrf_client.post('/token/', {'example': 'example'})
-        self.assertEqual(response.status_code, 401)
+        response.status_code.should.equal(401)
 
     def test_post_json_failing_token_auth(self):
         """Ensure POSTing json over token auth without correct credentials fails"""
         response = self.csrf_client.post('/token/', json.dumps({'example': 'example'}), 'application/json')
-        self.assertEqual(response.status_code, 401)
+        response.status_code.should.equal(401)
 
     def test_token_has_auto_assigned_key_if_none_provided(self):
         """Ensure creating a token with no key will auto-assign a key"""
         self.token.delete()
         token = Token.objects.create(user=self.user)
-        self.assertTrue(bool(token.key))
+        token.key.should.be.ok
 
     def test_token_login_json(self):
         """Ensure token login view using JSON POST works."""
         client = Client(enforce_csrf_checks=True)
         response = client.post('/auth-token/',
-                               json.dumps({'username': self.username, 'password': self.password}), 'application/json')
+            json.dumps({'username': self.username, 'password': self.password}), 'application/json')
         self.assertEqual(response.status_code, 200)
         self.assertEqual(json.loads(response.content)['token'], self.key)
 
@@ -165,20 +168,20 @@ class TokenAuthTests(TestCase):
         """Ensure token login view using JSON POST fails if bad credentials are used."""
         client = Client(enforce_csrf_checks=True)
         response = client.post('/auth-token/',
-                               json.dumps({'username': self.username, 'password': "badpass"}), 'application/json')
+            json.dumps({'username': self.username, 'password': "badpass"}), 'application/json')
         self.assertEqual(response.status_code, 400)
 
     def test_token_login_json_missing_fields(self):
         """Ensure token login view using JSON POST fails if missing fields."""
         client = Client(enforce_csrf_checks=True)
         response = client.post('/auth-token/',
-                               json.dumps({'username': self.username}), 'application/json')
+            json.dumps({'username': self.username}), 'application/json')
         self.assertEqual(response.status_code, 400)
 
     def test_token_login_form(self):
         """Ensure token login view using form POST works."""
         client = Client(enforce_csrf_checks=True)
         response = client.post('/auth-token/',
-                               {'username': self.username, 'password': self.password})
+            {'username': self.username, 'password': self.password})
         self.assertEqual(response.status_code, 200)
         self.assertEqual(json.loads(response.content)['token'], self.key)

rest_framework/tests/test_breadcrumbs.py

@@ -35,7 +35,7 @@ urlpatterns = patterns('',
 class BreadcrumbTests(TestCase):
     """Tests the breadcrumb functionality used by the HTML renderer."""
 
-    urls = 'rest_framework.tests.breadcrumbs'
+    urls = 'rest_framework.tests.test_breadcrumbs'
 
     def test_root_breadcrumbs(self):
         url = '/'
@@ -44,28 +44,28 @@ class BreadcrumbTests(TestCase):
     def test_resource_root_breadcrumbs(self):
         url = '/resource/'
         self.assertEqual(get_breadcrumbs(url), [('Root', '/'),
-                                            ('Resource Root', '/resource/')])
+                                                ('Resource Root', '/resource/')])
 
     def test_resource_instance_breadcrumbs(self):
         url = '/resource/123'
         self.assertEqual(get_breadcrumbs(url), [('Root', '/'),
-                                            ('Resource Root', '/resource/'),
+                                                ('Resource Root', '/resource/'),
-                                            ('Resource Instance', '/resource/123')])
+                                                ('Resource Instance', '/resource/123')])
 
     def test_nested_resource_breadcrumbs(self):
         url = '/resource/123/'
         self.assertEqual(get_breadcrumbs(url), [('Root', '/'),
-                                            ('Resource Root', '/resource/'),
+                                                ('Resource Root', '/resource/'),
-                                            ('Resource Instance', '/resource/123'),
+                                                ('Resource Instance', '/resource/123'),
-                                            ('Nested Resource Root', '/resource/123/')])
+                                                ('Nested Resource Root', '/resource/123/')])
 
     def test_nested_resource_instance_breadcrumbs(self):
         url = '/resource/123/abc'
         self.assertEqual(get_breadcrumbs(url), [('Root', '/'),
-                                            ('Resource Root', '/resource/'),
+                                                ('Resource Root', '/resource/'),
-                                            ('Resource Instance', '/resource/123'),
+                                                ('Resource Instance', '/resource/123'),
-                                            ('Nested Resource Root', '/resource/123/'),
+                                                ('Nested Resource Root', '/resource/123/'),
-                                            ('Nested Resource Instance', '/resource/123/abc')])
+                                                ('Nested Resource Instance', '/resource/123/abc')])
 
     def test_broken_url_breadcrumbs_handled_gracefully(self):
         url = '/foobar'

rest_framework/tests/test_decorators.py

@@ -14,13 +14,12 @@ from rest_framework.decorators import (
     authentication_classes,
     throttle_classes,
     permission_classes,
-)
+    )
 
 from rest_framework.tests.utils import RequestFactory
 
 
 class DecoratorTestCase(TestCase):
-
     def setUp(self):
         self.factory = RequestFactory()
 
@@ -51,7 +50,6 @@ class DecoratorTestCase(TestCase):
                 return Response()
 
     def test_calling_method(self):
-
         @api_view(['GET'])
         def view(request):
             return Response({})
@@ -65,7 +63,6 @@ class DecoratorTestCase(TestCase):
         self.assertEqual(response.status_code, 405)
 
     def test_calling_put_method(self):
-
         @api_view(['GET', 'PUT'])
         def view(request):
             return Response({})
@@ -79,7 +76,6 @@ class DecoratorTestCase(TestCase):
         self.assertEqual(response.status_code, 405)
 
     def test_calling_patch_method(self):
-
         @api_view(['GET', 'PATCH'])
         def view(request):
             return Response({})
@@ -93,7 +89,6 @@ class DecoratorTestCase(TestCase):
         self.assertEqual(response.status_code, 405)
 
     def test_renderer_classes(self):
-
         @api_view(['GET'])
         @renderer_classes([JSONRenderer])
         def view(request):
@@ -104,33 +99,30 @@ class DecoratorTestCase(TestCase):
         self.assertTrue(isinstance(response.accepted_renderer, JSONRenderer))
 
     def test_parser_classes(self):
-
         @api_view(['GET'])
         @parser_classes([JSONParser])
         def view(request):
             self.assertEqual(len(request.parsers), 1)
             self.assertTrue(isinstance(request.parsers[0],
-                                       JSONParser))
+                JSONParser))
             return Response({})
 
         request = self.factory.get('/')
         view(request)
 
     def test_authentication_classes(self):
-
         @api_view(['GET'])
         @authentication_classes([BasicAuthentication])
         def view(request):
             self.assertEqual(len(request.authenticators), 1)
             self.assertTrue(isinstance(request.authenticators[0],
-                                       BasicAuthentication))
+                BasicAuthentication))
             return Response({})
 
         request = self.factory.get('/')
         view(request)
 
     def test_permission_classes(self):
-
         @api_view(['GET'])
         @permission_classes([IsAuthenticated])
         def view(request):

rest_framework/tests/test_description.py

@@ -48,20 +48,25 @@ MARKED_DOWN_gte_21 = """<h2 id="an-example-docstring">an example docstring</h2>
 class TestViewNamesAndDescriptions(TestCase):
     def test_resource_name_uses_classname_by_default(self):
         """Ensure Resource names are based on the classname by default."""
+
         class MockView(APIView):
             pass
+
         self.assertEquals(MockView().get_name(), 'Mock')
 
     def test_resource_name_can_be_set_explicitly(self):
         """Ensure Resource names can be set using the 'get_name' method."""
         example = 'Some Other Name'
+
         class MockView(APIView):
             def get_name(self):
                 return example
+
         self.assertEquals(MockView().get_name(), example)
 
     def test_resource_description_uses_docstring_by_default(self):
         """Ensure Resource names are based on the docstring by default."""
+
         class MockView(APIView):
             """an example docstring
             ====================
@@ -86,8 +91,10 @@ class TestViewNamesAndDescriptions(TestCase):
 
         class MockView(APIView):
             """docstring"""
+
             def get_description(self):
                 return example
+
         self.assertEquals(MockView().get_description(), example)
 
     def test_resource_description_does_not_require_docstring(self):
@@ -97,12 +104,15 @@ class TestViewNamesAndDescriptions(TestCase):
         class MockView(APIView):
             def get_description(self):
                 return example
+
         self.assertEquals(MockView().get_description(), example)
 
     def test_resource_description_can_be_empty(self):
         """Ensure that if a resource has no doctring or 'description' class attribute, then it's description is the empty string."""
+
         class MockView(APIView):
             pass
+
         self.assertEquals(MockView().get_description(), '')
 
     def test_markdown(self):

rest_framework/tests/test_filterset.py

@@ -9,7 +9,6 @@ from rest_framework.tests.models import FilterableItem, BasicModel
 
 factory = RequestFactory()
 
-
 if django_filters:
     # Basic filter on a list view.
     class FilterFieldsRootView(generics.ListCreateAPIView):
@@ -142,7 +141,7 @@ class IntegrationTestFiltering(TestCase):
         response = view(request).render()
         self.assertEquals(response.status_code, status.HTTP_200_OK)
         expected_data = [f for f in self.data if f['date'] > search_date and
-                                                  f['decimal'] < search_decimal]
+                                                 f['decimal'] < search_decimal]
         self.assertEquals(response.data, expected_data)
 
     @unittest.skipUnless(django_filters, 'django-filters not installed')

rest_framework/tests/test_generics.py

@@ -49,8 +49,8 @@ class TestRootView(TestCase):
             BasicModel(text=item).save()
         self.objects = BasicModel.objects
         self.data = [
-            {'id': obj.id, 'text': obj.text}
+        {'id': obj.id, 'text': obj.text}
-            for obj in self.objects.all()
+        for obj in self.objects.all()
         ]
         self.view = RootView.as_view()
 
@@ -69,7 +69,7 @@ class TestRootView(TestCase):
         """
         content = {'text': 'foobar'}
         request = factory.post('/', json.dumps(content),
-                               content_type='application/json')
+            content_type='application/json')
         response = self.view(request).render()
         self.assertEquals(response.status_code, status.HTTP_201_CREATED)
         self.assertEquals(response.data, {'id': 4, 'text': u'foobar'})
@@ -82,7 +82,7 @@ class TestRootView(TestCase):
         """
         content = {'text': 'foobar'}
         request = factory.put('/', json.dumps(content),
-                              content_type='application/json')
+            content_type='application/json')
         response = self.view(request).render()
         self.assertEquals(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
         self.assertEquals(response.data, {"detail": "Method 'PUT' not allowed."})
@@ -124,7 +124,7 @@ class TestRootView(TestCase):
         """
         content = {'id': 999, 'text': 'foobar'}
         request = factory.post('/', json.dumps(content),
-                               content_type='application/json')
+            content_type='application/json')
         response = self.view(request).render()
         self.assertEquals(response.status_code, status.HTTP_201_CREATED)
         self.assertEquals(response.data, {'id': 4, 'text': u'foobar'})
@@ -142,8 +142,8 @@ class TestInstanceView(TestCase):
             BasicModel(text=item).save()
         self.objects = BasicModel.objects
         self.data = [
-            {'id': obj.id, 'text': obj.text}
+        {'id': obj.id, 'text': obj.text}
-            for obj in self.objects.all()
+        for obj in self.objects.all()
         ]
         self.view = InstanceView.as_view()
         self.slug_based_view = SlugBasedInstanceView.as_view()
@@ -163,7 +163,7 @@ class TestInstanceView(TestCase):
         """
         content = {'text': 'foobar'}
         request = factory.post('/', json.dumps(content),
-                               content_type='application/json')
+            content_type='application/json')
         response = self.view(request).render()
         self.assertEquals(response.status_code, status.HTTP_405_METHOD_NOT_ALLOWED)
         self.assertEquals(response.data, {"detail": "Method 'POST' not allowed."})
@@ -174,7 +174,7 @@ class TestInstanceView(TestCase):
         """
         content = {'text': 'foobar'}
         request = factory.put('/1', json.dumps(content),
-                              content_type='application/json')
+            content_type='application/json')
         response = self.view(request, pk='1').render()
         self.assertEquals(response.status_code, status.HTTP_200_OK)
         self.assertEquals(response.data, {'id': 1, 'text': 'foobar'})
@@ -187,7 +187,7 @@ class TestInstanceView(TestCase):
         """
         content = {'text': 'foobar'}
         request = factory.patch('/1', json.dumps(content),
-                              content_type='application/json')
+            content_type='application/json')
 
         response = self.view(request, pk=1).render()
         self.assertEquals(response.status_code, status.HTTP_200_OK)
@@ -234,7 +234,7 @@ class TestInstanceView(TestCase):
         """
         content = {'id': 999, 'text': 'foobar'}
         request = factory.put('/1', json.dumps(content),
-                              content_type='application/json')
+            content_type='application/json')
         response = self.view(request, pk=1).render()
         self.assertEquals(response.status_code, status.HTTP_200_OK)
         self.assertEquals(response.data, {'id': 1, 'text': 'foobar'})
@@ -249,7 +249,7 @@ class TestInstanceView(TestCase):
         self.objects.get(id=1).delete()
         content = {'text': 'foobar'}
         request = factory.put('/1', json.dumps(content),
-                              content_type='application/json')
+            content_type='application/json')
         response = self.view(request, pk=1).render()
         self.assertEquals(response.status_code, status.HTTP_201_CREATED)
         self.assertEquals(response.data, {'id': 1, 'text': 'foobar'})
@@ -264,7 +264,7 @@ class TestInstanceView(TestCase):
         content = {'text': 'foobar'}
         # pk fields can not be created on demand, only the database can set th pk for a new object
         request = factory.put('/5', json.dumps(content),
-                              content_type='application/json')
+            content_type='application/json')
         response = self.view(request, pk=5).render()
         self.assertEquals(response.status_code, status.HTTP_201_CREATED)
         new_obj = self.objects.get(pk=5)
@@ -277,7 +277,7 @@ class TestInstanceView(TestCase):
         """
         content = {'text': 'foobar'}
         request = factory.put('/test_slug', json.dumps(content),
-                              content_type='application/json')
+            content_type='application/json')
         response = self.slug_based_view(request, slug='test_slug').render()
         self.assertEquals(response.status_code, status.HTTP_201_CREATED)
         self.assertEquals(response.data, {'slug': 'test_slug', 'text': 'foobar'})
@@ -311,7 +311,7 @@ class TestCreateModelWithAutoNowAddField(TestCase):
         """
         content = {'email': 'foobar@example.com', 'content': 'foobar'}
         request = factory.post('/', json.dumps(content),
-                               content_type='application/json')
+            content_type='application/json')
         response = self.view(request).render()
         self.assertEquals(response.status_code, status.HTTP_201_CREATED)
         created = self.objects.get(id=1)

rest_framework/tests/test_htmlrenderer.py

@@ -39,7 +39,7 @@ urlpatterns = patterns('',
 
 
 class TemplateHTMLRendererTests(TestCase):
-    urls = 'rest_framework.tests.htmlrenderer'
+    urls = 'rest_framework.tests.test_htmlrenderer'
 
     def setUp(self):
         """
@@ -79,7 +79,7 @@ class TemplateHTMLRendererTests(TestCase):
 
 
 class TemplateHTMLRendererExceptionTests(TestCase):
-    urls = 'rest_framework.tests.htmlrenderer'
+    urls = 'rest_framework.tests.test_htmlrenderer'
 
     def setUp(self):
         """

rest_framework/tests/test_hyperlinkedserializers.py

@@ -20,7 +20,8 @@ class BlogPostCommentSerializer(serializers.ModelSerializer):
 
 class PhotoSerializer(serializers.Serializer):
     description = serializers.CharField()
-    album_url = serializers.HyperlinkedRelatedField(source='album', view_name='album-detail', queryset=Album.objects.all(), slug_field='title', slug_url_kwarg='title')
+    album_url = serializers.HyperlinkedRelatedField(source='album', view_name='album-detail',
+        queryset=Album.objects.all(), slug_field='title', slug_url_kwarg='title')
 
     def restore_object(self, attrs, instance=None):
         return Photo(**attrs)
@@ -95,7 +96,7 @@ urlpatterns = patterns('',
 
 
 class TestBasicHyperlinkedView(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -106,8 +107,8 @@ class TestBasicHyperlinkedView(TestCase):
             BasicModel(text=item).save()
         self.objects = BasicModel.objects
         self.data = [
-            {'url': 'http://testserver/basic/%d/' % obj.id, 'text': obj.text}
+        {'url': 'http://testserver/basic/%d/' % obj.id, 'text': obj.text}
-            for obj in self.objects.all()
+        for obj in self.objects.all()
         ]
         self.list_view = BasicList.as_view()
         self.detail_view = BasicDetail.as_view()
@@ -132,7 +133,7 @@ class TestBasicHyperlinkedView(TestCase):
 
 
 class TestManyToManyHyperlinkedView(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -150,13 +151,13 @@ class TestManyToManyHyperlinkedView(TestCase):
         manytomany.rel.add(*anchors)
 
         self.data = [{
-            'url': 'http://testserver/manytomany/1/',
+                         'url': 'http://testserver/manytomany/1/',
-            'rel': [
+                         'rel': [
-                'http://testserver/anchor/1/',
+                             'http://testserver/anchor/1/',
-                'http://testserver/anchor/2/',
+                             'http://testserver/anchor/2/',
-                'http://testserver/anchor/3/',
+                             'http://testserver/anchor/3/',
-            ]
+                         ]
-        }]
+                     }]
         self.list_view = ManyToManyList.as_view()
         self.detail_view = ManyToManyDetail.as_view()
 
@@ -180,7 +181,7 @@ class TestManyToManyHyperlinkedView(TestCase):
 
 
 class TestCreateWithForeignKeys(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -190,7 +191,6 @@ class TestCreateWithForeignKeys(TestCase):
         self.create_view = BlogPostCommentListCreate.as_view()
 
     def test_create_comment(self):
-
         data = {
             'text': 'A test comment',
             'blog_post_url': 'http://testserver/posts/1/'
@@ -205,7 +205,7 @@ class TestCreateWithForeignKeys(TestCase):
 
 
 class TestCreateWithForeignKeysAndCustomSlug(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -215,7 +215,6 @@ class TestCreateWithForeignKeysAndCustomSlug(TestCase):
         self.list_create_view = PhotoListCreate.as_view()
 
     def test_create_photo(self):
-
         data = {
             'description': 'A test photo',
             'album_url': 'http://testserver/albums/test-album/'
@@ -224,13 +223,14 @@ class TestCreateWithForeignKeysAndCustomSlug(TestCase):
         request = factory.post('/photos/', data=data)
         response = self.list_create_view(request)
         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
-        self.assertNotIn('Location', response, msg='Location should only be included if there is a "url" field on the serializer')
+        self.assertNotIn('Location', response,
+            msg='Location should only be included if there is a "url" field on the serializer')
         self.assertEqual(self.post.photo_set.count(), 1)
         self.assertEqual(self.post.photo_set.all()[0].description, 'A test photo')
 
 
 class TestOptionalRelationHyperlinkedView(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -257,6 +257,6 @@ class TestOptionalRelationHyperlinkedView(TestCase):
         should accept None for non existing relations.
         """
         response = self.client.put('/optionalrelation/1/',
-                                   data=json.dumps(self.data),
+            data=json.dumps(self.data),
-                                   content_type='application/json')
+            content_type='application/json')
         self.assertEqual(response.status_code, status.HTTP_200_OK)

rest_framework/tests/test_pagination.py

@@ -62,8 +62,8 @@ class IntegrationTestPagination(TestCase):
             BasicModel(text=char * 3).save()
         self.objects = BasicModel.objects
         self.data = [
-            {'id': obj.id, 'text': obj.text}
+        {'id': obj.id, 'text': obj.text}
-            for obj in self.objects.all()
+        for obj in self.objects.all()
         ]
         self.view = RootView.as_view()
 
@@ -97,7 +97,6 @@ class IntegrationTestPagination(TestCase):
 
 
 class IntegrationTestPaginationAndFiltering(TestCase):
-
     def setUp(self):
         """
         Create 50 FilterableItem instances.

rest_framework/tests/test_relations_hyperlink.py

@@ -59,7 +59,7 @@ class NullableOneToOneTargetSerializer(serializers.HyperlinkedModelSerializer):
 # TODO: Add test that .data cannot be accessed prior to .is_valid
 
 class HyperlinkedManyToManyTests(TestCase):
-    urls = 'rest_framework.tests.relations_hyperlink'
+    urls = 'rest_framework.tests.test_relations_hyperlink'
 
     def setUp(self):
         for idx in range(1, 4):
@@ -74,9 +74,11 @@ class HyperlinkedManyToManyTests(TestCase):
         queryset = ManyToManySource.objects.all()
         serializer = ManyToManySourceSerializer(queryset)
         expected = [
-                {'url': '/manytomanysource/1/', 'name': u'source-1', 'targets': ['/manytomanytarget/1/']},
+            {'url': '/manytomanysource/1/', 'name': u'source-1', 'targets': ['/manytomanytarget/1/']},
-                {'url': '/manytomanysource/2/', 'name': u'source-2', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/']},
+            {'url': '/manytomanysource/2/', 'name': u'source-2',
-                {'url': '/manytomanysource/3/', 'name': u'source-3', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']}
+             'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/']},
+            {'url': '/manytomanysource/3/', 'name': u'source-3',
+             'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']}
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -84,14 +86,17 @@ class HyperlinkedManyToManyTests(TestCase):
         queryset = ManyToManyTarget.objects.all()
         serializer = ManyToManyTargetSerializer(queryset)
         expected = [
-            {'url': '/manytomanytarget/1/', 'name': u'target-1', 'sources': ['/manytomanysource/1/', '/manytomanysource/2/', '/manytomanysource/3/']},
+            {'url': '/manytomanytarget/1/', 'name': u'target-1',
-            {'url': '/manytomanytarget/2/', 'name': u'target-2', 'sources': ['/manytomanysource/2/', '/manytomanysource/3/']},
+             'sources': ['/manytomanysource/1/', '/manytomanysource/2/', '/manytomanysource/3/']},
+            {'url': '/manytomanytarget/2/', 'name': u'target-2',
+             'sources': ['/manytomanysource/2/', '/manytomanysource/3/']},
             {'url': '/manytomanytarget/3/', 'name': u'target-3', 'sources': ['/manytomanysource/3/']}
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_many_to_many_update(self):
-        data = {'url': '/manytomanysource/1/', 'name': u'source-1', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']}
+        data = {'url': '/manytomanysource/1/', 'name': u'source-1',
+                'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']}
         instance = ManyToManySource.objects.get(pk=1)
         serializer = ManyToManySourceSerializer(instance, data=data)
         self.assertTrue(serializer.is_valid())
@@ -102,9 +107,12 @@ class HyperlinkedManyToManyTests(TestCase):
         queryset = ManyToManySource.objects.all()
         serializer = ManyToManySourceSerializer(queryset)
         expected = [
-                {'url': '/manytomanysource/1/', 'name': u'source-1', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']},
+            {'url': '/manytomanysource/1/', 'name': u'source-1',
-                {'url': '/manytomanysource/2/', 'name': u'source-2', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/']},
+             'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']},
-                {'url': '/manytomanysource/3/', 'name': u'source-3', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']}
+            {'url': '/manytomanysource/2/', 'name': u'source-2',
+             'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/']},
+            {'url': '/manytomanysource/3/', 'name': u'source-3',
+             'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']}
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -121,14 +129,16 @@ class HyperlinkedManyToManyTests(TestCase):
         serializer = ManyToManyTargetSerializer(queryset)
         expected = [
             {'url': '/manytomanytarget/1/', 'name': u'target-1', 'sources': ['/manytomanysource/1/']},
-            {'url': '/manytomanytarget/2/', 'name': u'target-2', 'sources': ['/manytomanysource/2/', '/manytomanysource/3/']},
+            {'url': '/manytomanytarget/2/', 'name': u'target-2',
+             'sources': ['/manytomanysource/2/', '/manytomanysource/3/']},
             {'url': '/manytomanytarget/3/', 'name': u'target-3', 'sources': ['/manytomanysource/3/']}
 
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_many_to_many_create(self):
-        data = {'url': '/manytomanysource/4/', 'name': u'source-4', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/3/']}
+        data = {'url': '/manytomanysource/4/', 'name': u'source-4',
+                'targets': ['/manytomanytarget/1/', '/manytomanytarget/3/']}
         serializer = ManyToManySourceSerializer(data=data)
         self.assertTrue(serializer.is_valid())
         obj = serializer.save()
@@ -140,14 +150,18 @@ class HyperlinkedManyToManyTests(TestCase):
         serializer = ManyToManySourceSerializer(queryset)
         expected = [
             {'url': '/manytomanysource/1/', 'name': u'source-1', 'targets': ['/manytomanytarget/1/']},
-            {'url': '/manytomanysource/2/', 'name': u'source-2', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/']},
+            {'url': '/manytomanysource/2/', 'name': u'source-2',
-            {'url': '/manytomanysource/3/', 'name': u'source-3', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']},
+             'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/']},
-            {'url': '/manytomanysource/4/', 'name': u'source-4', 'targets': ['/manytomanytarget/1/', '/manytomanytarget/3/']}
+            {'url': '/manytomanysource/3/', 'name': u'source-3',
+             'targets': ['/manytomanytarget/1/', '/manytomanytarget/2/', '/manytomanytarget/3/']},
+            {'url': '/manytomanysource/4/', 'name': u'source-4',
+             'targets': ['/manytomanytarget/1/', '/manytomanytarget/3/']}
         ]
         self.assertEquals(serializer.data, expected)
 
     def test_reverse_many_to_many_create(self):
-        data = {'url': '/manytomanytarget/4/', 'name': u'target-4', 'sources': ['/manytomanysource/1/', '/manytomanysource/3/']}
+        data = {'url': '/manytomanytarget/4/', 'name': u'target-4',
+                'sources': ['/manytomanysource/1/', '/manytomanysource/3/']}
         serializer = ManyToManyTargetSerializer(data=data)
         self.assertTrue(serializer.is_valid())
         obj = serializer.save()
@@ -158,16 +172,19 @@ class HyperlinkedManyToManyTests(TestCase):
         queryset = ManyToManyTarget.objects.all()
         serializer = ManyToManyTargetSerializer(queryset)
         expected = [
-            {'url': '/manytomanytarget/1/', 'name': u'target-1', 'sources': ['/manytomanysource/1/', '/manytomanysource/2/', '/manytomanysource/3/']},
+            {'url': '/manytomanytarget/1/', 'name': u'target-1',
-            {'url': '/manytomanytarget/2/', 'name': u'target-2', 'sources': ['/manytomanysource/2/', '/manytomanysource/3/']},
+             'sources': ['/manytomanysource/1/', '/manytomanysource/2/', '/manytomanysource/3/']},
+            {'url': '/manytomanytarget/2/', 'name': u'target-2',
+             'sources': ['/manytomanysource/2/', '/manytomanysource/3/']},
             {'url': '/manytomanytarget/3/', 'name': u'target-3', 'sources': ['/manytomanysource/3/']},
-            {'url': '/manytomanytarget/4/', 'name': u'target-4', 'sources': ['/manytomanysource/1/', '/manytomanysource/3/']}
+            {'url': '/manytomanytarget/4/', 'name': u'target-4',
+             'sources': ['/manytomanysource/1/', '/manytomanysource/3/']}
         ]
         self.assertEquals(serializer.data, expected)
 
 
 class HyperlinkedForeignKeyTests(TestCase):
-    urls = 'rest_framework.tests.relations_hyperlink'
+    urls = 'rest_framework.tests.test_relations_hyperlink'
 
     def setUp(self):
         target = ForeignKeyTarget(name='target-1')
@@ -192,7 +209,8 @@ class HyperlinkedForeignKeyTests(TestCase):
         queryset = ForeignKeyTarget.objects.all()
         serializer = ForeignKeyTargetSerializer(queryset)
         expected = [
-            {'url': '/foreignkeytarget/1/', 'name': u'target-1', 'sources': ['/foreignkeysource/1/', '/foreignkeysource/2/', '/foreignkeysource/3/']},
+            {'url': '/foreignkeytarget/1/', 'name': u'target-1',
+             'sources': ['/foreignkeysource/1/', '/foreignkeysource/2/', '/foreignkeysource/3/']},
             {'url': '/foreignkeytarget/2/', 'name': u'target-2', 'sources': []},
         ]
         self.assertEquals(serializer.data, expected)
@@ -223,7 +241,8 @@ class HyperlinkedForeignKeyTests(TestCase):
         self.assertEquals(serializer.errors, {'target': [u'Incorrect type.  Expected url string, received int.']})
 
     def test_reverse_foreign_key_update(self):
-        data = {'url': '/foreignkeytarget/2/', 'name': u'target-2', 'sources': ['/foreignkeysource/1/', '/foreignkeysource/3/']}
+        data = {'url': '/foreignkeytarget/2/', 'name': u'target-2',
+                'sources': ['/foreignkeysource/1/', '/foreignkeysource/3/']}
         instance = ForeignKeyTarget.objects.get(pk=2)
         serializer = ForeignKeyTargetSerializer(instance, data=data)
         self.assertTrue(serializer.is_valid())
@@ -232,7 +251,8 @@ class HyperlinkedForeignKeyTests(TestCase):
         queryset = ForeignKeyTarget.objects.all()
         new_serializer = ForeignKeyTargetSerializer(queryset)
         expected = [
-            {'url': '/foreignkeytarget/1/', 'name': u'target-1', 'sources': ['/foreignkeysource/1/', '/foreignkeysource/2/', '/foreignkeysource/3/']},
+            {'url': '/foreignkeytarget/1/', 'name': u'target-1',
+             'sources': ['/foreignkeysource/1/', '/foreignkeysource/2/', '/foreignkeysource/3/']},
             {'url': '/foreignkeytarget/2/', 'name': u'target-2', 'sources': []},
         ]
         self.assertEquals(new_serializer.data, expected)
@@ -245,7 +265,8 @@ class HyperlinkedForeignKeyTests(TestCase):
         serializer = ForeignKeyTargetSerializer(queryset)
         expected = [
             {'url': '/foreignkeytarget/1/', 'name': u'target-1', 'sources': ['/foreignkeysource/2/']},
-            {'url': '/foreignkeytarget/2/', 'name': u'target-2', 'sources': ['/foreignkeysource/1/', '/foreignkeysource/3/']},
+            {'url': '/foreignkeytarget/2/', 'name': u'target-2',
+             'sources': ['/foreignkeysource/1/', '/foreignkeysource/3/']},
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -269,7 +290,8 @@ class HyperlinkedForeignKeyTests(TestCase):
         self.assertEquals(serializer.data, expected)
 
     def test_reverse_foreign_key_create(self):
-        data = {'url': '/foreignkeytarget/3/', 'name': u'target-3', 'sources': ['/foreignkeysource/1/', '/foreignkeysource/3/']}
+        data = {'url': '/foreignkeytarget/3/', 'name': u'target-3',
+                'sources': ['/foreignkeysource/1/', '/foreignkeysource/3/']}
         serializer = ForeignKeyTargetSerializer(data=data)
         self.assertTrue(serializer.is_valid())
         obj = serializer.save()
@@ -282,7 +304,8 @@ class HyperlinkedForeignKeyTests(TestCase):
         expected = [
             {'url': '/foreignkeytarget/1/', 'name': u'target-1', 'sources': ['/foreignkeysource/2/']},
             {'url': '/foreignkeytarget/2/', 'name': u'target-2', 'sources': []},
-            {'url': '/foreignkeytarget/3/', 'name': u'target-3', 'sources': ['/foreignkeysource/1/', '/foreignkeysource/3/']},
+            {'url': '/foreignkeytarget/3/', 'name': u'target-3',
+             'sources': ['/foreignkeysource/1/', '/foreignkeysource/3/']},
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -295,7 +318,7 @@ class HyperlinkedForeignKeyTests(TestCase):
 
 
 class HyperlinkedNullableForeignKeyTests(TestCase):
-    urls = 'rest_framework.tests.relations_hyperlink'
+    urls = 'rest_framework.tests.test_relations_hyperlink'
 
     def setUp(self):
         target = ForeignKeyTarget(name='target-1')
@@ -400,30 +423,30 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
         ]
         self.assertEquals(serializer.data, expected)
 
-    # reverse foreign keys MUST be read_only
+        # reverse foreign keys MUST be read_only
-    # In the general case they do not provide .remove() or .clear()
+        # In the general case they do not provide .remove() or .clear()
-    # and cannot be arbitrarily set.
+        # and cannot be arbitrarily set.
 
-    # def test_reverse_foreign_key_update(self):
+        # def test_reverse_foreign_key_update(self):
-    #     data = {'id': 1, 'name': u'target-1', 'sources': [1]}
+        #     data = {'id': 1, 'name': u'target-1', 'sources': [1]}
-    #     instance = ForeignKeyTarget.objects.get(pk=1)
+        #     instance = ForeignKeyTarget.objects.get(pk=1)
-    #     serializer = ForeignKeyTargetSerializer(instance, data=data)
+        #     serializer = ForeignKeyTargetSerializer(instance, data=data)
-    #     self.assertTrue(serializer.is_valid())
+        #     self.assertTrue(serializer.is_valid())
-    #     self.assertEquals(serializer.data, data)
+        #     self.assertEquals(serializer.data, data)
-    #     serializer.save()
+        #     serializer.save()
 
-    #     # Ensure target 1 is updated, and everything else is as expected
+        #     # Ensure target 1 is updated, and everything else is as expected
-    #     queryset = ForeignKeyTarget.objects.all()
+        #     queryset = ForeignKeyTarget.objects.all()
-    #     serializer = ForeignKeyTargetSerializer(queryset)
+        #     serializer = ForeignKeyTargetSerializer(queryset)
-    #     expected = [
+        #     expected = [
-    #         {'id': 1, 'name': u'target-1', 'sources': [1]},
+        #         {'id': 1, 'name': u'target-1', 'sources': [1]},
-    #         {'id': 2, 'name': u'target-2', 'sources': []},
+        #         {'id': 2, 'name': u'target-2', 'sources': []},
-    #     ]
+        #     ]
-    #     self.assertEquals(serializer.data, expected)
+        #     self.assertEquals(serializer.data, expected)
 
 
 class HyperlinkedNullableOneToOneTests(TestCase):
-    urls = 'rest_framework.tests.relations_hyperlink'
+    urls = 'rest_framework.tests.test_relations_hyperlink'
 
     def setUp(self):
         target = OneToOneTarget(name='target-1')

rest_framework/tests/test_relations_pk.py

@@ -56,9 +56,9 @@ class PKManyToManyTests(TestCase):
         queryset = ManyToManySource.objects.all()
         serializer = ManyToManySourceSerializer(queryset)
         expected = [
-                {'id': 1, 'name': u'source-1', 'targets': [1]},
+            {'id': 1, 'name': u'source-1', 'targets': [1]},
-                {'id': 2, 'name': u'source-2', 'targets': [1, 2]},
+            {'id': 2, 'name': u'source-2', 'targets': [1, 2]},
-                {'id': 3, 'name': u'source-3', 'targets': [1, 2, 3]}
+            {'id': 3, 'name': u'source-3', 'targets': [1, 2, 3]}
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -84,9 +84,9 @@ class PKManyToManyTests(TestCase):
         queryset = ManyToManySource.objects.all()
         serializer = ManyToManySourceSerializer(queryset)
         expected = [
-                {'id': 1, 'name': u'source-1', 'targets': [1, 2, 3]},
+            {'id': 1, 'name': u'source-1', 'targets': [1, 2, 3]},
-                {'id': 2, 'name': u'source-2', 'targets': [1, 2]},
+            {'id': 2, 'name': u'source-2', 'targets': [1, 2]},
-                {'id': 3, 'name': u'source-3', 'targets': [1, 2, 3]}
+            {'id': 3, 'name': u'source-3', 'targets': [1, 2, 3]}
         ]
         self.assertEquals(serializer.data, expected)
 
@@ -377,26 +377,26 @@ class PKNullableForeignKeyTests(TestCase):
         ]
         self.assertEquals(serializer.data, expected)
 
-    # reverse foreign keys MUST be read_only
+        # reverse foreign keys MUST be read_only
-    # In the general case they do not provide .remove() or .clear()
+        # In the general case they do not provide .remove() or .clear()
-    # and cannot be arbitrarily set.
+        # and cannot be arbitrarily set.
 
-    # def test_reverse_foreign_key_update(self):
+        # def test_reverse_foreign_key_update(self):
-    #     data = {'id': 1, 'name': u'target-1', 'sources': [1]}
+        #     data = {'id': 1, 'name': u'target-1', 'sources': [1]}
-    #     instance = ForeignKeyTarget.objects.get(pk=1)
+        #     instance = ForeignKeyTarget.objects.get(pk=1)
-    #     serializer = ForeignKeyTargetSerializer(instance, data=data)
+        #     serializer = ForeignKeyTargetSerializer(instance, data=data)
-    #     self.assertTrue(serializer.is_valid())
+        #     self.assertTrue(serializer.is_valid())
-    #     self.assertEquals(serializer.data, data)
+        #     self.assertEquals(serializer.data, data)
-    #     serializer.save()
+        #     serializer.save()
 
-    #     # Ensure target 1 is updated, and everything else is as expected
+        #     # Ensure target 1 is updated, and everything else is as expected
-    #     queryset = ForeignKeyTarget.objects.all()
+        #     queryset = ForeignKeyTarget.objects.all()
-    #     serializer = ForeignKeyTargetSerializer(queryset)
+        #     serializer = ForeignKeyTargetSerializer(queryset)
-    #     expected = [
+        #     expected = [
-    #         {'id': 1, 'name': u'target-1', 'sources': [1]},
+        #         {'id': 1, 'name': u'target-1', 'sources': [1]},
-    #         {'id': 2, 'name': u'target-2', 'sources': []},
+        #         {'id': 2, 'name': u'target-2', 'sources': []},
-    #     ]
+        #     ]
-    #     self.assertEquals(serializer.data, expected)
+        #     self.assertEquals(serializer.data, expected)
 
 
 class PKNullableOneToOneTests(TestCase):

rest_framework/tests/test_renderers.py

@@ -9,7 +9,7 @@ from rest_framework import status, permissions
 from rest_framework.compat import yaml, patterns, url, include
 from rest_framework.response import Response
 from rest_framework.views import APIView
-from rest_framework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer, \
+from rest_framework.renderers import BaseRenderer, JSONRenderer, YAMLRenderer,\
     XMLRenderer, JSONPRenderer, BrowsableAPIRenderer
 from rest_framework.parsers import YAMLParser, XMLParser
 from rest_framework.settings import api_settings
@@ -25,7 +25,6 @@ DUMMYCONTENT = 'dummycontent'
 RENDERER_A_SERIALIZER = lambda x: 'Renderer A: %s' % x
 RENDERER_B_SERIALIZER = lambda x: 'Renderer B: %s' % x
 
-
 expected_results = [
     ((elem for elem in [1, 2, 3]), JSONRenderer, '[1, 2, 3]')  # Generator
 ]
@@ -63,7 +62,6 @@ class MockView(APIView):
 
 
 class MockGETView(APIView):
-
     def get(self, request, **kwargs):
         return Response({'foo': ['bar', 'baz']})
 
@@ -126,7 +124,7 @@ class RendererEndToEndTests(TestCase):
     End-to-end testing of renderers using an RendererMixin on a generic view.
     """
 
-    urls = 'rest_framework.tests.renderers'
+    urls = 'rest_framework.tests.test_renderers'
 
     def test_default_renderer_serializes_content(self):
         """If the Accept header is not set the default renderer should serialize the response."""
@@ -170,7 +168,7 @@ class RendererEndToEndTests(TestCase):
         param = '?%s=%s' % (
             api_settings.URL_ACCEPT_OVERRIDE,
             RendererB.media_type
-        )
+            )
         resp = self.client.get('/' + param)
         self.assertEquals(resp['Content-Type'], RendererB.media_type)
         self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
@@ -187,7 +185,7 @@ class RendererEndToEndTests(TestCase):
         param = '?%s=%s' % (
             api_settings.URL_FORMAT_OVERRIDE,
             RendererB.format
-        )
+            )
         resp = self.client.get('/' + param)
         self.assertEquals(resp['Content-Type'], RendererB.media_type)
         self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
@@ -207,9 +205,9 @@ class RendererEndToEndTests(TestCase):
         param = '?%s=%s' % (
             api_settings.URL_FORMAT_OVERRIDE,
             RendererB.format
-        )
+            )
         resp = self.client.get('/' + param,
-                               HTTP_ACCEPT=RendererB.media_type)
+            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)
@@ -257,14 +255,14 @@ class JSONPRendererTests(TestCase):
     Tests specific to the JSONP Renderer
     """
 
-    urls = 'rest_framework.tests.renderers'
+    urls = 'rest_framework.tests.test_renderers'
 
     def test_without_callback_with_json_renderer(self):
         """
         Test JSONP rendering with View JSON Renderer.
         """
         resp = self.client.get('/jsonp/jsonrenderer',
-                               HTTP_ACCEPT='application/javascript')
+            HTTP_ACCEPT='application/javascript')
         self.assertEquals(resp.status_code, 200)
         self.assertEquals(resp['Content-Type'], 'application/javascript')
         self.assertEquals(resp.content, 'callback(%s);' % _flat_repr)
@@ -274,7 +272,7 @@ class JSONPRendererTests(TestCase):
         Test JSONP rendering without View JSON Renderer.
         """
         resp = self.client.get('/jsonp/nojsonrenderer',
-                               HTTP_ACCEPT='application/javascript')
+            HTTP_ACCEPT='application/javascript')
         self.assertEquals(resp.status_code, 200)
         self.assertEquals(resp['Content-Type'], 'application/javascript')
         self.assertEquals(resp.content, 'callback(%s);' % _flat_repr)
@@ -285,7 +283,7 @@ class JSONPRendererTests(TestCase):
         """
         callback_func = 'myjsonpcallback'
         resp = self.client.get('/jsonp/nojsonrenderer?callback=' + callback_func,
-                               HTTP_ACCEPT='application/javascript')
+            HTTP_ACCEPT='application/javascript')
         self.assertEquals(resp.status_code, 200)
         self.assertEquals(resp['Content-Type'], 'application/javascript')
         self.assertEquals(resp.content, '%s(%s);' % (callback_func, _flat_repr))
@@ -426,7 +424,7 @@ class CacheRenderTest(TestCase):
     Tests specific to caching responses
     """
 
-    urls = 'rest_framework.tests.renderers'
+    urls = 'rest_framework.tests.test_renderers'
 
     cache_key = 'just_a_cache_key'
 

rest_framework/tests/test_request.py

@@ -15,7 +15,7 @@ from rest_framework.parsers import (
     FormParser,
     MultiPartParser,
     JSONParser
-)
+    )
 from rest_framework.request import Request
 from rest_framework.response import Response
 from rest_framework.settings import api_settings
@@ -111,8 +111,9 @@ class TestContentParsing(TestCase):
 
         if VERSION >= (1, 5):
             from django.test.client import MULTIPART_CONTENT, BOUNDARY, encode_multipart
+
             request = Request(factory.put('/', encode_multipart(BOUNDARY, data),
-                                  content_type=MULTIPART_CONTENT))
+                content_type=MULTIPART_CONTENT))
         else:
             request = Request(factory.put('/', data))
 
@@ -145,88 +146,88 @@ class TestContentParsing(TestCase):
         request.parsers = (JSONParser(), )
         self.assertEqual(request.DATA, json_data)
 
-    # 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(APIView):
@@ -244,7 +245,7 @@ urlpatterns = patterns('',
 
 
 class TestContentParsingWithAuthentication(TestCase):
-    urls = 'rest_framework.tests.request'
+    urls = 'rest_framework.tests.test_request'
 
     def setUp(self):
         self.csrf_client = Client(enforce_csrf_checks=True)
@@ -266,21 +267,20 @@ class TestContentParsingWithAuthentication(TestCase):
         response = self.csrf_client.post('/', content)
         self.assertEqual(status.HTTP_200_OK, response.status_code)
 
-    # def test_user_logged_in_authentication_has_post_when_logged_in(self):
+        # def test_user_logged_in_authentication_has_post_when_logged_in(self):
-    #     """Ensures request.POST exists after UserLoggedInAuthentication when user does log in"""
+        #     """Ensures request.POST exists after UserLoggedInAuthentication when user does log in"""
-    #     self.client.login(username='john', password='password')
+        #     self.client.login(username='john', password='password')
-    #     self.csrf_client.login(username='john', password='password')
+        #     self.csrf_client.login(username='john', password='password')
-    #     content = {'example': 'example'}
+        #     content = {'example': 'example'}
 
-    #     response = self.client.post('/', content)
+        #     response = self.client.post('/', content)
-    #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")
+        #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")
 
-    #     response = self.csrf_client.post('/', content)
+        #     response = self.csrf_client.post('/', content)
-    #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")
+        #     self.assertEqual(status.OK, response.status_code, "POST data is malformed")
 
 
 class TestUserSetter(TestCase):
-
     def setUp(self):
         # Pass request object through session middleware so session is
         # available to login and logout functions
@@ -306,7 +306,6 @@ class TestUserSetter(TestCase):
 
 
 class TestAuthSetter(TestCase):
-
     def test_auth_can_be_set(self):
         request = Request(factory.get('/'))
         request.auth = 'DUMMY'

rest_framework/tests/test_response.py

@@ -7,7 +7,7 @@ from rest_framework.renderers import (
     BaseRenderer,
     JSONRenderer,
     BrowsableAPIRenderer
-)
+    )
 from rest_framework.settings import api_settings
 
 
@@ -78,7 +78,7 @@ class RendererIntegrationTests(TestCase):
     End-to-end testing of renderers using an ResponseMixin on a generic view.
     """
 
-    urls = 'rest_framework.tests.response'
+    urls = 'rest_framework.tests.test_response'
 
     def test_default_renderer_serializes_content(self):
         """If the Accept header is not set the default renderer should serialize the response."""
@@ -122,7 +122,7 @@ class RendererIntegrationTests(TestCase):
         param = '?%s=%s' % (
             api_settings.URL_ACCEPT_OVERRIDE,
             RendererB.media_type
-        )
+            )
         resp = self.client.get('/' + param)
         self.assertEquals(resp['Content-Type'], RendererB.media_type)
         self.assertEquals(resp.content, RENDERER_B_SERIALIZER(DUMMYCONTENT))
@@ -148,7 +148,7 @@ class RendererIntegrationTests(TestCase):
         """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)
+            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)
@@ -158,7 +158,7 @@ class Issue122Tests(TestCase):
     """
     Tests that covers #122.
     """
-    urls = 'rest_framework.tests.response'
+    urls = 'rest_framework.tests.test_response'
 
     def test_only_html_renderer(self):
         """

rest_framework/tests/test_reverse.py

@@ -18,7 +18,7 @@ class ReverseTests(TestCase):
     """
     Tests for fully qualifed URLs when using `reverse`.
     """
-    urls = 'rest_framework.tests.reverse'
+    urls = 'rest_framework.tests.test_reverse'
 
     def test_reversed_urls_are_fully_qualified(self):
         request = factory.get('/view')

rest_framework/tests/test_serializer.py

@@ -3,8 +3,8 @@ import pickle
 from django.test import TestCase
 from rest_framework import serializers
 from rest_framework.tests.models import (HasPositiveIntegerAsChoice, Album, ActionItem, Anchor, BasicModel,
-    BlankFieldModel, BlogPost, Book, CallableDefaultValueModel, DefaultValueModel,
+                                         BlankFieldModel, BlogPost, Book, CallableDefaultValueModel, DefaultValueModel,
-    ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo)
+                                         ManyToManyModel, Person, ReadOnlyManyToManyModel, Photo)
 
 
 class SubComment(object):
@@ -49,7 +49,6 @@ class BookSerializer(serializers.ModelSerializer):
 
 
 class ActionItemSerializer(serializers.ModelSerializer):
-
     class Meta:
         model = ActionItem
 
@@ -64,7 +63,6 @@ class PersonSerializer(serializers.ModelSerializer):
 
 
 class AlbumsSerializer(serializers.ModelSerializer):
-
     class Meta:
         model = Album
         fields = ['title']  # lists are also valid options
@@ -148,7 +146,7 @@ class BasicTests(TestCase):
         """
         serializer = PersonSerializer(self.person)
         self.assertEquals(set(serializer.data.keys()),
-                          set(['name', 'age', 'info']))
+            set(['name', 'age', 'info']))
 
     def test_field_with_dictionary(self):
         """
@@ -182,17 +180,19 @@ class ValidationTests(TestCase):
             'content': 'x' * 1001,
             'created': datetime.datetime(2012, 1, 1)
         }
-        self.actionitem = ActionItem(title='Some to do item',)
+        self.actionitem = ActionItem(title='Some to do item', )
 
     def test_create(self):
         serializer = CommentSerializer(data=self.data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
+        self.assertEquals(serializer.errors,
+            {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
 
     def test_update(self):
         serializer = CommentSerializer(self.comment, data=self.data)
         self.assertEquals(serializer.is_valid(), False)
-        self.assertEquals(serializer.errors, {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
+        self.assertEquals(serializer.errors,
+            {'content': [u'Ensure this value has at most 1000 characters (it has 1001).']})
 
     def test_update_missing_field(self):
         data = {
@@ -234,9 +234,7 @@ class ValidationTests(TestCase):
         self.assertEquals(serializer.errors, {'non_field_errors': [u'Invalid data']})
 
     def test_cross_field_validation(self):
-
         class CommentSerializerWithCrossFieldValidator(CommentSerializer):
-
             def validate(self, attrs):
                 if attrs["email"] not in attrs["content"]:
                     raise serializers.ValidationError("Email address not in content")
@@ -285,7 +283,6 @@ class ValidationTests(TestCase):
 
 class CustomValidationTests(TestCase):
     class CommentSerializerWithFieldValidator(CommentSerializer):
-
         def validate_email(self, attrs, source):
             value = attrs[source]
 
@@ -356,7 +353,7 @@ class ModelValidationTests(TestCase):
         serializer.save()
         second_serializer = AlbumsSerializer(data={'title': 'a'})
         self.assertFalse(second_serializer.is_valid())
-        self.assertEqual(second_serializer.errors,  {'title': [u'Album with this Title already exists.']})
+        self.assertEqual(second_serializer.errors, {'title': [u'Album with this Title already exists.']})
 
     def test_foreign_key_with_partial(self):
         """
@@ -383,8 +380,8 @@ class ModelValidationTests(TestCase):
 
         # Updating only the description
         photo_serializer = PhotoSerializer(instance=photo,
-                                           data={'description': 'new'},
+            data={'description': 'new'},
-                                           partial=True)
+            partial=True)
 
         self.assertTrue(photo_serializer.is_valid())
         self.assertTrue(photo_serializer.save())
@@ -718,12 +715,12 @@ class RelatedTraversalTest(TestCase):
         expected = {
             'title': u'Test blog post',
             'comments': [{
-                'text': u'I love this blog post',
+                             'text': u'I love this blog post',
-                'post_owner': {
+                             'post_owner': {
-                    "name": u"django",
+                                 "name": u"django",
-                    "age": None
+                                 "age": None
-                }
+                             }
-            }]
+                         }]
         }
 
         self.assertEqual(serializer.data, expected)
@@ -731,7 +728,6 @@ class RelatedTraversalTest(TestCase):
 
 class SerializerMethodFieldTests(TestCase):
     def setUp(self):
-
         class BoopSerializer(serializers.Serializer):
             beep = serializers.SerializerMethodField('get_beep')
             boop = serializers.Field()
@@ -746,7 +742,6 @@ class SerializerMethodFieldTests(TestCase):
         self.serializer_class = BoopSerializer
 
     def test_serializer_method_field(self):
-
         class MyModel(object):
             boop = ['a', 'b', 'c']
 
@@ -766,7 +761,6 @@ class SerializerMethodFieldTests(TestCase):
 # Test for issue #324
 class BlankFieldTests(TestCase):
     def setUp(self):
-
         class BlankFieldModelSerializer(serializers.ModelSerializer):
             class Meta:
                 model = BlankFieldModel
@@ -825,6 +819,7 @@ class SerializerPickleTests(TestCase):
     """
     Test pickleability of the output of Serializers
     """
+
     def test_pickle_simple_model_serializer_data(self):
         """
         Test simple serializer
@@ -837,10 +832,12 @@ class SerializerPickleTests(TestCase):
         have unpickleable meta data--in order to make sure metadata doesn't get pulled into the pickle.
         See DictWithMetadata.__getstate__
         """
+
         class InnerPersonSerializer(serializers.ModelSerializer):
             class Meta:
                 model = Person
                 fields = ('name', 'age')
+
         pickle.dumps(InnerPersonSerializer(Person(name="Noah", age=950)).data)
 
 
@@ -882,13 +879,13 @@ class DepthTest(TestCase):
 
 
 class NestedSerializerContextTests(TestCase):
-
     def test_nested_serializer_context(self):
         """
         Regression for #497
 
         https://github.com/tomchristie/django-rest-framework/issues/497
         """
+
         class PhotoSerializer(serializers.ModelSerializer):
             class Meta:
                 model = Photo

rest_framework/tests/test_settings.py

@@ -9,13 +9,17 @@ class TestSettings(TestCase):
 
     def test_non_import_errors(self):
         """Make sure other errors aren't suppressed."""
-        settings = APISettings({'DEFAULT_MODEL_SERIALIZER_CLASS': 'rest_framework.tests.extras.bad_import.ModelSerializer'}, DEFAULTS, IMPORT_STRINGS)
+        settings = APISettings(
+            {'DEFAULT_MODEL_SERIALIZER_CLASS': 'rest_framework.tests.extras.bad_import.ModelSerializer'}, DEFAULTS,
+            IMPORT_STRINGS)
         with self.assertRaises(ValueError):
             settings.DEFAULT_MODEL_SERIALIZER_CLASS
 
     def test_import_error_message_maintained(self):
         """Make sure real import errors are captured and raised sensibly."""
-        settings = APISettings({'DEFAULT_MODEL_SERIALIZER_CLASS': 'rest_framework.tests.extras.not_here.ModelSerializer'}, DEFAULTS, IMPORT_STRINGS)
+        settings = APISettings(
+            {'DEFAULT_MODEL_SERIALIZER_CLASS': 'rest_framework.tests.extras.not_here.ModelSerializer'}, DEFAULTS,
+            IMPORT_STRINGS)
         with self.assertRaises(ImportError) as cm:
             settings.DEFAULT_MODEL_SERIALIZER_CLASS
         self.assertTrue('ImportError' in str(cm.exception))

rest_framework/tests/test_testcases.py

@@ -16,13 +16,14 @@ class TestSettingsManager(object):
     modified.
 
     """
+
     def __init__(self):
         self._original_settings = {}
 
     def set(self, **kwargs):
         for k, v in kwargs.iteritems():
             self._original_settings.setdefault(k, getattr(settings, k,
-                                                          NO_SETTING))
+                NO_SETTING))
             setattr(settings, k, v)
         if 'INSTALLED_APPS' in kwargs:
             self.syncdb()
@@ -51,6 +52,7 @@ class SettingsTestCase(TestCase):
     self.settings_manager.revert().
 
     """
+
     def __init__(self, *args, **kwargs):
         super(SettingsTestCase, self).__init__(*args, **kwargs)
         self.settings_manager = TestSettingsManager()

rest_framework/tests/test_throttling.py

@@ -37,7 +37,7 @@ class MockView_MinuteThrottling(APIView):
 
 
 class ThrottlingTests(TestCase):
-    urls = 'rest_framework.tests.throttling'
+    urls = 'rest_framework.tests.test_throttling'
 
     def setUp(self):
         """
@@ -113,22 +113,22 @@ class ThrottlingTests(TestCase):
         Ensure for second based throttles.
         """
         self.ensure_response_header_contains_proper_throttle_field(MockView,
-         ((0, None),
+            ((0, None),
-          (0, None),
+             (0, None),
-          (0, None),
+             (0, None),
-          (0, '1')
+             (0, '1')
-         ))
+                ))
 
     def test_minutes_fields(self):
         """
         Ensure for minute based throttles.
         """
         self.ensure_response_header_contains_proper_throttle_field(MockView_MinuteThrottling,
-         ((0, None),
+            ((0, None),
-          (0, None),
+             (0, None),
-          (0, None),
+             (0, None),
-          (0, '60')
+             (0, '60')
-         ))
+                ))
 
     def test_next_rate_remains_constant_if_followed(self):
         """
@@ -136,9 +136,9 @@ class ThrottlingTests(TestCase):
         the throttling rate should stay constant.
         """
         self.ensure_response_header_contains_proper_throttle_field(MockView_MinuteThrottling,
-         ((0, None),
+            ((0, None),
-          (20, None),
+             (20, None),
-          (40, None),
+             (40, None),
-          (60, None),
+             (60, None),
-          (80, None)
+             (80, None)
-         ))
+                ))

rest_framework/tests/test_urlpatterns.py

@@ -21,6 +21,7 @@ class FormatSuffixTests(TestCase):
     """
     Tests `format_suffix_patterns` against different URLPatterns to ensure the URLs still resolve properly, including any captured parameters.
     """
+
     def _resolve_urlpatterns(self, urlpatterns, test_paths):
         factory = RequestFactory()
         try:

rest_framework/tests/tests.py

@@ -1,13 +0,0 @@
-"""
-Force import of all modules in this package in order to get the standard test
-runner to pick up the tests.  Yowzers.
-"""
-import os
-
-modules = [filename.rsplit('.', 1)[0]
-           for filename in os.listdir(os.path.dirname(__file__))
-           if filename.endswith('.py') and not filename.startswith('_')]
-__test__ = dict()
-
-for module in modules:
-    exec("from rest_framework.tests.%s import *" % module)