Replaced the custom runner with django-discover-runner.

.gitignore

@@ -2,6 +2,7 @@
 *.db
 *~
 .*
+coverage.xml
 
 html/
 coverage/

.travis.yml

@@ -12,6 +12,7 @@ env:
 install:
   - pip install $DJANGO
   - pip install django-filter==0.5.4 --use-mirrors
+  - pip install -r development.txt
   - export PYTHONPATH=.
 
 script:

README.md

@@ -75,13 +75,17 @@ To build the docs.
 
     ./mkdocs.py
 
+Both the tests and the code coverage are depended on django-discover-runner.
+To start hacking type.
+
+    pip install -r development.txt
+
 To run the tests.
 
     ./rest_framework/runtests/runtests.py
 
 To run the tests with code coverage.
 
-    pip install -r development.txt
     ./rest_framework/runtests/runcoverage.py
 
 # Changelog

development.txt

@@ -1 +1,2 @@
 coverage
+django-discover-runner>=0.2.2

manage.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+import os
+import sys
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "rest_framework.tests.settings")
+
+from django.core.management import execute_from_command_line
+
+execute_from_command_line(sys.argv)

rest_framework/runtests/runcoverage.py

@@ -11,40 +11,25 @@ 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...")
+    exit(1)
+
+def report(cov, cov_files):
+    cov.report(cov_files)
+
+    if '--html' in sys.argv:
+        cov.html_report(cov_files, directory='coverage')
+
+    if '--xml' in sys.argv:
+        cov.xml_report(cov_files, outfile='../../coverage.xml')
 
 
-def main():
+def prepare_report(project_dir):
-    """Run the tests for rest_framework and generate a coverage report."""
-
-    cov = coverage()
-    cov.erase()
-    cov.start()
-
-    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
-        )
-        failures = TestRunner(['tests'])
-    else:
-        test_runner = TestRunner()
-        failures = test_runner.run_tests(['tests'])
-    cov.stop()
-
-    # Discover the list of all modules that we should test coverage for
-    import rest_framework
-
-    project_dir = os.path.dirname(rest_framework.__file__)
     cov_files = []
 
     for (path, dirs, files) in os.walk(project_dir):
@@ -66,9 +51,47 @@ def main():
 
         cov_files.extend([os.path.join(path, file) for file in files if file.endswith('.py')])
 
-    cov.report(cov_files)
+    return cov_files
-    if '--html' in sys.argv:
+
-        cov.html_report(cov_files, directory='coverage')
+
+def run_tests(app):
+    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
+        )
+        failures = TestRunner([app])
+    else:
+        test_runner = TestRunner()
+        failures = test_runner.run_tests([app])
+    return failures
+
+
+def main():
+    """Run the tests for rest_framework and generate a coverage report."""
+
+    cov = coverage()
+    cov.erase()
+    cov.start()
+
+    failures = run_tests('rest_framework')
+    cov.stop()
+
+    # Discover the list of all modules that we should test coverage for
+    import rest_framework
+
+    project_dir = os.path.dirname(rest_framework.__file__)
+    cov_files = prepare_report(project_dir)
+
+    report(cov, cov_files)
     sys.exit(failures)
 
 if __name__ == '__main__':

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/settings.py

@@ -1,21 +1,122 @@
-"""Tests for the settings module"""
+# Django settings for testproject project.
-from django.test import TestCase
 
-from rest_framework.settings import APISettings, DEFAULTS, IMPORT_STRINGS
+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',
+    'discover_runner'
+    )
+
+TEST_RUNNER = 'discover_runner.runner.DiscoverRunner'
+
+STATIC_URL = '/static/'
+
+import django
+
+if django.VERSION < (1, 3):
+    INSTALLED_APPS += ('staticfiles',)
 
 
-class TestSettings(TestCase):
+# If we're running on the Jenkins server we want to archive the coverage reports as XML.
-    """Tests relating to the api settings"""
+import os
 
