django/tests/runtests.py

788 lines
26 KiB
Python
Executable File

#!/usr/bin/env python
import argparse
import atexit
import copy
import gc
import multiprocessing
import os
import shutil
import socket
import subprocess
import sys
import tempfile
import warnings
from pathlib import Path
try:
import django
except ImportError as e:
raise RuntimeError(
"Django module not found, reference tests/README.rst for instructions."
) from e
else:
from django.apps import apps
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
from django.db import connection, connections
from django.test import TestCase, TransactionTestCase
from django.test.runner import get_max_test_processes, parallel_type
from django.test.selenium import SeleniumTestCaseBase
from django.test.utils import NullTimeKeeper, TimeKeeper, get_runner
from django.utils.deprecation import (
RemovedInDjango50Warning,
RemovedInDjango51Warning,
)
from django.utils.log import DEFAULT_LOGGING
try:
import MySQLdb
except ImportError:
pass
else:
# Ignore informational warnings from QuerySet.explain().
warnings.filterwarnings("ignore", r"\(1003, *", category=MySQLdb.Warning)
# Make deprecation warnings errors to ensure no usage of deprecated features.
warnings.simplefilter("error", RemovedInDjango50Warning)
warnings.simplefilter("error", RemovedInDjango51Warning)
# Make resource and runtime warning errors to ensure no usage of error prone
# patterns.
warnings.simplefilter("error", ResourceWarning)
warnings.simplefilter("error", RuntimeWarning)
# Ignore known warnings in test dependencies.
warnings.filterwarnings(
"ignore", "'U' mode is deprecated", DeprecationWarning, module="docutils.io"
)
# Reduce garbage collection frequency to improve performance. Since CPython
# uses refcounting, garbage collection only collects objects with cyclic
# references, which are a minority, so the garbage collection threshold can be
# larger than the default threshold of 700 allocations + deallocations without
# much increase in memory usage.
gc.set_threshold(100_000)
RUNTESTS_DIR = os.path.abspath(os.path.dirname(__file__))
TEMPLATE_DIR = os.path.join(RUNTESTS_DIR, "templates")
# Create a specific subdirectory for the duration of the test suite.
TMPDIR = tempfile.mkdtemp(prefix="django_")
# Set the TMPDIR environment variable in addition to tempfile.tempdir
# so that children processes inherit it.
tempfile.tempdir = os.environ["TMPDIR"] = TMPDIR
# Removing the temporary TMPDIR.
atexit.register(shutil.rmtree, TMPDIR)
# This is a dict mapping RUNTESTS_DIR subdirectory to subdirectories of that
# directory to skip when searching for test modules.
SUBDIRS_TO_SKIP = {
"": {"import_error_package", "test_runner_apps"},
"gis_tests": {"data"},
}
ALWAYS_INSTALLED_APPS = [
"django.contrib.contenttypes",
"django.contrib.auth",
"django.contrib.sites",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.admin.apps.SimpleAdminConfig",
"django.contrib.staticfiles",
]
ALWAYS_MIDDLEWARE = [
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
]
# Need to add the associated contrib app to INSTALLED_APPS in some cases to
# avoid "RuntimeError: Model class X doesn't declare an explicit app_label
# and isn't in an application in INSTALLED_APPS."
CONTRIB_TESTS_TO_APPS = {
"deprecation": ["django.contrib.flatpages", "django.contrib.redirects"],
"flatpages_tests": ["django.contrib.flatpages"],
"redirects_tests": ["django.contrib.redirects"],
}
def get_test_modules(gis_enabled):
"""
Scan the tests directory and yield the names of all test modules.
The yielded names have either one dotted part like "test_runner" or, in
the case of GIS tests, two dotted parts like "gis_tests.gdal_tests".
"""
discovery_dirs = [""]
if gis_enabled:
# GIS tests are in nested apps
discovery_dirs.append("gis_tests")
else:
SUBDIRS_TO_SKIP[""].add("gis_tests")
for dirname in discovery_dirs:
dirpath = os.path.join(RUNTESTS_DIR, dirname)
subdirs_to_skip = SUBDIRS_TO_SKIP[dirname]
with os.scandir(dirpath) as entries:
for f in entries:
if (
"." in f.name
or os.path.basename(f.name) in subdirs_to_skip
or f.is_file()
or not os.path.exists(os.path.join(f.path, "__init__.py"))
):
continue
test_module = f.name
if dirname:
test_module = dirname + "." + test_module
yield test_module
def get_label_module(label):
"""Return the top-level module part for a test label."""
path = Path(label)
if len(path.parts) == 1:
# Interpret the label as a dotted module name.
return label.split(".")[0]
# Otherwise, interpret the label as a path. Check existence first to
# provide a better error message than relative_to() if it doesn't exist.
if not path.exists():
raise RuntimeError(f"Test label path {label} does not exist")
path = path.resolve()
rel_path = path.relative_to(RUNTESTS_DIR)
return rel_path.parts[0]
def get_filtered_test_modules(start_at, start_after, gis_enabled, test_labels=None):
if test_labels is None:
test_labels = []
# Reduce each test label to just the top-level module part.
label_modules = set()
for label in test_labels:
test_module = get_label_module(label)
label_modules.add(test_module)
# It would be nice to put this validation earlier but it must come after
# django.setup() so that connection.features.gis_enabled can be accessed.
if "gis_tests" in label_modules and not gis_enabled:
print("Aborting: A GIS database backend is required to run gis_tests.")
sys.exit(1)
def _module_match_label(module_name, label):
# Exact or ancestor match.
return module_name == label or module_name.startswith(label + ".")
start_label = start_at or start_after
for test_module in get_test_modules(gis_enabled):
if start_label:
if not _module_match_label(test_module, start_label):
continue
start_label = ""
if not start_at:
assert start_after
# Skip the current one before starting.
continue
# If the module (or an ancestor) was named on the command line, or
# no modules were named (i.e., run all), include the test module.
if not test_labels or any(
_module_match_label(test_module, label_module)
for label_module in label_modules
):
yield test_module
def setup_collect_tests(start_at, start_after, test_labels=None):
state = {
"INSTALLED_APPS": settings.INSTALLED_APPS,
"ROOT_URLCONF": getattr(settings, "ROOT_URLCONF", ""),
"TEMPLATES": settings.TEMPLATES,
"LANGUAGE_CODE": settings.LANGUAGE_CODE,
"STATIC_URL": settings.STATIC_URL,
"STATIC_ROOT": settings.STATIC_ROOT,
"MIDDLEWARE": settings.MIDDLEWARE,
}
# Redirect some settings for the duration of these tests.
settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
settings.ROOT_URLCONF = "urls"
settings.STATIC_URL = "static/"
settings.STATIC_ROOT = os.path.join(TMPDIR, "static")
settings.TEMPLATES = [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [TEMPLATE_DIR],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.template.context_processors.debug",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
],
},
}
]
settings.LANGUAGE_CODE = "en"
settings.SITE_ID = 1
settings.MIDDLEWARE = ALWAYS_MIDDLEWARE
settings.MIGRATION_MODULES = {
# This lets us skip creating migrations for the test models as many of
# them depend on one of the following contrib applications.
"auth": None,
"contenttypes": None,
"sessions": None,
}
log_config = copy.deepcopy(DEFAULT_LOGGING)
# Filter out non-error logging so we don't have to capture it in lots of
# tests.
log_config["loggers"]["django"]["level"] = "ERROR"
settings.LOGGING = log_config
settings.SILENCED_SYSTEM_CHECKS = [
"fields.W342", # ForeignKey(unique=True) -> OneToOneField
]
# RemovedInDjango50Warning
settings.FORM_RENDERER = "django.forms.renderers.DjangoDivFormRenderer"
# Load all the ALWAYS_INSTALLED_APPS.
django.setup()
# This flag must be evaluated after django.setup() because otherwise it can
# raise AppRegistryNotReady when running gis_tests in isolation on some
# backends (e.g. PostGIS).
gis_enabled = connection.features.gis_enabled
test_modules = list(
get_filtered_test_modules(
start_at,
start_after,
gis_enabled,
test_labels=test_labels,
)
)
return test_modules, state
def teardown_collect_tests(state):
# Restore the old settings.
for key, value in state.items():
setattr(settings, key, value)
def get_installed():
return [app_config.name for app_config in apps.get_app_configs()]
# This function should be called only after calling django.setup(),
# since it calls connection.features.gis_enabled.
def get_apps_to_install(test_modules):
for test_module in test_modules:
if test_module in CONTRIB_TESTS_TO_APPS:
yield from CONTRIB_TESTS_TO_APPS[test_module]
yield test_module
# Add contrib.gis to INSTALLED_APPS if needed (rather than requiring
# @override_settings(INSTALLED_APPS=...) on all test cases.
if connection.features.gis_enabled:
yield "django.contrib.gis"
def setup_run_tests(verbosity, start_at, start_after, test_labels=None):
test_modules, state = setup_collect_tests(
start_at, start_after, test_labels=test_labels
)
installed_apps = set(get_installed())
for app in get_apps_to_install(test_modules):
if app in installed_apps:
continue
if verbosity >= 2:
print(f"Importing application {app}")
settings.INSTALLED_APPS.append(app)
installed_apps.add(app)
apps.set_installed_apps(settings.INSTALLED_APPS)
# Force declaring available_apps in TransactionTestCase for faster tests.
def no_available_apps(self):
raise Exception(
"Please define available_apps in TransactionTestCase and its subclasses."
)
TransactionTestCase.available_apps = property(no_available_apps)
TestCase.available_apps = None
# Set an environment variable that other code may consult to see if
# Django's own test suite is running.
os.environ["RUNNING_DJANGOS_TEST_SUITE"] = "true"
test_labels = test_labels or test_modules
return test_labels, state
def teardown_run_tests(state):
teardown_collect_tests(state)
# Discard the multiprocessing.util finalizer that tries to remove a
# temporary directory that's already removed by this script's
# atexit.register(shutil.rmtree, TMPDIR) handler. Prevents
# FileNotFoundError at the end of a test run (#27890).
from multiprocessing.util import _finalizer_registry
_finalizer_registry.pop((-100, 0), None)
del os.environ["RUNNING_DJANGOS_TEST_SUITE"]
class ActionSelenium(argparse.Action):
"""
Validate the comma-separated list of requested browsers.
"""
def __call__(self, parser, namespace, values, option_string=None):
try:
import selenium # NOQA
except ImportError as e:
raise ImproperlyConfigured(f"Error loading selenium module: {e}")
browsers = values.split(",")
for browser in browsers:
try:
SeleniumTestCaseBase.import_webdriver(browser)
except ImportError:
raise argparse.ArgumentError(
self, "Selenium browser specification '%s' is not valid." % browser
)
setattr(namespace, self.dest, browsers)
def django_tests(
verbosity,
interactive,
failfast,
keepdb,
reverse,
test_labels,
debug_sql,
parallel,
tags,
exclude_tags,
test_name_patterns,
start_at,
start_after,
pdb,
buffer,
timing,
shuffle,
):
if parallel in {0, "auto"}:
max_parallel = get_max_test_processes()
else:
max_parallel = parallel
if verbosity >= 1:
msg = "Testing against Django installed in '%s'" % os.path.dirname(
django.__file__
)
if max_parallel > 1:
msg += " with up to %d processes" % max_parallel
print(msg)
process_setup_args = (verbosity, start_at, start_after, test_labels)
test_labels, state = setup_run_tests(*process_setup_args)
# Run the test suite, including the extra validation tests.
if not hasattr(settings, "TEST_RUNNER"):
settings.TEST_RUNNER = "django.test.runner.DiscoverRunner"
if parallel in {0, "auto"}:
# This doesn't work before django.setup() on some databases.
if all(conn.features.can_clone_databases for conn in connections.all()):
parallel = max_parallel
else:
parallel = 1
TestRunner = get_runner(settings)
TestRunner.parallel_test_suite.process_setup = setup_run_tests
TestRunner.parallel_test_suite.process_setup_args = process_setup_args
test_runner = TestRunner(
verbosity=verbosity,
interactive=interactive,
failfast=failfast,
keepdb=keepdb,
reverse=reverse,
debug_sql=debug_sql,
parallel=parallel,
tags=tags,
exclude_tags=exclude_tags,
test_name_patterns=test_name_patterns,
pdb=pdb,
buffer=buffer,
timing=timing,
shuffle=shuffle,
)
failures = test_runner.run_tests(test_labels)
teardown_run_tests(state)
return failures
def collect_test_modules(start_at, start_after):
test_modules, state = setup_collect_tests(start_at, start_after)
teardown_collect_tests(state)
return test_modules
def get_subprocess_args(options):
subprocess_args = [sys.executable, __file__, "--settings=%s" % options.settings]
if options.failfast:
subprocess_args.append("--failfast")
if options.verbosity:
subprocess_args.append("--verbosity=%s" % options.verbosity)
if not options.interactive:
subprocess_args.append("--noinput")
if options.tags:
subprocess_args.append("--tag=%s" % options.tags)
if options.exclude_tags:
subprocess_args.append("--exclude_tag=%s" % options.exclude_tags)
if options.shuffle is not False:
if options.shuffle is None:
subprocess_args.append("--shuffle")
else:
subprocess_args.append("--shuffle=%s" % options.shuffle)
return subprocess_args
def bisect_tests(bisection_label, options, test_labels, start_at, start_after):
if not test_labels:
test_labels = collect_test_modules(start_at, start_after)
print("***** Bisecting test suite: %s" % " ".join(test_labels))
# Make sure the bisection point isn't in the test list
# Also remove tests that need to be run in specific combinations
for label in [bisection_label, "model_inheritance_same_model_name"]:
try:
test_labels.remove(label)
except ValueError:
pass
subprocess_args = get_subprocess_args(options)
iteration = 1
while len(test_labels) > 1:
midpoint = len(test_labels) // 2
test_labels_a = test_labels[:midpoint] + [bisection_label]
test_labels_b = test_labels[midpoint:] + [bisection_label]
print("***** Pass %da: Running the first half of the test suite" % iteration)
print("***** Test labels: %s" % " ".join(test_labels_a))
failures_a = subprocess.run(subprocess_args + test_labels_a)
print("***** Pass %db: Running the second half of the test suite" % iteration)
print("***** Test labels: %s" % " ".join(test_labels_b))
print("")
failures_b = subprocess.run(subprocess_args + test_labels_b)
if failures_a.returncode and not failures_b.returncode:
print("***** Problem found in first half. Bisecting again...")
iteration += 1
test_labels = test_labels_a[:-1]
elif failures_b.returncode and not failures_a.returncode:
print("***** Problem found in second half. Bisecting again...")
iteration += 1
test_labels = test_labels_b[:-1]
elif failures_a.returncode and failures_b.returncode:
print("***** Multiple sources of failure found")
break
else:
print("***** No source of failure found... try pair execution (--pair)")
break
if len(test_labels) == 1:
print("***** Source of error: %s" % test_labels[0])
def paired_tests(paired_test, options, test_labels, start_at, start_after):
if not test_labels:
test_labels = collect_test_modules(start_at, start_after)
print("***** Trying paired execution")
# Make sure the constant member of the pair isn't in the test list
# Also remove tests that need to be run in specific combinations
for label in [paired_test, "model_inheritance_same_model_name"]:
try:
test_labels.remove(label)
except ValueError:
pass
subprocess_args = get_subprocess_args(options)
for i, label in enumerate(test_labels):
print(
"***** %d of %d: Check test pairing with %s"
% (i + 1, len(test_labels), label)
)
failures = subprocess.call(subprocess_args + [label, paired_test])
if failures:
print("***** Found problem pair with %s" % label)
return
print("***** No problem pair found")
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Run the Django test suite.")
parser.add_argument(
"modules",
nargs="*",
metavar="module",
help='Optional path(s) to test modules; e.g. "i18n" or '
'"i18n.tests.TranslationTests.test_lazy_objects".',
)
parser.add_argument(
"-v",
"--verbosity",
default=1,
type=int,
choices=[0, 1, 2, 3],
help="Verbosity level; 0=minimal output, 1=normal output, 2=all output",
)
parser.add_argument(
"--noinput",
action="store_false",
dest="interactive",
help="Tells Django to NOT prompt the user for input of any kind.",
)
parser.add_argument(
"--failfast",
action="store_true",
help="Tells Django to stop running the test suite after first failed test.",
)
parser.add_argument(
"--keepdb",
action="store_true",
help="Tells Django to preserve the test database between runs.",
)
parser.add_argument(
"--settings",
help='Python path to settings module, e.g. "myproject.settings". If '
"this isn't provided, either the DJANGO_SETTINGS_MODULE "
'environment variable or "test_sqlite" will be used.',
)
parser.add_argument(
"--bisect",
help="Bisect the test suite to discover a test that causes a test "
"failure when combined with the named test.",
)
parser.add_argument(
"--pair",
help="Run the test suite in pairs with the named test to find problem pairs.",
)
parser.add_argument(
"--shuffle",
nargs="?",
default=False,
type=int,
metavar="SEED",
help=(
"Shuffle the order of test cases to help check that tests are "
"properly isolated."
),
)
parser.add_argument(
"--reverse",
action="store_true",
help="Sort test suites and test cases in opposite order to debug "
"test side effects not apparent with normal execution lineup.",
)
parser.add_argument(
"--selenium",
action=ActionSelenium,
metavar="BROWSERS",
help="A comma-separated list of browsers to run the Selenium tests against.",
)
parser.add_argument(
"--headless",
action="store_true",
help="Run selenium tests in headless mode, if the browser supports the option.",
)
parser.add_argument(
"--selenium-hub",
help="A URL for a selenium hub instance to use in combination with --selenium.",
)
parser.add_argument(
"--external-host",
default=socket.gethostname(),
help=(
"The external host that can be reached by the selenium hub instance when "
"running Selenium tests via Selenium Hub."
),
)
parser.add_argument(
"--debug-sql",
action="store_true",
help="Turn on the SQL query logger within tests.",
)
# 0 is converted to "auto" or 1 later on, depending on a method used by
# multiprocessing to start subprocesses and on the backend support for
# cloning databases.
parser.add_argument(
"--parallel",
nargs="?",
const="auto",
default=0,
type=parallel_type,
metavar="N",
help=(
'Run tests using up to N parallel processes. Use the value "auto" '
"to run one test process for each processor core."
),
)
parser.add_argument(
"--tag",
dest="tags",
action="append",
help="Run only tests with the specified tags. Can be used multiple times.",
)
parser.add_argument(
"--exclude-tag",
dest="exclude_tags",
action="append",
help="Do not run tests with the specified tag. Can be used multiple times.",
)
parser.add_argument(
"--start-after",
dest="start_after",
help="Run tests starting after the specified top-level module.",
)
parser.add_argument(
"--start-at",
dest="start_at",
help="Run tests starting at the specified top-level module.",
)
parser.add_argument(
"--pdb", action="store_true", help="Runs the PDB debugger on error or failure."
)
parser.add_argument(
"-b",
"--buffer",
action="store_true",
help="Discard output of passing tests.",
)
parser.add_argument(
"--timing",
action="store_true",
help="Output timings, including database set up and total run time.",
)
parser.add_argument(
"-k",
dest="test_name_patterns",
action="append",
help=(
"Only run test methods and classes matching test name pattern. "
"Same as unittest -k option. Can be used multiple times."
),
)
options = parser.parse_args()
using_selenium_hub = options.selenium and options.selenium_hub
if options.selenium_hub and not options.selenium:
parser.error(
"--selenium-hub and --external-host require --selenium to be used."
)
if using_selenium_hub and not options.external_host:
parser.error("--selenium-hub and --external-host must be used together.")
# Allow including a trailing slash on app_labels for tab completion convenience
options.modules = [os.path.normpath(labels) for labels in options.modules]
mutually_exclusive_options = [
options.start_at,
options.start_after,
options.modules,
]
enabled_module_options = [
bool(option) for option in mutually_exclusive_options
].count(True)
if enabled_module_options > 1:
print(
"Aborting: --start-at, --start-after, and test labels are mutually "
"exclusive."
)
sys.exit(1)
for opt_name in ["start_at", "start_after"]:
opt_val = getattr(options, opt_name)
if opt_val:
if "." in opt_val:
print(
"Aborting: --%s must be a top-level module."
% opt_name.replace("_", "-")
)
sys.exit(1)
setattr(options, opt_name, os.path.normpath(opt_val))
if options.settings:
os.environ["DJANGO_SETTINGS_MODULE"] = options.settings
else:
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "test_sqlite")
options.settings = os.environ["DJANGO_SETTINGS_MODULE"]
if options.selenium:
if multiprocessing.get_start_method() == "spawn" and options.parallel != 1:
parser.error(
"You cannot use --selenium with parallel tests on this system. "
"Pass --parallel=1 to use --selenium."
)
if not options.tags:
options.tags = ["selenium"]
elif "selenium" not in options.tags:
options.tags.append("selenium")
if options.selenium_hub:
SeleniumTestCaseBase.selenium_hub = options.selenium_hub
SeleniumTestCaseBase.external_host = options.external_host
SeleniumTestCaseBase.headless = options.headless
SeleniumTestCaseBase.browsers = options.selenium
if options.bisect:
bisect_tests(
options.bisect,
options,
options.modules,
options.start_at,
options.start_after,
)
elif options.pair:
paired_tests(
options.pair,
options,
options.modules,
options.start_at,
options.start_after,
)
else:
time_keeper = TimeKeeper() if options.timing else NullTimeKeeper()
with time_keeper.timed("Total run"):
failures = django_tests(
options.verbosity,
options.interactive,
options.failfast,
options.keepdb,
options.reverse,
options.modules,
options.debug_sql,
options.parallel,
options.tags,
options.exclude_tags,
getattr(options, "test_name_patterns", None),
options.start_at,
options.start_after,
options.pdb,
options.buffer,
options.timing,
options.shuffle,
)
time_keeper.print_results()
if failures:
sys.exit(1)