From 9376d4ed5bd175eff87788ccf11e761fdef42b8b Mon Sep 17 00:00:00 2001
From: Russell Keith-Magee <russell@keith-magee.com>
Date: Thu, 10 Jul 2008 12:12:41 +0000
Subject: [PATCH] Refs #5943, #6107 -- Added framework and tests to check for
 the correct operation of django-admin and manage.py. Thanks for Simon
 Willison and Karen Tracey for their contributions and assistance testing this
 patch.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@7876 bcc190cf-cafb-0310-a4f2-bffc1f526a37
---
 .../regressiontests/admin_scripts/__init__.py |   0
 .../admin_scripts/management/__init__.py      |   0
 .../management/commands/__init__.py           |   0
 .../management/commands/app_command.py        |  10 +
 .../management/commands/base_command.py       |   9 +
 .../management/commands/label_command.py      |   9 +
 .../management/commands/noargs_command.py     |   9 +
 tests/regressiontests/admin_scripts/models.py |  12 +
 tests/regressiontests/admin_scripts/tests.py  | 813 ++++++++++++++++++
 9 files changed, 862 insertions(+)
 create mode 100644 tests/regressiontests/admin_scripts/__init__.py
 create mode 100644 tests/regressiontests/admin_scripts/management/__init__.py
 create mode 100644 tests/regressiontests/admin_scripts/management/commands/__init__.py
 create mode 100644 tests/regressiontests/admin_scripts/management/commands/app_command.py
 create mode 100644 tests/regressiontests/admin_scripts/management/commands/base_command.py
 create mode 100644 tests/regressiontests/admin_scripts/management/commands/label_command.py
 create mode 100644 tests/regressiontests/admin_scripts/management/commands/noargs_command.py
 create mode 100644 tests/regressiontests/admin_scripts/models.py
 create mode 100644 tests/regressiontests/admin_scripts/tests.py

