summaryrefslogtreecommitdiff
path: root/tests/admin_scripts/tests.py
diff options
context:
space:
mode:
authordjango-bot <ops@djangoproject.com>2022-02-03 20:24:19 +0100
committerMariusz Felisiak <felisiak.mariusz@gmail.com>2022-02-07 20:37:05 +0100
commit9c19aff7c7561e3a82978a272ecdaad40dda5c00 (patch)
treef0506b668a013d0063e5fba3dbf4863b466713ba /tests/admin_scripts/tests.py
parentf68fa8b45dfac545cfc4111d4e52804c86db68d3 (diff)
Refs #33476 -- Reformatted code with Black.
Diffstat (limited to 'tests/admin_scripts/tests.py')
-rw-r--r--tests/admin_scripts/tests.py1486
1 files changed, 837 insertions, 649 deletions
diff --git a/tests/admin_scripts/tests.py b/tests/admin_scripts/tests.py
index c8d81e1fc0..55880802c2 100644
--- a/tests/admin_scripts/tests.py
+++ b/tests/admin_scripts/tests.py
@@ -18,20 +18,18 @@ from unittest import mock
from django import conf, get_version
from django.conf import settings
from django.core.management import (
- BaseCommand, CommandError, call_command, color, execute_from_command_line,
+ BaseCommand,
+ CommandError,
+ call_command,
+ color,
+ execute_from_command_line,
)
from django.core.management.commands.loaddata import Command as LoaddataCommand
-from django.core.management.commands.runserver import (
- Command as RunserverCommand,
-)
-from django.core.management.commands.testserver import (
- Command as TestserverCommand,
-)
+from django.core.management.commands.runserver import Command as RunserverCommand
+from django.core.management.commands.testserver import Command as TestserverCommand
from django.db import ConnectionHandler, connection
from django.db.migrations.recorder import MigrationRecorder
-from django.test import (
- LiveServerTestCase, SimpleTestCase, TestCase, override_settings,
-)
+from django.test import LiveServerTestCase, SimpleTestCase, TestCase, override_settings
from django.test.utils import captured_stderr, captured_stdout
from django.urls import path
from django.utils.version import PY39
@@ -39,9 +37,9 @@ from django.views.static import serve
from . import urls
-custom_templates_dir = os.path.join(os.path.dirname(__file__), 'custom_templates')
+custom_templates_dir = os.path.join(os.path.dirname(__file__), "custom_templates")
-SYSTEM_CHECK_MSG = 'System check identified no issues'
+SYSTEM_CHECK_MSG = "System check identified no issues"
class AdminScriptTestCase(SimpleTestCase):
@@ -50,27 +48,29 @@ class AdminScriptTestCase(SimpleTestCase):
self.addCleanup(tmpdir.cleanup)
# os.path.realpath() is required for temporary directories on macOS,
# where `/var` is a symlink to `/private/var`.
- self.test_dir = os.path.realpath(os.path.join(tmpdir.name, 'test_project'))
+ self.test_dir = os.path.realpath(os.path.join(tmpdir.name, "test_project"))
os.mkdir(self.test_dir)
def write_settings(self, filename, apps=None, is_dir=False, sdict=None, extra=None):
if is_dir:
settings_dir = os.path.join(self.test_dir, filename)
os.mkdir(settings_dir)
- settings_file_path = os.path.join(settings_dir, '__init__.py')
+ settings_file_path = os.path.join(settings_dir, "__init__.py")
else:
settings_file_path = os.path.join(self.test_dir, filename)
- with open(settings_file_path, 'w') as settings_file:
- settings_file.write('# Settings file automatically generated by admin_scripts test case\n')
+ with open(settings_file_path, "w") as settings_file:
+ settings_file.write(
+ "# Settings file automatically generated by admin_scripts test case\n"
+ )
if extra:
settings_file.write("%s\n" % extra)
exports = [
- 'DATABASES',
- 'DEFAULT_AUTO_FIELD',
- 'ROOT_URLCONF',
- 'SECRET_KEY',
- 'USE_TZ',
+ "DATABASES",
+ "DEFAULT_AUTO_FIELD",
+ "ROOT_URLCONF",
+ "SECRET_KEY",
+ "USE_TZ",
]
for s in exports:
if hasattr(settings, s):
@@ -80,7 +80,11 @@ class AdminScriptTestCase(SimpleTestCase):
settings_file.write("%s = %s\n" % (s, o))
if apps is None:
- apps = ['django.contrib.auth', 'django.contrib.contenttypes', 'admin_scripts']
+ apps = [
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ "admin_scripts",
+ ]
settings_file.write("INSTALLED_APPS = %s\n" % apps)
@@ -94,8 +98,8 @@ class AdminScriptTestCase(SimpleTestCase):
"""
paths = []
for backend in settings.DATABASES.values():
- package = backend['ENGINE'].split('.')[0]
- if package != 'django':
+ package = backend["ENGINE"].split(".")[0]
+ if package != "django":
backend_pkg = __import__(package)
backend_dir = os.path.dirname(backend_pkg.__file__)
paths.append(os.path.dirname(backend_dir))
@@ -116,13 +120,13 @@ class AdminScriptTestCase(SimpleTestCase):
# Set the test environment
if settings_file:
- test_environ['DJANGO_SETTINGS_MODULE'] = settings_file
- elif 'DJANGO_SETTINGS_MODULE' in test_environ:
- del test_environ['DJANGO_SETTINGS_MODULE']
+ test_environ["DJANGO_SETTINGS_MODULE"] = settings_file
+ elif "DJANGO_SETTINGS_MODULE" in test_environ:
+ del test_environ["DJANGO_SETTINGS_MODULE"]
python_path = [base_dir, django_dir, tests_dir]
python_path.extend(ext_backend_base_dirs)
- test_environ['PYTHONPATH'] = os.pathsep.join(python_path)
- test_environ['PYTHONWARNINGS'] = ''
+ test_environ["PYTHONPATH"] = os.pathsep.join(python_path)
+ test_environ["PYTHONWARNINGS"] = ""
p = subprocess.run(
[sys.executable, *args],
@@ -131,48 +135,60 @@ class AdminScriptTestCase(SimpleTestCase):
env=test_environ,
text=True,
# subprocess.run()'s umask was added in Python 3.9.
- **({'umask': umask} if umask and PY39 else {}),
+ **({"umask": umask} if umask and PY39 else {}),
)
return p.stdout, p.stderr
def run_django_admin(self, args, settings_file=None, umask=None):
- return self.run_test(['-m', 'django', *args], settings_file, umask=umask)
+ return self.run_test(["-m", "django", *args], settings_file, umask=umask)
def run_manage(self, args, settings_file=None, manage_py=None):
template_manage_py = (
os.path.join(os.path.dirname(__file__), manage_py)
- if manage_py else
- os.path.join(os.path.dirname(conf.__file__), 'project_template', 'manage.py-tpl')
+ if manage_py
+ else os.path.join(
+ os.path.dirname(conf.__file__), "project_template", "manage.py-tpl"
+ )
)
- test_manage_py = os.path.join(self.test_dir, 'manage.py')
+ test_manage_py = os.path.join(self.test_dir, "manage.py")
shutil.copyfile(template_manage_py, test_manage_py)
with open(test_manage_py) as fp:
manage_py_contents = fp.read()
manage_py_contents = manage_py_contents.replace(
- "{{ project_name }}", "test_project")
- with open(test_manage_py, 'w') as fp:
+ "{{ project_name }}", "test_project"
+ )
+ with open(test_manage_py, "w") as fp:
fp.write(manage_py_contents)
- return self.run_test(['./manage.py', *args], settings_file)
+ return self.run_test(["./manage.py", *args], settings_file)
def assertNoOutput(self, stream):
"Utility assertion: assert that the given stream is empty"
- self.assertEqual(len(stream), 0, "Stream should be empty: actually contains '%s'" % stream)
+ self.assertEqual(
+ len(stream), 0, "Stream should be empty: actually contains '%s'" % stream
+ )
def assertOutput(self, stream, msg, regex=False):
"Utility assertion: assert that the given message exists in the output"
if regex:
self.assertIsNotNone(
re.search(msg, stream),
- "'%s' does not match actual output text '%s'" % (msg, stream)
+ "'%s' does not match actual output text '%s'" % (msg, stream),
)
else:
- self.assertIn(msg, stream, "'%s' does not match actual output text '%s'" % (msg, stream))
+ self.assertIn(
+ msg,
+ stream,
+ "'%s' does not match actual output text '%s'" % (msg, stream),
+ )
def assertNotInOutput(self, stream, msg):
"Utility assertion: assert that the given message doesn't exist in the output"
- self.assertNotIn(msg, stream, "'%s' matches actual output text '%s'" % (msg, stream))
+ self.assertNotIn(
+ msg, stream, "'%s' matches actual output text '%s'" % (msg, stream)
+ )
+
##########################################################################
# DJANGO ADMIN TESTS
@@ -186,22 +202,22 @@ class DjangoAdminNoSettings(AdminScriptTestCase):
def test_builtin_command(self):
"no settings: django-admin builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'settings are not configured')
+ self.assertOutput(err, "settings are not configured")
def test_builtin_with_bad_settings(self):
"no settings: django-admin builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"no settings: django-admin builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@@ -210,8 +226,8 @@ class DjangoAdminNoSettings(AdminScriptTestCase):
Commands that don't require settings succeed if the settings file
doesn't exist.
"""
- args = ['startproject']
- out, err = self.run_django_admin(args, settings_file='bad_settings')
+ args = ["startproject"]
+ out, err = self.run_django_admin(args, settings_file="bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "You must provide a project name", regex=True)
@@ -221,48 +237,49 @@ class DjangoAdminDefaultSettings(AdminScriptTestCase):
A series of tests for django-admin when using a settings.py file that
contains the test application.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py')
+ self.write_settings("settings.py")
def test_builtin_command(self):
"default: django-admin builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'settings are not configured')
+ self.assertOutput(err, "settings are not configured")
def test_builtin_with_settings(self):
"default: django-admin builtin commands succeed if settings are provided as argument"
- args = ['check', '--settings=test_project.settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self):
"default: django-admin builtin commands succeed if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self):
"default: django-admin builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"default: django-admin builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"default: django-admin can't execute user commands if it isn't provided settings"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No Django settings specified")
@@ -270,15 +287,15 @@ class DjangoAdminDefaultSettings(AdminScriptTestCase):
def test_custom_command_with_settings(self):
"default: django-admin can execute user commands if settings are provided as argument"
- args = ['noargs_command', '--settings=test_project.settings']
+ args = ["noargs_command", "--settings=test_project.settings"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_environment(self):
"default: django-admin can execute user commands if settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["noargs_command"]
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
@@ -288,49 +305,57 @@ class DjangoAdminFullPathDefaultSettings(AdminScriptTestCase):
A series of tests for django-admin when using a settings.py file that
contains the test application specified using a full path.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py', ['django.contrib.auth', 'django.contrib.contenttypes',
- 'admin_scripts', 'admin_scripts.complex_app'])
+ self.write_settings(
+ "settings.py",
+ [
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ "admin_scripts",
+ "admin_scripts.complex_app",
+ ],
+ )
def test_builtin_command(self):
"fulldefault: django-admin builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'settings are not configured')
+ self.assertOutput(err, "settings are not configured")
def test_builtin_with_settings(self):
"fulldefault: django-admin builtin commands succeed if a settings file is provided"
- args = ['check', '--settings=test_project.settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self):
"fulldefault: django-admin builtin commands succeed if the environment contains settings"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self):
"fulldefault: django-admin builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"fulldefault: django-admin builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"fulldefault: django-admin can't execute user commands unless settings are provided"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No Django settings specified")
@@ -338,15 +363,15 @@ class DjangoAdminFullPathDefaultSettings(AdminScriptTestCase):
def test_custom_command_with_settings(self):
"fulldefault: django-admin can execute user commands if settings are provided as argument"
- args = ['noargs_command', '--settings=test_project.settings']
+ args = ["noargs_command", "--settings=test_project.settings"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_environment(self):
"fulldefault: django-admin can execute user commands if settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["noargs_command"]
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
@@ -356,48 +381,51 @@ class DjangoAdminMinimalSettings(AdminScriptTestCase):
A series of tests for django-admin when using a settings.py file that
doesn't contain the test application.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py', apps=['django.contrib.auth', 'django.contrib.contenttypes'])
+ self.write_settings(
+ "settings.py", apps=["django.contrib.auth", "django.contrib.contenttypes"]
+ )
def test_builtin_command(self):
"minimal: django-admin builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'settings are not configured')
+ self.assertOutput(err, "settings are not configured")
def test_builtin_with_settings(self):
"minimal: django-admin builtin commands fail if settings are provided as argument"
- args = ['check', '--settings=test_project.settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_environment(self):
"minimal: django-admin builtin commands fail if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_bad_settings(self):
"minimal: django-admin builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"minimal: django-admin builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"minimal: django-admin can't execute user commands unless settings are provided"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No Django settings specified")
@@ -405,15 +433,15 @@ class DjangoAdminMinimalSettings(AdminScriptTestCase):
def test_custom_command_with_settings(self):
"minimal: django-admin can't execute user commands, even if settings are provided as argument"
- args = ['noargs_command', '--settings=test_project.settings']
+ args = ["noargs_command", "--settings=test_project.settings"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "Unknown command: 'noargs_command'")
def test_custom_command_with_environment(self):
"minimal: django-admin can't execute user commands, even if settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["noargs_command"]
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(out)
self.assertOutput(err, "Unknown command: 'noargs_command'")
@@ -423,48 +451,49 @@ class DjangoAdminAlternateSettings(AdminScriptTestCase):
A series of tests for django-admin when using a settings file with a name
other than 'settings.py'.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('alternate_settings.py')
+ self.write_settings("alternate_settings.py")
def test_builtin_command(self):
"alternate: django-admin builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'settings are not configured')
+ self.assertOutput(err, "settings are not configured")
def test_builtin_with_settings(self):
"alternate: django-admin builtin commands succeed if settings are provided as argument"
- args = ['check', '--settings=test_project.alternate_settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.alternate_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self):
"alternate: django-admin builtin commands succeed if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'test_project.alternate_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "test_project.alternate_settings")
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self):
"alternate: django-admin builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"alternate: django-admin builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"alternate: django-admin can't execute user commands unless settings are provided"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No Django settings specified")
@@ -472,15 +501,15 @@ class DjangoAdminAlternateSettings(AdminScriptTestCase):
def test_custom_command_with_settings(self):
"alternate: django-admin can execute user commands if settings are provided as argument"
- args = ['noargs_command', '--settings=test_project.alternate_settings']
+ args = ["noargs_command", "--settings=test_project.alternate_settings"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_environment(self):
"alternate: django-admin can execute user commands if settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_django_admin(args, 'test_project.alternate_settings')
+ args = ["noargs_command"]
+ out, err = self.run_django_admin(args, "test_project.alternate_settings")
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
@@ -492,48 +521,51 @@ class DjangoAdminMultipleSettings(AdminScriptTestCase):
file is insufficient for performing the operations described, so the
alternate settings must be used by the running script.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py', apps=['django.contrib.auth', 'django.contrib.contenttypes'])
- self.write_settings('alternate_settings.py')
+ self.write_settings(
+ "settings.py", apps=["django.contrib.auth", "django.contrib.contenttypes"]
+ )
+ self.write_settings("alternate_settings.py")
def test_builtin_command(self):
"alternate: django-admin builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'settings are not configured')
+ self.assertOutput(err, "settings are not configured")
def test_builtin_with_settings(self):
"alternate: django-admin builtin commands succeed if settings are provided as argument"
- args = ['check', '--settings=test_project.alternate_settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.alternate_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self):
"alternate: django-admin builtin commands succeed if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'test_project.alternate_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "test_project.alternate_settings")
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self):
"alternate: django-admin builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"alternate: django-admin builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"alternate: django-admin can't execute user commands unless settings are provided"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No Django settings specified")
@@ -541,15 +573,15 @@ class DjangoAdminMultipleSettings(AdminScriptTestCase):
def test_custom_command_with_settings(self):
"alternate: django-admin can execute user commands if settings are provided as argument"
- args = ['noargs_command', '--settings=test_project.alternate_settings']
+ args = ["noargs_command", "--settings=test_project.alternate_settings"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_environment(self):
"alternate: django-admin can execute user commands if settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_django_admin(args, 'test_project.alternate_settings')
+ args = ["noargs_command"]
+ out, err = self.run_django_admin(args, "test_project.alternate_settings")
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
@@ -562,65 +594,65 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
def setUp(self):
super().setUp()
- self.write_settings('settings', is_dir=True)
+ self.write_settings("settings", is_dir=True)
def test_setup_environ(self):
"directory: startapp creates the correct directory"
- args = ['startapp', 'settings_test']
- app_path = os.path.join(self.test_dir, 'settings_test')
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["startapp", "settings_test"]
+ app_path = os.path.join(self.test_dir, "settings_test")
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(err)
self.assertTrue(os.path.exists(app_path))
- with open(os.path.join(app_path, 'apps.py')) as f:
+ with open(os.path.join(app_path, "apps.py")) as f:
content = f.read()
self.assertIn("class SettingsTestConfig(AppConfig)", content)
self.assertIn("name = 'settings_test'", content)
def test_setup_environ_custom_template(self):
"directory: startapp creates the correct directory with a custom template"
- template_path = os.path.join(custom_templates_dir, 'app_template')
- args = ['startapp', '--template', template_path, 'custom_settings_test']
- app_path = os.path.join(self.test_dir, 'custom_settings_test')
- out, err = self.run_django_admin(args, 'test_project.settings')
+ template_path = os.path.join(custom_templates_dir, "app_template")
+ args = ["startapp", "--template", template_path, "custom_settings_test"]
+ app_path = os.path.join(self.test_dir, "custom_settings_test")
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(err)
self.assertTrue(os.path.exists(app_path))
- self.assertTrue(os.path.exists(os.path.join(app_path, 'api.py')))
+ self.assertTrue(os.path.exists(os.path.join(app_path, "api.py")))
def test_startapp_unicode_name(self):
"""startapp creates the correct directory with Unicode characters."""
- args = ['startapp', 'こんにちは']
- app_path = os.path.join(self.test_dir, 'こんにちは')
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["startapp", "こんにちは"]
+ app_path = os.path.join(self.test_dir, "こんにちは")
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(err)
self.assertTrue(os.path.exists(app_path))
- with open(os.path.join(app_path, 'apps.py'), encoding='utf8') as f:
+ with open(os.path.join(app_path, "apps.py"), encoding="utf8") as f:
content = f.read()
self.assertIn("class こんにちはConfig(AppConfig)", content)
self.assertIn("name = 'こんにちは'", content)
def test_builtin_command(self):
"directory: django-admin builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'settings are not configured')
+ self.assertOutput(err, "settings are not configured")
def test_builtin_with_bad_settings(self):
"directory: django-admin builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"directory: django-admin builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"directory: django-admin can't execute user commands unless settings are provided"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "No Django settings specified")
@@ -628,15 +660,15 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
def test_builtin_with_settings(self):
"directory: django-admin builtin commands succeed if settings are provided as argument"
- args = ['check', '--settings=test_project.settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.settings", "admin_scripts"]
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self):
"directory: django-admin builtin commands succeed if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_django_admin(args, 'test_project.settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_django_admin(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
@@ -647,13 +679,17 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
# of the generated manage.py script
##########################################################################
+
class ManageManuallyConfiguredSettings(AdminScriptTestCase):
"""Customized manage.py calling settings.configure()."""
+
def test_non_existent_command_output(self):
- out, err = self.run_manage(['invalid_command'], manage_py='configured_settings_manage.py')
+ out, err = self.run_manage(
+ ["invalid_command"], manage_py="configured_settings_manage.py"
+ )
self.assertNoOutput(out)
self.assertOutput(err, "Unknown command: 'invalid_command'")
- self.assertNotInOutput(err, 'No Django settings specified')
+ self.assertNotInOutput(err, "No Django settings specified")
class ManageNoSettings(AdminScriptTestCase):
@@ -661,22 +697,24 @@ class ManageNoSettings(AdminScriptTestCase):
def test_builtin_command(self):
"no settings: manage.py builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
- self.assertOutput(err, r"No module named '?(test_project\.)?settings'?", regex=True)
+ self.assertOutput(
+ err, r"No module named '?(test_project\.)?settings'?", regex=True
+ )
def test_builtin_with_bad_settings(self):
"no settings: manage.py builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"no settings: manage.py builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@@ -685,63 +723,64 @@ class ManageDefaultSettings(AdminScriptTestCase):
"""A series of tests for manage.py when using a settings.py file that
contains the test application.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py')
+ self.write_settings("settings.py")
def test_builtin_command(self):
"default: manage.py builtin commands succeed when default settings are appropriate"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_settings(self):
"default: manage.py builtin commands succeed if settings are provided as argument"
- args = ['check', '--settings=test_project.settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self):
"default: manage.py builtin commands succeed if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'test_project.settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self):
"default: manage.py builtin commands succeed if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"default: manage.py builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"default: manage.py can execute user commands when default settings are appropriate"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_settings(self):
"default: manage.py can execute user commands when settings are provided as argument"
- args = ['noargs_command', '--settings=test_project.settings']
+ args = ["noargs_command", "--settings=test_project.settings"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_environment(self):
"default: manage.py can execute user commands when settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_manage(args, 'test_project.settings')
+ args = ["noargs_command"]
+ out, err = self.run_manage(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
@@ -750,63 +789,67 @@ class ManageFullPathDefaultSettings(AdminScriptTestCase):
"""A series of tests for manage.py when using a settings.py file that
contains the test application specified using a full path.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py', ['django.contrib.auth', 'django.contrib.contenttypes', 'admin_scripts'])
+ self.write_settings(
+ "settings.py",
+ ["django.contrib.auth", "django.contrib.contenttypes", "admin_scripts"],
+ )
def test_builtin_command(self):
"fulldefault: manage.py builtin commands succeed when default settings are appropriate"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_settings(self):
"fulldefault: manage.py builtin commands succeed if settings are provided as argument"
- args = ['check', '--settings=test_project.settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self):
"fulldefault: manage.py builtin commands succeed if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'test_project.settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self):
"fulldefault: manage.py builtin commands succeed if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"fulldefault: manage.py builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"fulldefault: manage.py can execute user commands when default settings are appropriate"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_settings(self):
"fulldefault: manage.py can execute user commands when settings are provided as argument"
- args = ['noargs_command', '--settings=test_project.settings']
+ args = ["noargs_command", "--settings=test_project.settings"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_environment(self):
"fulldefault: manage.py can execute user commands when settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_manage(args, 'test_project.settings')
+ args = ["noargs_command"]
+ out, err = self.run_manage(args, "test_project.settings")
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
@@ -815,63 +858,66 @@ class ManageMinimalSettings(AdminScriptTestCase):
"""A series of tests for manage.py when using a settings.py file that
doesn't contain the test application.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py', apps=['django.contrib.auth', 'django.contrib.contenttypes'])
+ self.write_settings(
+ "settings.py", apps=["django.contrib.auth", "django.contrib.contenttypes"]
+ )
def test_builtin_command(self):
"minimal: manage.py builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_settings(self):
"minimal: manage.py builtin commands fail if settings are provided as argument"
- args = ['check', '--settings=test_project.settings', 'admin_scripts']
+ args = ["check", "--settings=test_project.settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_environment(self):
"minimal: manage.py builtin commands fail if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'test_project.settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "test_project.settings")
self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_bad_settings(self):
"minimal: manage.py builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"minimal: manage.py builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"minimal: manage.py can't execute user commands without appropriate settings"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "Unknown command: 'noargs_command'")
def test_custom_command_with_settings(self):
"minimal: manage.py can't execute user commands, even if settings are provided as argument"
- args = ['noargs_command', '--settings=test_project.settings']
+ args = ["noargs_command", "--settings=test_project.settings"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "Unknown command: 'noargs_command'")
def test_custom_command_with_environment(self):
"minimal: manage.py can't execute user commands, even if settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_manage(args, 'test_project.settings')
+ args = ["noargs_command"]
+ out, err = self.run_manage(args, "test_project.settings")
self.assertNoOutput(out)
self.assertOutput(err, "Unknown command: 'noargs_command'")
@@ -880,85 +926,90 @@ class ManageAlternateSettings(AdminScriptTestCase):
"""A series of tests for manage.py when using a settings file
with a name other than 'settings.py'.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('alternate_settings.py')
+ self.write_settings("alternate_settings.py")
def test_builtin_command(self):
"alternate: manage.py builtin commands fail with an error when no default settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
- self.assertOutput(err, r"No module named '?(test_project\.)?settings'?", regex=True)
+ self.assertOutput(
+ err, r"No module named '?(test_project\.)?settings'?", regex=True
+ )
def test_builtin_with_settings(self):
"alternate: manage.py builtin commands work with settings provided as argument"
- args = ['check', '--settings=alternate_settings', 'admin_scripts']
+ args = ["check", "--settings=alternate_settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertOutput(out, SYSTEM_CHECK_MSG)
self.assertNoOutput(err)
def test_builtin_with_environment(self):
"alternate: manage.py builtin commands work if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'alternate_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "alternate_settings")
self.assertOutput(out, SYSTEM_CHECK_MSG)
self.assertNoOutput(err)
def test_builtin_with_bad_settings(self):
"alternate: manage.py builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"alternate: manage.py builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"alternate: manage.py can't execute user commands without settings"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
- self.assertOutput(err, r"No module named '?(test_project\.)?settings'?", regex=True)
+ self.assertOutput(
+ err, r"No module named '?(test_project\.)?settings'?", regex=True
+ )
def test_custom_command_with_settings(self):
"alternate: manage.py can execute user commands if settings are provided as argument"
- args = ['noargs_command', '--settings=alternate_settings']
+ args = ["noargs_command", "--settings=alternate_settings"]
out, err = self.run_manage(args)
self.assertOutput(
out,
"EXECUTE: noargs_command options=[('force_color', False), "
"('no_color', False), ('pythonpath', None), ('settings', "
- "'alternate_settings'), ('traceback', False), ('verbosity', 1)]"
+ "'alternate_settings'), ('traceback', False), ('verbosity', 1)]",
)
self.assertNoOutput(err)
def test_custom_command_with_environment(self):
"alternate: manage.py can execute user commands if settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_manage(args, 'alternate_settings')
+ args = ["noargs_command"]
+ out, err = self.run_manage(args, "alternate_settings")
self.assertOutput(
out,
"EXECUTE: noargs_command options=[('force_color', False), "
"('no_color', False), ('pythonpath', None), ('settings', None), "
- "('traceback', False), ('verbosity', 1)]"
+ "('traceback', False), ('verbosity', 1)]",
)
self.assertNoOutput(err)
def test_custom_command_output_color(self):
"alternate: manage.py output syntax color can be deactivated with the `--no-color` option"
- args = ['noargs_command', '--no-color', '--settings=alternate_settings']
+ args = ["noargs_command", "--no-color", "--settings=alternate_settings"]
out, err = self.run_manage(args)
self.assertOutput(
out,
"EXECUTE: noargs_command options=[('force_color', False), "
"('no_color', True), ('pythonpath', None), ('settings', "
- "'alternate_settings'), ('traceback', False), ('verbosity', 1)]"
+ "'alternate_settings'), ('traceback', False), ('verbosity', 1)]",
)
self.assertNoOutput(err)
@@ -969,64 +1020,67 @@ class ManageMultipleSettings(AdminScriptTestCase):
file is insufficient for performing the operations described, so the
alternate settings must be used by the running script.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py', apps=['django.contrib.auth', 'django.contrib.contenttypes'])
- self.write_settings('alternate_settings.py')
+ self.write_settings(
+ "settings.py", apps=["django.contrib.auth", "django.contrib.contenttypes"]
+ )
+ self.write_settings("alternate_settings.py")
def test_builtin_command(self):
"multiple: manage.py builtin commands fail with an error when no settings provided"
- args = ['check', 'admin_scripts']
+ args = ["check", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_settings(self):
"multiple: manage.py builtin commands succeed if settings are provided as argument"
- args = ['check', '--settings=alternate_settings', 'admin_scripts']
+ args = ["check", "--settings=alternate_settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self):
"multiple: manage.py can execute builtin commands if settings are provided in the environment"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'alternate_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "alternate_settings")
self.assertNoOutput(err)
self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self):
"multiple: manage.py builtin commands fail if settings file (from argument) doesn't exist"
- args = ['check', '--settings=bad_settings', 'admin_scripts']
+ args = ["check", "--settings=bad_settings", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self):
"multiple: manage.py builtin commands fail if settings file (from environment) doesn't exist"
- args = ['check', 'admin_scripts']
- out, err = self.run_manage(args, 'bad_settings')
+ args = ["check", "admin_scripts"]
+ out, err = self.run_manage(args, "bad_settings")
self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_custom_command(self):
"multiple: manage.py can't execute user commands using default settings"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "Unknown command: 'noargs_command'")
def test_custom_command_with_settings(self):
"multiple: manage.py can execute user commands if settings are provided as argument"
- args = ['noargs_command', '--settings=alternate_settings']
+ args = ["noargs_command", "--settings=alternate_settings"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
def test_custom_command_with_environment(self):
"multiple: manage.py can execute user commands if settings are provided in environment"
- args = ['noargs_command']
- out, err = self.run_manage(args, 'alternate_settings')
+ args = ["noargs_command"]
+ out, err = self.run_manage(args, "alternate_settings")
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE: noargs_command")
@@ -1036,19 +1090,24 @@ class ManageSettingsWithSettingsErrors(AdminScriptTestCase):
Tests for manage.py when using the default settings.py file containing
runtime errors.
"""
+
def write_settings_with_import_error(self, filename):
settings_file_path = os.path.join(self.test_dir, filename)
- with open(settings_file_path, 'w') as settings_file:
- settings_file.write('# Settings file automatically generated by admin_scripts test case\n')
- settings_file.write('# The next line will cause an import error:\nimport foo42bar\n')
+ with open(settings_file_path, "w") as settings_file:
+ settings_file.write(
+ "# Settings file automatically generated by admin_scripts test case\n"
+ )
+ settings_file.write(
+ "# The next line will cause an import error:\nimport foo42bar\n"
+ )
def test_import_error(self):
"""
import error: manage.py builtin commands shows useful diagnostic info
when settings with import errors is provided (#14130).
"""
- self.write_settings_with_import_error('settings.py')
- args = ['check', 'admin_scripts']
+ self.write_settings_with_import_error("settings.py")
+ args = ["check", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "No module named")
@@ -1059,15 +1118,15 @@ class ManageSettingsWithSettingsErrors(AdminScriptTestCase):
manage.py builtin commands does not swallow attribute error due to bad
settings (#18845).
"""
- self.write_settings('settings.py', sdict={'BAD_VAR': 'INSTALLED_APPS.crash'})
- args = ['collectstatic', 'admin_scripts']
+ self.write_settings("settings.py", sdict={"BAD_VAR": "INSTALLED_APPS.crash"})
+ args = ["collectstatic", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "AttributeError: 'list' object has no attribute 'crash'")
def test_key_error(self):
- self.write_settings('settings.py', sdict={'BAD_VAR': 'DATABASES["blah"]'})
- args = ['collectstatic', 'admin_scripts']
+ self.write_settings("settings.py", sdict={"BAD_VAR": 'DATABASES["blah"]'})
+ args = ["collectstatic", "admin_scripts"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "KeyError: 'blah'")
@@ -1078,13 +1137,13 @@ class ManageSettingsWithSettingsErrors(AdminScriptTestCase):
available.
"""
self.write_settings(
- 'settings.py',
- extra='from django.core.exceptions import ImproperlyConfigured\n'
- 'raise ImproperlyConfigured()',
+ "settings.py",
+ extra="from django.core.exceptions import ImproperlyConfigured\n"
+ "raise ImproperlyConfigured()",
)
- args = ['help']
+ args = ["help"]
out, err = self.run_manage(args)
- self.assertOutput(out, 'only Django core commands are listed')
+ self.assertOutput(out, "only Django core commands are listed")
self.assertNoOutput(err)
@@ -1092,101 +1151,101 @@ class ManageCheck(AdminScriptTestCase):
def test_nonexistent_app(self):
"""check reports an error on a nonexistent app in INSTALLED_APPS."""
self.write_settings(
- 'settings.py',
- apps=['admin_scriptz.broken_app'],
- sdict={'USE_I18N': False},
+ "settings.py",
+ apps=["admin_scriptz.broken_app"],
+ sdict={"USE_I18N": False},
)
- args = ['check']
+ args = ["check"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'ModuleNotFoundError')
- self.assertOutput(err, 'No module named')
- self.assertOutput(err, 'admin_scriptz')
+ self.assertOutput(err, "ModuleNotFoundError")
+ self.assertOutput(err, "No module named")
+ self.assertOutput(err, "admin_scriptz")
def test_broken_app(self):
- """ manage.py check reports an ImportError if an app's models.py
- raises one on import """
+ """manage.py check reports an ImportError if an app's models.py
+ raises one on import"""
- self.write_settings('settings.py', apps=['admin_scripts.broken_app'])
- args = ['check']
+ self.write_settings("settings.py", apps=["admin_scripts.broken_app"])
+ args = ["check"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
- self.assertOutput(err, 'ImportError')
+ self.assertOutput(err, "ImportError")
def test_complex_app(self):
- """ manage.py check does not raise an ImportError validating a
- complex app with nested calls to load_app """
+ """manage.py check does not raise an ImportError validating a
+ complex app with nested calls to load_app"""
self.write_settings(
- 'settings.py',
+ "settings.py",
apps=[
- 'admin_scripts.complex_app',
- 'admin_scripts.simple_app',
- 'django.contrib.admin.apps.SimpleAdminConfig',
- 'django.contrib.auth',
- 'django.contrib.contenttypes',
- 'django.contrib.messages',
+ "admin_scripts.complex_app",
+ "admin_scripts.simple_app",
+ "django.contrib.admin.apps.SimpleAdminConfig",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ "django.contrib.messages",
],
sdict={
- 'DEBUG': True,
- 'MIDDLEWARE': [
- 'django.contrib.messages.middleware.MessageMiddleware',
- 'django.contrib.auth.middleware.AuthenticationMiddleware',
- 'django.contrib.sessions.middleware.SessionMiddleware',
+ "DEBUG": True,
+ "MIDDLEWARE": [
+ "django.contrib.messages.middleware.MessageMiddleware",
+ "django.contrib.auth.middleware.AuthenticationMiddleware",
+ "django.contrib.sessions.middleware.SessionMiddleware",
],
- 'TEMPLATES': [
+ "TEMPLATES": [
{
- 'BACKEND': 'django.template.backends.django.DjangoTemplates',
- 'DIRS': [],
- 'APP_DIRS': True,
- 'OPTIONS': {
- 'context_processors': [
- 'django.template.context_processors.request',
- 'django.contrib.auth.context_processors.auth',
- 'django.contrib.messages.context_processors.messages',
+ "BACKEND": "django.template.backends.django.DjangoTemplates",
+ "DIRS": [],
+ "APP_DIRS": True,
+ "OPTIONS": {
+ "context_processors": [
+ "django.template.context_processors.request",
+ "django.contrib.auth.context_processors.auth",
+ "django.contrib.messages.context_processors.messages",
],
},
},
],
- }
+ },
)
- args = ['check']
+ args = ["check"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
- self.assertEqual(out, 'System check identified no issues (0 silenced).\n')
+ self.assertEqual(out, "System check identified no issues (0 silenced).\n")
def test_app_with_import(self):
- """ manage.py check does not raise errors when an app imports a base
- class that itself has an abstract base. """
+ """manage.py check does not raise errors when an app imports a base
+ class that itself has an abstract base."""
self.write_settings(
- 'settings.py',
+ "settings.py",
apps=[
- 'admin_scripts.app_with_import',
- 'django.contrib.auth',
- 'django.contrib.contenttypes',
- 'django.contrib.sites',
+ "admin_scripts.app_with_import",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ "django.contrib.sites",
],
- sdict={'DEBUG': True},
+ sdict={"DEBUG": True},
)
- args = ['check']
+ args = ["check"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
- self.assertEqual(out, 'System check identified no issues (0 silenced).\n')
+ self.assertEqual(out, "System check identified no issues (0 silenced).\n")
def test_output_format(self):
- """ All errors/warnings should be sorted by level and by message. """
+ """All errors/warnings should be sorted by level and by message."""
self.write_settings(
- 'settings.py',
+ "settings.py",
apps=[
- 'admin_scripts.app_raising_messages',
- 'django.contrib.auth',
- 'django.contrib.contenttypes',
+ "admin_scripts.app_raising_messages",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
],
- sdict={'DEBUG': True},
+ sdict={"DEBUG": True},
)
- args = ['check']
+ args = ["check"]
out, err = self.run_manage(args)
expected_err = (
"SystemCheckError: System check identified some issues:\n"
@@ -1215,15 +1274,15 @@ class ManageCheck(AdminScriptTestCase):
"""
self.write_settings(
- 'settings.py',
+ "settings.py",
apps=[
- 'admin_scripts.app_raising_warning',
- 'django.contrib.auth',
- 'django.contrib.contenttypes',
+ "admin_scripts.app_raising_warning",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
],
- sdict={'DEBUG': True},
+ sdict={"DEBUG": True},
)
- args = ['check']
+ args = ["check"]
out, err = self.run_manage(args)
expected_err = (
"System check identified some issues:\n" # No "CommandError: " part
@@ -1254,101 +1313,104 @@ class ManageRunserver(SimpleTestCase):
def test_runserver_addrport(self):
call_command(self.cmd)
- self.assertServerSettings('127.0.0.1', '8000')
+ self.assertServerSettings("127.0.0.1", "8000")
call_command(self.cmd, addrport="1.2.3.4:8000")
- self.assertServerSettings('1.2.3.4', '8000')
+ self.assertServerSettings("1.2.3.4", "8000")
call_command(self.cmd, addrport="7000")
- self.assertServerSettings('127.0.0.1', '7000')
+ self.assertServerSettings("127.0.0.1", "7000")
@unittest.skipUnless(socket.has_ipv6, "platform doesn't support IPv6")
def test_runner_addrport_ipv6(self):
call_command(self.cmd, addrport="", use_ipv6=True)
- self.assertServerSettings('::1', '8000', ipv6=True, raw_ipv6=True)
+ self.assertServerSettings("::1", "8000", ipv6=True, raw_ipv6=True)
call_command(self.cmd, addrport="7000", use_ipv6=True)
- self.assertServerSettings('::1', '7000', ipv6=True, raw_ipv6=True)
+ self.assertServerSettings("::1", "7000", ipv6=True, raw_ipv6=True)
call_command(self.cmd, addrport="[2001:0db8:1234:5678::9]:7000")
- self.assertServerSettings('2001:0db8:1234:5678::9', '7000', ipv6=True, raw_ipv6=True)
+ self.assertServerSettings(
+ "2001:0db8:1234:5678::9", "7000", ipv6=True, raw_ipv6=True
+ )
def test_runner_hostname(self):
call_command(self.cmd, addrport="localhost:8000")
- self.assertServerSettings('localhost', '8000')
+ self.assertServerSettings("localhost", "8000")
call_command(self.cmd, addrport="test.domain.local:7000")
- self.assertServerSettings('test.domain.local', '7000')
+ self.assertServerSettings("test.domain.local", "7000")
@unittest.skipUnless(socket.has_ipv6, "platform doesn't support IPv6")
def test_runner_hostname_ipv6(self):
call_command(self.cmd, addrport="test.domain.local:7000", use_ipv6=True)
- self.assertServerSettings('test.domain.local', '7000', ipv6=True)
+ self.assertServerSettings("test.domain.local", "7000", ipv6=True)
def test_runner_custom_defaults(self):
- self.cmd.default_addr = '0.0.0.0'
- self.cmd.default_port = '5000'
+ self.cmd.default_addr = "0.0.0.0"
+ self.cmd.default_port = "5000"
call_command(self.cmd)
- self.assertServerSettings('0.0.0.0', '5000')
+ self.assertServerSettings("0.0.0.0", "5000")
@unittest.skipUnless(socket.has_ipv6, "platform doesn't support IPv6")
def test_runner_custom_defaults_ipv6(self):
- self.cmd.default_addr_ipv6 = '::'
+ self.cmd.default_addr_ipv6 = "::"
call_command(self.cmd, use_ipv6=True)
- self.assertServerSettings('::', '8000', ipv6=True, raw_ipv6=True)
+ self.assertServerSettings("::", "8000", ipv6=True, raw_ipv6=True)
def test_runner_ambiguous(self):
# Only 4 characters, all of which could be in an ipv6 address
call_command(self.cmd, addrport="beef:7654")
- self.assertServerSettings('beef', '7654')
+ self.assertServerSettings("beef", "7654")
# Uses only characters that could be in an ipv6 address
call_command(self.cmd, addrport="deadbeef:7654")
- self.assertServerSettings('deadbeef', '7654')
+ self.assertServerSettings("deadbeef", "7654")
def test_no_database(self):
"""
Ensure runserver.check_migrations doesn't choke on empty DATABASES.
"""
tested_connections = ConnectionHandler({})
- with mock.patch('django.core.management.base.connections', new=tested_connections):
+ with mock.patch(
+ "django.core.management.base.connections", new=tested_connections
+ ):
self.cmd.check_migrations()
def test_readonly_database(self):
"""
runserver.check_migrations() doesn't choke when a database is read-only.
"""
- with mock.patch.object(MigrationRecorder, 'has_table', return_value=False):
+ with mock.patch.object(MigrationRecorder, "has_table", return_value=False):
self.cmd.check_migrations()
# You have # ...
- self.assertIn('unapplied migration(s)', self.output.getvalue())
+ self.assertIn("unapplied migration(s)", self.output.getvalue())
- @mock.patch('django.core.management.commands.runserver.run')
- @mock.patch('django.core.management.base.BaseCommand.check_migrations')
- @mock.patch('django.core.management.base.BaseCommand.check')
+ @mock.patch("django.core.management.commands.runserver.run")
+ @mock.patch("django.core.management.base.BaseCommand.check_migrations")
+ @mock.patch("django.core.management.base.BaseCommand.check")
def test_skip_checks(self, mocked_check, *mocked_objects):
call_command(
- 'runserver',
+ "runserver",
use_reloader=False,
skip_checks=True,
stdout=self.output,
)
- self.assertNotIn('Performing system checks...', self.output.getvalue())
+ self.assertNotIn("Performing system checks...", self.output.getvalue())
mocked_check.assert_not_called()
self.output.truncate(0)
call_command(
- 'runserver',
+ "runserver",
use_reloader=False,
skip_checks=False,
stdout=self.output,
)
- self.assertIn('Performing system checks...', self.output.getvalue())
+ self.assertIn("Performing system checks...", self.output.getvalue())
mocked_check.assert_called()
class ManageRunserverMigrationWarning(TestCase):
-
def setUp(self):
self.stdout = StringIO()
self.runserver_command = RunserverCommand(stdout=self.stdout)
@@ -1357,8 +1419,8 @@ class ManageRunserverMigrationWarning(TestCase):
def test_migration_warning_one_app(self):
self.runserver_command.check_migrations()
output = self.stdout.getvalue()
- self.assertIn('You have 1 unapplied migration(s)', output)
- self.assertIn('apply the migrations for app(s): app_waiting_migration.', output)
+ self.assertIn("You have 1 unapplied migration(s)", output)
+ self.assertIn("apply the migrations for app(s): app_waiting_migration.", output)
@override_settings(
INSTALLED_APPS=[
@@ -1369,56 +1431,71 @@ class ManageRunserverMigrationWarning(TestCase):
def test_migration_warning_multiple_apps(self):
self.runserver_command.check_migrations()
output = self.stdout.getvalue()
- self.assertIn('You have 2 unapplied migration(s)', output)
+ self.assertIn("You have 2 unapplied migration(s)", output)
self.assertIn(
- 'apply the migrations for app(s): another_app_waiting_migration, '
- 'app_waiting_migration.', output
+ "apply the migrations for app(s): another_app_waiting_migration, "
+ "app_waiting_migration.",
+ output,
)
class ManageRunserverEmptyAllowedHosts(AdminScriptTestCase):
def setUp(self):
super().setUp()
- self.write_settings('settings.py', sdict={
- 'ALLOWED_HOSTS': [],
- 'DEBUG': False,
- })
+ self.write_settings(
+ "settings.py",
+ sdict={
+ "ALLOWED_HOSTS": [],
+ "DEBUG": False,
+ },
+ )
def test_empty_allowed_hosts_error(self):
- out, err = self.run_manage(['runserver'])
+ out, err = self.run_manage(["runserver"])
self.assertNoOutput(out)
- self.assertOutput(err, 'CommandError: You must set settings.ALLOWED_HOSTS if DEBUG is False.')
+ self.assertOutput(
+ err, "CommandError: You must set settings.ALLOWED_HOSTS if DEBUG is False."
+ )
class ManageRunserverHelpOutput(AdminScriptTestCase):
def test_suppressed_options(self):
"""runserver doesn't support --verbosity and --trackback options."""
- out, err = self.run_manage(['runserver', '--help'])
- self.assertNotInOutput(out, '--verbosity')
- self.assertNotInOutput(out, '--trackback')
- self.assertOutput(out, '--settings')
+ out, err = self.run_manage(["runserver", "--help"])
+ self.assertNotInOutput(out, "--verbosity")
+ self.assertNotInOutput(out, "--trackback")
+ self.assertOutput(out, "--settings")
class ManageTestserver(SimpleTestCase):
-
- @mock.patch.object(TestserverCommand, 'handle', return_value='')
+ @mock.patch.object(TestserverCommand, "handle", return_value="")
def test_testserver_handle_params(self, mock_handle):
out = StringIO()
- call_command('testserver', 'blah.json', stdout=out)
+ call_command("testserver", "blah.json", stdout=out)
mock_handle.assert_called_with(
- 'blah.json',
- stdout=out, settings=None, pythonpath=None, verbosity=1,
- traceback=False, addrport='', no_color=False, use_ipv6=False,
- skip_checks=True, interactive=True, force_color=False,
+ "blah.json",
+ stdout=out,
+ settings=None,
+ pythonpath=None,
+ verbosity=1,
+ traceback=False,
+ addrport="",
+ no_color=False,
+ use_ipv6=False,
+ skip_checks=True,
+ interactive=True,
+ force_color=False,
)
- @mock.patch('django.db.connection.creation.create_test_db', return_value='test_db')
- @mock.patch.object(LoaddataCommand, 'handle', return_value='')
- @mock.patch.object(RunserverCommand, 'handle', return_value='')
- def test_params_to_runserver(self, mock_runserver_handle, mock_loaddata_handle, mock_create_test_db):
- call_command('testserver', 'blah.json')
+ @mock.patch("django.db.connection.creation.create_test_db", return_value="test_db")
+ @mock.patch.object(LoaddataCommand, "handle", return_value="")
+ @mock.patch.object(RunserverCommand, "handle", return_value="")
+ def test_params_to_runserver(
+ self, mock_runserver_handle, mock_loaddata_handle, mock_create_test_db
+ ):
+ call_command("testserver", "blah.json")
mock_runserver_handle.assert_called_with(
- addrport='',
+ addrport="",
force_color=False,
insecure_serving=False,
no_color=False,
@@ -1447,113 +1524,118 @@ class ColorCommand(BaseCommand):
requires_system_checks = []
def handle(self, *args, **options):
- self.stdout.write('Hello, world!', self.style.ERROR)
- self.stderr.write('Hello, world!', self.style.ERROR)
+ self.stdout.write("Hello, world!", self.style.ERROR)
+ self.stderr.write("Hello, world!", self.style.ERROR)
class CommandTypes(AdminScriptTestCase):
"Tests for the various types of base command types that can be defined."
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py')
+ self.write_settings("settings.py")
def test_version(self):
"version is handled as a special case"
- args = ['version']
+ args = ["version"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, get_version())
def test_version_alternative(self):
"--version is equivalent to version"
- args1, args2 = ['version'], ['--version']
+ args1, args2 = ["version"], ["--version"]
# It's possible one outputs on stderr and the other on stdout, hence the set
self.assertEqual(set(self.run_manage(args1)), set(self.run_manage(args2)))
def test_help(self):
"help is handled as a special case"
- args = ['help']
+ args = ["help"]
out, err = self.run_manage(args)
- self.assertOutput(out, "Type 'manage.py help <subcommand>' for help on a specific subcommand.")
- self.assertOutput(out, '[django]')
- self.assertOutput(out, 'startapp')
- self.assertOutput(out, 'startproject')
+ self.assertOutput(
+ out, "Type 'manage.py help <subcommand>' for help on a specific subcommand."
+ )
+ self.assertOutput(out, "[django]")
+ self.assertOutput(out, "startapp")
+ self.assertOutput(out, "startproject")
def test_help_commands(self):
"help --commands shows the list of all available commands"
- args = ['help', '--commands']
+ args = ["help", "--commands"]
out, err = self.run_manage(args)
- self.assertNotInOutput(out, 'usage:')
- self.assertNotInOutput(out, 'Options:')
- self.assertNotInOutput(out, '[django]')
- self.assertOutput(out, 'startapp')
- self.assertOutput(out, 'startproject')
- self.assertNotInOutput(out, '\n\n')
+ self.assertNotInOutput(out, "usage:")
+ self.assertNotInOutput(out, "Options:")
+ self.assertNotInOutput(out, "[django]")
+ self.assertOutput(out, "startapp")
+ self.assertOutput(out, "startproject")
+ self.assertNotInOutput(out, "\n\n")
def test_help_alternative(self):
"--help is equivalent to help"
- args1, args2 = ['help'], ['--help']
+ args1, args2 = ["help"], ["--help"]
self.assertEqual(self.run_manage(args1), self.run_manage(args2))
def test_help_short_altert(self):
"-h is handled as a short form of --help"
- args1, args2 = ['--help'], ['-h']
+ args1, args2 = ["--help"], ["-h"]
self.assertEqual(self.run_manage(args1), self.run_manage(args2))
def test_specific_help(self):
"--help can be used on a specific command"
- args = ['check', '--help']
+ args = ["check", "--help"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
# Command-specific options like --tag appear before options common to
# all commands like --version.
- tag_location = out.find('--tag')
- version_location = out.find('--version')
+ tag_location = out.find("--tag")
+ version_location = out.find("--version")
self.assertNotEqual(tag_location, -1)
self.assertNotEqual(version_location, -1)
self.assertLess(tag_location, version_location)
- self.assertOutput(out, "Checks the entire Django project for potential problems.")
+ self.assertOutput(
+ out, "Checks the entire Django project for potential problems."
+ )
def test_help_default_options_with_custom_arguments(self):
- args = ['base_command', '--help']
+ args = ["base_command", "--help"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
expected_options = [
- '-h',
- '--option_a OPTION_A',
- '--option_b OPTION_B',
- '--option_c OPTION_C',
- '--version',
- '-v {0,1,2,3}',
- '--settings SETTINGS',
- '--pythonpath PYTHONPATH',
- '--traceback',
- '--no-color',
- '--force-color',
- 'args ...',
+ "-h",
+ "--option_a OPTION_A",
+ "--option_b OPTION_B",
+ "--option_c OPTION_C",
+ "--version",
+ "-v {0,1,2,3}",
+ "--settings SETTINGS",
+ "--pythonpath PYTHONPATH",
+ "--traceback",
+ "--no-color",
+ "--force-color",
+ "args ...",
]
for option in expected_options:
- self.assertOutput(out, f'[{option}]')
- self.assertOutput(out, '--option_a OPTION_A, -a OPTION_A')
- self.assertOutput(out, '--option_b OPTION_B, -b OPTION_B')
- self.assertOutput(out, '--option_c OPTION_C, -c OPTION_C')
- self.assertOutput(out, '-v {0,1,2,3}, --verbosity {0,1,2,3}')
+ self.assertOutput(out, f"[{option}]")
+ self.assertOutput(out, "--option_a OPTION_A, -a OPTION_A")
+ self.assertOutput(out, "--option_b OPTION_B, -b OPTION_B")
+ self.assertOutput(out, "--option_c OPTION_C, -c OPTION_C")
+ self.assertOutput(out, "-v {0,1,2,3}, --verbosity {0,1,2,3}")
def test_color_style(self):
style = color.no_style()
- self.assertEqual(style.ERROR('Hello, world!'), 'Hello, world!')
+ self.assertEqual(style.ERROR("Hello, world!"), "Hello, world!")
- style = color.make_style('nocolor')
- self.assertEqual(style.ERROR('Hello, world!'), 'Hello, world!')
+ style = color.make_style("nocolor")
+ self.assertEqual(style.ERROR("Hello, world!"), "Hello, world!")
- style = color.make_style('dark')
- self.assertIn('Hello, world!', style.ERROR('Hello, world!'))
- self.assertNotEqual(style.ERROR('Hello, world!'), 'Hello, world!')
+ style = color.make_style("dark")
+ self.assertIn("Hello, world!", style.ERROR("Hello, world!"))
+ self.assertNotEqual(style.ERROR("Hello, world!"), "Hello, world!")
# Default palette has color.
- style = color.make_style('')
- self.assertIn('Hello, world!', style.ERROR('Hello, world!'))
- self.assertNotEqual(style.ERROR('Hello, world!'), 'Hello, world!')
+ style = color.make_style("")
+ self.assertIn("Hello, world!", style.ERROR("Hello, world!"))
+ self.assertNotEqual(style.ERROR("Hello, world!"), "Hello, world!")
def test_command_color(self):
out = StringIO()
@@ -1561,13 +1643,13 @@ class CommandTypes(AdminScriptTestCase):
command = ColorCommand(stdout=out, stderr=err)
call_command(command)
if color.supports_color():
- self.assertIn('Hello, world!\n', out.getvalue())
- self.assertIn('Hello, world!\n', err.getvalue())
- self.assertNotEqual(out.getvalue(), 'Hello, world!\n')
- self.assertNotEqual(err.getvalue(), 'Hello, world!\n')
+ self.assertIn("Hello, world!\n", out.getvalue())
+ self.assertIn("Hello, world!\n", err.getvalue())
+ self.assertNotEqual(out.getvalue(), "Hello, world!\n")
+ self.assertNotEqual(err.getvalue(), "Hello, world!\n")
else:
- self.assertEqual(out.getvalue(), 'Hello, world!\n')
- self.assertEqual(err.getvalue(), 'Hello, world!\n')
+ self.assertEqual(out.getvalue(), "Hello, world!\n")
+ self.assertEqual(err.getvalue(), "Hello, world!\n")
def test_command_no_color(self):
"--no-color prevent colorization of the output"
@@ -1575,33 +1657,33 @@ class CommandTypes(AdminScriptTestCase):
err = StringIO()
command = ColorCommand(stdout=out, stderr=err, no_color=True)
call_command(command)
- self.assertEqual(out.getvalue(), 'Hello, world!\n')
- self.assertEqual(err.getvalue(), 'Hello, world!\n')
+ self.assertEqual(out.getvalue(), "Hello, world!\n")
+ self.assertEqual(err.getvalue(), "Hello, world!\n")
out = StringIO()
err = StringIO()
command = ColorCommand(stdout=out, stderr=err)
call_command(command, no_color=True)
- self.assertEqual(out.getvalue(), 'Hello, world!\n')
- self.assertEqual(err.getvalue(), 'Hello, world!\n')
+ self.assertEqual(out.getvalue(), "Hello, world!\n")
+ self.assertEqual(err.getvalue(), "Hello, world!\n")
def test_force_color_execute(self):
out = StringIO()
err = StringIO()
- with mock.patch.object(sys.stdout, 'isatty', lambda: False):
+ with mock.patch.object(sys.stdout, "isatty", lambda: False):
command = ColorCommand(stdout=out, stderr=err)
call_command(command, force_color=True)
- self.assertEqual(out.getvalue(), '\x1b[31;1mHello, world!\n\x1b[0m')
- self.assertEqual(err.getvalue(), '\x1b[31;1mHello, world!\n\x1b[0m')
+ self.assertEqual(out.getvalue(), "\x1b[31;1mHello, world!\n\x1b[0m")
+ self.assertEqual(err.getvalue(), "\x1b[31;1mHello, world!\n\x1b[0m")
def test_force_color_command_init(self):
out = StringIO()
err = StringIO()
- with mock.patch.object(sys.stdout, 'isatty', lambda: False):
+ with mock.patch.object(sys.stdout, "isatty", lambda: False):
command = ColorCommand(stdout=out, stderr=err, force_color=True)
call_command(command)
- self.assertEqual(out.getvalue(), '\x1b[31;1mHello, world!\n\x1b[0m')
- self.assertEqual(err.getvalue(), '\x1b[31;1mHello, world!\n\x1b[0m')
+ self.assertEqual(out.getvalue(), "\x1b[31;1mHello, world!\n\x1b[0m")
+ self.assertEqual(err.getvalue(), "\x1b[31;1mHello, world!\n\x1b[0m")
def test_no_color_force_color_mutually_exclusive_execute(self):
msg = "The --no-color and --force-color options can't be used together."
@@ -1649,37 +1731,37 @@ class CommandTypes(AdminScriptTestCase):
def test_base_command(self):
"User BaseCommands can execute when a label is provided"
- args = ['base_command', 'testlabel']
+ args = ["base_command", "testlabel"]
expected_labels = "('testlabel',)"
self._test_base_command(args, expected_labels)
def test_base_command_no_label(self):
"User BaseCommands can execute when no labels are provided"
- args = ['base_command']
+ args = ["base_command"]
expected_labels = "()"
self._test_base_command(args, expected_labels)
def test_base_command_multiple_label(self):
"User BaseCommands can execute when no labels are provided"
- args = ['base_command', 'testlabel', 'anotherlabel']
+ args = ["base_command", "testlabel", "anotherlabel"]
expected_labels = "('testlabel', 'anotherlabel')"
self._test_base_command(args, expected_labels)
def test_base_command_with_option(self):
"User BaseCommands can execute with options when a label is provided"
- args = ['base_command', 'testlabel', '--option_a=x']
+ args = ["base_command", "testlabel", "--option_a=x"]
expected_labels = "('testlabel',)"
self._test_base_command(args, expected_labels, option_a="'x'")
def test_base_command_with_options(self):
"User BaseCommands can execute with multiple options when a label is provided"
- args = ['base_command', 'testlabel', '-a', 'x', '--option_b=y']
+ args = ["base_command", "testlabel", "-a", "x", "--option_b=y"]
expected_labels = "('testlabel',)"
self._test_base_command(args, expected_labels, option_a="'x'", option_b="'y'")
def test_base_command_with_wrong_option(self):
"User BaseCommands outputs command usage when wrong option is specified"
- args = ['base_command', '--invalid']
+ args = ["base_command", "--invalid"]
out, err = self.run_manage(args)
self.assertNoOutput(out)
self.assertOutput(err, "usage: manage.py base_command")
@@ -1693,7 +1775,8 @@ class CommandTypes(AdminScriptTestCase):
"options=[('force_color', False), ('no_color', False), "
"('option_a', %s), ('option_b', %s), ('option_c', '3'), "
"('pythonpath', None), ('settings', None), ('traceback', False), "
- "('verbosity', 1)]") % (labels, option_a, option_b)
+ "('verbosity', 1)]"
+ ) % (labels, option_a, option_b)
self.assertNoOutput(err)
self.assertOutput(out, expected_out)
@@ -1713,7 +1796,7 @@ class CommandTypes(AdminScriptTestCase):
# If the Exception is not CommandError it should always
# raise the original exception.
with self.assertRaises(TypeError):
- command.run_from_argv(['', ''])
+ command.run_from_argv(["", ""])
# If the Exception is CommandError and --traceback is not present
# this command should raise a SystemExit and don't print any
@@ -1721,7 +1804,7 @@ class CommandTypes(AdminScriptTestCase):
command.execute = raise_command_error
err.truncate(0)
with self.assertRaises(SystemExit):
- command.run_from_argv(['', ''])
+ command.run_from_argv(["", ""])
err_message = err.getvalue()
self.assertNotIn("Traceback", err_message)
self.assertIn("CommandError", err_message)
@@ -1731,13 +1814,14 @@ class CommandTypes(AdminScriptTestCase):
# were not a CommandError.
err.truncate(0)
with self.assertRaises(CommandError):
- command.run_from_argv(['', '', '--traceback'])
+ command.run_from_argv(["", "", "--traceback"])
def test_run_from_argv_non_ascii_error(self):
"""
Non-ASCII message of CommandError does not raise any
UnicodeDecodeError in run_from_argv.
"""
+
def raise_command_error(*args, **kwargs):
raise CommandError("Erreur personnalisée")
@@ -1745,7 +1829,7 @@ class CommandTypes(AdminScriptTestCase):
command.execute = raise_command_error
with self.assertRaises(SystemExit):
- command.run_from_argv(['', ''])
+ command.run_from_argv(["", ""])
def test_run_from_argv_closes_connections(self):
"""
@@ -1755,32 +1839,32 @@ class CommandTypes(AdminScriptTestCase):
command = BaseCommand()
command.check = lambda: []
command.handle = lambda *args, **kwargs: args
- with mock.patch('django.core.management.base.connections') as mock_connections:
- command.run_from_argv(['', ''])
+ with mock.patch("django.core.management.base.connections") as mock_connections:
+ command.run_from_argv(["", ""])
# Test connections have been closed
self.assertTrue(mock_connections.close_all.called)
def test_noargs(self):
"NoArg Commands can be executed"
- args = ['noargs_command']
+ args = ["noargs_command"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(
out,
"EXECUTE: noargs_command options=[('force_color', False), "
"('no_color', False), ('pythonpath', None), ('settings', None), "
- "('traceback', False), ('verbosity', 1)]"
+ "('traceback', False), ('verbosity', 1)]",
)
def test_noargs_with_args(self):
"NoArg Commands raise an error if an argument is provided"
- args = ['noargs_command', 'argument']
+ args = ["noargs_command", "argument"]
out, err = self.run_manage(args)
self.assertOutput(err, "error: unrecognized arguments: argument")
def test_app_command(self):
"User AppCommands can execute when a single app name is provided"
- args = ['app_command', 'auth']
+ args = ["app_command", "auth"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE:AppCommand name=django.contrib.auth, options=")
@@ -1788,18 +1872,18 @@ class CommandTypes(AdminScriptTestCase):
out,
", options=[('force_color', False), ('no_color', False), "
"('pythonpath', None), ('settings', None), ('traceback', False), "
- "('verbosity', 1)]"
+ "('verbosity', 1)]",
)
def test_app_command_no_apps(self):
"User AppCommands raise an error when no app name is provided"
- args = ['app_command']
+ args = ["app_command"]
out, err = self.run_manage(args)
- self.assertOutput(err, 'error: Enter at least one application label.')
+ self.assertOutput(err, "error: Enter at least one application label.")
def test_app_command_multiple_apps(self):
"User AppCommands raise an error when multiple app names are provided"
- args = ['app_command', 'auth', 'contenttypes']
+ args = ["app_command", "auth", "contenttypes"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "EXECUTE:AppCommand name=django.contrib.auth, options=")
@@ -1807,82 +1891,84 @@ class CommandTypes(AdminScriptTestCase):
out,
", options=[('force_color', False), ('no_color', False), "
"('pythonpath', None), ('settings', None), ('traceback', False), "
- "('verbosity', 1)]"
+ "('verbosity', 1)]",
+ )
+ self.assertOutput(
+ out, "EXECUTE:AppCommand name=django.contrib.contenttypes, options="
)
- self.assertOutput(out, "EXECUTE:AppCommand name=django.contrib.contenttypes, options=")
self.assertOutput(
out,
", options=[('force_color', False), ('no_color', False), "
"('pythonpath', None), ('settings', None), ('traceback', False), "
- "('verbosity', 1)]"
+ "('verbosity', 1)]",
)
def test_app_command_invalid_app_label(self):
"User AppCommands can execute when a single app name is provided"
- args = ['app_command', 'NOT_AN_APP']
+ args = ["app_command", "NOT_AN_APP"]
out, err = self.run_manage(args)
self.assertOutput(err, "No installed app with label 'NOT_AN_APP'.")
def test_app_command_some_invalid_app_labels(self):
"User AppCommands can execute when some of the provided app names are invalid"
- args = ['app_command', 'auth', 'NOT_AN_APP']
+ args = ["app_command", "auth", "NOT_AN_APP"]
out, err = self.run_manage(args)
self.assertOutput(err, "No installed app with label 'NOT_AN_APP'.")
def test_label_command(self):
"User LabelCommands can execute when a label is provided"
- args = ['label_command', 'testlabel']
+ args = ["label_command", "testlabel"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(
out,
"EXECUTE:LabelCommand label=testlabel, options=[('force_color', "
"False), ('no_color', False), ('pythonpath', None), ('settings', "
- "None), ('traceback', False), ('verbosity', 1)]"
+ "None), ('traceback', False), ('verbosity', 1)]",
)
def test_label_command_no_label(self):
"User LabelCommands raise an error if no label is provided"
- args = ['label_command']
+ args = ["label_command"]
out, err = self.run_manage(args)
- self.assertOutput(err, 'Enter at least one label')
+ self.assertOutput(err, "Enter at least one label")
def test_label_command_multiple_label(self):
"User LabelCommands are executed multiple times if multiple labels are provided"
- args = ['label_command', 'testlabel', 'anotherlabel']
+ args = ["label_command", "testlabel", "anotherlabel"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(
out,
"EXECUTE:LabelCommand label=testlabel, options=[('force_color', "
"False), ('no_color', False), ('pythonpath', None), "
- "('settings', None), ('traceback', False), ('verbosity', 1)]"
+ "('settings', None), ('traceback', False), ('verbosity', 1)]",
)
self.assertOutput(
out,
"EXECUTE:LabelCommand label=anotherlabel, options=[('force_color', "
"False), ('no_color', False), ('pythonpath', None), "
- "('settings', None), ('traceback', False), ('verbosity', 1)]"
+ "('settings', None), ('traceback', False), ('verbosity', 1)]",
)
def test_suppress_base_options_command_help(self):
- args = ['suppress_base_options_command', '--help']
+ args = ["suppress_base_options_command", "--help"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
- self.assertOutput(out, 'Test suppress base options command.')
- self.assertNotInOutput(out, 'input file')
- self.assertOutput(out, '-h, --help')
- self.assertNotInOutput(out, '--version')
- self.assertNotInOutput(out, '--verbosity')
- self.assertNotInOutput(out, '-v {0,1,2,3}')
- self.assertNotInOutput(out, '--settings')
- self.assertNotInOutput(out, '--pythonpath')
- self.assertNotInOutput(out, '--traceback')
- self.assertNotInOutput(out, '--no-color')
- self.assertNotInOutput(out, '--force-color')
+ self.assertOutput(out, "Test suppress base options command.")
+ self.assertNotInOutput(out, "input file")
+ self.assertOutput(out, "-h, --help")
+ self.assertNotInOutput(out, "--version")
+ self.assertNotInOutput(out, "--verbosity")
+ self.assertNotInOutput(out, "-v {0,1,2,3}")
+ self.assertNotInOutput(out, "--settings")
+ self.assertNotInOutput(out, "--pythonpath")
+ self.assertNotInOutput(out, "--traceback")
+ self.assertNotInOutput(out, "--no-color")
+ self.assertNotInOutput(out, "--force-color")
def test_suppress_base_options_command_defaults(self):
- args = ['suppress_base_options_command']
+ args = ["suppress_base_options_command"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(
@@ -1890,30 +1976,37 @@ class CommandTypes(AdminScriptTestCase):
"EXECUTE:SuppressBaseOptionsCommand options=[('file', None), "
"('force_color', False), ('no_color', False), "
"('pythonpath', None), ('settings', None), "
- "('traceback', False), ('verbosity', 1)]"
+ "('traceback', False), ('verbosity', 1)]",
)
class Discovery(SimpleTestCase):
-
def test_precedence(self):
"""
Apps listed first in INSTALLED_APPS have precedence.
"""
- with self.settings(INSTALLED_APPS=['admin_scripts.complex_app',
- 'admin_scripts.simple_app',
- 'django.contrib.auth',
- 'django.contrib.contenttypes']):
+ with self.settings(
+ INSTALLED_APPS=[
+ "admin_scripts.complex_app",
+ "admin_scripts.simple_app",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ ]
+ ):
out = StringIO()
- call_command('duplicate', stdout=out)
- self.assertEqual(out.getvalue().strip(), 'complex_app')
- with self.settings(INSTALLED_APPS=['admin_scripts.simple_app',
- 'admin_scripts.complex_app',
- 'django.contrib.auth',
- 'django.contrib.contenttypes']):
+ call_command("duplicate", stdout=out)
+ self.assertEqual(out.getvalue().strip(), "complex_app")
+ with self.settings(
+ INSTALLED_APPS=[
+ "admin_scripts.simple_app",
+ "admin_scripts.complex_app",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ ]
+ ):
out = StringIO()
- call_command('duplicate', stdout=out)
- self.assertEqual(out.getvalue().strip(), 'simple_app')
+ call_command("duplicate", stdout=out)
+ self.assertEqual(out.getvalue().strip(), "simple_app")
class ArgumentOrder(AdminScriptTestCase):
@@ -1925,35 +2018,54 @@ class ArgumentOrder(AdminScriptTestCase):
passed to the command parser, which extracts commands of interest to the
individual command.
"""
+
def setUp(self):
super().setUp()
- self.write_settings('settings.py', apps=['django.contrib.auth', 'django.contrib.contenttypes'])
- self.write_settings('alternate_settings.py')
+ self.write_settings(
+ "settings.py", apps=["django.contrib.auth", "django.contrib.contenttypes"]
+ )
+ self.write_settings("alternate_settings.py")
def test_setting_then_option(self):
- """ Options passed after settings are correctly handled. """
- args = ['base_command', 'testlabel', '--settings=alternate_settings', '--option_a=x']
+ """Options passed after settings are correctly handled."""
+ args = [
+ "base_command",
+ "testlabel",
+ "--settings=alternate_settings",
+ "--option_a=x",
+ ]
self._test(args)
def test_setting_then_short_option(self):
- """ Short options passed after settings are correctly handled. """
- args = ['base_command', 'testlabel', '--settings=alternate_settings', '-a', 'x']
+ """Short options passed after settings are correctly handled."""
+ args = ["base_command", "testlabel", "--settings=alternate_settings", "-a", "x"]
self._test(args)
def test_option_then_setting(self):
- """ Options passed before settings are correctly handled. """
- args = ['base_command', 'testlabel', '--option_a=x', '--settings=alternate_settings']
+ """Options passed before settings are correctly handled."""
+ args = [
+ "base_command",
+ "testlabel",
+ "--option_a=x",
+ "--settings=alternate_settings",
+ ]
self._test(args)
def test_short_option_then_setting(self):
- """ Short options passed before settings are correctly handled. """
- args = ['base_command', 'testlabel', '-a', 'x', '--settings=alternate_settings']
+ """Short options passed before settings are correctly handled."""
+ args = ["base_command", "testlabel", "-a", "x", "--settings=alternate_settings"]
self._test(args)
def test_option_then_setting_then_option(self):
- """ Options are correctly handled when they are passed before and after
- a setting. """
- args = ['base_command', 'testlabel', '--option_a=x', '--settings=alternate_settings', '--option_b=y']
+ """Options are correctly handled when they are passed before and after
+ a setting."""
+ args = [
+ "base_command",
+ "testlabel",
+ "--option_a=x",
+ "--settings=alternate_settings",
+ "--option_b=y",
+ ]
self._test(args, option_b="'y'")
def _test(self, args, option_b="'2'"):
@@ -1965,7 +2077,7 @@ class ArgumentOrder(AdminScriptTestCase):
"('force_color', False), ('no_color', False), ('option_a', 'x'), "
"('option_b', %s), ('option_c', '3'), ('pythonpath', None), "
"('settings', 'alternate_settings'), ('traceback', False), "
- "('verbosity', 1)]" % option_b
+ "('verbosity', 1)]" % option_b,
)
@@ -1975,35 +2087,35 @@ class ExecuteFromCommandLine(SimpleTestCase):
Program name is computed from the execute_from_command_line()'s argv
argument, not sys.argv.
"""
- args = ['help', 'shell']
+ args = ["help", "shell"]
with captured_stdout() as out, captured_stderr() as err:
- with mock.patch('sys.argv', [None] + args):
- execute_from_command_line(['django-admin'] + args)
- self.assertIn('usage: django-admin shell', out.getvalue())
- self.assertEqual(err.getvalue(), '')
+ with mock.patch("sys.argv", [None] + args):
+ execute_from_command_line(["django-admin"] + args)
+ self.assertIn("usage: django-admin shell", out.getvalue())
+ self.assertEqual(err.getvalue(), "")
-@override_settings(ROOT_URLCONF='admin_scripts.urls')
+@override_settings(ROOT_URLCONF="admin_scripts.urls")
class StartProject(LiveServerTestCase, AdminScriptTestCase):
available_apps = [
- 'admin_scripts',
- 'django.contrib.auth',
- 'django.contrib.contenttypes',
- 'django.contrib.sessions',
+ "admin_scripts",
+ "django.contrib.auth",
+ "django.contrib.contenttypes",
+ "django.contrib.sessions",
]
def test_wrong_args(self):
"Make sure passing the wrong kinds of arguments outputs an error and prints usage"
- out, err = self.run_django_admin(['startproject'])
+ out, err = self.run_django_admin(["startproject"])
self.assertNoOutput(out)
self.assertOutput(err, "usage:")
self.assertOutput(err, "You must provide a project name.")
def test_simple_project(self):
"Make sure the startproject management command creates a project"
- args = ['startproject', 'testproject']
- testproject_dir = os.path.join(self.test_dir, 'testproject')
+ args = ["startproject", "testproject"]
+ testproject_dir = os.path.join(self.test_dir, "testproject")
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
@@ -2021,16 +2133,16 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
def test_invalid_project_name(self):
"Make sure the startproject management command validates a project name"
- for bad_name in ('7testproject', '../testproject'):
+ for bad_name in ("7testproject", "../testproject"):
with self.subTest(project_name=bad_name):
- args = ['startproject', bad_name]
+ args = ["startproject", bad_name]
testproject_dir = os.path.join(self.test_dir, bad_name)
out, err = self.run_django_admin(args)
self.assertOutput(
err,
"Error: '%s' is not a valid project name. Please make "
- "sure the name is a valid identifier." % bad_name
+ "sure the name is a valid identifier." % bad_name,
)
self.assertFalse(os.path.exists(testproject_dir))
@@ -2039,8 +2151,8 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
startproject validates that project name doesn't clash with existing
Python modules.
"""
- bad_name = 'os'
- args = ['startproject', bad_name]
+ bad_name = "os"
+ args = ["startproject", bad_name]
testproject_dir = os.path.join(self.test_dir, bad_name)
out, err = self.run_django_admin(args)
@@ -2048,19 +2160,19 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
err,
"CommandError: 'os' conflicts with the name of an existing "
"Python module and cannot be used as a project name. Please try "
- "another name."
+ "another name.",
)
self.assertFalse(os.path.exists(testproject_dir))
def test_simple_project_different_directory(self):
"Make sure the startproject management command creates a project in a specific directory"
- args = ['startproject', 'testproject', 'othertestproject']
- testproject_dir = os.path.join(self.test_dir, 'othertestproject')
+ args = ["startproject", "testproject", "othertestproject"]
+ testproject_dir = os.path.join(self.test_dir, "othertestproject")
os.mkdir(testproject_dir)
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
- self.assertTrue(os.path.exists(os.path.join(testproject_dir, 'manage.py')))
+ self.assertTrue(os.path.exists(os.path.join(testproject_dir, "manage.py")))
# running again..
out, err = self.run_django_admin(args)
@@ -2068,133 +2180,160 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
self.assertOutput(
err,
"already exists. Overlaying a project into an existing directory "
- "won't replace conflicting files."
+ "won't replace conflicting files.",
)
def test_custom_project_template(self):
"Make sure the startproject management command is able to use a different project template"
- template_path = os.path.join(custom_templates_dir, 'project_template')
- args = ['startproject', '--template', template_path, 'customtestproject']
- testproject_dir = os.path.join(self.test_dir, 'customtestproject')
+ template_path = os.path.join(custom_templates_dir, "project_template")
+ args = ["startproject", "--template", template_path, "customtestproject"]
+ testproject_dir = os.path.join(self.test_dir, "customtestproject")
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertTrue(os.path.isdir(testproject_dir))
- self.assertTrue(os.path.exists(os.path.join(testproject_dir, 'additional_dir')))
+ self.assertTrue(os.path.exists(os.path.join(testproject_dir, "additional_dir")))
def test_template_dir_with_trailing_slash(self):
"Ticket 17475: Template dir passed has a trailing path separator"
- template_path = os.path.join(custom_templates_dir, 'project_template' + os.sep)
- args = ['startproject', '--template', template_path, 'customtestproject']
- testproject_dir = os.path.join(self.test_dir, 'customtestproject')
+ template_path = os.path.join(custom_templates_dir, "project_template" + os.sep)
+ args = ["startproject", "--template", template_path, "customtestproject"]
+ testproject_dir = os.path.join(self.test_dir, "customtestproject")
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertTrue(os.path.isdir(testproject_dir))
- self.assertTrue(os.path.exists(os.path.join(testproject_dir, 'additional_dir')))
+ self.assertTrue(os.path.exists(os.path.join(testproject_dir, "additional_dir")))
def test_custom_project_template_from_tarball_by_path(self):
"Make sure the startproject management command is able to use a different project template from a tarball"
- template_path = os.path.join(custom_templates_dir, 'project_template.tgz')
- args = ['startproject', '--template', template_path, 'tarballtestproject']
- testproject_dir = os.path.join(self.test_dir, 'tarballtestproject')
+ template_path = os.path.join(custom_templates_dir, "project_template.tgz")
+ args = ["startproject", "--template", template_path, "tarballtestproject"]
+ testproject_dir = os.path.join(self.test_dir, "tarballtestproject")
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertTrue(os.path.isdir(testproject_dir))
- self.assertTrue(os.path.exists(os.path.join(testproject_dir, 'run.py')))
+ self.assertTrue(os.path.exists(os.path.join(testproject_dir, "run.py")))
def test_custom_project_template_from_tarball_to_alternative_location(self):
"Startproject can use a project template from a tarball and create it in a specified location"
- template_path = os.path.join(custom_templates_dir, 'project_template.tgz')
- args = ['startproject', '--template', template_path, 'tarballtestproject', 'altlocation']
- testproject_dir = os.path.join(self.test_dir, 'altlocation')
+ template_path = os.path.join(custom_templates_dir, "project_template.tgz")
+ args = [
+ "startproject",
+ "--template",
+ template_path,
+ "tarballtestproject",
+ "altlocation",
+ ]
+ testproject_dir = os.path.join(self.test_dir, "altlocation")
os.mkdir(testproject_dir)
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertTrue(os.path.isdir(testproject_dir))
- self.assertTrue(os.path.exists(os.path.join(testproject_dir, 'run.py')))
+ self.assertTrue(os.path.exists(os.path.join(testproject_dir, "run.py")))
def test_custom_project_template_from_tarball_by_url(self):
"""
The startproject management command is able to use a different project
template from a tarball via a URL.
"""
- template_url = '%s/custom_templates/project_template.tgz' % self.live_server_url
+ template_url = "%s/custom_templates/project_template.tgz" % self.live_server_url
- args = ['startproject', '--template', template_url, 'urltestproject']
- testproject_dir = os.path.join(self.test_dir, 'urltestproject')
+ args = ["startproject", "--template", template_url, "urltestproject"]
+ testproject_dir = os.path.join(self.test_dir, "urltestproject")
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertTrue(os.path.isdir(testproject_dir))
- self.assertTrue(os.path.exists(os.path.join(testproject_dir, 'run.py')))
+ self.assertTrue(os.path.exists(os.path.join(testproject_dir, "run.py")))
def test_custom_project_template_from_tarball_by_url_django_user_agent(self):
user_agent = None
def serve_template(request, *args, **kwargs):
nonlocal user_agent
- user_agent = request.headers['User-Agent']
+ user_agent = request.headers["User-Agent"]
return serve(request, *args, **kwargs)
old_urlpatterns = urls.urlpatterns[:]
try:
urls.urlpatterns += [
path(
- 'user_agent_check/<path:path>',
+ "user_agent_check/<path:path>",
serve_template,
- {'document_root': os.path.join(urls.here, 'custom_templates')},
+ {"document_root": os.path.join(urls.here, "custom_templates")},
),
]
- template_url = f'{self.live_server_url}/user_agent_check/project_template.tgz'
- args = ['startproject', '--template', template_url, 'urltestproject']
+ template_url = (
+ f"{self.live_server_url}/user_agent_check/project_template.tgz"
+ )
+ args = ["startproject", "--template", template_url, "urltestproject"]
_, err = self.run_django_admin(args)
self.assertNoOutput(err)
- self.assertIn('Django/%s' % get_version(), user_agent)
+ self.assertIn("Django/%s" % get_version(), user_agent)
finally:
urls.urlpatterns = old_urlpatterns
def test_project_template_tarball_url(self):
"Startproject management command handles project template tar/zip balls from non-canonical urls"
- template_url = '%s/custom_templates/project_template.tgz/' % self.live_server_url
+ template_url = (
+ "%s/custom_templates/project_template.tgz/" % self.live_server_url
+ )
- args = ['startproject', '--template', template_url, 'urltestproject']
- testproject_dir = os.path.join(self.test_dir, 'urltestproject')
+ args = ["startproject", "--template", template_url, "urltestproject"]
+ testproject_dir = os.path.join(self.test_dir, "urltestproject")
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertTrue(os.path.isdir(testproject_dir))
- self.assertTrue(os.path.exists(os.path.join(testproject_dir, 'run.py')))
+ self.assertTrue(os.path.exists(os.path.join(testproject_dir, "run.py")))
def test_file_without_extension(self):
"Make sure the startproject management command is able to render custom files"
- template_path = os.path.join(custom_templates_dir, 'project_template')
- args = ['startproject', '--template', template_path, 'customtestproject', '-e', 'txt', '-n', 'Procfile']
- testproject_dir = os.path.join(self.test_dir, 'customtestproject')
+ template_path = os.path.join(custom_templates_dir, "project_template")
+ args = [
+ "startproject",
+ "--template",
+ template_path,
+ "customtestproject",
+ "-e",
+ "txt",
+ "-n",
+ "Procfile",
+ ]
+ testproject_dir = os.path.join(self.test_dir, "customtestproject")
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertTrue(os.path.isdir(testproject_dir))
- self.assertTrue(os.path.exists(os.path.join(testproject_dir, 'additional_dir')))
- base_path = os.path.join(testproject_dir, 'additional_dir')
- for f in ('Procfile', 'additional_file.py', 'requirements.txt'):
+ self.assertTrue(os.path.exists(os.path.join(testproject_dir, "additional_dir")))
+ base_path = os.path.join(testproject_dir, "additional_dir")
+ for f in ("Procfile", "additional_file.py", "requirements.txt"):
self.assertTrue(os.path.exists(os.path.join(base_path, f)))
with open(os.path.join(base_path, f)) as fh:
- self.assertEqual(fh.read().strip(), '# some file for customtestproject test project')
+ self.assertEqual(
+ fh.read().strip(), "# some file for customtestproject test project"
+ )
def test_custom_project_template_context_variables(self):
"Make sure template context variables are rendered with proper values"
- template_path = os.path.join(custom_templates_dir, 'project_template')
- args = ['startproject', '--template', template_path, 'another_project', 'project_dir']
- testproject_dir = os.path.join(self.test_dir, 'project_dir')
+ template_path = os.path.join(custom_templates_dir, "project_template")
+ args = [
+ "startproject",
+ "--template",
+ template_path,
+ "another_project",
+ "project_dir",
+ ]
+ testproject_dir = os.path.join(self.test_dir, "project_dir")
os.mkdir(testproject_dir)
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
- test_manage_py = os.path.join(testproject_dir, 'manage.py')
+ test_manage_py = os.path.join(testproject_dir, "manage.py")
with open(test_manage_py) as fp:
content = fp.read()
self.assertIn("project_name = 'another_project'", content)
@@ -2203,18 +2342,23 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
def test_no_escaping_of_project_variables(self):
"Make sure template context variables are not html escaped"
# We're using a custom command so we need the alternate settings
- self.write_settings('alternate_settings.py')
- template_path = os.path.join(custom_templates_dir, 'project_template')
+ self.write_settings("alternate_settings.py")
+ template_path = os.path.join(custom_templates_dir, "project_template")
args = [
- 'custom_startproject', '--template', template_path,
- 'another_project', 'project_dir', '--extra', '<&>',
- '--settings=alternate_settings',
+ "custom_startproject",
+ "--template",
+ template_path,
+ "another_project",
+ "project_dir",
+ "--extra",
+ "<&>",
+ "--settings=alternate_settings",
]
- testproject_dir = os.path.join(self.test_dir, 'project_dir')
+ testproject_dir = os.path.join(self.test_dir, "project_dir")
os.mkdir(testproject_dir)
out, err = self.run_manage(args)
self.assertNoOutput(err)
- test_manage_py = os.path.join(testproject_dir, 'additional_dir', 'extra.py')
+ test_manage_py = os.path.join(testproject_dir, "additional_dir", "extra.py")
with open(test_manage_py) as fp:
content = fp.read()
self.assertIn("<&>", content)
@@ -2224,12 +2368,22 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
Make sure an exception is raised when the provided
destination directory doesn't exist
"""
- template_path = os.path.join(custom_templates_dir, 'project_template')
- args = ['startproject', '--template', template_path, 'yet_another_project', 'project_dir2']
- testproject_dir = os.path.join(self.test_dir, 'project_dir2')
+ template_path = os.path.join(custom_templates_dir, "project_template")
+ args = [
+ "startproject",
+ "--template",
+ template_path,
+ "yet_another_project",
+ "project_dir2",
+ ]
+ testproject_dir = os.path.join(self.test_dir, "project_dir2")
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertOutput(err, "Destination directory '%s' does not exist, please create it first." % testproject_dir)
+ self.assertOutput(
+ err,
+ "Destination directory '%s' does not exist, please create it first."
+ % testproject_dir,
+ )
self.assertFalse(os.path.exists(testproject_dir))
def test_custom_project_template_with_non_ascii_templates(self):
@@ -2237,35 +2391,42 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
The startproject management command is able to render templates with
non-ASCII content.
"""
- template_path = os.path.join(custom_templates_dir, 'project_template')
- args = ['startproject', '--template', template_path, '--extension=txt', 'customtestproject']
- testproject_dir = os.path.join(self.test_dir, 'customtestproject')
+ template_path = os.path.join(custom_templates_dir, "project_template")
+ args = [
+ "startproject",
+ "--template",
+ template_path,
+ "--extension=txt",
+ "customtestproject",
+ ]
+ testproject_dir = os.path.join(self.test_dir, "customtestproject")
out, err = self.run_django_admin(args)
self.assertNoOutput(err)
self.assertTrue(os.path.isdir(testproject_dir))
- path = os.path.join(testproject_dir, 'ticket-18091-non-ascii-template.txt')
- with open(path, encoding='utf-8') as f:
- self.assertEqual(f.read().splitlines(False), [
- 'Some non-ASCII text for testing ticket #18091:',
- 'üäö €'])
+ path = os.path.join(testproject_dir, "ticket-18091-non-ascii-template.txt")
+ with open(path, encoding="utf-8") as f:
+ self.assertEqual(
+ f.read().splitlines(False),
+ ["Some non-ASCII text for testing ticket #18091:", "üäö €"],
+ )
def test_custom_project_template_hidden_directory_default_excluded(self):
"""Hidden directories are excluded by default."""
- template_path = os.path.join(custom_templates_dir, 'project_template')
+ template_path = os.path.join(custom_templates_dir, "project_template")
args = [
- 'startproject',
- '--template',
+ "startproject",
+ "--template",
template_path,
- 'custom_project_template_hidden_directories',
- 'project_dir',
+ "custom_project_template_hidden_directories",
+ "project_dir",
]
- testproject_dir = os.path.join(self.test_dir, 'project_dir')
+ testproject_dir = os.path.join(self.test_dir, "project_dir")
os.mkdir(testproject_dir)
_, err = self.run_django_admin(args)
self.assertNoOutput(err)
- hidden_dir = os.path.join(testproject_dir, '.hidden')
+ hidden_dir = os.path.join(testproject_dir, ".hidden")
self.assertIs(os.path.exists(hidden_dir), False)
def test_custom_project_template_hidden_directory_included(self):
@@ -2273,25 +2434,25 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
Template context variables in hidden directories are rendered, if not
excluded.
"""
- template_path = os.path.join(custom_templates_dir, 'project_template')
- project_name = 'custom_project_template_hidden_directories_included'
+ template_path = os.path.join(custom_templates_dir, "project_template")
+ project_name = "custom_project_template_hidden_directories_included"
args = [
- 'startproject',
- '--template',
+ "startproject",
+ "--template",
template_path,
project_name,
- 'project_dir',
- '--exclude',
+ "project_dir",
+ "--exclude",
]
- testproject_dir = os.path.join(self.test_dir, 'project_dir')
+ testproject_dir = os.path.join(self.test_dir, "project_dir")
os.mkdir(testproject_dir)
_, err = self.run_django_admin(args)
self.assertNoOutput(err)
- render_py_path = os.path.join(testproject_dir, '.hidden', 'render.py')
+ render_py_path = os.path.join(testproject_dir, ".hidden", "render.py")
with open(render_py_path) as fp:
self.assertIn(
- f'# The {project_name} should be rendered.',
+ f"# The {project_name} should be rendered.",
fp.read(),
)
@@ -2300,29 +2461,29 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
Excluded directories (in addition to .git and __pycache__) are not
included in the project.
"""
- template_path = os.path.join(custom_templates_dir, 'project_template')
- project_name = 'custom_project_with_excluded_directories'
+ template_path = os.path.join(custom_templates_dir, "project_template")
+ project_name = "custom_project_with_excluded_directories"
args = [
- 'startproject',
- '--template',
+ "startproject",
+ "--template",
template_path,
project_name,
- 'project_dir',
- '--exclude',
- 'additional_dir',
- '-x',
- '.hidden',
+ "project_dir",
+ "--exclude",
+ "additional_dir",
+ "-x",
+ ".hidden",
]
- testproject_dir = os.path.join(self.test_dir, 'project_dir')
+ testproject_dir = os.path.join(self.test_dir, "project_dir")
os.mkdir(testproject_dir)
_, err = self.run_django_admin(args)
self.assertNoOutput(err)
excluded_directories = [
- '.hidden',
- 'additional_dir',
- '.git',
- '__pycache__',
+ ".hidden",
+ "additional_dir",
+ ".git",
+ "__pycache__",
]
for directory in excluded_directories:
self.assertIs(
@@ -2333,19 +2494,19 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
self.assertIs(os.path.exists(not_excluded), True)
@unittest.skipIf(
- sys.platform == 'win32',
- 'Windows only partially supports umasks and chmod.',
+ sys.platform == "win32",
+ "Windows only partially supports umasks and chmod.",
)
@unittest.skipUnless(PY39, "subprocess.run()'s umask was added in Python 3.9.")
def test_honor_umask(self):
- _, err = self.run_django_admin(['startproject', 'testproject'], umask=0o077)
+ _, err = self.run_django_admin(["startproject", "testproject"], umask=0o077)
self.assertNoOutput(err)
- testproject_dir = os.path.join(self.test_dir, 'testproject')
+ testproject_dir = os.path.join(self.test_dir, "testproject")
self.assertIs(os.path.isdir(testproject_dir), True)
tests = [
- (['manage.py'], 0o700),
- (['testproject'], 0o700),
- (['testproject', 'settings.py'], 0o600),
+ (["manage.py"], 0o700),
+ (["testproject"], 0o700),
+ (["testproject", "settings.py"], 0o600),
]
for paths, expected_mode in tests:
file_path = os.path.join(testproject_dir, *paths)
@@ -2357,19 +2518,18 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
class StartApp(AdminScriptTestCase):
-
def test_invalid_name(self):
"""startapp validates that app name is a valid Python identifier."""
- for bad_name in ('7testproject', '../testproject'):
+ for bad_name in ("7testproject", "../testproject"):
with self.subTest(app_name=bad_name):
- args = ['startapp', bad_name]
+ args = ["startapp", bad_name]
testproject_dir = os.path.join(self.test_dir, bad_name)
out, err = self.run_django_admin(args)
self.assertOutput(
err,
"CommandError: '{}' is not a valid app name. Please make "
- "sure the name is a valid identifier.".format(bad_name)
+ "sure the name is a valid identifier.".format(bad_name),
)
self.assertFalse(os.path.exists(testproject_dir))
@@ -2378,8 +2538,8 @@ class StartApp(AdminScriptTestCase):
startapp validates that app name doesn't clash with existing Python
modules.
"""
- bad_name = 'os'
- args = ['startapp', bad_name]
+ bad_name = "os"
+ args = ["startapp", bad_name]
testproject_dir = os.path.join(self.test_dir, bad_name)
out, err = self.run_django_admin(args)
@@ -2387,55 +2547,61 @@ class StartApp(AdminScriptTestCase):
err,
"CommandError: 'os' conflicts with the name of an existing "
"Python module and cannot be used as an app name. Please try "
- "another name."
+ "another name.",
)
self.assertFalse(os.path.exists(testproject_dir))
def test_invalid_target_name(self):
- for bad_target in ('invalid.dir_name', '7invalid_dir_name', '.invalid_dir_name'):
+ for bad_target in (
+ "invalid.dir_name",
+ "7invalid_dir_name",
+ ".invalid_dir_name",
+ ):
with self.subTest(bad_target):
- _, err = self.run_django_admin(['startapp', 'app', bad_target])
+ _, err = self.run_django_admin(["startapp", "app", bad_target])
self.assertOutput(
err,
"CommandError: '%s' is not a valid app directory. Please "
- "make sure the directory is a valid identifier." % bad_target
+ "make sure the directory is a valid identifier." % bad_target,
)
def test_importable_target_name(self):
- _, err = self.run_django_admin(['startapp', 'app', 'os'])
+ _, err = self.run_django_admin(["startapp", "app", "os"])
self.assertOutput(
err,
"CommandError: 'os' conflicts with the name of an existing Python "
"module and cannot be used as an app directory. Please try "
- "another directory."
+ "another directory.",
)
def test_trailing_slash_in_target_app_directory_name(self):
- app_dir = os.path.join(self.test_dir, 'apps', 'app1')
+ app_dir = os.path.join(self.test_dir, "apps", "app1")
os.makedirs(app_dir)
- _, err = self.run_django_admin(['startapp', 'app', os.path.join('apps', 'app1', '')])
+ _, err = self.run_django_admin(
+ ["startapp", "app", os.path.join("apps", "app1", "")]
+ )
self.assertNoOutput(err)
- self.assertIs(os.path.exists(os.path.join(app_dir, 'apps.py')), True)
+ self.assertIs(os.path.exists(os.path.join(app_dir, "apps.py")), True)
def test_overlaying_app(self):
# Use a subdirectory so it is outside the PYTHONPATH.
- os.makedirs(os.path.join(self.test_dir, 'apps/app1'))
- self.run_django_admin(['startapp', 'app1', 'apps/app1'])
- out, err = self.run_django_admin(['startapp', 'app2', 'apps/app1'])
+ os.makedirs(os.path.join(self.test_dir, "apps/app1"))
+ self.run_django_admin(["startapp", "app1", "apps/app1"])
+ out, err = self.run_django_admin(["startapp", "app2", "apps/app1"])
self.assertOutput(
err,
"already exists. Overlaying an app into an existing directory "
- "won't replace conflicting files."
+ "won't replace conflicting files.",
)
def test_template(self):
- out, err = self.run_django_admin(['startapp', 'new_app'])
+ out, err = self.run_django_admin(["startapp", "new_app"])
self.assertNoOutput(err)
- app_path = os.path.join(self.test_dir, 'new_app')
+ app_path = os.path.join(self.test_dir, "new_app")
self.assertIs(os.path.exists(app_path), True)
- with open(os.path.join(app_path, 'apps.py')) as f:
+ with open(os.path.join(app_path, "apps.py")) as f:
content = f.read()
- self.assertIn('class NewAppConfig(AppConfig)', content)
+ self.assertIn("class NewAppConfig(AppConfig)", content)
self.assertIn(
"default_auto_field = 'django.db.models.BigAutoField'",
content,
@@ -2448,31 +2614,35 @@ class DiffSettings(AdminScriptTestCase):
def test_basic(self):
"""Runs without error and emits settings diff."""
- self.write_settings('settings_to_diff.py', sdict={'FOO': '"bar"'})
- args = ['diffsettings', '--settings=settings_to_diff']
+ self.write_settings("settings_to_diff.py", sdict={"FOO": '"bar"'})
+ args = ["diffsettings", "--settings=settings_to_diff"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "FOO = 'bar' ###")
# Attributes from django.conf.Settings don't appear.
- self.assertNotInOutput(out, 'is_overridden = ')
+ self.assertNotInOutput(out, "is_overridden = ")
def test_settings_configured(self):
- out, err = self.run_manage(['diffsettings'], manage_py='configured_settings_manage.py')
+ out, err = self.run_manage(
+ ["diffsettings"], manage_py="configured_settings_manage.py"
+ )
self.assertNoOutput(err)
- self.assertOutput(out, 'CUSTOM = 1 ###\nDEBUG = True')
+ self.assertOutput(out, "CUSTOM = 1 ###\nDEBUG = True")
# Attributes from django.conf.UserSettingsHolder don't appear.
- self.assertNotInOutput(out, 'default_settings = ')
+ self.assertNotInOutput(out, "default_settings = ")
def test_dynamic_settings_configured(self):
# Custom default settings appear.
- out, err = self.run_manage(['diffsettings'], manage_py='configured_dynamic_settings_manage.py')
+ out, err = self.run_manage(
+ ["diffsettings"], manage_py="configured_dynamic_settings_manage.py"
+ )
self.assertNoOutput(err)
self.assertOutput(out, "FOO = 'bar' ###")
def test_all(self):
"""The all option also shows settings with the default value."""
- self.write_settings('settings_to_diff.py', sdict={'STATIC_URL': 'None'})
- args = ['diffsettings', '--settings=settings_to_diff', '--all']
+ self.write_settings("settings_to_diff.py", sdict={"STATIC_URL": "None"})
+ args = ["diffsettings", "--settings=settings_to_diff", "--all"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "### STATIC_URL = None")
@@ -2482,17 +2652,27 @@ class DiffSettings(AdminScriptTestCase):
The --default option specifies an alternate settings module for
comparison.
"""
- self.write_settings('settings_default.py', sdict={'FOO': '"foo"', 'BAR': '"bar1"'})
- self.write_settings('settings_to_diff.py', sdict={'FOO': '"foo"', 'BAR': '"bar2"'})
- out, err = self.run_manage(['diffsettings', '--settings=settings_to_diff', '--default=settings_default'])
+ self.write_settings(
+ "settings_default.py", sdict={"FOO": '"foo"', "BAR": '"bar1"'}
+ )
+ self.write_settings(
+ "settings_to_diff.py", sdict={"FOO": '"foo"', "BAR": '"bar2"'}
+ )
+ out, err = self.run_manage(
+ [
+ "diffsettings",
+ "--settings=settings_to_diff",
+ "--default=settings_default",
+ ]
+ )
self.assertNoOutput(err)
self.assertNotInOutput(out, "FOO")
self.assertOutput(out, "BAR = 'bar2'")
def test_unified(self):
"""--output=unified emits settings diff in unified mode."""
- self.write_settings('settings_to_diff.py', sdict={'FOO': '"bar"'})
- args = ['diffsettings', '--settings=settings_to_diff', '--output=unified']
+ self.write_settings("settings_to_diff.py", sdict={"FOO": '"bar"'})
+ args = ["diffsettings", "--settings=settings_to_diff", "--output=unified"]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, "+ FOO = 'bar'")
@@ -2505,8 +2685,13 @@ class DiffSettings(AdminScriptTestCase):
--output=unified --all emits settings diff in unified mode and includes
settings with the default value.
"""
- self.write_settings('settings_to_diff.py', sdict={'FOO': '"bar"'})
- args = ['diffsettings', '--settings=settings_to_diff', '--output=unified', '--all']
+ self.write_settings("settings_to_diff.py", sdict={"FOO": '"bar"'})
+ args = [
+ "diffsettings",
+ "--settings=settings_to_diff",
+ "--output=unified",
+ "--all",
+ ]
out, err = self.run_manage(args)
self.assertNoOutput(err)
self.assertOutput(out, " APPEND_SLASH = True")
@@ -2519,14 +2704,14 @@ class Dumpdata(AdminScriptTestCase):
def setUp(self):
super().setUp()
- self.write_settings('settings.py')
+ self.write_settings("settings.py")
def test_pks_parsing(self):
"""Regression for #20509
Test would raise an exception rather than printing an error message.
"""
- args = ['dumpdata', '--pks=1']
+ args = ["dumpdata", "--pks=1"]
out, err = self.run_manage(args)
self.assertOutput(err, "You can only use --pks option with one model")
self.assertNoOutput(out)
@@ -2536,23 +2721,26 @@ class MainModule(AdminScriptTestCase):
"""python -m django works like django-admin."""
def test_program_name_in_help(self):
- out, err = self.run_test(['-m', 'django', 'help'])
- self.assertOutput(out, "Type 'python -m django help <subcommand>' for help on a specific subcommand.")
+ out, err = self.run_test(["-m", "django", "help"])
+ self.assertOutput(
+ out,
+ "Type 'python -m django help <subcommand>' for help on a specific subcommand.",
+ )
class DjangoAdminSuggestions(AdminScriptTestCase):
def setUp(self):
super().setUp()
- self.write_settings('settings.py')
+ self.write_settings("settings.py")
def test_suggestions(self):
- args = ['rnserver', '--settings=test_project.settings']
+ args = ["rnserver", "--settings=test_project.settings"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
self.assertOutput(err, "Unknown command: 'rnserver'. Did you mean runserver?")
def test_no_suggestions(self):
- args = ['abcdef', '--settings=test_project.settings']
+ args = ["abcdef", "--settings=test_project.settings"]
out, err = self.run_django_admin(args)
self.assertNoOutput(out)
- self.assertNotInOutput(err, 'Did you mean')
+ self.assertNotInOutput(err, "Did you mean")
generated by cgit v1.3 (git 2.53.0) at 2026-05-02 00:35:40 +0000