-    def test_non_import_errors(self):
+if os.environ.get('HUDSON_URL', None):
-        """Make sure other errors aren't suppressed."""
+    TEST_RUNNER = 'xmlrunner.extra.djangotestrunner.XMLTestRunner'
-        settings = APISettings({'DEFAULT_MODEL_SERIALIZER_CLASS': 'rest_framework.tests.extras.bad_import.ModelSerializer'}, DEFAULTS, IMPORT_STRINGS)
+    TEST_OUTPUT_VERBOSE = True
-        with self.assertRaises(ValueError):
+    TEST_OUTPUT_DESCRIPTIONS = True
-            settings.DEFAULT_MODEL_SERIALIZER_CLASS
+    TEST_OUTPUT_DIR = 'xmlrunner'
-
-    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)
-        with self.assertRaises(ImportError) as cm:
-            settings.DEFAULT_MODEL_SERIALIZER_CLASS
-        self.assertTrue('ImportError' in str(cm.exception))

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 = '/'

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):

rest_framework/tests/test_htmlrenderer.py

@@ -40,7 +40,7 @@ urlpatterns = patterns('',
 
 
 class TemplateHTMLRendererTests(TestCase):
-    urls = 'rest_framework.tests.htmlrenderer'
+    urls = 'rest_framework.tests.test_htmlrenderer'
 
     def setUp(self):
         """
@@ -80,7 +80,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

@@ -96,7 +96,7 @@ urlpatterns = patterns('',
 
 
 class TestBasicHyperlinkedView(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -133,7 +133,7 @@ class TestBasicHyperlinkedView(TestCase):
 
 
 class TestManyToManyHyperlinkedView(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -181,7 +181,7 @@ class TestManyToManyHyperlinkedView(TestCase):
 
 
 class TestCreateWithForeignKeys(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -205,7 +205,7 @@ class TestCreateWithForeignKeys(TestCase):
 
 
 class TestCreateWithForeignKeysAndCustomSlug(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """
@@ -230,7 +230,7 @@ class TestCreateWithForeignKeysAndCustomSlug(TestCase):
 
 
 class TestOptionalRelationHyperlinkedView(TestCase):
-    urls = 'rest_framework.tests.hyperlinkedserializers'
+    urls = 'rest_framework.tests.test_hyperlinkedserializers'
 
     def setUp(self):
         """

rest_framework/tests/test_pagination.py

@@ -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):
@@ -75,8 +75,10 @@ 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/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')
@@ -423,7 +446,7 @@ class HyperlinkedNullableForeignKeyTests(TestCase):
 
 
 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_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,6 +111,7 @@ 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))
         else:
@@ -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)
@@ -280,7 +281,6 @@ class TestContentParsingWithAuthentication(TestCase):
 
 
 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."""
@@ -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 qualified 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

@@ -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
@@ -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]
 
@@ -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

@@ -0,0 +1,25 @@
+"""Tests for the settings module"""
+from django.test import TestCase
+
+from rest_framework.settings import APISettings, DEFAULTS, IMPORT_STRINGS
+
+
+class TestSettings(TestCase):
+    """Tests relating to the api settings"""
+
+    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)
+        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)
+        with self.assertRaises(ImportError) as cm:
+            settings.DEFAULT_MODEL_SERIALIZER_CLASS
+        self.assertTrue('ImportError' in str(cm.exception))

rest_framework/tests/test_status.py

@@ -162,7 +162,7 @@ class TestStatus(TestCase):
         """Ensure that HTTP_500_INTERNAL_SERVER_ERROR equals 500."""
         self.assertEquals(status.HTTP_500_INTERNAL_SERVER_ERROR, 500)
 
-    def HTTP_501_NOT_IMPLEMENTED(self):
+    def test_status_HTTP_501_NOT_IMPLEMENTED(self):
         """Ensure that HTTP_501_NOT_IMPLEMENTED equals 501."""
         self.assertEquals(status.HTTP_501_NOT_IMPLEMENTED, 501)
 

rest_framework/tests/test_testcases.py

@@ -16,6 +16,7 @@ class TestSettingsManager(object):
     modified.
 
     """
+
     def __init__(self):
         self._original_settings = {}
 
@@ -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):
         """

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)