Refs #33476 -- Refactored code to strictly match 88 characters line length.

1 files changed, 373 insertions, 94 deletions

diff --git a/tests/admin_scripts/tests.py b/tests/admin_scripts/tests.py
index 55880802c2..3d5902f768 100644
--- a/tests/admin_scripts/tests.py
+++ b/tests/admin_scripts/tests.py
@@ -201,21 +201,30 @@ class DjangoAdminNoSettings(AdminScriptTestCase):
     "A series of tests for django-admin when there is no settings.py file."
 
     def test_builtin_command(self):
-        "no settings: django-admin builtin commands fail with an error when no settings provided"
+        """
+        no settings: django-admin builtin commands fail with an error when no
+        settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
         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"
+        """
+        no settings: django-admin builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(out)
@@ -243,42 +252,60 @@ class DjangoAdminDefaultSettings(AdminScriptTestCase):
         self.write_settings("settings.py")
 
     def test_builtin_command(self):
-        "default: django-admin builtin commands fail with an error when no settings provided"
+        """
+        default: django-admin builtin commands fail with an error when no
+        settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
         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"
+        """
+        default: django-admin builtin commands succeed if settings are provided
+        as argument.
+        """
         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"
+        """
+        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")
         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"
+        """
+        default: django-admin builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         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"
+        """
+        default: django-admin can't execute user commands if it isn't provided
+        settings.
+        """
         args = ["noargs_command"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
@@ -286,14 +313,20 @@ class DjangoAdminDefaultSettings(AdminScriptTestCase):
         self.assertOutput(err, "Unknown command: 'noargs_command'")
 
     def test_custom_command_with_settings(self):
-        "default: django-admin can execute user commands if settings are provided as argument"
+        """
+        default: django-admin can execute user commands if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(err)
@@ -319,42 +352,60 @@ class DjangoAdminFullPathDefaultSettings(AdminScriptTestCase):
         )
 
     def test_builtin_command(self):
-        "fulldefault: django-admin builtin commands fail with an error when no settings provided"
+        """
+        fulldefault: django-admin builtin commands fail with an error when no
+        settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
         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"
+        """
+        fulldefault: django-admin builtin commands succeed if a settings file
+        is provided.
+        """
         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"
+        """
+        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")
         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"
+        """
+        fulldefault: django-admin builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         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"
+        """
+        fulldefault: django-admin can't execute user commands unless settings
+        are provided.
+        """
         args = ["noargs_command"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
@@ -362,14 +413,20 @@ class DjangoAdminFullPathDefaultSettings(AdminScriptTestCase):
         self.assertOutput(err, "Unknown command: 'noargs_command'")
 
     def test_custom_command_with_settings(self):
-        "fulldefault: django-admin can execute user commands if settings are provided as argument"
+        """
+        fulldefault: django-admin can execute user commands if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(err)
@@ -389,35 +446,50 @@ class DjangoAdminMinimalSettings(AdminScriptTestCase):
         )
 
     def test_builtin_command(self):
-        "minimal: django-admin builtin commands fail with an error when no settings provided"
+        """
+        minimal: django-admin builtin commands fail with an error when no
+        settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
         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"
+        """
+        minimal: django-admin builtin commands fail if settings are provided as
+        argument.
+        """
         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"
+        """
+        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")
         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"
+        """
+        minimal: django-admin builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(out)
@@ -432,14 +504,20 @@ class DjangoAdminMinimalSettings(AdminScriptTestCase):
         self.assertOutput(err, "Unknown command: 'noargs_command'")
 
     def test_custom_command_with_settings(self):
-        "minimal: django-admin can't execute user commands, even if settings are provided as argument"
+        """
+        minimal: django-admin can't execute user commands, even if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(out)
@@ -457,42 +535,60 @@ class DjangoAdminAlternateSettings(AdminScriptTestCase):
         self.write_settings("alternate_settings.py")
 
     def test_builtin_command(self):
-        "alternate: django-admin builtin commands fail with an error when no settings provided"
+        """
+        alternate: django-admin builtin commands fail with an error when no
+        settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
         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"
+        """
+        alternate: django-admin builtin commands succeed if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         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"
+        """
+        alternate: django-admin builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         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"
+        """
+        alternate: django-admin can't execute user commands unless settings
+        are provided.
+        """
         args = ["noargs_command"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
@@ -500,14 +596,20 @@ class DjangoAdminAlternateSettings(AdminScriptTestCase):
         self.assertOutput(err, "Unknown command: 'noargs_command'")
 
     def test_custom_command_with_settings(self):
-        "alternate: django-admin can execute user commands if settings are provided as argument"
+        """
+        alternate: django-admin can execute user commands if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(err)
@@ -530,41 +632,59 @@ class DjangoAdminMultipleSettings(AdminScriptTestCase):
         self.write_settings("alternate_settings.py")
 
     def test_builtin_command(self):
