From 5bf3565a263533e37b2e1217e8d447cb7e02f5b4 Mon Sep 17 00:00:00 2001
From: Justin Bronn <jbronn@gmail.com>
Date: Sun, 13 Jul 2008 14:31:09 +0000
Subject: gis: Merged revisions
 7837-7838,7842-7852,7856-7869,7871,7876-7877,7882-7891,7900-7917 via svnmerge
 from trunk.

git-svn-id: http://code.djangoproject.com/svn/django/branches/gis@7918 bcc190cf-cafb-0310-a4f2-bffc1f526a37
---
 tests/regressiontests/admin_scripts/__init__.py    |   0
 .../admin_scripts/management/__init__.py           |   0
 .../admin_scripts/management/commands/__init__.py  |   0
 .../management/commands/app_command.py             |  15 +
 .../management/commands/base_command.py            |  20 +
 .../management/commands/label_command.py           |  14 +
 .../management/commands/noargs_command.py          |  14 +
 tests/regressiontests/admin_scripts/models.py      |  12 +
 tests/regressiontests/admin_scripts/tests.py       | 908 +++++++++++++++++++++
 9 files changed, 983 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

(limited to 'tests/regressiontests/admin_scripts')

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..3d8c43755c
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/management/commands/app_command.py
@@ -0,0 +1,15 @@
+from django.core.management.base import AppCommand
+# Python 2.3 doesn't have sorted()
+try:
+    sorted
+except NameError:
+    from django.utils.itercompat import sorted
+
+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..536f40409a
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/management/commands/base_command.py
@@ -0,0 +1,20 @@
+from django.core.management.base import BaseCommand
+from optparse import make_option
+# Python 2.3 doesn't have sorted()
+try:
+    sorted
+except NameError:
+    from django.utils.itercompat import sorted
+
+class Command(BaseCommand):
+    option_list = BaseCommand.option_list + (
+        make_option('--option_a','-a', action='store', dest='option_a', default='1'),
+        make_option('--option_b','-b', action='store', dest='option_b', default='2'),
+        make_option('--option_c','-c', action='store', dest='option_c', default='3'),
+    )
+    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..e749209d9c
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/management/commands/label_command.py
@@ -0,0 +1,14 @@
+from django.core.management.base import LabelCommand
+# Python 2.3 doesn't have sorted()
+try:
+    sorted
+except NameError:
+    from django.utils.itercompat import sorted
+
+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..f0f418752a
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/management/commands/noargs_command.py
@@ -0,0 +1,14 @@
+from django.core.management.base import NoArgsCommand
+# Python 2.3 doesn't have sorted()
+try:
+    sorted
+except NameError:
+    from django.utils.itercompat import sorted
+
+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..1bb0f7bed6
--- /dev/null
+++ b/tests/regressiontests/admin_scripts/tests.py
@@ -0,0 +1,908 @@
+"""
+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, get_version
+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', '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)
+        old_cwd = os.getcwd()
+        
+        # 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([test_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
+
+        # Move back to the old working directory
+        os.chdir(old_cwd)
+        
+        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=bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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=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,'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=bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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=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,'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=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,'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=bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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=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,'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=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,'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=bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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=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,'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=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,'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=bad_settings', 'admin_scripts']
+        out, err = self.run_django_admin(args)
+        self.assertOutput(err, "Could not import settings '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,'bad_settings')
+        self.assertNoOutput(out)
+        self.assertOutput(err, "Could not import settings '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=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,'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_version(self):
+        "--version is handled as a special case"
+        args = ['--version']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        # Only check the first part of the version number
+        self.assertOutput(out, get_version().split('-')[0])
+
+    def test_help(self):
+        "--help is handled as a special case"
+        args = ['--help']
+        out, err = self.run_manage(args)
+        self.assertOutput(out, "Usage: manage.py [options]")
+        self.assertOutput(err, "Type 'manage.py help <subcommand>' for help on a specific subcommand.")
+
+    def test_specific_help(self):
+        "--help can be used on a specific command"
+        args = ['sqlall','--help']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "Prints the CREATE TABLE, custom SQL and CREATE INDEX SQL statements for the given model module name(s).")
+    
+    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=[('option_a', '1'), ('option_b', '2'), ('option_c', '3'), ('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=[('option_a', '1'), ('option_b', '2'), ('option_c', '3'), ('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=[('option_a', '1'), ('option_b', '2'), ('option_c', '3'), ('pythonpath', None), ('settings', None), ('traceback', None)]")
+
+    def test_base_command_with_option(self):
+        "User BaseCommands can execute with options when a label is provided"
+        args = ['base_command','testlabel','--option_a=x']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel',), options=[('option_a', 'x'), ('option_b', '2'), ('option_c', '3'), ('pythonpath', None), ('settings', None), ('traceback', None)]")
+
+    def test_base_command_with_options(self):
+        "User BaseCommands can execute with multiple options when a label is provided"
+        args = ['base_command','testlabel','-a','x','--option_b=y']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel',), options=[('option_a', 'x'), ('option_b', 'y'), ('option_c', '3'), ('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.py'])) 
+        self.assertOutput(out, "'>, 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.py']))
+        self.assertOutput(out, "'>, 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)]")
+
+class ArgumentOrder(AdminScriptTestCase):
+    """Tests for 2-stage argument parsing scheme.
+
+    django-admin command arguments are parsed in 2 parts; the core arguments
+    (--settings, --traceback and --pythonpath) are parsed using a Lax parser.
+    This Lax parser ignores any unknown options. Then the full settings are 
+    passed to the command parser, which extracts commands of interest to the
+    individual command.    
+    """
+    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_setting_then_option(self):
+        "Options passed after settings are correctly handled"
+        args = ['base_command','testlabel','--settings=alternate_settings','--option_a=x']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel',), options=[('option_a', 'x'), ('option_b', '2'), ('option_c', '3'), ('pythonpath', None), ('settings', 'alternate_settings'), ('traceback', None)]")
+
+    def test_setting_then_short_option(self):
+        "Short options passed after settings are correctly handled"
+        args = ['base_command','testlabel','--settings=alternate_settings','--option_a=x']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel',), options=[('option_a', 'x'), ('option_b', '2'), ('option_c', '3'), ('pythonpath', None), ('settings', 'alternate_settings'), ('traceback', None)]")
+
+    def test_option_then_setting(self):
+        "Options passed before settings are correctly handled"
+        args = ['base_command','testlabel','--option_a=x','--settings=alternate_settings']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel',), options=[('option_a', 'x'), ('option_b', '2'), ('option_c', '3'), ('pythonpath', None), ('settings', 'alternate_settings'), ('traceback', None)]")
+
+    def test_short_option_then_setting(self):
+        "Short options passed before settings are correctly handled"
+        args = ['base_command','testlabel','-a','x','--settings=alternate_settings']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel',), options=[('option_a', 'x'), ('option_b', '2'), ('option_c', '3'), ('pythonpath', None), ('settings', 'alternate_settings'), ('traceback', None)]")
+
+    def test_option_then_setting_then_option(self):
+        "Options are correctly handled when they are passed before and after a setting"
+        args = ['base_command','testlabel','--option_a=x','--settings=alternate_settings','--option_b=y']
+        out, err = self.run_manage(args)
+        self.assertNoOutput(err)
+        self.assertOutput(out, "EXECUTE:BaseCommand labels=('testlabel',), options=[('option_a', 'x'), ('option_b', 'y'), ('option_c', '3'), ('pythonpath', None), ('settings', 'alternate_settings'), ('traceback', None)]")
+
-- 
cgit v1.3