def setUpClass(cls):
test_runner = DjangoTestSuiteRunner(interactive=False, verbosity=1)
test_db = test_runner.setup_databases()
load_fixture()
setattr(cls, "test_runner", test_runner)
setattr(cls, "test_db", test_db)
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
)
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)
import django
django.setup()
failures = test_runner.run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def runtests():
verbose_level = 1
args = sys.argv[1:]
if '-v' in args:
index = args.index('-v')
_ = args.pop(index)
verbose_level = int(args.pop(index))
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, verbose_level, True)
sys.exit(result)
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_suite = DjangoTestSuiteRunner(verbose_level, True)
result = test_suite.run_tests(test_labels)
sys.exit(result)
def run_tests(verbosity, *test_args):
if not test_args:
test_args = ['url_tracker']
test_runner = DjangoTestSuiteRunner(verbosity=verbosity)
num_failures = test_runner.run_tests(test_args)
if num_failures:
sys.exit(num_failures)
def runtests(*test_args):
if not test_args:
test_args = ['blog']
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True, failfast=False)
failures = runner.run_tests(test_args)
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():
import django
# Django >= 1.7: Call django.setup() to initialize Django
setup = getattr(django, 'setup', lambda: None)
setup()
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner(interactive=False)
runner.setup_test_environment()
request.addfinalizer(runner.teardown_test_environment)
return runner
def run_tests(verbosity, *test_args):
test_runner = DjangoTestSuiteRunner(verbosity=verbosity)
if not test_args:
test_args = ['oscar']
num_failures = test_runner.run_tests(test_args)
if num_failures:
sys.exit(num_failures)
def teardown_database(real_server):
'''
Destroys test database
'''
logger.info("Destroying test database.")
DjangoTestSuiteRunner.teardown_databases(world.test_runner, world.creaded_db)
def get_runner(config):
runner = DjangoTestSuiteRunner(interactive=False)
if config.option.no_db:
def cursor_wrapper_exception(*args, **kwargs):
raise RuntimeError('No database access is allowed since --no-db was used!')
def setup_databases():
# Monkey patch CursorWrapper to warn against database usage
django.db.backends.util.CursorWrapper = cursor_wrapper_exception
def teardown_databases(db_config):
pass
runner.setup_databases = setup_databases
runner.teardown_databases = teardown_databases
elif config.option.reuse_db:
if not config.option.create_db:
monkey_patch_creation_for_db_reuse()
# Leave the database for the next test run
runner.teardown_databases = lambda db_config: None
return runner
def test_setup_aliased_databases(self):
from django.db.backends.dummy.base import DatabaseCreation
runner = DjangoTestSuiteRunner(verbosity=0)
old_db_connections = db.connections
old_destroy_test_db = DatabaseCreation.destroy_test_db
old_create_test_db = DatabaseCreation.create_test_db
try:
destroyed_names = []
DatabaseCreation.destroy_test_db = lambda self, old_database_name, verbosity=1: destroyed_names.append(old_database_name)
DatabaseCreation.create_test_db = lambda self, verbosity=1, autoclobber=False: self._get_test_db_name()
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
},
'other': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
}
})
old_config = runner.setup_databases()
runner.teardown_databases(old_config)
self.assertEqual(destroyed_names.count('dbname'), 1)
finally:
DatabaseCreation.create_test_db = old_create_test_db
DatabaseCreation.destroy_test_db = old_destroy_test_db
db.connections = old_db_connections
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()
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 ''
print '-------------------------------------------------------------------'
print ' Unit Test Code Coverage Results'
print '-------------------------------------------------------------------'
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 '-------------------------------------------------------------------'
return test_results
def handle(self, *args, **options):
USE_SOUTH = getattr(settings, "SOUTH_TESTS_MIGRATE", True)
try:
if USE_SOUTH:
from south.management.commands import patch_for_test_db_setup
patch_for_test_db_setup()
except:
USE_SOUTH = False
self._test_runner = DjangoTestSuiteRunner(interactive=False)
DjangoTestSuiteRunner.setup_test_environment(self._test_runner)
self._created_db = DjangoTestSuiteRunner.setup_databases(self._test_runner)
call_command('syncdb', verbosity=0, interactive=False,)
if USE_SOUTH:
call_command('migrate', verbosity=0, interactive=False,)
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)
tags = options.get('tags', None)
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 setup():
global test_runner
global old_config
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def setup_django(self):
from django.conf import settings
# If Django < 1.2
if self.legacy_django:
from django.db import connection
from django.test.utils import setup_test_environment
# Setup Django test environment
setup_test_environment()
# Create Django test database
self.old_database_name = settings.DATABASE_NAME
connection.creation.create_test_db(self.verbosity,
autoclobber=True)
# If Django >= 1.2
else:
from django.test.simple import DjangoTestSuiteRunner
# Initialize Django tests runner
runner = DjangoTestSuiteRunner(interactive=self.interactive,
verbosity=self.verbosity)
# Setup test environment
runner.setup_test_environment()
# Setup test databases
self.old_config = runner.setup_databases()
self.runner = runner
def teardown_database(actual_server):
'''
This will destroy your test database after all of your tests have executed.
'''
logger.info("Destroying the test database ...")
DjangoTestSuiteRunner.teardown_databases(world.test_runner, world.created_db)
def main():
settings.configure(
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
}
},
ROOT_URLCONF='acme_challenge.urls',
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.admin',
'acme_challenge',)
)
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(['acme_challenge'])
if failures:
sys.exit(failures)
def runtests(*test_args):
"""Setup and run django-password-policies test suite.
This still uses the old django.test.simple.DjangoTestSuiteRunner for
compatibility reasons with older Django versions and because of the
abstract base classes which shouldn't be considered as tests, but are
discovered by the newer django.test.runner.DiscoverRunner.
"""
os.environ['DJANGO_SETTINGS_MODULE'] = 'password_policies.tests.settings'
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
try:
django.setup()
except AttributeError:
# Access one setting to trigger the initialization of the settings as
# workaround for older Django versions
settings.INSTALLED_APPS
try:
from django.test.runner import DiscoverRunner
potential_test_args = ['password_policies.tests']
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(interactive=False)
potential_test_args = ['password_policies']
else:
test_runner = DiscoverRunner(interactive=False)
if not test_args:
test_args = potential_test_args
failures = test_runner.run_tests(test_args)
sys.exit(bool(failures))
def run_tests():
"""
Use the Django test runner to run the tests.
"""
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner(verbosity=2)
runner.run_tests(None)
def runtests():
from django.test.simple import DjangoTestSuiteRunner
dtsr = DjangoTestSuiteRunner(verbosity=1,
interactive=True,
failfast=False)
failures = dtsr.run_tests(['django_unique_submission'])
sys.exit(failures)
def run_tests(*test_args):
from django.test.simple import DjangoTestSuiteRunner
if not test_args:
test_args = ['main']
tests_runner = DjangoTestSuiteRunner(
verbosity=1, interactive=True, failfast=False)
failures = tests_runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
test_args = test_args or ['testapp']
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True,
failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['django_measurement']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*args):
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
testrunner = DjangoTestSuiteRunner()
if not args:
args = None
failures = testrunner.run_tests(args)
sys.exit(failures)
def setup_django_test_database():
from django.test.simple import DjangoTestSuiteRunner
from django.test.utils import setup_test_environment
from south.management.commands import patch_for_test_db_setup
runner = DjangoTestSuiteRunner(verbosity=0, failfast=False)
patch_for_test_db_setup()
setup_test_environment()
return runner, runner.setup_databases()
def runtests(*args, **kwargs):
dts = DjangoTestSuiteRunner(
verbosity=kwargs.get('verbosity', 1),
interactive=kwargs.get('interactive', False),
failfast=kwargs.get('failfast')
)
failures = dts.run_tests(*args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ["dialogos"]
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ["linkcheck"]
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def runtests(args=None):
try:
from django.test.simple import DjangoTestSuiteRunner
except ImportError:
from django.test import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests(['census', ])
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ["tests"]
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=2, interactive=True, failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['pro', 'standard', 'ipn']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests(test_args, verbosity=1, interactive=True)
sys.exit(failures)
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 _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 _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 runtests():
if hasattr(django, 'setup'):
django.setup()
return DjangoTestSuiteRunner(failfast=False).run_tests([
'crispy_forms.TestBasicFunctionalityTags',
'crispy_forms.TestFormHelper',
'crispy_forms.TestBootstrapFormHelper',
'crispy_forms.TestBootstrap3FormHelper',
'crispy_forms.TestFormLayout',
'crispy_forms.TestBootstrapFormLayout',
'crispy_forms.TestBootstrap3FormLayout',
'crispy_forms.TestLayoutObjects',
'crispy_forms.TestBootstrapLayoutObjects',
'crispy_forms.TestDynamicLayouts',
],
verbosity=1,
interactive=True)
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 run_tests(self, test_labels=('pages', ), extra_tests=None):
if coverage:
cov = coverage()
cov.erase()
cov.use_cache(0)
cov.start()
results = DjangoTestSuiteRunner.run_tests(self, test_labels,
extra_tests)
if coverage:
cov.stop()
app = get_app('pages')
modules = get_all_coverage_modules(app)
cov.html_report(modules, directory='coverage')
sys.exit(results)
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 _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 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 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 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 _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 _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)
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 runtests(*test_args):
from django.test.simple import DjangoTestSuiteRunner
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: ## setup.py test
test_args = ['ajaxutils_tests', '--jenkins']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
if '--jenkins' in test_args:
call_command('jenkins',
'ajaxutils_tests',
verbosity=1,
interactive=True)
sys.exit(0)
else:
failures = DjangoTestSuiteRunner().run_tests(test_args)
sys.exit(failures)
def run_tests(self, test_labels=('pages', ), extra_tests=None):
if coverage_module_present:
cov = coverage()
cov.erase()
cov.use_cache(0)
cov.start()
else:
print("No coverage support")
results = DjangoTestSuiteRunner.run_tests(self, test_labels,
extra_tests)
if coverage_module_present:
cov.stop()
app = get_app('pages')
modules = get_all_coverage_modules(app)
cov.html_report(modules, directory='coverage')
print('Coverage report stored in directory "coverage"')
sys.exit(results)
def run_tests(self):
"""
Fire up the Django test suite developed for version 1.2
"""
settings.configure(
DATABASES={
'default': {
'ENGINE': 'django.contrib.gis.db.backends.spatialite',
'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: # pragma: no cover
sys.exit(failures)
def before_all(context):
from django.test.simple import DjangoTestSuiteRunner
# We'll use thise later to frog-march Django through the motions
# of setting up and tearing down the test environment, including
# test databases.
context.runner = DjangoTestSuiteRunner()
patch_for_test_db_setup()
host = context.host = 'localhost'
port = context.port = getattr(settings, 'TESTING_MECHANIZE_INTERCEPT_PORT',
17681)
# NOTE: Nothing is actually listening on this port. wsgi_intercept
# monkeypatches the networking internals to use a fake socket when
# connecting to this port.
wsgi_intercept.add_wsgi_intercept(host, port, WSGIHandler)
def browser_url(url):
"""Create a URL for the virtual WSGI server.
e.g context.browser_url('/'), context.browser_url(reverse('my_view'))
"""
return urlparse.urljoin('http://%s:%d/' % (host, port), url)
context.browser_url = browser_url
def parse_soup():
r = context.browser.response()
h = r.read()
r.seek(0)
return BeautifulSoup(h)
context.parse_soup = parse_soup
def parse_lxml():
r = context.browser.response()
data = r.read()
r.seek(0)
return html.fromstring(data)
context.parse_lxml = parse_lxml
def run_tests(self):
"""
Fire up the Django test suite developed for version 1.2
"""
settings.configure(
TEMPLATE_DIRS = ('jsignature/templates/',),
ROOT_URLCONF = 'jsignature.tests',
DEBUG = True,
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(self.DIRNAME, 'database.db'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
},
MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
),
INSTALLED_APPS = self.INSTALLED_APPS + self.apps
)
# Setup is needed for Django >= 1.7
import django
if hasattr(django, 'setup'):
django.setup()
try:
from django.test.runner import DiscoverRunner
failures = DiscoverRunner().run_tests(self.apps, verbosity=1)
except ImportError:
# DjangoTestSuiteRunner has been deprecated in Django 1.7
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures: # pragma: no cover
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': os.path.join(self.DIRNAME, 'database.db'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
},
INSTALLED_APPS=self.INSTALLED_APPS + self.apps,
ROOT_URLCONF='unfriendly.tests.urls',
)
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def test_transaction_support(self):
"""Ticket #16329: sqlite3 in-memory test databases"""
old_db_connections = db.connections
for option in ('NAME', 'TEST_NAME'):
try:
db.connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.sqlite3',
option: ':memory:',
},
'other': {
'ENGINE': 'django.db.backends.sqlite3',
option: ':memory:',
},
})
other = db.connections['other']
DjangoTestSuiteRunner(verbosity=0).setup_databases()
msg = "DATABASES setting '%s' option set to sqlite3's ':memory:' value shouldn't interfere with transaction support detection." % option
# Transaction support should be properly initialised for the 'other' DB
self.assertTrue(other.features.supports_transactions, msg)
# And all the DBs should report that they support transactions
self.assertTrue(connections_support_transactions(), msg)
finally:
db.connections = old_db_connections
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,
FACEBOOK_REALTIME_VERIFY_TOKEN=
'EJEgWVcZCyx7NNoKT83xbxrKPy0sQPYZBZCkEZAm31PPoOoHojlTHPhGgZDAA',
ROOT_URLCONF='urlstest')
from django.test.simple import DjangoTestSuiteRunner
failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1)
if failures:
sys.exit(failures)
def tearDownClass(cls):
DjangoTestSuiteRunner().teardown_databases(cls.old_state)
settings.configure(
DEBUG=True,
# AUTH_USER_MODEL='testdata.CustomUser',
DATABASES={'default': {
'ENGINE': 'django.db.backends.sqlite3',
}},
SITE_ID=1,
ROOT_URLCONF=None,
INSTALLED_APPS=(
'djmoney',
'djmoney.tests.testapp',
'south',
),
USE_TZ=True,
SOUTH_TESTS_MIGRATE=True,
)
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
# If you use South for migrations, uncomment this to monkeypatch
# syncdb to get migrations to run.
from south.management.commands import patch_for_test_db_setup
patch_for_test_db_setup()
failures = test_runner.run_tests([
'djmoney',
])
if failures:
sys.exit(failures)
def setUpClass(cls):
cls.old_state = DjangoTestSuiteRunner().setup_databases()
def run_tests(test_labels, verbosity=1, interactive=True, failfast=False, 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.
If the settings file has an entry for COVERAGE_MODULES or test_labels is true it will prints the
coverage report for modules/apps
Returns number of tests that failed.
"""
do_coverage = (hasattr(settings, 'COVERAGE_MODULES') or
hasattr(settings, 'COVERAGE_APPS') or
bool(test_labels))
if do_coverage:
coverage.erase()
coverage.start()
DjangoTestSuiteRunner = None
try:
from django.test.simple import DjangoTestSuiteRunner
except ImportError:
from django.test import simple
if DjangoTestSuiteRunner:
testrunner = DjangoTestSuiteRunner(verbosity=verbosity, interactive=interactive, failfast=failfast)
retval = testrunner.run_tests(test_labels, extra_tests)
else:
retval = simple.run_tests(test_labels, verbosity, interactive, extra_tests)
if do_coverage:
coverage.stop()
# Print code metrics header
print ''
print '----------------------------------------------------------------------'
print ' Unit Test Code Coverage Results'
print '----------------------------------------------------------------------'
# try to import all modules for the coverage report.
modules = []
if test_labels or hasattr(settings, 'COVERAGE_APPS'):
# apps entered at the command line prompt override those specified in settings
labels = test_labels or settings.COVERAGE_APPS
for label in labels:
label = label.split('.')[0] #remove test class or test method from label
pkg = _get_app_package(label)
modules.extend(_package_modules(*pkg))
elif hasattr(settings, 'COVERAGE_MODULES'):
modules = [__import__(module, {}, {}, ['']) for module in settings.COVERAGE_MODULES]
if hasattr(settings, 'COVERAGE_EXCLUDE_MODULES'):
for exclude_module_name in settings.COVERAGE_EXCLUDE_MODULES:
# Test designed to avoid accidentally removing a module whose
# name is prefixed by an excluded module name, but still remove
# submodules
modules = [module for module in modules
if not module.__name__ == exclude_module_name and
not module.__name__.startswith(exclude_module_name + '.')]
coverage.report(modules, show_missing=1)
return retval
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(DIRNAME, 'database.db'),
}
}
settings.configure(
DEBUG=True,
DATABASES=DATABASES,
USE_TZ=True,
AUTHY_KEY='12345678910111213141516171819201234567891011121314151617181920',
ROOT_URLCONF='authy.urls',
PASSWORD_HASHERS=('django.contrib.auth.hashers.MD5PasswordHasher',
), # simple fast hasher but not secure
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.admin',
'authy',
))
from django.test.simple import DjangoTestSuiteRunner
call_command('syncdb', interactive=False)
failures = DjangoTestSuiteRunner().run_tests([
'authy',
], verbosity=1)
if failures:
sys.exit(failures)
def __init__(self, on_run_suite):
DjangoTestSuiteRunner.__init__(self)
self.on_run_suite = on_run_suite
def runtests():
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests([
APP,
])
sys.exit(failures)
def run_tests(test_args, verbosity, interactive):
runner = DjangoTestSuiteRunner(
verbosity=verbosity, interactive=interactive, failfast=False)
return runner.run_tests(test_args)