-        "alternate: django-admin builtin commands fail with an error when no settings provided"
+        """
+        alternate: django-admin builtin commands fail with an error when no
+        settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
         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"
+        """
+        alternate: django-admin builtin commands succeed if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         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"
+        """
+        alternate: django-admin builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         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"
+        """
+        alternate: django-admin can't execute user commands unless settings are
+        provided.
+        """
         args = ["noargs_command"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
@@ -572,14 +692,20 @@ class DjangoAdminMultipleSettings(AdminScriptTestCase):
         self.assertOutput(err, "Unknown command: 'noargs_command'")
 
     def test_custom_command_with_settings(self):
-        "alternate: django-admin can execute user commands if settings are provided as argument"
+        """
+        alternate: django-admin can execute user commands if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(err)
@@ -631,27 +757,39 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
             self.assertIn("name = 'こんにちは'", content)
 
     def test_builtin_command(self):
-        "directory: django-admin builtin commands fail with an error when no settings provided"
+        """
+        directory: django-admin builtin commands fail with an error when no
+        settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
         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"
+        """
+        directory: django-admin builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         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"
+        """
+        directory: django-admin can't execute user commands unless settings are
+        provided.
+        """
         args = ["noargs_command"]
         out, err = self.run_django_admin(args)
         self.assertNoOutput(out)
@@ -659,14 +797,20 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
         self.assertOutput(err, "Unknown command: 'noargs_command'")
 
     def test_builtin_with_settings(self):
-        "directory: django-admin builtin commands succeed if settings are provided as argument"
+        """
+        directory: django-admin builtin commands succeed if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(err)
@@ -696,7 +840,10 @@ class ManageNoSettings(AdminScriptTestCase):
     "A series of tests for manage.py when there is no settings.py file."
 
     def test_builtin_command(self):
-        "no settings: manage.py builtin commands fail with an error when no settings provided"
+        """
+        no settings: manage.py builtin commands fail with an error when no
+        settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_manage(args)
         self.assertNoOutput(out)
@@ -705,14 +852,20 @@ class ManageNoSettings(AdminScriptTestCase):
         )
 
     def test_builtin_with_bad_settings(self):
-        "no settings: manage.py builtin commands fail if settings file (from argument) doesn't exist"
+        """
+        no settings: manage.py builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(out)
@@ -729,56 +882,80 @@ class ManageDefaultSettings(AdminScriptTestCase):
         self.write_settings("settings.py")
 
     def test_builtin_command(self):
-        "default: manage.py builtin commands succeed when default settings are appropriate"
+        """
+        default: manage.py builtin commands succeed when default settings are
+        appropriate.
+        """
         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"
+        """
+        default: manage.py builtin commands succeed if settings are provided as
+        argument.
+        """
         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"
+        """
+        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")
         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"
+        """
+        default: manage.py builtin commands succeed if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         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"
+        """
+        default: manage.py can execute user commands when default settings are
+        appropriate.
+        """
         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"
+        """
+        default: manage.py can execute user commands when settings are provided
+        as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(err)
@@ -798,56 +975,80 @@ class ManageFullPathDefaultSettings(AdminScriptTestCase):
         )
 
     def test_builtin_command(self):
-        "fulldefault: manage.py builtin commands succeed when default settings are appropriate"
+        """
+        fulldefault: manage.py builtin commands succeed when default settings
+        are appropriate.
+        """
         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"
+        """
+        fulldefault: manage.py builtin commands succeed if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         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"
+        """
+        fulldefault: manage.py builtin commands succeed if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         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"
+        """
+        fulldefault: manage.py can execute user commands when default settings
+        are appropriate.
+        """
         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"
+        """
+        fulldefault: manage.py can execute user commands when settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(err)
@@ -866,7 +1067,10 @@ class ManageMinimalSettings(AdminScriptTestCase):
         )
 
     def test_builtin_command(self):
-        "minimal: manage.py builtin commands fail with an error when no settings provided"
+        """
+        minimal: manage.py builtin commands fail with an error when no settings
+        provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_manage(args)
         self.assertNoOutput(out)
@@ -880,21 +1084,30 @@ class ManageMinimalSettings(AdminScriptTestCase):
         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"
+        """
+        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")
         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"
+        """
+        minimal: manage.py builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(out)
@@ -908,14 +1121,20 @@ class ManageMinimalSettings(AdminScriptTestCase):
         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"
