Added a ``checksetup`` management command for verifying Django compatibility.

django/core/compat_checks/base.py

@@ -0,0 +1,39 @@
+from __future__ import unicode_literals
+import warnings
+
+from django.core.compat_checks import django_1_6_0
+
+
+COMPAT_CHECKS = [
+    # Add new modules at the top, so we keep things in descending order.
+    # After two-three minor releases, old versions should get dropped.
+    django_1_6_0,
+]
+
+
+def check_compatibility():
+    """
+    Runs through compatibility checks to warn the user with an existing install
+    about changes in an up-to-date Django.
+
+    Modules should be located in ``django.core.compat_checks`` (typically one
+    per release of Django) & must have a ``run_checks`` function that runs
+    all the checks.
+
+    Returns a list of informational messages about incompatibilities.
+    """
+    messages = []
+
+    for check_module in COMPAT_CHECKS:
+        check = getattr(check_module, u'run_checks', None)
+
+        if check is None:
+            warnings.warn(
+                u"The '%s' module lacks a " % check_module.__name__ +
+                u"'run_checks' method, which is needed to verify compatibility."
+            )
+            continue
+
+        messages.extend(check())
+
+    return messages

django/core/compat_checks/django_1_6_0.py

@@ -0,0 +1,37 @@
+from __future__ import unicode_literals
+
+
+def check_test_runner():
+    """
+    Checks if the user has *not* overridden the ``TEST_RUNNER`` setting &
+    warns them about the default behavior changes.
+
+    If the user has overridden that setting, we presume they know what they're
+    doing & avoid generating a message.
+    """
+    from django.conf import settings
+    new_default = u'django.test.runner.DiscoverRunner'
+    test_runner_setting = getattr(settings, u'TEST_RUNNER', new_default)
+
+    if test_runner_setting == new_default:
+        message = [
+            u"You have not explicitly set 'TEST_RUNNER'. In Django 1.6,",
+            u"there is a new test runner ('%s')" % new_default,
+            u"by default. You should ensure your tests are still all",
+            u"running & behaving as expected. See",
+            u"https://docs.djangoproject.com/en/dev/releases/1.6/#discovery-of-tests-in-any-test-module",
+            u"for more information.",
+        ]
+        return u' '.join(message)
+
+
+def run_checks():
+    """
+    Required by the ``checksetup`` management command, this returns a list of
+    messages from all the relevant check functions for this version of Django.
+    """
+    checks = [
+        check_test_runner()
+    ]
+    # Filter out the ``None`` or empty strings.
+    return [output for output in checks if output]

django/core/management/commands/checksetup.py

@@ -0,0 +1,14 @@
+from __future__ import unicode_literals
+import warnings
+
+from django.core.compat_checks.base import check_compatibility
+from django.core.management.base import NoArgsCommand
+
+
+class Command(NoArgsCommand):
+    help = u"Checks your configuration's compatibility with this version " + \
+           u"of Django."
+
+    def handle_noargs(self, **options):
+        for message in check_compatibility():
+            warnings.warn(message)

docs/releases/1.6.txt

@@ -121,6 +121,13 @@ GeoDjango now provides :ref:`form fields and widgets <ref-gis-forms-api>` for
 its geo-specialized fields. They are OpenLayers-based by default, but they can
 be customized to use any other JS framework.
 
+``checksetup`` management command added for verifying compatibility
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+A ``checksetup`` management command was added, enabling you to verify if your
+current configuration (currently oriented at settings) is compatible with the
+current version of Django.
+
 Minor features
 ~~~~~~~~~~~~~~
 

tests/compat_checks/models.py

@@ -0,0 +1 @@
+# Stubby.

tests/compat_checks/tests.py

