p15693087
/
django
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replaced sqlall in some bash_completion/admin_scripts tests. 

sqlall will be removed in Django 1.9, so now's a good time to remove
its usage where it's not important.
This commit is contained in:
Tim Graham 2014-12-26 18:23:00 -05:00
parent 0821b3d53c
commit 75bbcfa332
3 changed files with 90 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
django/core/management/__init__.py
View File

@ -85,7 +85,7 @@ def call_command(name, *args, **options):
Some examples: Some examples:
call_command('syncdb') call_command('syncdb')
call_command('shell', plain=True) call_command('shell', plain=True)
call_command('sqlall', 'myapp') call_command('sqlmigrate', 'myapp')
""" """
# Load the command object. # Load the command object.
try: try:
@ -240,7 +240,7 @@ class ManagementUtility(object):
options.extend((k, 1) for k in FASTCGI_OPTIONS) options.extend((k, 1) for k in FASTCGI_OPTIONS)
# special case: add the names of installed apps to options # special case: add the names of installed apps to options
elif cwords[0] in ('dumpdata', 'sql', 'sqlall', 'sqlclear', elif cwords[0] in ('dumpdata', 'sql', 'sqlall', 'sqlclear',
'sqlcustom', 'sqlindexes', 'sqlsequencereset', 'test'): 'sqlcustom', 'sqlindexes', 'sqlmigrate', 'sqlsequencereset', 'test'):
try: try:
app_configs = apps.get_app_configs() app_configs = apps.get_app_configs()
# Get the last part of the dotted path as the app name. # Get the last part of the dotted path as the app name.

174
tests/admin_scripts/tests.py
View File