+        """
+        minimal: manage.py can't execute user commands, even if settings are
+        provided as argument.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(out)
@@ -932,7 +1151,10 @@ class ManageAlternateSettings(AdminScriptTestCase):
         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"
+        """
+        alternate: manage.py builtin commands fail with an error when no
+        default settings provided.
+        """
         args = ["check", "admin_scripts"]
         out, err = self.run_manage(args)
         self.assertNoOutput(out)
@@ -948,21 +1170,30 @@ class ManageAlternateSettings(AdminScriptTestCase):
         self.assertNoOutput(err)
 
     def test_builtin_with_environment(self):
-        "alternate: manage.py builtin commands work if settings are provided in the environment"
+        """
+        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")
         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"
+        """
+        alternate: manage.py builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(out)
@@ -978,7 +1209,10 @@ class ManageAlternateSettings(AdminScriptTestCase):
         )
 
     def test_custom_command_with_settings(self):
-        "alternate: manage.py can execute user commands if settings are provided as argument"
+        """
+        alternate: manage.py can execute user commands if settings are provided
+        as argument
+        """
         args = ["noargs_command", "--settings=alternate_settings"]
         out, err = self.run_manage(args)
         self.assertOutput(
@@ -990,7 +1224,10 @@ class ManageAlternateSettings(AdminScriptTestCase):
         self.assertNoOutput(err)
 
     def test_custom_command_with_environment(self):
-        "alternate: manage.py can execute user commands if settings are provided in environment"
+        """
+        alternate: manage.py can execute user commands if settings are provided
+        in environment.
+        """
         args = ["noargs_command"]
         out, err = self.run_manage(args, "alternate_settings")
         self.assertOutput(
@@ -1002,7 +1239,10 @@ class ManageAlternateSettings(AdminScriptTestCase):
         self.assertNoOutput(err)
 
     def test_custom_command_output_color(self):
-        "alternate: manage.py output syntax color can be deactivated with the `--no-color` option"
+        """
+        alternate: manage.py output syntax color can be deactivated with the
+        `--no-color` option.
+        """
         args = ["noargs_command", "--no-color", "--settings=alternate_settings"]
         out, err = self.run_manage(args)
         self.assertOutput(
@@ -1029,35 +1269,50 @@ class ManageMultipleSettings(AdminScriptTestCase):
         self.write_settings("alternate_settings.py")
 
     def test_builtin_command(self):
-        "multiple: manage.py builtin commands fail with an error when no settings provided"
+        """
+        multiple: manage.py builtin commands fail with an error when no
+        settings provided.
+        """
         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"
+        """
+        multiple: manage.py builtin commands succeed if settings are provided
+        as argument.
+        """
         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"
+        """
+        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")
         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"
+        """
+        multiple: manage.py builtin commands fail if settings file (from
+        argument) doesn't exist.
+        """
         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"
+        """
+        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")
         self.assertNoOutput(out)
@@ -1071,14 +1326,20 @@ class ManageMultipleSettings(AdminScriptTestCase):
         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"
+        """
+        multiple: manage.py can execute user commands if settings are provided
+        as argument.
+        """
         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"
+        """
+        multiple: manage.py can execute user commands if settings are provided
+        in environment.
+        """
         args = ["noargs_command"]
         out, err = self.run_manage(args, "alternate_settings")
         self.assertNoOutput(err)
@@ -2106,7 +2367,9 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
     ]
 
     def test_wrong_args(self):
-        "Make sure passing the wrong kinds of arguments outputs an error and prints usage"
+        """
+        Passing the wrong kinds of arguments outputs an error and prints usage.
+        """
         out, err = self.run_django_admin(["startproject"])
         self.assertNoOutput(out)
         self.assertOutput(err, "usage:")
@@ -2165,7 +2428,10 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
         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"
+        """
+        The startproject management command creates a project in a specific
+        directory.
+        """
         args = ["startproject", "testproject", "othertestproject"]
         testproject_dir = os.path.join(self.test_dir, "othertestproject")
         os.mkdir(testproject_dir)
@@ -2184,7 +2450,10 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
         )
 
     def test_custom_project_template(self):
-        "Make sure the startproject management command is able to use a different project template"
+        """
+        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")
@@ -2206,7 +2475,10 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
         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"
+        """
+        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")
@@ -2217,7 +2489,10 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
         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"
+        """
+        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",
@@ -2279,7 +2554,10 @@ class StartProject(LiveServerTestCase, AdminScriptTestCase):
             urls.urlpatterns = old_urlpatterns
 
     def test_project_template_tarball_url(self):
-        "Startproject management command handles project template tar/zip balls from non-canonical urls"
+        """ "
+        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
         )
@@ -2724,7 +3002,8 @@ class MainModule(AdminScriptTestCase):
         out, err = self.run_test(["-m", "django", "help"])
         self.assertOutput(
             out,
-            "Type 'python -m django help <subcommand>' for help on a specific subcommand.",
+            "Type 'python -m django help <subcommand>' for help on a specific "
+            "subcommand.",
         )