def _tests_1_2(self):
"""
Fire up the Django test suite developed for version 1.2 and up
"""
test_settings = self.custom_settings
installed_apps = test_settings.pop('INSTALLED_APPS', ())
settings.configure(DEBUG=True,
DATABASES=self.get_database(1.2),
INSTALLED_APPS=tuple(self.INSTALLED_APPS +
installed_apps + self.apps),
**test_settings)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def setup():
global test_runner
global old_config
try:
# Django 1.7
from django.test.runner import DiscoverRunner
import django
django.setup()
test_runner = DiscoverRunner()
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def runtests(*test_args, **kwargs):
if 'south' in settings.INSTALLED_APPS:
from south.management.commands import patch_for_test_db_setup
patch_for_test_db_setup()
if not test_args:
test_args = ['tests']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=kwargs.get('verbosity', 1),
interactive=kwargs.get(
'interactive', False),
failfast=kwargs.get('failfast'))
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def runtests():
if hasattr(django, 'setup'):
django.setup()
return DjangoTestSuiteRunner(failfast=False).run_tests([
'crispy_forms.TestBasicFunctionalityTags',
'crispy_forms.TestFormHelper',
'crispy_forms.TestUniformFormHelper',
'crispy_forms.TestFormLayout',
'crispy_forms.TestUniformFormLayout',
'crispy_forms.TestLayoutObjects',
'crispy_forms.TestDynamicLayouts',
'crispy_forms.TestUniformDynamicLayouts',
],
verbosity=1,
interactive=True)
def setup():
global test_runner
global old_config
# If you want to support Django 1.5 and older, you need
# this try-except block.
try:
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def test_setup_databases(self):
"""
Test that setup_databases() doesn't fail with dummy database backend.
"""
runner = DjangoTestSuiteRunner(verbosity=0)
old_db_connections = db.connections
try:
db.connections = db.ConnectionHandler({})
old_config = runner.setup_databases()
runner.teardown_databases(old_config)
except Exception as e:
self.fail("setup_databases/teardown_databases unexpectedly raised "
"an error: %s" % e)
finally:
db.connections = old_db_connections
def handle(self, *args, **options):
setup_test_environment()
settings.DEBUG = options.get('debug', False)
verbosity = int(options.get('verbosity', 4))
apps_to_run = tuple(options.get('apps', '').split(","))
apps_to_avoid = tuple(options.get('avoid_apps', '').split(","))
run_server = not options.get('no_server', False)
test_database = options.get('test_database', False)
tags = options.get('tags', None)
failfast = options.get('failfast', False)
auto_pdb = options.get('auto_pdb', False)
if test_database:
migrate_south = getattr(settings, "SOUTH_TESTS_MIGRATE", True)
try:
from south.management.commands import patch_for_test_db_setup
patch_for_test_db_setup()
except:
migrate_south = False
pass
from django.test.simple import DjangoTestSuiteRunner
self._testrunner = DjangoTestSuiteRunner()
self._testrunner.setup_test_environment()
self._old_db_config = self._testrunner.setup_databases()
call_command(
'syncdb',
verbosity=0,
interactive=False,
)
if migrate_south:
call_command(
'migrate',
verbosity=0,
interactive=False,
)
server = Server(port=options['port'])
paths = self.get_paths(args, apps_to_run, apps_to_avoid)
if run_server:
try:
server.start()
except LettuceServerException, e:
raise SystemExit(e)
def runtests():
settings.configure(**DEFAULT_SETTINGS)
try:
# Django <= 1.8
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
except ImportError:
# Django >= 1.8
django.setup()
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(['cotidia'])
if failures:
sys.exit(failures)
def main():
# Configure python path
parent = os.path.dirname(os.path.abspath(__file__))
if not parent in sys.path:
sys.path.insert(0, parent)
# Discover tests
os.environ['DJANGO_SETTINGS_MODULE'] = 'djedi.tests.settings'
unittest2.defaultTestLoader.discover('djedi')
# Run tests
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True, failfast=False)
exit_code = runner.run_tests(['djedi'])
sys.exit(exit_code)
def _tests_1_2(self):
"""
Fire up the Django test suite developed for version 1.2 and up
"""
INSTALLED_APPS, settings_test = self.get_custom_settings()
settings.configure(DEBUG=True,
DATABASES=self.get_database(),
INSTALLED_APPS=self.INSTALLED_APPS +
INSTALLED_APPS + self.apps,
**settings_test)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def __init__(self, *args, **kwargs):
self.configure()
self.cov = coverage()
self.cov.start()
self.packages = self.resolve_packages()
super(SetupTestSuite, self).__init__(tests=self.build_tests(), \
*args, **kwargs)
# Setup testrunner.
from django.test.simple import DjangoTestSuiteRunner
self.test_runner = DjangoTestSuiteRunner(verbosity=1,
interactive=True,
failfast=False)
self.test_runner.setup_test_environment()
self.old_config = self.test_runner.setup_databases()
def runtests():
args = sys.argv[1:]
if args:
test_labels = ["model_mommy.%s" % arg for arg in args]
else:
test_labels = ['model_mommy']
try:
from django.test.simple import run_tests
result = run_tests(test_labels, 1, True)
sys.exit(result)
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_suite = DjangoTestSuiteRunner(1, True)
result = test_suite.run_tests(test_labels)
sys.exit(result)
def _new_tests(self):
"""
Fire up the Django test suite developed for version 1.2
"""
settings.configure(DEBUG=True,
DATABASES={
'default': {
'ENGINE':
'django.db.backends.sqlite3',
'NAME':
os.path.join(self.DIRNAME, 'database.db'),
'USER':
'',
'PASSWORD':
'',
'HOST':
'',
'PORT':
'',
}
},
INSTALLED_APPS=self.INSTALLED_APPS + self.apps,
MIDDLEWARE_CLASSES=self.MIDDLEWARE_CLASSES,
ROOT_URLCONF='helpdesk.tests.urls',
STATIC_URL='/static/',
TEMPLATES=self.TEMPLATES)
# compatibility with django 1.8 downwards
# see: http://stackoverflow.com/questions/3841725/how-to-launch-tests-for-django-reusable-app
try:
# Django >= 1.6
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
except ImportError:
# Django <= 1.5
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
if django.VERSION >= (1, 7):
django.setup()
failures = test_runner.run_tests(self.apps)
if failures:
sys.exit(failures)
def _new_tests(self):
"""
Fire up the Django test suite developed for version 1.2
"""
INSTALLED_APPS, settings_test = self.custom_settings()
test_db = os.environ.get('DB', 'sqlite')
if test_db == 'mysql':
database = {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'django',
'USER': '******',
}
elif test_db == 'postgres':
database = {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'USER': '******',
'NAME': 'django',
'OPTIONS': {
'autocommit': True,
}
}
else:
database = {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(self.DIRNAME, 'database.db'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
settings.configure(
DEBUG = True,
DATABASES = {
'default': database,
},
INSTALLED_APPS = self.INSTALLED_APPS + INSTALLED_APPS + self.apps,
**settings_test
)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def runtests():
os.environ['DJANGO_SETTINGS_MODULE'] = 'tests.settings'
# Django >= 1.7
if hasattr(django, 'setup'):
django.setup()
try:
# Django <= 1.8
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
except ImportError:
# Django >= 1.8
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(['portfolio'])
sys.exit(failures)
def setup_database(actual_server):
'''
This will setup your database, sync it, and run migrations if you are using South.
It does this before the Test Django server is set up.
'''
logger.info("Setting up a test database...")
# Uncomment if you are using South
patch_for_test_db_setup()
world.test_runner = DjangoTestSuiteRunner(interactive=False)
DjangoTestSuiteRunner.setup_test_environment(world.test_runner)
world.created_db = DjangoTestSuiteRunner.setup_databases(world.test_runner)
call_command('syncdb', interactive=False, verbosity=0)
# Uncomment if you are using South
call_command('migrate', interactive=False, verbosity=0)
def runtests(*test_args):
if not settings.configured:
settings.configure(**DEFAULT_SETTINGS)
# Compatibility with Django 1.7's stricter initialization
if hasattr(django, "setup"):
django.setup()
if not test_args:
test_args = ["tests"]
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner(
verbosity=1, interactive=True, failfast=False).run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['location']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
if not TRAVIS:
from django.db import connection
cursor = connection.cursor()
cursor.execute("SELECT InitSpatialMetaData();")
runner = DjangoTestSuiteRunner(
verbosity=1,
interactive=False,
failfast=False
)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['django_mailbox']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
try:
# ensure that AppRegistry has loaded
setup()
except NameError:
# This version of Django is too old for an app registry.
pass
runner = DjangoTestSuiteRunner(
verbosity=1,
interactive=False,
failfast=False
)
failures = runner.run_tests(test_args)
sys.exit(failures)
def test_ticket_16885(self):
"""Features are also confirmed on mirrored databases."""
old_db_connections = db.connections
try:
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.sqlite3',
},
'slave': {
'ENGINE': 'django.db.backends.sqlite3',
'TEST_MIRROR': 'default',
},
})
slave = db.connections['slave']
self.assertEqual(slave.features.supports_transactions, None)
DjangoTestSuiteRunner(verbosity=0).setup_databases()
self.assertNotEqual(slave.features.supports_transactions, None)
finally:
db.connections = old_db_connections
def runtests():
settings.configure(**DEFAULT_SETTINGS)
# parent = os.path.dirname(os.path.abspath(__file__))
# sys.path.insert(0, parent)
try:
# Django <= 1.8
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
except ImportError:
# Django >= 1.8
django.setup()
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(['cotidia'])
if failures:
sys.exit(failures)
def _new_tests(self):
settings.configure(
DEBUG = True,
DATABASES = {
'default' : {
'ENGINE' : 'django.db.backends.sqlite3',
'NAME' : os.path.join(self.DIRNAME, 'database.db'),
'USER' : '',
'PASSWORD' : '',
'HOST' : '',
'PORT' : '',
}
},
INSTALLED_APPS = self.INSTALLED_APPS + self.apps
)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def run_tests(self):
"""
Fire up the Django test suite developed for version 1.2
"""
settings.configure(
DEBUG=True,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(self.DIRNAME, 'database.db'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
},
LOGGING={
'version': 1,
'formatters': {
'simple': {
'format':
'%(levelname)s %(asctime)s %(name)s %(message)s'
}
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'formatter': 'simple'
}
},
'loggers': {
'screamshot': {
'handlers': ['console'],
'level': 'DEBUG'
}
}
},
INSTALLED_APPS=self.INSTALLED_APPS + self.apps)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures: # pragma: no cover
sys.exit(failures)
def __init__(self, *args, **kwargs):
self.cov = coverage()
self.cov.start()
self.configure()
self.packages = self.resolve_packages()
parser = argparse.ArgumentParser()
parser.add_argument('-a', '--autoreload', dest='autoreload',
action='store_const', const=True, default=False,)
parser.add_argument('-f', '--failfast', dest='failfast',
action='store_const', const=True, default=False,)
parser.add_argument('-l', '--label', dest='label')
self.options = vars(parser.parse_args(sys.argv[2:]))
sys.argv = sys.argv[:2]
runner_options = {
'verbosity': 1,
'interactive': True,
'failfast': False,
}
if django.VERSION >= (1, 8):
from django.test.runner import DiscoverRunner
self.test_runner = DiscoverRunner(**runner_options)
tests = self.test_runner.build_suite()
else:
from django.test.simple import DjangoTestSuiteRunner
self.test_runner = DjangoTestSuiteRunner(**runner_options)
tests = self.build_tests()
super(SetupTestSuite, self).__init__(tests=tests, *args, **kwargs)
# South patches the test management command to handle the
# SOUTH_TESTS_MIGRATE setting. Apply that patch if South is installed.
if django.VERSION < (1,7):
try:
from south.management.commands import patch_for_test_db_setup
patch_for_test_db_setup()
except ImportError:
pass
self.test_runner.setup_test_environment()
self.old_config = self.test_runner.setup_databases()
def test_runner_with_coverage(test_labels,
verbosity=1,
interactive=True,
failfast=None,
extra_tests=[]):
"""
Custom test runner. Follows the django.test.simple.run_tests() interface.
"""
# Start code coverage before anything else if necessary
if hasattr(settings, 'COVERAGE_MODULES'):
cov = coverage.coverage()
#coverage.use_cache(0) # Do not cache any of the coverage.py stuff
cov.use_cache(0) # Do not cache any of the coverage.py stuff
cov.start()
test_runner = DjangoTestSuiteRunner(verbosity=verbosity,
interactive=interactive,
failfast=failfast)
test_results = test_runner.run_tests(test_labels, extra_tests=extra_tests)
# Stop code coverage after tests have completed
if hasattr(settings, 'COVERAGE_MODULES'):
cov.stop()
# Print code metrics header
print ''
print '----------------------------------------------------------------------'
print ' Unit Test Code Coverage Results'
print '----------------------------------------------------------------------'
# Report code coverage metrics
if hasattr(settings, 'COVERAGE_MODULES'):
coverage_modules = []
for module in settings.COVERAGE_MODULES:
coverage_modules.append(
__import__(module, globals(), locals(), ['']))
cov.report(coverage_modules, show_missing=1)
cov.html_report(coverage_modules, directory='coverage_report')
# Print code metrics footer
print '----------------------------------------------------------------------'
return test_results
def runtests(*test_args):
if not test_args:
test_args = ['django_pandas']
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
if django.VERSION < (1, 8):
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner(verbosity=1,
interactive=True,
failfast=False).run_tests(['tests'])
sys.exit(failures)
else:
from django.test.runner import DiscoverRunner
failures = DiscoverRunner(verbosity=1,
interactive=True,
failfast=False).run_tests(test_args)
sys.exit(failures)
def _tests_1_7(self):
"""
Fire up the Django test suite developed for version 1.7 and up
"""
INSTALLED_APPS, settings_test = self.get_custom_settings()
settings.configure(
DEBUG=True,
DATABASES=self.get_database(),
MIDDLEWARE_CLASSES=('django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware'),
INSTALLED_APPS=self.INSTALLED_APPS + INSTALLED_APPS + self.apps,
**settings_test)
from django.test.simple import DjangoTestSuiteRunner
import django
django.setup()
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def _new_tests(self):
"""
Fire up the Django test suite developed for version 1.2
"""
settings.configure(DEBUG=True,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': 'foobar',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
},
INSTALLED_APPS=self.INSTALLED_APPS + self.apps)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def _django_runner(request):
"""Create the django runner, internal to pytest-django
This does important things like setting up the local memory email
backend etc.
XXX It is a little dodgy that this is an autouse fixture. Perhaps
an email fixture should be requested in order to be able to
use the Django email machinery just like you need to request a
db fixture for access to the Django database, etc. But
without duplicating a lot more of Django's test support code
we need to follow this model.
"""
if django_settings_is_configured():
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner(interactive=False)
runner.setup_test_environment()
request.addfinalizer(runner.teardown_test_environment)
return runner
def _tests_1_7(self):
"""
Fire up the Django test suite developed for version 1.7 and up
"""
test_settings = self.custom_settings
installed_apps = test_settings.pop('INSTALLED_APPS', ())
settings.configure(
DEBUG=True,
DATABASES=self.get_database(1.7),
MIDDLEWARE_CLASSES=('django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware'),
INSTALLED_APPS=tuple(self.INSTALLED_APPS + installed_apps +
self.apps),
**test_settings)
from django.test.simple import DjangoTestSuiteRunner
import django
django.setup()
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
