def build_tests(self):
"""
Build tests for inclusion in suite from resolved packages for <= 1.8
TODO: Cleanup/simplify this method, flow too complex,
too much duplication.
"""
from django.core.exceptions import ImproperlyConfigured
from django.test.simple import build_suite, build_test
try:
from django.apps import apps
get_app = apps.get_app_config
except ImportError:
from django.db.models import get_app
tests = []
packages = [self.options['label'], ] if \
self.options['label'] else self.packages
for package in packages:
try:
if not self.options['autoreload']:
if self.options['label']:
try:
tests.append(build_test(package))
except (ImproperlyConfigured, ValueError) as e:
self.handle_label_exception(e)
else:
app = get_app(package)
tests.append(build_suite(app))
else:
# Wait for exceptions to be resolved.
exception = None
while True:
try:
if self.options['label']:
try:
tests.append(build_test(package))
except (ImproperlyConfigured, ValueError) as e:
self.handle_label_exception(e)
else:
app = get_app(package)
tests.append(build_suite(app))
break
except LabelException:
raise
except Exception as e:
if exception != str(e):
traceback.print_exc()
exception = str(e)
time.sleep(1)
except ImproperlyConfigured as e:
log.info("Warning: %s" % traceback.format_exc())
except ImportError as e:
log.info("Warning: %s" % traceback.format_exc())
return tests
def build_suite(self, test_labels, extra_tests=None, **kwargs):
if not test_labels:
return super(TeleduTestRunner, self).build_suite(test_labels, extra_tests, **kwargs)
suite = TestSuite()
for label in test_labels:
parts = label.split('.')
if parts[0].lower() == 'teledu':
if len(parts) < 2:
suite.addTest(unittest.TestLoader().discover(start_dir = self.testPath, pattern = 'when*.py'))
else:
suite.addTest(self._loadTestsFromLabel(parts[1]))
else:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return suite
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if "." in label:
from django.test.simple import build_test
suite.addTest(build_test(label))
else:
sub_suite = self.find_tests_and_apps(label)
suite.addTest(sub_suite)
else:
from django.db.models import get_apps
for app in get_apps():
from django.test.simple import build_suite
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
from django.test.simple import reorder_suite
from unittest import TestCase
return reorder_suite(suite, (TestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
# Get ignored tests
ignored_labels = getattr(settings, "IGNORE_TESTS", ())
ignored_apps = []
for ilabel in ignored_labels:
if "." in ilabel:
ilabel = ilabel.split(".")[-1]
try:
app = get_app(ilabel)
except Exception as e:
print e
ignored_apps.append(app)
for app in get_apps():
if app not in ignored_apps:
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase, ))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
print "Excluding apps: %s" % ', '.join(
settings.APPS_NOT_FOR_TESTING)
for app in get_apps():
if app.__package__ in settings.APPS_NOT_FOR_TESTING or \
app.__name__ in settings.APPS_NOT_FOR_TESTING:
continue
print "Will test %s" % app.__name__
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
print "Adding extra test %s" % test
suite.addTest(test)
return reorder_suite(suite, (TestCase, ))
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
old_name = settings.DATABASE_NAME
from django.db import connection
connection.creation.create_test_db(verbosity, autoclobber=not interactive)
result = XMLTestRunner(verbosity=verbosity).run(suite)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
print test_labels
for label in test_labels:
print label
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
print 'Filtering applications to test...'
for app in get_apps():
if isinstance(
app.__package__,
basestring) and app.__package__.startswith('esp.'):
print ' Adding: %s' % app.__package__
suite.addTest(build_suite(app))
else:
print ' Skipping: %s' % app.__package__
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase, ))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
# Get ignored tests
ignored_labels = getattr(settings, "IGNORE_TESTS", ())
ignored_apps = []
for ilabel in ignored_labels:
if "." in ilabel:
ilabel = ilabel.split(".")[-1]
try:
app = get_app(ilabel)
except Exception as e:
print e
else:
ignored_apps.append(app)
for app in get_apps():
if app not in ignored_apps:
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase,))
def run_the_old_way(extra_tests, kwargs, test_labels, verbosity):
from django.test.simple import build_suite, build_test, get_app, get_apps, \
setup_test_environment, teardown_test_environment
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
old_name = settings.DATABASE_NAME
from django.db import connection
connection.creation.create_test_db(verbosity, autoclobber=False)
result = DjangoTeamcityTestRunner().run(suite, **kwargs)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""Run the unit tests without using the ORM.
"""
setup_test_environment()
settings.DEBUG = False
settings.DATABASE_SUPPORTS_TRANSACTIONS = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
runner = unittest.TextTestRunner(verbosity=verbosity)
result = runner.run(suite)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
pkg = app.__name__
if self.is_excluded(pkg):
print "Deleting %s" % pkg
#del suite._tests[key]
else:
print "Keeping %s" % pkg
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
pass
#suite.addTest(test)
return reorder_suite(suite, (TestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
app_name = guess_app(app)
for pattern in getattr(settings, 'TEST_WHITELIST', ('%s.*'%__name__.split('.')[0],)):
if fnmatch(app_name, pattern):
suite.addTest(build_suite(app))
break
for name in getattr(settings, 'TEST_EXTRA', ()):
mod = import_module(name + '.' + TEST_MODULE)
extra_suite = unittest.defaultTestLoader.loadTestsFromModule(mod)
suite.addTest(extra_suite)
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase,))
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
# Same as django.test.simple.run_tests but return the result object.
# http://code.djangoproject.com/browser/django/trunk/django/test/simple.py#L149
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
old_name = settings.DATABASE_NAME
from django.db import connection
connection.creation.create_test_db(verbosity, autoclobber=not interactive)
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
return result
def testing_an_individual_test_via_managepy():
from tests.app import tests
assert tests.TEST_HAS_RUN == False
test_suite = build_test("app.test_case.test_change_global")
test_suite.debug() # runs the tests
assert tests.TEST_HAS_RUN == True
def safe_build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
try:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
except Exception:
log.warning("Could not add test for label: %s" %label)
else:
for app in get_apps():
try:
suite.addTest(build_suite(app))
except Exception:
log.warning("Could not add tests for app: %s" %app)
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
# Get ignored tests
ignored_labels = getattr(settings, "IGNORE_TESTS", ())
ignored_apps = []
for ilabel in ignored_labels:
if "." in ilabel:
ilabel = ilabel.split(".")[-1]
app = get_app(ilabel)
ignored_apps.append(app)
for app in get_apps():
if app not in ignored_apps:
suite.addTest(build_suite(app))
suite = reorder_suite(suite, (TestCase,))
# signals.build_suite.send(sender=self, suite=suite)
return suite
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
# Get ignored tests
ignored_labels = getattr(settings, "IGNORE_TESTS", ())
ignored_apps = []
for ilabel in ignored_labels:
if "." in ilabel:
ilabel = ilabel.split(".")[-1]
app = get_app(ilabel)
ignored_apps.append(app)
for app in get_apps():
if app not in ignored_apps:
suite.addTest(build_suite(app))
suite = reorder_suite(suite, (TestCase, ))
# signals.build_suite.send(sender=self, suite=suite)
return suite
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""Run the unit tests without using the ORM.
"""
setup_test_environment()
settings.DEBUG = False
settings.DATABASE_SUPPORTS_TRANSACTIONS = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase, ))
runner = unittest.TextTestRunner(verbosity=verbosity)
result = runner.run(suite)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def run_tests(self, test_labels, verbosity=1, interactive=True, extra_tests=[]): """ Run the unit tests for all the test labels in the provided list. Labels must be of the form: - app.TestClass.test_method Run a single specific test method - app.TestClass Run all the test methods in a given class - app Search for doctests and unittests in the named application. When looking for tests, the test runner will look in the models and tests modules for the application. A list of 'extra' tests may also be provided; these tests will be added to the test suite. Returns the number of tests that failed. """ setup_test_environment() settings.DEBUG = False verbose = getattr(settings, 'TEST_OUTPUT_VERBOSE', False) descriptions = getattr(settings, 'TEST_OUTPUT_DESCRIPTIONS', False) output = getattr(settings, 'TEST_OUTPUT_DIR', '.') exclude_apps = getattr(settings, 'EXCLUDE_APPS', None) suite = unittest.TestSuite() if test_labels: for label in test_labels: if '.' in label: suite.addTest(build_test(label)) else: app = get_app(label) suite.addTest(build_suite(app)) else: for app in get_apps(): exclude = False if exclude_apps: for e_app in exclude_apps: if app.__name__.startswith(e_app): exclude = True if not exclude: suite.addTest(build_suite(app)) for test in extra_tests: suite.addTest(test) old_config = self.setup_databases() result = xmlrunner.XMLTestRunner(verbose=verbose, descriptions=descriptions, output=output, resultclass=self.resultclass).run(suite) self.teardown_databases(old_config) teardown_test_environment() return len(result.failures) + len(result.errors)
def run_tests(test_labels,
verbosity=1,
interactive=True,
extra_tests=[],
suite=None):
"""
Set `TEST_RUNNER` in your settings with this routine in order to
scaffold test spatial databases correctly for your GeoDjango models.
For more documentation, please consult the following URL:
http://geodjango.org/docs/testing.html.
"""
from django.conf import settings
from django.db import connection
from django.db.models import get_app, get_apps
from django.test.simple import build_suite, build_test, reorder_suite, TestCase
from django.test.utils import setup_test_environment, teardown_test_environment
# The `create_test_spatial_db` routine abstracts away all the steps needed
# to properly construct a spatial database for the backend.
from django.contrib.gis.db.backend import create_test_spatial_db
# Setting up for testing.
setup_test_environment()
settings.DEBUG = False
old_name = settings.DATABASE_NAME
# Creating the test spatial database.
create_test_spatial_db(verbosity=verbosity, autoclobber=not interactive)
# The suite may be passed in manually, e.g., when we run the GeoDjango test,
# we want to build it and pass it in due to some customizations. Otherwise,
# the normal test suite creation process from `django.test.simple.run_tests`
# is used to create the test suite.
if suite is None:
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase, ))
# Executing the tests (including the model tests), and destorying the
# test database after the tests have completed.
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
# Returning the total failures and errors
return len(result.failures) + len(result.errors)
def run_tests(test_labels, verbosity=1, interactive=False, extra_tests=[],
**kwargs):
"""
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
TeamcityServiceMessages(sys.stdout).testMatrixEntered()
if VERSION[1] > 1:
return DjangoTeamcityTestRunner().run_tests(test_labels,
extra_tests=extra_tests, **kwargs)
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
old_name = settings.DATABASE_NAME
from django.db import connection
connection.creation.create_test_db(verbosity, autoclobber=False)
result = DjangoTeamcityTestRunner().run(suite, **kwargs)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
modules_to_cover = []
# if passed a list of tests...
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
# ...otherwise use all installed
else:
for app in get_apps():
# skip apps named "Django" because they use a database
if not app.__name__.startswith('django'):
# get the actual app name
app_name = app.__name__.replace('.models', '')
# get a list of the files inside that module
files = glob('%s/*.py' % app_name)
# remove models because we don't use them, stupid
new_files = [i for i in files if not i.endswith('models.py')]
modules_to_cover.extend(new_files)
# actually test the file
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
modules_to_cover = []
# if passed a list of tests...
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
# ...otherwise use all installed
else:
for app in get_apps():
# skip apps named "Django" because they use a database
if not app.__name__.startswith('django'):
# get the actual app name
app_name = app.__name__.replace('.models', '')
# get a list of the files inside that module
files = glob('%s/*.py' % app_name)
# remove models because we don't use them, stupid
new_files = [i for i in files if not i.endswith('models.py')]
modules_to_cover.extend(new_files)
# actually test the file
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def build_suite(self, test_labels, *args, **kwargs):
"""
Override the default test suite builder to exclude doctests, use
'tests.selenium' as the test module path, allow excluding the tests of
any apps contained in settings.SELENIUM['EXCLUDE_APPS'].
"""
from django.test.simple import (unittest, build_test, get_app,
get_apps, reorder_suite, TestCase, doctest,
build_suite as _build_suite)
# Hack to remove doctests from test suite without reimplementing
# build_suite
def _filter_suite(suite):
tests = []
for test in suite._tests:
if isinstance(test, unittest.TestSuite):
tests.append(_filter_suite(test))
elif not isinstance(test, doctest.DocTestCase):
tests.append(test)
suite._tests = tests
return suite
def build_suite(*args, **kwargs):
suite = _build_suite(*args, **kwargs)
return _filter_suite(suite)
exclude_apps = settings.SELENIUM_SETUP.get('EXCLUDE_APPS', [])
test_labels = [l for l in test_labels
if all(not l.startswith(app) for app in exclude_apps)]
import django.test.simple
orig_test_module = django.test.simple.TEST_MODULE
django.test.simple.TEST_MODULE = SELENIUM_TEST_MODULE
try:
# copied from django TestSuiteRunner
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
name = app.__name__
if all(('.%s' % a) not in name for a in exclude_apps):
suite.addTest(build_suite(app))
return reorder_suite(suite, (TestCase,))
finally:
django.test.simple.TEST_MODULE = orig_test_module
def test_discover_within_package(self):
"""
Verify labels like applabel.TestCase find tests defined in
applabel/tests/__init__.py. Fixes #22478.
"""
from django.test.simple import build_test
suite = build_test('valid_app.SampleTest')
self.assertEqual(suite.countTestCases(), 1)
def test_discover_within_package(self):
"""
Verify labels like applabel.TestCase find tests defined in
applabel/tests/__init__.py. Fixes #22478.
"""
from django.test.simple import build_test
suite = build_test('valid_app.SampleTest')
self.assertEqual(suite.countTestCases(), 1)
def run(request):
"""
Runs all the tests.
"""
# Some stuff.
verbosity=1
interactive=True
extra_tests=[]
# Setup the response.
response = HttpResponse()
# Get the installed apps for this project.
installed_apps = settings.INSTALLED_APPS
# The list of applications which will be tested.
test_labels = []
# Populate the test_labels list with the POST data.
for item in request.POST.getlist('apps'):
test_labels.append(settings.INSTALLED_APPS[int(item)])
try:
setup_test_environment()
settings.DEBUG = False
settings.DATABASE_ENGINE = 'sqlite3'
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
old_name = settings.DATABASE_NAME
from django.db import connection
connection.creation.create_test_db(verbosity, autoclobber=not interactive)
result = HTMLTestRunner.HTMLTestRunner(stream=response, verbosity=verbosity).run(suite)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
except Exception, e:
from ipdb import set_trace; set_trace()
raise e
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[], suite=None):
"""
Set `TEST_RUNNER` in your settings with this routine in order to
scaffold test spatial databases correctly for your GeoDjango models.
For more documentation, please consult the following URL:
http://geodjango.org/docs/testing.html.
"""
from django.conf import settings
from django.db import connection
from django.db.models import get_app, get_apps
from django.test.simple import build_suite, build_test
from django.test.utils import setup_test_environment, teardown_test_environment
# The `create_test_spatial_db` routine abstracts away all the steps needed
# to properly construct a spatial database for the backend.
from django.contrib.gis.db.backend import create_test_spatial_db
# Setting up for testing.
setup_test_environment()
settings.DEBUG = False
old_name = settings.DATABASE_NAME
# Creating the test spatial database.
create_test_spatial_db(verbosity=verbosity, autoclobber=not interactive)
# The suite may be passed in manually, e.g., when we run the GeoDjango test,
# we want to build it and pass it in due to some customizations. Otherwise,
# the normal test suite creation process from `django.test.simple.run_tests`
# is used to create the test suite.
if suite is None:
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if "." in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
# Executing the tests (including the model tests), and destorying the
# test database after the tests have completed.
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
# Returning the total failures and errors
return len(result.failures) + len(result.errors)
def build_suite(self, suite, **kwargs):
if self.test_labels:
for label in self.test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
def build_suite(self, suite, **kwargs):
if self.test_labels:
for label in self.test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
def run_tests(self, test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
verbose = getattr(settings, 'TEST_OUTPUT_VERBOSE', False)
descriptions = getattr(settings, 'TEST_OUTPUT_DESCRIPTIONS', False)
output = getattr(settings, 'TEST_OUTPUT_DIR', '.')
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
old_config = self.setup_databases()
result = xmlrunner.XMLTestRunner(
verbose=verbose, descriptions=descriptions, output=output).run(suite)
self.teardown_databases(old_config)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def build_tests(self):
"""
Build tests for inclusion in suite from resolved packages.
TODO: Cleanup/simplify this method, flow too complex,
too much duplication.
"""
from django.core.exceptions import ImproperlyConfigured
from django.db.models import get_app
from django.test.simple import build_suite, build_test
tests = []
packages = [self.options['label'], ] if \
self.options['label'] else self.packages
for package in packages:
try:
if not self.options['autoreload']:
if self.options['label']:
try:
tests.append(build_test(package))
except (ImproperlyConfigured, ValueError), e:
self.handle_label_exception(e)
else:
app = get_app(package)
tests.append(build_suite(app))
else:
# Wait for exceptions to be resolved.
exception = None
while True:
try:
if self.options['label']:
try:
tests.append(build_test(package))
except (ImproperlyConfigured, ValueError), e:
self.handle_label_exception(e)
else:
app = get_app(package)
tests.append(build_suite(app))
break
except LabelException:
raise
def build_suite(self, suite, **kwargs):
if self.test_labels:
for label in self.test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
try:
app = get_app(label)
suite.addTest(build_suite(app))
except ImproperlyConfigured:
pass
else:
for app in get_apps():
suite.addTest(build_suite(app))
def build_suite(self, test_labels, *args, **kwargs):
"""
Override the default test suite builder to exclude doctests, use
'tests.selenium' as the test module path.
"""
from django.test.simple import (unittest, build_test, get_app,
get_apps, reorder_suite, TestCase, doctest,
build_suite as _build_suite)
# Hack to remove doctests from test suite without reimplementing
# build_suite
def _filter_suite(suite):
tests = []
for test in suite._tests:
if isinstance(test, unittest.TestSuite):
tests.append(_filter_suite(test))
elif not isinstance(test, doctest.DocTestCase):
tests.append(test)
suite._tests = tests
return suite
def build_suite(*args, **kwargs):
suite = _build_suite(*args, **kwargs)
return _filter_suite(suite)
import django.test.simple
orig_test_module = django.test.simple.TEST_MODULE
django.test.simple.TEST_MODULE = SELENIUM_TEST_MODULE
try:
# copied from django TestSuiteRunner
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
return reorder_suite(suite, (TestCase,))
finally:
django.test.simple.TEST_MODULE = orig_test_module
def build_suite(self, suite, **kwargs):
if self.test_labels:
for label in self.test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
try:
app = get_app(label)
suite.addTest(build_suite(app))
except ImproperlyConfigured:
pass
else:
for app in get_apps():
suite.addTest(build_suite(app))
def run_tests_until_fail(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Stops the tests at the first failure and returns 1. If all test pass,
returns 0.
Also displays only the first failure in the failing test suite.
"""
setup_test_environment()
settings.DEBUG = False
suite = TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
old_name = settings.DATABASE_NAME
create_test_db(verbosity, autoclobber=not interactive)
result = FailStopTextTestRunner(verbosity=verbosity).run(suite)
destroy_test_db(old_name, verbosity)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
old_name = settings.DATABASE_NAME
from django.db import connection
connection.creation.create_test_db(verbosity, autoclobber=not interactive)
result = JUnitXMLTestRunner('.').run(suite)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
return len(result.failures) + len(result.errors)
def optimize_apps_for_test_labels(test_labels):
test_map = AppAndTestMap()
for label in test_labels:
if "." in label:
test_map.add_test(label.split(".")[0], build_test(label))
else:
test_map.add_app(label)
_real_installed_apps = settings.INSTALLED_APPS
needed_apps = test_map.get_needed_installed_apps()
print "overriding settings.INSTALLED_APPS to {}".format(",".join(test_map.get_needed_installed_apps()))
settings.INSTALLED_APPS = tuple(needed_apps)
apps.set_installed_apps(settings.INSTALLED_APPS)
try:
yield
finally:
settings.INSTALLED_APPS = _real_installed_apps
apps.unset_installed_apps()
def build_suite(self, suite, **kwargs):
if self.test_labels:
for label in self.test_labels:
if label not in self.exclude_apps:
if '.' in label:
if self._check_not_excluded(label):
suite.addTest(build_test(label))
else:
try:
app = get_app(label)
if self._check_not_excluded(app.__name__):
suite.addTest(build_suite(app))
except ImproperlyConfigured:
pass
else:
for app in get_apps():
if self._check_not_excluded(app.__name__):
suite.addTest(build_suite(app))
def get_tests(self, test_labels=None):
from django.test import simple
simple.TEST_MODULE = self.test_module
suite = self.testdb.FixtureTestSuiteFactory()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
return reorder_suite(suite, (TestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = TestCaseSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return suite
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if "." in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app, self.test_type, self.host))
else:
for app in get_apps():
suite.addTest(build_suite(app, self.test_type, self.host))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (unittest.TestCase,))
def _build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
app_name = app.__name__
if app_name.endswith('.models'):
app_name = app_name[:-7]
if app_name not in getattr(settings, 'TEST_SKIP_APP_TESTS', ()):
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase, ))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
if app.__name__.startswith('django.'):
continue # disable django built-in tests
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase, ))
def optimize_apps_for_test_labels(test_labels):
# TODO make this work on Django 1.8 (django.test.simple has been removed)
from django.test.simple import build_test
test_map = AppAndTestMap()
for label in test_labels:
if isinstance(label, tuple):
test_map.add_test(*label)
elif '.' in label:
test_map.add_test(label.split('.')[0], build_test(label))
else:
test_map.add_app(label)
_real_installed_apps = settings.INSTALLED_APPS
needed_apps = test_map.get_needed_installed_apps()
print 'overriding settings.INSTALLED_APPS to {}'.format(','.join(
test_map.get_needed_installed_apps()))
settings.INSTALLED_APPS = tuple(needed_apps)
apps.set_installed_apps(settings.INSTALLED_APPS)
try:
yield
finally:
settings.INSTALLED_APPS = _real_installed_apps
apps.unset_installed_apps()
def run_tests_with_coverage(test_labels,
verbosity=1,
interactive=True,
extra_tests=[],
xml_out=False):
"""
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
modules_to_cover = []
# start doing some coverage action
cov = coverage.coverage()
cov.erase()
cov.start()
# if passed a list of tests...
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
# ...otherwise use all installed
else:
for app in get_apps():
# skip apps named "Django" because they use a database
if not app.__name__.startswith('django'):
# get the actual app name
app_name = app.__name__.replace('.models', '')
# get a list of the files inside that module
files = glob('%s/*.py' % app_name)
# remove models because we don't use them, stupid
new_files = [i for i in files if not i.endswith('models.py')]
modules_to_cover.extend(new_files)
# actually test the file
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
teardown_test_environment()
# stop coverage
cov.stop()
# output results
print ''
print '--------------------------'
print 'Unit test coverage results'
print '--------------------------'
print ''
if xml_out:
# using the same output directory as the --xml function uses for testing
if not os.path.isdir(os.path.join("temp", "xml")):
os.makedirs(os.path.join("temp", "xml"))
output_filename = 'temp/xml/coverage_output.xml'
cov.xml_report(morfs=coverage_modules, outfile=output_filename)
cov.report(modules_to_cover, show_missing=1)
return len(result.failures) + len(result.errors)
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
worsk exactly as per normal test
but only creates the test_db if it doesn't yet exist
and does not destroy it when done
tables are flushed and fixtures loaded between tests as per usual
but if your schema has not changed then this saves significant amounts of time
and speeds up the test cycle
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = apps.get_app(label)
suite.addTest(build_suite(app))
else:
for app in apps.get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase, ))
old_name = settings.DATABASES['default']['NAME']
# Everything up to here is from django.test.simple
from django.db.backends import creation
from django.db import connection, DatabaseError
if settings.DATABASES['default']['TEST_NAME']:
settings.DATABASES['default']['NAME'] = settings.DATABASES['default'][
'TEST_NAME']
else:
settings.DATABASES['default'][
'NAME'] = creation.TEST_DATABASE_PREFIX + settings.DATABASES[
'default']['NAME']
connection.settings_dict["DATABASE_NAME"] = settings.DATABASES['default'][
'NAME']
# does test db exist already ?
try:
if settings.DATABASES['default']['ENGINE'] == 'sqlite3':
if not os.path.exists(settings.DATABASES['default']['NAME']):
raise DatabaseError
cursor = connection.cursor()
except Exception:
# db does not exist
# juggling ! create_test_db switches the DATABASE_NAME to the TEST_DATABASE_NAME
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
connection.creation.create_test_db(verbosity, autoclobber=True)
else:
connection.close()
settings.DATABASES['default'][
'SUPPORTS_TRANSACTIONS'] = connections_support_transactions()
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
# Since we don't call destory_test_db, we need to set the db name back.
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
teardown_test_environment()
return len(result.failures) + len(result.errors)
def run_tests(test_labels,
verbosity=1,
interactive=True,
extra_tests=[],
suite=None):
"""
This module allows users to run tests for GIS apps that require the creation
of a spatial database. Currently, this is only required for PostgreSQL as
PostGIS needs extra overhead in test database creation.
In order to create a PostGIS database, the DATABASE_USER (or
TEST_DATABASE_USER, if defined) will require superuser priviliges.
To accomplish this outside the `postgres` user, you have a few options:
(A) Make your user a super user:
This may be done at the time the user is created, for example:
$ createuser --superuser <user_name>
Or you may alter the user's role from the SQL shell (assuming this
is done from an existing superuser role):
postgres# ALTER ROLE <user_name> SUPERUSER;
(B) Create your own PostgreSQL database as a local user:
1. Initialize database: `initdb -D /path/to/user/db`
2. If there's already a Postgres instance on the machine, it will need
to use a different TCP port than 5432. Edit postgresql.conf (in
/path/to/user/db) to change the database port (e.g. `port = 5433`).
3. Start this database `pg_ctl -D /path/to/user/db start`
(C) On Windows platforms the pgAdmin III utility may also be used as
a simple way to add superuser privileges to your database user.
The TEST_RUNNER needs to be set in your settings like so:
TEST_RUNNER='django.contrib.gis.tests.run_tests'
Note: This test runner assumes that the PostGIS SQL files ('lwpostgis.sql'
and 'spatial_ref_sys.sql') are installed in the directory specified by
`pg_config --sharedir` (and defaults to /usr/local/share if that fails).
This behavior is overridden if POSTGIS_SQL_PATH is set in your settings.
Windows users should set POSTGIS_SQL_PATH manually because the output
of `pg_config` uses paths like 'C:/PROGRA~1/POSTGR~1/..'.
Finally, the tests may be run by invoking `./manage.py test`.
"""
from django.conf import settings
from django.db import connection
from django.db.models import get_app, get_apps
from django.test.simple import build_suite, build_test
from django.test.utils import setup_test_environment, teardown_test_environment
# The `create_spatial_db` routine abstracts away all the steps needed
# to properly construct a spatial database for the backend.
from django.contrib.gis.db.backend import create_spatial_db
# Setting up for testing.
setup_test_environment()
settings.DEBUG = False
old_name = settings.DATABASE_NAME
# The suite may be passed in manually, e.g., when we run the GeoDjango test,
# we want to build it and pass it in due to some customizations. Otherwise,
# the normal test suite creation process from `django.test.simple.run_tests`
# is used to create the test suite.
if suite is None:
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
# Creating the test spatial database.
create_spatial_db(test=True, verbosity=verbosity)
# Executing the tests (including the model tests), and destorying the
# test database after the tests have completed.
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
connection.creation.destroy_test_db(old_name, verbosity)
teardown_test_environment()
# Returning the total failures and errors
return len(result.failures) + len(result.errors)
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[],
include_coverage=False, include_profile=False, profile_all=False):
"""
Copy and munge of django's django.test.simple.run_tests method,
we're extending it to handle coverage
-- Original Docs --
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
utils.setup_test_environment()
settings.DEBUG = False
profile.PROFILE_ALL_TESTS = False
suite = unittest.TestSuite()
coverage_modules = []
if include_coverage:
coverage.start()
if profile_all:
profile.PROFILE_ALL_TESTS = True
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(simple.build_test(label))
else:
app = models.get_app(label)
suite.addTest(simple.build_suite(app))
coverage_modules.append(app)
else:
for app in models.get_apps():
if app.__name__.startswith('appengine_django'):
continue
suite.addTest(simple.build_suite(app))
coverage_modules.append(app)
for test in extra_tests:
suite.addTest(test)
old_name = settings.DATABASE_NAME
from django.db import connection
connection.creation.create_test_db(verbosity, autoclobber=not interactive)
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
if include_coverage:
coverage.stop()
app_names = [mod.__name__.split('.')[0] for mod in coverage_modules]
coverage_paths = ['%s/*.py' % app
for app in settings.INSTALLED_APPS
if _any_startswith(app, app_names)]
coverage.report(coverage_paths, ignore_errors=1)
if profile_all or include_profile:
f = open(settings.PROFILING_DATA_PATH, 'w')
f.write(profile.csv())
f.close()
profile.clear()
connection.creation.destroy_test_db(old_name, verbosity)
utils.teardown_test_environment()
return len(result.failures) + len(result.errors)
