Fixed #23421 -- Corrected TEST SERIALIZE setting.

Thanks gkoller for the report.

django/test/runner.py

@@ -301,7 +301,7 @@ def setup_databases(verbosity, interactive, keepdb=False, **kwargs):
                     verbosity,
                     autoclobber=not interactive,
                     keepdb=keepdb,
-                    serialize=connection.settings_dict.get("TEST_SERIALIZE", True),
+                    serialize=connection.settings_dict.get("TEST", {}).get("SERIALIZE", True),
                 )
                 destroy = True
             else:

docs/ref/settings.txt

@@ -683,6 +683,19 @@ test database will use the name ``'test_' + DATABASE_NAME``.
 
 See :ref:`the-test-database`.
 
+.. setting:: TEST_SERIALIZE
+
+SERIALIZE
+^^^^^^^^^
+
+.. versionadded:: 1.7.1
+
+Boolean value to control whether or not the default test runnner serializes the
+database into an in-memory JSON string before running tests (used to restore
+the database state between tests if you don't have transactions). You can set
+this to ``False`` to speed up creation time if you don't have any test classes
+with :ref:`serialized_rollback=True <test-case-serialized-rollback>`.
+
 .. setting:: TEST_CREATE
 
 CREATE_DB

docs/releases/1.7.1.txt

@@ -70,3 +70,6 @@ Bugfixes
 
 * Made ``migrations.RunSQL`` no longer require percent sign escaping. This is
   now consistent with ``cursor.execute()`` (:ticket:`23426`).
+
+* Made the :setting:`SERIALIZE <TEST_SERIALIZE>` entry in the
+  :setting:`TEST <DATABASE-TEST>` dictionary usable (:ticket:`23421`).

docs/topics/testing/advanced.txt

@@ -525,8 +525,14 @@ can be useful during testing.
     ``serialize`` determines if Django serializes the database into an
     in-memory JSON string before running tests (used to restore the database
     state between tests if you don't have transactions). You can set this to
-    False to significantly speed up creation time if you know you don't need
+    ``False`` to speed up creation time if you don't have any test classes
-    data persistence outside of test fixtures.
+    with :ref:`serialized_rollback=True <test-case-serialized-rollback>`.
+
+    .. versionadded:: 1.7.1
+
+        If you are using the default test runner, you can control this with the
+        the :setting:`SERIALIZE <TEST_SERIALIZE>` entry in the
+        :setting:`TEST <DATABASE-TEST>` dictionary
 
     ``keepdb`` determines if the test run should use an existing
     database, or create a new one. If ``True``, the existing

tests/test_runner/tests.py

@@ -5,9 +5,10 @@ from __future__ import unicode_literals
 
 import unittest
 
+from django import db
 from django.core.exceptions import ImproperlyConfigured
 from django.core.management import call_command
-from django import db
+from django.db.backends.dummy.base import DatabaseCreation
 from django.test import runner, TestCase, TransactionTestCase, skipUnlessDBFeature
 from django.test.testcases import connections_support_transactions
 from django.test.utils import override_system_checks
@@ -299,38 +300,72 @@ class AliasedDefaultTestSetupTest(unittest.TestCase):
             db.connections = old_db_connections
 
 
-class AliasedDatabaseTeardownTest(unittest.TestCase):
+class SetupDatabasesTests(unittest.TestCase):
+
+    def setUp(self):
+        self._old_db_connections = db.connections
+        self._old_destroy_test_db = DatabaseCreation.destroy_test_db
+        self._old_create_test_db = DatabaseCreation.create_test_db
+        self.runner_instance = runner.DiscoverRunner(verbosity=0)
+
+    def tearDown(self):
+        DatabaseCreation.create_test_db = self._old_create_test_db
+        DatabaseCreation.destroy_test_db = self._old_destroy_test_db
+        db.connections = self._old_db_connections
+
     def test_setup_aliased_databases(self):
-        from django.db.backends.dummy.base import DatabaseCreation
+        destroyed_names = []
+        DatabaseCreation.destroy_test_db = (
+            lambda self, old_database_name, verbosity=1, keepdb=False, serialize=True:
+            destroyed_names.append(old_database_name)
+        )
+        DatabaseCreation.create_test_db = (
+            lambda self, verbosity=1, autoclobber=False, keepdb=False, serialize=True:
+            self._get_test_db_name()
+        )
 
-        runner_instance = runner.DiscoverRunner(verbosity=0)
+        db.connections = db.ConnectionHandler({
-        old_db_connections = db.connections
+            'default': {
-        old_destroy_test_db = DatabaseCreation.destroy_test_db
+                'ENGINE': 'django.db.backends.dummy',
-        old_create_test_db = DatabaseCreation.create_test_db
+                'NAME': 'dbname',
-        try:
+            },
-            destroyed_names = []
+            'other': {
-            DatabaseCreation.destroy_test_db = lambda self, old_database_name, verbosity=1, keepdb=False, serialize=True: destroyed_names.append(old_database_name)
+                'ENGINE': 'django.db.backends.dummy',
-            DatabaseCreation.create_test_db = lambda self, verbosity=1, autoclobber=False, keepdb=False, serialize=True: self._get_test_db_name()
+                'NAME': 'dbname',
+            }
+        })
 
-            db.connections = db.ConnectionHandler({
+        old_config = self.runner_instance.setup_databases()
-                'default': {
+        self.runner_instance.teardown_databases(old_config)
-                    'ENGINE': 'django.db.backends.dummy',
-                    'NAME': 'dbname',
-                },
-                'other': {
-                    'ENGINE': 'django.db.backends.dummy',
-                    'NAME': 'dbname',
-                }
-            })
 
-            old_config = runner_instance.setup_databases()
+        self.assertEqual(destroyed_names.count('dbname'), 1)
-            runner_instance.teardown_databases(old_config)
 
-            self.assertEqual(destroyed_names.count('dbname'), 1)
+    def test_serialization(self):
-        finally:
+        serialize = []
-            DatabaseCreation.create_test_db = old_create_test_db
+        DatabaseCreation.create_test_db = (
-            DatabaseCreation.destroy_test_db = old_destroy_test_db
+            lambda *args, **kwargs: serialize.append(kwargs.get('serialize'))
-            db.connections = old_db_connections
+        )
+        db.connections = db.ConnectionHandler({
+            'default': {
+                'ENGINE': 'django.db.backends.dummy',
+            },
+        })
+        self.runner_instance.setup_databases()
+        self.assertEqual(serialize, [True])
+
+    def test_serialized_off(self):
+        serialize = []
+        DatabaseCreation.create_test_db = (
+            lambda *args, **kwargs: serialize.append(kwargs.get('serialize'))
+        )
+        db.connections = db.ConnectionHandler({
+            'default': {
+                'ENGINE': 'django.db.backends.dummy',
+                'TEST': {'SERIALIZE': False},
+            },
+        })
+        self.runner_instance.setup_databases()
+        self.assertEqual(serialize, [False])
 
 
 class DeprecationDisplayTest(AdminScriptTestCase):