@@ -0,0 +1,107 @@
+from django.core.compat_checks import base
+from django.core.compat_checks import django_1_6_0
+from django.core.management.commands import checksetup
+from django.core.management import call_command
+from django.test import TestCase
+
+
+class StubCheckModule(object):
+    # Has no ``run_checks`` attribute & will trigger a warning.
+    __name__ = 'StubCheckModule'
+
+
+class FakeWarnings(object):
+    def __init__(self):
+        self._warnings = []
+
+    def warn(self, message):
+        self._warnings.append(message)
+
+
+class CompatChecksTestCase(TestCase):
+    def setUp(self):
+        super(CompatChecksTestCase, self).setUp()
+
+        # We're going to override the list of checks to perform for test
+        # consistency in the future.
+        self.old_compat_checks = base.COMPAT_CHECKS
+        base.COMPAT_CHECKS = [
+            django_1_6_0,
+        ]
+
+    def tearDown(self):
+        # Restore what's supposed to be in ``COMPAT_CHECKS``.
+        base.COMPAT_CHECKS = self.old_compat_checks
+        super(CompatChecksTestCase, self).tearDown()
+
+    def test_check_test_runner_new_default(self):
+        with self.settings(TEST_RUNNER='django.test.runner.DiscoverRunner'):
+            result = django_1_6_0.check_test_runner()
+            self.assertTrue("You have not explicitly set 'TEST_RUNNER'" in result)
+
+    def test_check_test_runner_overridden(self):
+        with self.settings(TEST_RUNNER='myapp.test.CustomRunnner'):
+            self.assertEqual(django_1_6_0.check_test_runner(), None)
+
+    def test_run_checks_new_default(self):
+        with self.settings(TEST_RUNNER='django.test.runner.DiscoverRunner'):
+            result = django_1_6_0.run_checks()
+            self.assertEqual(len(result), 1)
+            self.assertTrue("You have not explicitly set 'TEST_RUNNER'" in result[0])
+
+    def test_run_checks_overridden(self):
+        with self.settings(TEST_RUNNER='myapp.test.CustomRunnner'):
+            self.assertEqual(len(django_1_6_0.run_checks()), 0)
+
+    def test_check_compatibility(self):
+        with self.settings(TEST_RUNNER='django.test.runner.DiscoverRunner'):
+            result = base.check_compatibility()
+            self.assertEqual(len(result), 1)
+            self.assertTrue("You have not explicitly set 'TEST_RUNNER'" in result[0])
+
+        with self.settings(TEST_RUNNER='myapp.test.CustomRunnner'):
+            self.assertEqual(len(base.check_compatibility()), 0)
+
+    def test_check_compatibility_warning(self):
+        # First, we're patching over the ``COMPAT_CHECKS`` with a stub which
+        # will trigger the warning.
+        base.COMPAT_CHECKS = [
+            StubCheckModule(),
+        ]
+
+        # Next, we unfortunately have to patch out ``warnings``.
+        old_warnings = base.warnings
+        base.warnings = FakeWarnings()
+
+        self.assertEqual(len(base.warnings._warnings), 0)
+
+        with self.settings(TEST_RUNNER='myapp.test.CustomRunnner'):
+            self.assertEqual(len(base.check_compatibility()), 0)
+
+        self.assertEqual(len(base.warnings._warnings), 1)
+        self.assertTrue("The 'StubCheckModule' module lacks a 'run_checks'" in base.warnings._warnings[0])
+
+        # Restore the ``warnings``.
+        base.warnings = old_warnings
+
+    def test_management_command(self):
+        # Again, we unfortunately have to patch out ``warnings``. Different
+        old_warnings = checksetup.warnings
+        checksetup.warnings = FakeWarnings()
+
+        self.assertEqual(len(checksetup.warnings._warnings), 0)
+
+        # Should not produce any warnings.
+        with self.settings(TEST_RUNNER='myapp.test.CustomRunnner'):
+            call_command('checksetup')
+
+        self.assertEqual(len(checksetup.warnings._warnings), 0)
+
+        with self.settings(TEST_RUNNER='django.test.runner.DiscoverRunner'):
+            call_command('checksetup')
+
+        self.assertEqual(len(checksetup.warnings._warnings), 1)
+        self.assertTrue("You have not explicitly set 'TEST_RUNNER'" in checksetup.warnings._warnings[0])
+
+        # Restore the ``warnings``.
+        base.warnings = old_warnings