diff --git a/tests/regressiontests/admin_scripts/__init__.py b/tests/regressiontests/admin_scripts/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/regressiontests/admin_scripts/management/__init__.py b/tests/regressiontests/admin_scripts/management/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/regressiontests/admin_scripts/management/commands/__init__.py b/tests/regressiontests/admin_scripts/management/commands/__init__.py
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/tests/regressiontests/admin_scripts/management/commands/app_command.py b/tests/regressiontests/admin_scripts/management/commands/app_command.py
new file mode 100644
index 0000000000..f72e912ac0
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/management/commands/app_command.py
@@ -0,0 +1,10 @@
+from django.core.management.base import AppCommand
+
+class Command(AppCommand):
+    help = 'Test Application-based commands'
+    requires_model_validation = False
+    args = '[appname ...]'
+
+    def handle_app(self, app, **options):
+        print 'EXECUTE:AppCommand app=%s, options=%s' % (app, sorted(options.items()))
+        
diff --git a/tests/regressiontests/admin_scripts/management/commands/base_command.py b/tests/regressiontests/admin_scripts/management/commands/base_command.py
new file mode 100644
index 0000000000..0187a23b29
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/management/commands/base_command.py
@@ -0,0 +1,9 @@
+from django.core.management.base import BaseCommand
+
+class Command(BaseCommand):
+    help = 'Test basic commands'
+    requires_model_validation = False
+    args = '[labels ...]'
+
+    def handle(self, *labels, **options):
+        print 'EXECUTE:BaseCommand labels=%s, options=%s' % (labels, sorted(options.items()))
diff --git a/tests/regressiontests/admin_scripts/management/commands/label_command.py b/tests/regressiontests/admin_scripts/management/commands/label_command.py
new file mode 100644
index 0000000000..2b735c8e60
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/management/commands/label_command.py
@@ -0,0 +1,9 @@
+from django.core.management.base import LabelCommand
+
+class Command(LabelCommand):
+    help = "Test Label-based commands"
+    requires_model_validation = False
+    args = '<label>'
+
+    def handle_label(self, label, **options):
+        print 'EXECUTE:LabelCommand label=%s, options=%s' % (label, sorted(options.items()))
diff --git a/tests/regressiontests/admin_scripts/management/commands/noargs_command.py b/tests/regressiontests/admin_scripts/management/commands/noargs_command.py
new file mode 100644
index 0000000000..683eb7a62c
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/management/commands/noargs_command.py
@@ -0,0 +1,9 @@
+from django.core.management.base import NoArgsCommand
+
+class Command(NoArgsCommand):
+    help = "Test No-args commands"
+    requires_model_validation = False
+
+
+    def handle_noargs(self, **options):
+        print 'EXECUTE:NoArgsCommand options=%s' % sorted(options.items())
diff --git a/tests/regressiontests/admin_scripts/models.py b/tests/regressiontests/admin_scripts/models.py
new file mode 100644
index 0000000000..96a40d22b7
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/models.py
@@ -0,0 +1,12 @@
+from django.db import models
+
+class Article(models.Model):
+    headline = models.CharField(max_length=100, default='Default headline')
+    pub_date = models.DateTimeField()
+
+    def __unicode__(self):
+        return self.headline
+
+    class Meta:
+        ordering = ('-pub_date', 'headline')
+        
\ No newline at end of file
diff --git a/tests/regressiontests/admin_scripts/tests.py b/tests/regressiontests/admin_scripts/tests.py
new file mode 100644
index 0000000000..6a56f9114e
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/tests.py
@@ -0,0 +1,813 @@
+"""
+A series of tests to establish that the command-line managment tools work as 
+advertised - especially with regards to the handling of the DJANGO_SETTINGS_MODULE
+and default settings.py files.
+"""
+import os
+import unittest
+import shutil
+
+from django import conf, bin
+from django.conf import settings
+
+class AdminScriptTestCase(unittest.TestCase):
+    def write_settings(self, filename, apps=None):
+        test_dir = os.path.dirname(os.path.dirname(__file__)) 
+        settings_file = open(os.path.join(test_dir,filename), 'w')
+        settings_file.write('# Settings file automatically generated by regressiontests.admin_scripts test case\n')
+        exports = [
+            'DATABASE_ENGINE',
+            'DATABASE_NAME',
+            'DATABASE_USER',
+            'DATABASE_PASSWORD',
+            'DATABASE_HOST',
+            'DATABASE_PORT',
+            'ROOT_URLCONF'
+        ]
+        for s in exports:
+            if hasattr(settings,s):
+                settings_file.write("%s = '%s'\n" % (s, str(getattr(settings,s))))
+                
+        if apps is None:
+            apps = ['django.contrib.auth', 'django.contrib.contenttypes', 'regressiontests.admin_scripts']
+
+        if apps:
+            settings_file.write("INSTALLED_APPS = %s\n" % apps)
+        
+        settings_file.close()
+        
+    def remove_settings(self, filename):
+        test_dir = os.path.dirname(os.path.dirname(__file__)) 
+        os.remove(os.path.join(test_dir, filename))
+        # Also try to remove the pyc file; if it exists, it could
+        # mess up later tests that depend upon the .py file not existing
+        try:
+            os.remove(os.path.join(test_dir, filename + 'c'))
+        except OSError:
+            pass
+            
+    def run_test(self, script, args, settings_file=None, apps=None):
+        test_dir = os.path.dirname(os.path.dirname(__file__))
+        project_dir = os.path.dirname(test_dir)
+        base_dir = os.path.dirname(project_dir)
+        
+        # Build the command line
+        cmd = 'python "%s"' % script
+        cmd += ''.join(' %s' % arg for arg in args)
+        
+        # Remember the old environment
+        old_django_settings_module = os.environ.get('DJANGO_SETTINGS_MODULE', None)
+        old_python_path = os.environ.get('PYTHONPATH', None)
+        
+        # Set the test environment
+        if settings_file:
+            os.environ['DJANGO_SETTINGS_MODULE'] = settings_file
+        elif 'DJANGO_SETTINGS_MODULE' in os.environ:
+            del os.environ['DJANGO_SETTINGS_MODULE']
+        
+        os.environ['PYTHONPATH'] = os.pathsep.join([project_dir,base_dir])
+        
+        # Move to the test directory and run
+        os.chdir(test_dir)
+        stdin, stdout, stderr = os.popen3(cmd)
+        out, err = stdout.read(), stderr.read()
+        
+        # Restore the old environment
+        if old_django_settings_module:
+            os.environ['DJANGO_SETTINGS_MODULE'] = old_django_settings_module
+        if old_python_path:
+            os.environ['PYTHONPATH'] = old_python_path
+        
+        return out, err
+        
+    def run_django_admin(self, args, settings_file=None):
+        bin_dir = os.path.dirname(bin.__file__)
+        return self.run_test(os.path.join(bin_dir,'django-admin.py'), args, settings_file)
+        
+    def run_manage(self, args, settings_file=None):
+        conf_dir = os.path.dirname(conf.__file__)
+        template_manage_py = os.path.join(conf_dir, 'project_template', 'manage.py')
+
+        test_dir = os.path.dirname(os.path.dirname(__file__)) 
+        test_manage_py = os.path.join(test_dir, 'manage.py')
+        shutil.copyfile(template_manage_py, test_manage_py)
+
+        stdout, stderr = self.run_test('./manage.py', args, settings_file)
+
+        # Cleanup - remove the generated manage.py script
+        os.remove(test_manage_py)
+        
+        return stdout, stderr
+
+    def assertNoOutput(self, stream):
+        "Utility assertion: assert that the given stream is empty"
+        self.assertEquals(len(stream), 0, "Stream should be empty: actually contains '%s'" % stream)
+    def assertOutput(self, stream, msg):
+        "Utility assertion: assert that the given message exists in the output"
+        self.assertTrue(msg in stream, "'%s' does not match actual output text '%s'" % (msg, stream))
+
+##########################################################################
+# DJANGO ADMIN TESTS
+# This first series of test classes checks the environment processing
+# of the django-admin.py script
+##########################################################################
+
+
+class DjangoAdminNoSettings(AdminScriptTestCase):
+    "A series of tests for django-admin.py when there is no settings.py file."
+                
+    def test_builtin_command(self):
+        "no settings: django-admin builtin commands fail with an import error when no settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'environment variable DJANGO_SETTINGS_MODULE is undefined')
+                
+    def test_builtin_with_bad_settings(self):
+        "no settings: django-admin builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=regressiontests.bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+    def test_builtin_with_bad_environment(self):
+        "no settings: django-admin builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+
+class DjangoAdminDefaultSettings(AdminScriptTestCase):
+    """A series of tests for django-admin.py when using a settings.py file that
+    contains the test application.
+    """
+    def setUp(self):
+        self.write_settings('settings.py')
+        
+    def tearDown(self):
+        self.remove_settings('settings.py')
+            
+    def test_builtin_command(self):
+        "default: django-admin builtin commands fail with an import error when no settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'environment variable DJANGO_SETTINGS_MODULE is undefined')
+        
+    def test_builtin_with_settings(self):
+        "default: django-admin builtin commands succeed if settings are provided as argument"
+        args = ['sqlall','--settings=regressiontests.settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_environment(self):
+        "default: django-admin builtin commands succeed if settings are provided in the environment"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.settings')
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_bad_settings(self):
+        "default: django-admin builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=regressiontests.bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+    def test_builtin_with_bad_environment(self):
+        "default: django-admin builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+    def test_custom_command(self):
+        "default: django-admin can't execute user commands"
+        args = ['noargs_command']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+            
+    def test_custom_command_with_settings(self):
+        "default: django-admin can't execute user commands, even if settings are provided as argument"
+        args = ['noargs_command', '--settings=regressiontests.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):
+        "default: django-admin can't execute user commands, even if settings are provided in environment"
+        args = ['noargs_command']
+        out, err = self.run_django_admin(args,'regressiontests.settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+
+class DjangoAdminMinimalSettings(AdminScriptTestCase):
+    """A series of tests for django-admin.py when using a settings.py file that
+    doesn't contain the test application.
+    """
+    def setUp(self):
+        self.write_settings('settings.py', apps=['django.contrib.auth','django.contrib.contenttypes'])
+        
+    def tearDown(self):
+        self.remove_settings('settings.py')
+        
+    def test_builtin_command(self):
+        "minimal: django-admin builtin commands fail with an import error when no settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'environment variable DJANGO_SETTINGS_MODULE is undefined')
+        
+    def test_builtin_with_settings(self):
+        "minimal: django-admin builtin commands fail if settings are provided as argument"
+        args = ['sqlall','--settings=regressiontests.settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'App with label admin_scripts could not be found')
+
+    def test_builtin_with_environment(self):
+        "minimal: django-admin builtin commands fail if settings are provided in the environment"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'App with label admin_scripts could not be found')
+
+    def test_builtin_with_bad_settings(self):
+        "minimal: django-admin builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=regressiontests.bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+    def test_builtin_with_bad_environment(self):
+        "minimal: django-admin builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+            
+    def test_custom_command(self):
+        "minimal: django-admin can't execute user commands"
+        args = ['noargs_command']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        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"
+        args = ['noargs_command', '--settings=regressiontests.settings']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+            
+    def test_custom_command_with_environment(self):
+        "minimal: django-admin can't execute user commands, even if settings are provided in environment"
+        args = ['noargs_command']
+        out, err = self.run_django_admin(args,'regressiontests.settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+
+class DjangoAdminAlternateSettings(AdminScriptTestCase):
+    """A series of tests for django-admin.py when using a settings file
+    with a name other than 'settings.py'.
+    """
+    def setUp(self):
+        self.write_settings('alternate_settings.py')
+        
+    def tearDown(self):
+        self.remove_settings('alternate_settings.py')
+            
+    def test_builtin_command(self):
+        "alternate: django-admin builtin commands fail with an import error when no settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'environment variable DJANGO_SETTINGS_MODULE is undefined')
+
+    def test_builtin_with_settings(self):
+        "alternate: django-admin builtin commands succeed if settings are provided as argument"
+        args = ['sqlall','--settings=regressiontests.alternate_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_environment(self):
+        "alternate: django-admin builtin commands succeed if settings are provided in the environment"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.alternate_settings')
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_bad_settings(self):
+        "alternate: django-admin builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=regressiontests.bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+    def test_builtin_with_bad_environment(self):
+        "alternate: django-admin builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+    def test_custom_command(self):
+        "alternate: django-admin can't execute user commands"
+        args = ['noargs_command']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+
+    def test_custom_command_with_settings(self):
+        "alternate: django-admin can't execute user commands, even if settings are provided as argument"
+        args = ['noargs_command', '--settings=regressiontests.alternate_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):
+        "alternate: django-admin can't execute user commands, even if settings are provided in environment"
+        args = ['noargs_command']
+        out, err = self.run_django_admin(args,'regressiontests.alternate_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+
+
+class DjangoAdminMultipleSettings(AdminScriptTestCase):
+    """A series of tests for django-admin.py when multiple settings files
+    (including the default 'settings.py') are available. The default settings
+    file is insufficient for performing the operations described, so the 
+    alternate settings must be used by the running script.
+    """
+    def setUp(self):
+        self.write_settings('settings.py', apps=['django.contrib.auth','django.contrib.contenttypes'])
+        self.write_settings('alternate_settings.py')
+        
+    def tearDown(self):
+        self.remove_settings('settings.py')
+        self.remove_settings('alternate_settings.py')
+            
+    def test_builtin_command(self):
+        "alternate: django-admin builtin commands fail with an import error when no settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'environment variable DJANGO_SETTINGS_MODULE is undefined')
+
+    def test_builtin_with_settings(self):
+        "alternate: django-admin builtin commands succeed if settings are provided as argument"
+        args = ['sqlall','--settings=regressiontests.alternate_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_environment(self):
+        "alternate: django-admin builtin commands succeed if settings are provided in the environment"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.alternate_settings')
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_bad_settings(self):
+        "alternate: django-admin builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=regressiontests.bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+    def test_builtin_with_bad_environment(self):
+        "alternate: django-admin builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_django_admin(args,'regressiontests.bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'regressiontests.bad_settings'")
+
+    def test_custom_command(self):
+        "alternate: django-admin can't execute user commands"
+        args = ['noargs_command']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+
+    def test_custom_command_with_settings(self):
+        "alternate: django-admin can't execute user commands, even if settings are provided as argument"
+        args = ['noargs_command', '--settings=regressiontests.alternate_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):
+        "alternate: django-admin can't execute user commands, even if settings are provided in environment"
+        args = ['noargs_command']
+        out, err = self.run_django_admin(args,'regressiontests.alternate_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+        
+##########################################################################
+# MANAGE.PY TESTS
+# This next series of test classes checks the environment processing
+# of the generated manage.py script
+##########################################################################
+
+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 import error when no settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+                
+    def test_builtin_with_bad_settings(self):
+        "no settings: manage.py builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=bad_settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+    def test_builtin_with_bad_environment(self):
+        "no settings: manage.py builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+
+class ManageDefaultSettings(AdminScriptTestCase):
+    """A series of tests for manage.py when using a settings.py file that
+    contains the test application.
+    """
+    def setUp(self):
+        self.write_settings('settings.py')
+        
+    def tearDown(self):
+        self.remove_settings('settings.py')
+            
+    def test_builtin_command(self):
+        "default: manage.py builtin commands succeed when default settings are appropriate"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+        
+    def test_builtin_with_settings(self):
+        "default: manage.py builtin commands succeed if settings are provided as argument"
+        args = ['sqlall','--settings=settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_environment(self):
+        "default: manage.py builtin commands succeed if settings are provided in the environment"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'settings')
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_bad_settings(self):
+        "default: manage.py builtin commands succeed if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=bad_settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'bad_settings'")
+
+    def test_builtin_with_bad_environment(self):
+        "default: manage.py builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'bad_settings')
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_custom_command(self):
+        "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:NoArgsCommand")
+            
+    def test_custom_command_with_settings(self):
+        "default: manage.py can execute user commands when settings are provided as argument"
+        args = ['noargs_command', '--settings=settings']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:NoArgsCommand")
+            
+    def test_custom_command_with_environment(self):
+        "default: manage.py can execute user commands when settings are provided in environment"
+        args = ['noargs_command']
+        out, err = self.run_manage(args,'settings')
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:NoArgsCommand")
+
+class ManageMinimalSettings(AdminScriptTestCase):
+    """A series of tests for manage.py when using a settings.py file that
+    doesn't contain the test application.
+    """
+    def setUp(self):
+        self.write_settings('settings.py', apps=['django.contrib.auth','django.contrib.contenttypes'])
+        
+    def tearDown(self):
+        self.remove_settings('settings.py')
+        
+    def test_builtin_command(self):
+        "minimal: manage.py builtin commands fail with an import error when no settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'App with label admin_scripts could not be found')
+        
+    def test_builtin_with_settings(self):
+        "minimal: manage.py builtin commands fail if settings are provided as argument"
+        args = ['sqlall','--settings=settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'App with label admin_scripts could not be found')
+
+    def test_builtin_with_environment(self):
+        "minimal: manage.py builtin commands fail if settings are provided in the environment"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'App with label admin_scripts could not be found')
+
+    def test_builtin_with_bad_settings(self):
+        "minimal: manage.py builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=bad_settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'bad_settings'")
+
+    def test_builtin_with_bad_environment(self):
+        "minimal: manage.py builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'App with label admin_scripts could not be found')
+            
+    def test_custom_command(self):
+        "minimal: manage.py can't execute user commands without appropriate settings"
+        args = ['noargs_command']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+            
+    def test_custom_command_with_settings(self):
+        "minimal: manage.py can't execute user commands, even if settings are provided as argument"
+        args = ['noargs_command', '--settings=settings']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+            
+    def test_custom_command_with_environment(self):
+        "minimal: manage.py can't execute user commands, even if settings are provided in environment"
+        args = ['noargs_command']
+        out, err = self.run_manage(args,'settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+
+class ManageAlternateSettings(AdminScriptTestCase):
+    """A series of tests for manage.py when using a settings file
+    with a name other than 'settings.py'.
+    """
+    def setUp(self):
+        self.write_settings('alternate_settings.py')
+        
+    def tearDown(self):
+        self.remove_settings('alternate_settings.py')
+            
+    def test_builtin_command(self):
+        "alternate: manage.py builtin commands fail with an import error when no default settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+    def test_builtin_with_settings(self):
+        "alternate: manage.py builtin commands fail if settings are provided as argument but no defaults"
+        args = ['sqlall','--settings=alternate_settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+    def test_builtin_with_environment(self):
+        "alternate: manage.py builtin commands fail if settings are provided in the environment but no defaults"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'alternate_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+    def test_builtin_with_bad_settings(self):
+        "alternate: manage.py builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=bad_settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+    def test_builtin_with_bad_environment(self):
+        "alternate: manage.py builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+    def test_custom_command(self):
+        "alternate: manage.py can't execute user commands"
+        args = ['noargs_command']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+    def test_custom_command_with_settings(self):
+        "alternate: manage.py can't execute user commands, even if settings are provided as argument"
+        args = ['noargs_command', '--settings=alternate_settings']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+    def test_custom_command_with_environment(self):
+        "alternate: manage.py can't execute user commands, even if settings are provided in environment"
+        args = ['noargs_command']
+        out, err = self.run_manage(args,'alternate_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Can't find the file 'settings.py' in the directory containing './manage.py'")
+
+
+class ManageMultipleSettings(AdminScriptTestCase):
+    """A series of tests for manage.py when multiple settings files
+    (including the default 'settings.py') are available. The default settings
+    file is insufficient for performing the operations described, so the 
+    alternate settings must be used by the running script.
+    """
+    def setUp(self):
+        self.write_settings('settings.py', apps=['django.contrib.auth','django.contrib.contenttypes'])
+        self.write_settings('alternate_settings.py')
+        
+    def tearDown(self):
+        self.remove_settings('settings.py')
+        self.remove_settings('alternate_settings.py')
+            
+    def test_builtin_command(self):
+        "multiple: manage.py builtin commands fail with an import error when no settings provided"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'App with label admin_scripts could not be found.')
+
+    def test_builtin_with_settings(self):
+        "multiple: manage.py builtin commands succeed if settings are provided as argument"
+        args = ['sqlall','--settings=alternate_settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, 'CREATE TABLE')
+
+    def test_builtin_with_environment(self):
+        "multiple: manage.py builtin commands fail if settings are provided in the environment"
+        # FIXME: This doesn't seem to be the correct output.
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'alternate_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, 'App with label admin_scripts could not be found.')
+
+    def test_builtin_with_bad_settings(self):
+        "multiple: manage.py builtin commands fail if settings file (from argument) doesn't exist"
+        args = ['sqlall','--settings=bad_settings', 'admin_scripts']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings 'bad_settings'")
+
+    def test_builtin_with_bad_environment(self):
+        "multiple: manage.py builtin commands fail if settings file (from environment) doesn't exist"
+        args = ['sqlall','admin_scripts']
+        out, err = self.run_manage(args,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "App with label admin_scripts could not be found")
+
+    def test_custom_command(self):
+        "multiple: manage.py can't execute user commands using default settings"
+        args = ['noargs_command']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+
+    def test_custom_command_with_settings(self):
+        "multiple: manage.py can execute user commands if settings are provided as argument"
+        args = ['noargs_command', '--settings=alternate_settings']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:NoArgsCommand")
+
+    def test_custom_command_with_environment(self):
+        "multiple: manage.py can execute user commands if settings are provided in environment"
+        args = ['noargs_command']
+        out, err = self.run_manage(args,'alternate_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Unknown command: 'noargs_command'")
+
+##########################################################################
+# COMMAND PROCESSING TESTS
+# Check that user-space commands are correctly handled - in particular,
+# that arguments to the commands are correctly parsed and processed.
+##########################################################################
+
+class CommandTypes(AdminScriptTestCase):
+    "Tests for the various types of base command types that can be defined."
+    def setUp(self):
+        self.write_settings('settings.py')
+        
+    def tearDown(self):
+        self.remove_settings('settings.py')
+    
+    def test_base_command(self):
+        "User BaseCommands can execute when a label is provided"
+        args = ['base_command','testlabel']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel',), options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+        
+    def test_base_command_no_label(self):
+        "User BaseCommands can execute when no labels are provided"
+        args = ['base_command']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=(), options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+
+    def test_base_command_multiple_label(self):
+        "User BaseCommands can execute when no labels are provided"
+        args = ['base_command','testlabel','anotherlabel']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel', 'anotherlabel'), options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+                
+    def test_noargs(self):
+        "NoArg Commands can be executed"
+        args = ['noargs_command']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:NoArgsCommand options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+
+    def test_noargs_with_args(self):
+        "NoArg Commands raise an error if an argument is provided"
+        args = ['noargs_command','argument']
+        out, err = self.run_manage(args)
+        self.assertOutput(err, "Error: Command doesn't accept any arguments")
+        
+    def test_app_command(self):
+        "User AppCommands can execute when a single app name is provided"
+        args = ['app_command', 'auth']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:AppCommand app=<module 'django.contrib.auth.models'")
+        self.assertOutput(out, os.sep.join(['django','contrib','auth','models.pyc']) + "'>, options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+
+    def test_app_command_no_apps(self):
+        "User AppCommands raise an error when no app name is provided"
+        args = ['app_command']
+        out, err = self.run_manage(args)
+        self.assertOutput(err, 'Error: Enter at least one appname.')
+
+    def test_app_command_multiple_apps(self):
+        "User AppCommands raise an error when multiple app names are provided"
+        args = ['app_command','auth','contenttypes']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:AppCommand app=<module 'django.contrib.auth.models'")
+        self.assertOutput(out, os.sep.join(['django','contrib','auth','models.pyc']) + "'>, options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+        self.assertOutput(out, "EXECUTE:AppCommand app=<module 'django.contrib.contenttypes.models'")
+        self.assertOutput(out, os.sep.join(['django','contrib','contenttypes','models.pyc']) + "'>, options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+
+    def test_app_command_invalid_appname(self):
+        "User AppCommands can execute when a single app name is provided"
+        args = ['app_command', 'NOT_AN_APP']
+        out, err = self.run_manage(args)
+        self.assertOutput(err, "App with label NOT_AN_APP could not be found")
+            
+    def test_app_command_some_invalid_appnames(self):
+        "User AppCommands can execute when some of the provided app names are invalid"
+        args = ['app_command', 'auth', 'NOT_AN_APP']
+        out, err = self.run_manage(args)
+        self.assertOutput(err, "App with label NOT_AN_APP could not be found")
+
+    def test_label_command(self):
+        "User LabelCommands can execute when a label is provided"
+        args = ['label_command','testlabel']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:LabelCommand label=testlabel, options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+        
+    def test_label_command_no_label(self):
+        "User LabelCommands raise an error if no label is provided"
+        args = ['label_command']
+        out, err = self.run_manage(args)
+        self.assertOutput(err, 'Enter at least one label')
+
+    def test_label_command_multiple_label(self):
+        "User LabelCommands are executed multiple times if multiple labels are provided"
+        args = ['label_command','testlabel','anotherlabel']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:LabelCommand label=testlabel, options=[('pythonpath', None), ('settings', None), ('traceback', None)]")
+        self.assertOutput(out, "EXECUTE:LabelCommand label=anotherlabel, options=[('pythonpath', None), ('settings', None), ('traceback', None)]")