mirror of
https://github.com/django/django.git
synced 2024-12-26 19:16:11 +00:00
f758bdab5e
Previously, the flush was done before the test case execution and now it is performed after it. Other changes to the testing infrastructure include: * TransactionTestCase now doesn't reset autoincrement sequences either (previous behavior can achieved by using `reset_sequences`.) With this, no implicit such reset is performed by any of the provided TestCase classes. * New ordering of test cases: All unittest tes cases are run first and doctests are run at the end. THse changes could be backward-incompatible with test cases that relied on some kind of state being preserved between tests. Please read the relevant sections of the release notes and testing documentation for further details. Thanks Andreas Pelme for the initial patch. Karen Tracey and Anssi Kääriäinen for the feedback and Anssi for reviewing. This also fixes #12408.
372 lines
13 KiB
Python
372 lines
13 KiB
Python
import unittest as real_unittest
|
|
|
|
from django.conf import settings
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
from django.db.models import get_app, get_apps
|
|
from django.test import _doctest as doctest
|
|
from django.test.utils import setup_test_environment, teardown_test_environment
|
|
from django.test.testcases import OutputChecker, DocTestRunner
|
|
from django.utils import unittest
|
|
from django.utils.importlib import import_module
|
|
from django.utils.module_loading import module_has_submodule
|
|
|
|
__all__ = ('DjangoTestSuiteRunner')
|
|
|
|
# The module name for tests outside models.py
|
|
TEST_MODULE = 'tests'
|
|
|
|
doctestOutputChecker = OutputChecker()
|
|
|
|
|
|
def get_tests(app_module):
|
|
parts = app_module.__name__.split('.')
|
|
prefix, last = parts[:-1], parts[-1]
|
|
try:
|
|
test_module = import_module('.'.join(prefix + [TEST_MODULE]))
|
|
except ImportError:
|
|
# Couldn't import tests.py. Was it due to a missing file, or
|
|
# due to an import error in a tests.py that actually exists?
|
|
# app_module either points to a models.py file, or models/__init__.py
|
|
# Tests are therefore either in same directory, or one level up
|
|
if last == 'models':
|
|
app_root = import_module('.'.join(prefix))
|
|
else:
|
|
app_root = app_module
|
|
|
|
if not module_has_submodule(app_root, TEST_MODULE):
|
|
test_module = None
|
|
else:
|
|
# The module exists, so there must be an import error in the test
|
|
# module itself.
|
|
raise
|
|
return test_module
|
|
|
|
|
|
def build_suite(app_module):
|
|
"""
|
|
Create a complete Django test suite for the provided application module.
|
|
"""
|
|
suite = unittest.TestSuite()
|
|
|
|
# Load unit and doctests in the models.py module. If module has
|
|
# a suite() method, use it. Otherwise build the test suite ourselves.
|
|
if hasattr(app_module, 'suite'):
|
|
suite.addTest(app_module.suite())
|
|
else:
|
|
suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(
|
|
app_module))
|
|
try:
|
|
suite.addTest(doctest.DocTestSuite(app_module,
|
|
checker=doctestOutputChecker,
|
|
runner=DocTestRunner))
|
|
except ValueError:
|
|
# No doc tests in models.py
|
|
pass
|
|
|
|
# Check to see if a separate 'tests' module exists parallel to the
|
|
# models module
|
|
test_module = get_tests(app_module)
|
|
if test_module:
|
|
# Load unit and doctests in the tests.py module. If module has
|
|
# a suite() method, use it. Otherwise build the test suite ourselves.
|
|
if hasattr(test_module, 'suite'):
|
|
suite.addTest(test_module.suite())
|
|
else:
|
|
suite.addTest(unittest.defaultTestLoader.loadTestsFromModule(
|
|
test_module))
|
|
try:
|
|
suite.addTest(doctest.DocTestSuite(
|
|
test_module, checker=doctestOutputChecker,
|
|
runner=DocTestRunner))
|
|
except ValueError:
|
|
# No doc tests in tests.py
|
|
pass
|
|
return suite
|
|
|
|
|
|
def build_test(label):
|
|
"""
|
|
Construct a test case with the specified label. Label should be of the
|
|
form model.TestClass or model.TestClass.test_method. Returns an
|
|
instantiated test or test suite corresponding to the label provided.
|
|
|
|
"""
|
|
parts = label.split('.')
|
|
if len(parts) < 2 or len(parts) > 3:
|
|
raise ValueError("Test label '%s' should be of the form app.TestCase "
|
|
"or app.TestCase.test_method" % label)
|
|
|
|
#
|
|
# First, look for TestCase instances with a name that matches
|
|
#
|
|
app_module = get_app(parts[0])
|
|
test_module = get_tests(app_module)
|
|
TestClass = getattr(app_module, parts[1], None)
|
|
|
|
# Couldn't find the test class in models.py; look in tests.py
|
|
if TestClass is None:
|
|
if test_module:
|
|
TestClass = getattr(test_module, parts[1], None)
|
|
|
|
try:
|
|
if issubclass(TestClass, (unittest.TestCase, real_unittest.TestCase)):
|
|
if len(parts) == 2: # label is app.TestClass
|
|
try:
|
|
return unittest.TestLoader().loadTestsFromTestCase(
|
|
TestClass)
|
|
except TypeError:
|
|
raise ValueError(
|
|
"Test label '%s' does not refer to a test class"
|
|
% label)
|
|
else: # label is app.TestClass.test_method
|
|
return TestClass(parts[2])
|
|
except TypeError:
|
|
# TestClass isn't a TestClass - it must be a method or normal class
|
|
pass
|
|
|
|
#
|
|
# If there isn't a TestCase, look for a doctest that matches
|
|
#
|
|
tests = []
|
|
for module in app_module, test_module:
|
|
try:
|
|
doctests = doctest.DocTestSuite(module,
|
|
checker=doctestOutputChecker,
|
|
runner=DocTestRunner)
|
|
# Now iterate over the suite, looking for doctests whose name
|
|
# matches the pattern that was given
|
|
for test in doctests:
|
|
if test._dt_test.name in (
|
|
'%s.%s' % (module.__name__, '.'.join(parts[1:])),
|
|
'%s.__test__.%s' % (
|
|
module.__name__, '.'.join(parts[1:]))):
|
|
tests.append(test)
|
|
except ValueError:
|
|
# No doctests found.
|
|
pass
|
|
|
|
# If no tests were found, then we were given a bad test label.
|
|
if not tests:
|
|
raise ValueError("Test label '%s' does not refer to a test" % label)
|
|
|
|
# Construct a suite out of the tests that matched.
|
|
return unittest.TestSuite(tests)
|
|
|
|
|
|
def partition_suite(suite, classes, bins):
|
|
"""
|
|
Partitions a test suite by test type.
|
|
|
|
classes is a sequence of types
|
|
bins is a sequence of TestSuites, one more than classes
|
|
|
|
Tests of type classes[i] are added to bins[i],
|
|
tests with no match found in classes are place in bins[-1]
|
|
"""
|
|
for test in suite:
|
|
if isinstance(test, unittest.TestSuite):
|
|
partition_suite(test, classes, bins)
|
|
else:
|
|
for i in range(len(classes)):
|
|
if isinstance(test, classes[i]):
|
|
bins[i].addTest(test)
|
|
break
|
|
else:
|
|
bins[-1].addTest(test)
|
|
|
|
|
|
def reorder_suite(suite, classes):
|
|
"""
|
|
Reorders a test suite by test type.
|
|
|
|
`classes` is a sequence of types
|
|
|
|
All tests of type classes[0] are placed first, then tests of type
|
|
classes[1], etc. Tests with no match in classes are placed last.
|
|
"""
|
|
class_count = len(classes)
|
|
bins = [unittest.TestSuite() for i in range(class_count+1)]
|
|
partition_suite(suite, classes, bins)
|
|
for i in range(class_count):
|
|
bins[0].addTests(bins[i+1])
|
|
return bins[0]
|
|
|
|
|
|
def dependency_ordered(test_databases, dependencies):
|
|
"""
|
|
Reorder test_databases into an order that honors the dependencies
|
|
described in TEST_DEPENDENCIES.
|
|
"""
|
|
ordered_test_databases = []
|
|
resolved_databases = set()
|
|
|
|
# Maps db signature to dependencies of all it's aliases
|
|
dependencies_map = {}
|
|
|
|
# sanity check - no DB can depend on it's own alias
|
|
for sig, (_, aliases) in test_databases:
|
|
all_deps = set()
|
|
for alias in aliases:
|
|
all_deps.update(dependencies.get(alias, []))
|
|
if not all_deps.isdisjoint(aliases):
|
|
raise ImproperlyConfigured(
|
|
"Circular dependency: databases %r depend on each other, "
|
|
"but are aliases." % aliases)
|
|
dependencies_map[sig] = all_deps
|
|
|
|
while test_databases:
|
|
changed = False
|
|
deferred = []
|
|
|
|
# Try to find a DB that has all it's dependencies met
|
|
for signature, (db_name, aliases) in test_databases:
|
|
if dependencies_map[signature].issubset(resolved_databases):
|
|
resolved_databases.update(aliases)
|
|
ordered_test_databases.append((signature, (db_name, aliases)))
|
|
changed = True
|
|
else:
|
|
deferred.append((signature, (db_name, aliases)))
|
|
|
|
if not changed:
|
|
raise ImproperlyConfigured(
|
|
"Circular dependency in TEST_DEPENDENCIES")
|
|
test_databases = deferred
|
|
return ordered_test_databases
|
|
|
|
|
|
class DjangoTestSuiteRunner(object):
|
|
def __init__(self, verbosity=1, interactive=True, failfast=True, **kwargs):
|
|
self.verbosity = verbosity
|
|
self.interactive = interactive
|
|
self.failfast = failfast
|
|
|
|
def setup_test_environment(self, **kwargs):
|
|
setup_test_environment()
|
|
settings.DEBUG = False
|
|
unittest.installHandler()
|
|
|
|
def build_suite(self, test_labels, extra_tests=None, **kwargs):
|
|
suite = unittest.TestSuite()
|
|
|
|
if test_labels:
|
|
for label in test_labels:
|
|
if '.' in label:
|
|
suite.addTest(build_test(label))
|
|
else:
|
|
app = get_app(label)
|
|
suite.addTest(build_suite(app))
|
|
else:
|
|
for app in get_apps():
|
|
suite.addTest(build_suite(app))
|
|
|
|
if extra_tests:
|
|
for test in extra_tests:
|
|
suite.addTest(test)
|
|
|
|
return reorder_suite(suite, (unittest.TestCase,))
|
|
|
|
def setup_databases(self, **kwargs):
|
|
from django.db import connections, DEFAULT_DB_ALIAS
|
|
|
|
# First pass -- work out which databases actually need to be created,
|
|
# and which ones are test mirrors or duplicate entries in DATABASES
|
|
mirrored_aliases = {}
|
|
test_databases = {}
|
|
dependencies = {}
|
|
for alias in connections:
|
|
connection = connections[alias]
|
|
if connection.settings_dict['TEST_MIRROR']:
|
|
# If the database is marked as a test mirror, save
|
|
# the alias.
|
|
mirrored_aliases[alias] = (
|
|
connection.settings_dict['TEST_MIRROR'])
|
|
else:
|
|
# Store a tuple with DB parameters that uniquely identify it.
|
|
# If we have two aliases with the same values for that tuple,
|
|
# we only need to create the test database once.
|
|
item = test_databases.setdefault(
|
|
connection.creation.test_db_signature(),
|
|
(connection.settings_dict['NAME'], set())
|
|
)
|
|
item[1].add(alias)
|
|
|
|
if 'TEST_DEPENDENCIES' in connection.settings_dict:
|
|
dependencies[alias] = (
|
|
connection.settings_dict['TEST_DEPENDENCIES'])
|
|
else:
|
|
if alias != DEFAULT_DB_ALIAS:
|
|
dependencies[alias] = connection.settings_dict.get(
|
|
'TEST_DEPENDENCIES', [DEFAULT_DB_ALIAS])
|
|
|
|
# Second pass -- actually create the databases.
|
|
old_names = []
|
|
mirrors = []
|
|
|
|
for signature, (db_name, aliases) in dependency_ordered(
|
|
test_databases.items(), dependencies):
|
|
test_db_name = None
|
|
# Actually create the database for the first connection
|
|
|
|
for alias in aliases:
|
|
connection = connections[alias]
|
|
old_names.append((connection, db_name, True))
|
|
if test_db_name is None:
|
|
test_db_name = connection.creation.create_test_db(
|
|
self.verbosity, autoclobber=not self.interactive)
|
|
else:
|
|
connection.settings_dict['NAME'] = test_db_name
|
|
|
|
for alias, mirror_alias in mirrored_aliases.items():
|
|
mirrors.append((alias, connections[alias].settings_dict['NAME']))
|
|
connections[alias].settings_dict['NAME'] = (
|
|
connections[mirror_alias].settings_dict['NAME'])
|
|
|
|
return old_names, mirrors
|
|
|
|
def run_suite(self, suite, **kwargs):
|
|
return unittest.TextTestRunner(
|
|
verbosity=self.verbosity, failfast=self.failfast).run(suite)
|
|
|
|
def teardown_databases(self, old_config, **kwargs):
|
|
"""
|
|
Destroys all the non-mirror databases.
|
|
"""
|
|
old_names, mirrors = old_config
|
|
for connection, old_name, destroy in old_names:
|
|
if destroy:
|
|
connection.creation.destroy_test_db(old_name, self.verbosity)
|
|
|
|
def teardown_test_environment(self, **kwargs):
|
|
unittest.removeHandler()
|
|
teardown_test_environment()
|
|
|
|
def suite_result(self, suite, result, **kwargs):
|
|
return len(result.failures) + len(result.errors)
|
|
|
|
def run_tests(self, test_labels, extra_tests=None, **kwargs):
|
|
"""
|
|
Run the unit tests for all the test labels in the provided list.
|
|
Labels must be of the form:
|
|
- app.TestClass.test_method
|
|
Run a single specific test method
|
|
- app.TestClass
|
|
Run all the test methods in a given class
|
|
- app
|
|
Search for doctests and unittests in the named application.
|
|
|
|
When looking for tests, the test runner will look in the models and
|
|
tests modules for the application.
|
|
|
|
A list of 'extra' tests may also be provided; these tests
|
|
will be added to the test suite.
|
|
|
|
Returns the number of tests that failed.
|
|
"""
|
|
self.setup_test_environment()
|
|
suite = self.build_suite(test_labels, extra_tests)
|
|
old_config = self.setup_databases()
|
|
result = self.run_suite(suite)
|
|
self.teardown_databases(old_config)
|
|
self.teardown_test_environment()
|
|
return self.suite_result(suite, result)
|