diff options
Diffstat (limited to 'tests/admin_scripts/tests.py')
| -rw-r--r-- | tests/admin_scripts/tests.py | 1462 |
1 files changed, 825 insertions, 637 deletions
diff --git a/tests/admin_scripts/tests.py b/tests/admin_scripts/tests.py index 9467bf32c3..b879dfd6b1 100644 --- a/tests/admin_scripts/tests.py +++ b/tests/admin_scripts/tests.py @@ -17,25 +17,23 @@ 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 -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): @@ -44,27 +42,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): @@ -74,7 +74,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) @@ -88,8 +92,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)) @@ -110,60 +114,74 @@ 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], - stdout=subprocess.PIPE, stderr=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, cwd=self.test_dir, - env=test_environ, universal_newlines=True, + env=test_environ, + universal_newlines=True, ) return p.stdout, p.stderr def run_django_admin(self, args, settings_file=None): - return self.run_test(['-m', 'django', *args], settings_file) + return self.run_test(["-m", "django", *args], settings_file) 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 @@ -177,22 +195,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) @@ -201,8 +219,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) @@ -212,48 +230,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") @@ -261,15 +280,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") @@ -279,49 +298,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") @@ -329,15 +356,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") @@ -347,48 +374,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") @@ -396,15 +426,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'") @@ -414,48 +444,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") @@ -463,15 +494,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") @@ -483,48 +514,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") @@ -532,15 +566,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") @@ -553,65 +587,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") @@ -619,15 +653,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) @@ -638,13 +672,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): @@ -652,22 +690,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) @@ -676,63 +716,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") @@ -741,63 +782,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") @@ -806,63 +851,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'") @@ -871,85 +919,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) @@ -960,64 +1013,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") @@ -1027,19 +1083,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") @@ -1050,15 +1111,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'") @@ -1069,13 +1130,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) @@ -1083,101 +1144,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" @@ -1206,15 +1267,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 @@ -1245,101 +1306,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) @@ -1348,8 +1412,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=[ @@ -1360,56 +1424,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, @@ -1438,113 +1517,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() @@ -1552,13 +1636,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" @@ -1566,33 +1650,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." @@ -1640,37 +1724,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") @@ -1684,7 +1768,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) @@ -1704,7 +1789,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 @@ -1712,7 +1797,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) @@ -1722,13 +1807,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") @@ -1736,7 +1822,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): """ @@ -1746,32 +1832,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=") @@ -1779,18 +1865,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=") @@ -1798,82 +1884,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( @@ -1881,30 +1969,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): @@ -1916,35 +2011,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'"): @@ -1956,7 +2070,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, ) @@ -1966,35 +2080,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) @@ -2012,16 +2126,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)) @@ -2030,8 +2144,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) @@ -2039,19 +2153,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) @@ -2059,106 +2173,131 @@ 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_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) @@ -2167,18 +2306,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) @@ -2188,12 +2332,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): @@ -2201,35 +2355,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): @@ -2237,25 +2398,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(), ) @@ -2264,29 +2425,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( @@ -2298,19 +2459,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)) @@ -2319,8 +2479,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) @@ -2328,55 +2488,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, @@ -2389,31 +2555,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") @@ -2423,17 +2593,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'") @@ -2446,8 +2626,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") @@ -2460,14 +2645,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) @@ -2477,23 +2662,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") |