@ -22,7 +22,6 @@ from django import conf, get_version
from django.conf import settings from django.conf import settings
from django.core.exceptions import ImproperlyConfigured from django.core.exceptions import ImproperlyConfigured
from django.core.management import BaseCommand, CommandError, call_command, color from django.core.management import BaseCommand, CommandError, call_command, color
from django.db import connection
from django.utils.encoding import force_text from django.utils.encoding import force_text
from django.utils._os import npath, upath from django.utils._os import npath, upath
from django.utils.six import StringIO from django.utils.six import StringIO
@ -36,6 +35,7 @@ if not os.path.exists(test_dir):
open(os.path.join(test_dir, '__init__.py'), 'w').close() open(os.path.join(test_dir, '__init__.py'), 'w').close()
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'
class AdminScriptTestCase(unittest.TestCase): class AdminScriptTestCase(unittest.TestCase):
@ -209,21 +209,21 @@ class DjangoAdminNoSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, 'settings are not configured') self.assertOutput(err, 'settings are not configured')
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'bad_settings') out, err = self.run_django_admin(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -241,35 +241,35 @@ class DjangoAdminDefaultSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, 'settings are not configured') self.assertOutput(err, 'settings are not configured')
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=test_project.settings', 'admin_scripts'] args = ['check', '--settings=test_project.settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'test_project.settings') out, err = self.run_django_admin(args, 'test_project.settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'bad_settings') out, err = self.run_django_admin(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -309,17 +309,17 @@ class DjangoAdminFullPathDefaultSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, 'settings are not configured') self.assertOutput(err, 'settings are not configured')
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=test_project.settings', 'admin_scripts'] args = ['check', '--settings=test_project.settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_sqlclear_builtin_with_settings(self): def test_sqlclear_builtin_with_settings(self):
"fulldefault: django-admin builtin commands succeed if a setting file is provided" "fulldefault: django-admin builtin commands succeed if a setting file is provided"
@ -330,21 +330,21 @@ class DjangoAdminFullPathDefaultSettings(AdminScriptTestCase):
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'test_project.settings') out, err = self.run_django_admin(args, 'test_project.settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'bad_settings') out, err = self.run_django_admin(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -383,35 +383,35 @@ class DjangoAdminMinimalSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, 'settings are not configured') self.assertOutput(err, 'settings are not configured')
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=test_project.settings', 'admin_scripts'] args = ['check', '--settings=test_project.settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.") self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'test_project.settings') out, err = self.run_django_admin(args, 'test_project.settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.") self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'bad_settings') out, err = self.run_django_admin(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -450,35 +450,35 @@ class DjangoAdminAlternateSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, 'settings are not configured') self.assertOutput(err, 'settings are not configured')
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=test_project.alternate_settings', 'admin_scripts'] args = ['check', '--settings=test_project.alternate_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'test_project.alternate_settings') out, err = self.run_django_admin(args, 'test_project.alternate_settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'bad_settings') out, err = self.run_django_admin(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -521,34 +521,34 @@ class DjangoAdminMultipleSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, 'settings are not configured') self.assertOutput(err, 'settings are not configured')
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=test_project.alternate_settings', 'admin_scripts'] args = ['check', '--settings=test_project.alternate_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'test_project.alternate_settings') out, err = self.run_django_admin(args, 'test_project.alternate_settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'bad_settings') out, err = self.run_django_admin(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -609,20 +609,20 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, 'settings are not configured') self.assertOutput(err, 'settings are not configured')
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'bad_settings') out, err = self.run_django_admin(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -636,17 +636,17 @@ class DjangoAdminSettingsDirectory(AdminScriptTestCase):
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=test_project.settings', 'admin_scripts'] args = ['check', '--settings=test_project.settings', 'admin_scripts']
out, err = self.run_django_admin(args) out, err = self.run_django_admin(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_django_admin(args, 'test_project.settings') out, err = self.run_django_admin(args, 'test_project.settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
########################################################################## ##########################################################################
@ -660,21 +660,21 @@ class ManageNoSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?(test_project\.)?settings'?", regex=True) self.assertOutput(err, "No module named '?(test_project\.)?settings'?", regex=True)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'bad_settings') out, err = self.run_manage(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -692,35 +692,35 @@ class ManageDefaultSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=test_project.settings', 'admin_scripts'] args = ['check', '--settings=test_project.settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'test_project.settings') out, err = self.run_manage(args, 'test_project.settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'bad_settings') out, err = self.run_manage(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -759,35 +759,35 @@ class ManageFullPathDefaultSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=test_project.settings', 'admin_scripts'] args = ['check', '--settings=test_project.settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'test_project.settings') out, err = self.run_manage(args, 'test_project.settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'bad_settings') out, err = self.run_manage(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -826,35 +826,35 @@ class ManageMinimalSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.") self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_settings(self): def test_builtin_with_settings(self):
"minimal: manage.py builtin commands fail if settings are provided as argument" "minimal: manage.py builtin commands fail if settings are provided as argument"
args = ['sqlall', '--settings=test_project.settings', 'admin_scripts'] args = ['check', '--settings=test_project.settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.") self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'test_project.settings') out, err = self.run_manage(args, 'test_project.settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.") self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'bad_settings') out, err = self.run_manage(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -893,39 +893,35 @@ class ManageAlternateSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?(test_project\.)?settings'?", regex=True) self.assertOutput(err, "No module named '?(test_project\.)?settings'?", regex=True)
def test_builtin_with_settings(self): def test_builtin_with_settings(self):
"alternate: manage.py builtin commands work with settings provided as argument" "alternate: manage.py builtin commands work with settings provided as argument"
args = ['sqlall', '--settings=alternate_settings', 'admin_scripts'] args = ['check', '--settings=alternate_settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
expected = ('create table %s' self.assertOutput(out, SYSTEM_CHECK_MSG)
% connection.ops.quote_name('admin_scripts_article'))
self.assertIn(expected.lower(), out.lower())
self.assertNoOutput(err) self.assertNoOutput(err)
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'alternate_settings') out, err = self.run_manage(args, 'alternate_settings')
expected = ('create table %s' self.assertOutput(out, SYSTEM_CHECK_MSG)
% connection.ops.quote_name('admin_scripts_article'))
self.assertIn(expected.lower(), out.lower())
self.assertNoOutput(err) self.assertNoOutput(err)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'bad_settings') out, err = self.run_manage(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -975,35 +971,35 @@ class ManageMultipleSettings(AdminScriptTestCase):
def test_builtin_command(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No installed app with label 'admin_scripts'.") self.assertOutput(err, "No installed app with label 'admin_scripts'.")
def test_builtin_with_settings(self): 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 = ['sqlall', '--settings=alternate_settings', 'admin_scripts'] args = ['check', '--settings=alternate_settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'alternate_settings') out, err = self.run_manage(args, 'alternate_settings')
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, 'CREATE TABLE') self.assertOutput(out, SYSTEM_CHECK_MSG)
def test_builtin_with_bad_settings(self): 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 = ['sqlall', '--settings=bad_settings', 'admin_scripts'] args = ['check', '--settings=bad_settings', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
def test_builtin_with_bad_environment(self): 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 = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args, 'bad_settings') out, err = self.run_manage(args, 'bad_settings')
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named '?bad_settings'?", regex=True) self.assertOutput(err, "No module named '?bad_settings'?", regex=True)
@ -1050,7 +1046,7 @@ class ManageSettingsWithSettingsErrors(AdminScriptTestCase):
when settings with import errors is provided (#14130). when settings with import errors is provided (#14130).
""" """
self.write_settings_with_import_error('settings.py') self.write_settings_with_import_error('settings.py')
args = ['sqlall', 'admin_scripts'] args = ['check', 'admin_scripts']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(out) self.assertNoOutput(out)
self.assertOutput(err, "No module named") self.assertOutput(err, "No module named")
@ -1386,10 +1382,10 @@ class CommandTypes(AdminScriptTestCase):
def test_specific_help(self): def test_specific_help(self):
"--help can be used on a specific command" "--help can be used on a specific command"
args = ['sqlall', '--help'] args = ['check', '--help']
out, err = self.run_manage(args) out, err = self.run_manage(args)
self.assertNoOutput(err) self.assertNoOutput(err)
self.assertOutput(out, "Prints the CREATE TABLE, custom SQL and CREATE INDEX SQL statements for the\ngiven model module name(s).") self.assertOutput(out, "Checks the entire Django project for potential problems.")
self.assertEqual(out.count('optional arguments'), 1) self.assertEqual(out.count('optional arguments'), 1)
def test_color_style(self): def test_color_style(self):

6
tests/bash_completion/tests.py
View File

@ -58,13 +58,13 @@ class BashCompletionTests(unittest.TestCase):
def test_django_admin_py(self): def test_django_admin_py(self):
"django_admin.py will autocomplete option flags" "django_admin.py will autocomplete option flags"
self._user_input('django-admin sqlall --verb') self._user_input('django-admin sqlmigrate --verb')
output = self._run_autocomplete() output = self._run_autocomplete()
self.assertEqual(output, ['--verbosity=']) self.assertEqual(output, ['--verbosity='])
def test_manage_py(self): def test_manage_py(self):
"manage.py will autocomplete option flags" "manage.py will autocomplete option flags"
self._user_input('manage.py sqlall --verb') self._user_input('manage.py sqlmigrate --verb')
output = self._run_autocomplete() output = self._run_autocomplete()
self.assertEqual(output, ['--verbosity=']) self.assertEqual(output, ['--verbosity='])
@ -101,7 +101,7 @@ class BashCompletionTests(unittest.TestCase):
def test_app_completion(self): def test_app_completion(self):
"Application names will be autocompleted for an AppCommand" "Application names will be autocompleted for an AppCommand"
self._user_input('django-admin sqlall a') self._user_input('django-admin sqlmigrate a')
output = self._run_autocomplete() output = self._run_autocomplete()
a_labels = sorted(app_config.label a_labels = sorted(app_config.label
for app_config in apps.get_app_configs() for app_config in apps.get_app_configs()