def main():
"""
Standalone django model test with a 'memory-only-django-installation'.
You can play with a django model without a complete django app installation.
http://www.djangosnippets.org/snippets/1044/
"""
settings.configure(
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.sessions',
'django.contrib.contenttypes',
'upyun',
),
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
}
},
ROOT_URLCONF='beproud.django.authutils.tests.test_urls',
DEFAULT_FILE_STORAGE='django_upyun.UpYunStorage',
UPYUN_USERNAME=os.getenv('UPYUN_USERNAME'),
UPYUN_PASSWORD=os.getenv('UPYUN_PASSWORD'),
UPYUN_BUCKET=os.getenv('UPYUN_BUCKET'),
MEDIA_URL="http://%s.b0.upaiyun.com/media/" % os.getenv('UPYUN_BUCKET'),
STATIC_URL="http://%s.b0.upaiyun.com/static/" % os.getenv('UPYUN_BUCKET')
)
django.setup()
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(['upyun'])
sys.exit(failures)
def run_tests(self):
"""
Fire up the Django test suite
"""
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
)
django.setup()
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(self.apps)
if failures: # pragma: no cover
sys.exit(failures)
def test_reverse(self):
"""
Reverse should reorder tests while maintaining the grouping specified
by ``DiscoverRunner.reorder_by``.
"""
runner = DiscoverRunner(reverse=True)
suite = runner.build_suite(
test_labels=('test_runner_apps.sample', 'test_runner_apps.simple'))
self.assertIn('test_runner_apps.simple', next(iter(suite)).id(),
msg="Test labels should be reversed.")
suite = runner.build_suite(test_labels=('test_runner_apps.simple',))
suite = tuple(suite)
self.assertIn('DjangoCase', suite[0].id(),
msg="Test groups should not be reversed.")
self.assertIn('SimpleCase', suite[4].id(),
msg="Test groups order should be preserved.")
self.assertIn('DjangoCase2', suite[0].id(),
msg="Django test cases should be reversed.")
self.assertIn('SimpleCase2', suite[4].id(),
msg="Simple test cases should be reversed.")
self.assertIn('UnittestCase2', suite[8].id(),
msg="Unittest test cases should be reversed.")
self.assertIn('test_2', suite[0].id(),
msg="Methods of Django cases should be reversed.")
self.assertIn('test_2', suite[4].id(),
msg="Methods of simple cases should be reversed.")
self.assertIn('test_2', suite[8].id(),
msg="Methods of unittest cases should be reversed.")
def setup():
global test_runner
global old_config
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def add_arguments(cls, parser):
DiscoverRunner.add_arguments(parser)
parser.add_argument(
'--mayan-apps', action='store_true', default=False,
dest='mayan_apps',
help='Test all Mayan apps that report to have tests.'
)
def run_tests():
sys.stdout.write(
"\nRunning spirit test suite, using settings %(settings)r\n\n" %
{"settings": os.environ['DJANGO_SETTINGS_MODULE']})
test_runner = DiscoverRunner()
failures = test_runner.run_tests([])
sys.exit(failures)
def run_tests():
import django
from django.conf import global_settings
from django.conf import settings
settings.configure(
INSTALLED_APPS=[
'corsheaders',
],
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'TEST_NAME': ':memory:',
},
},
MIDDLEWARE_CLASSES=global_settings.MIDDLEWARE_CLASSES + (
'corsheaders.middleware.CorsMiddleware',),
)
if hasattr(django, 'setup'):
django.setup()
try:
from django.test.runner import DiscoverRunner as Runner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as Runner
test_runner = Runner(verbosity=1)
return test_runner.run_tests(['corsheaders'])
def run_tests():
import django
from django.conf import settings, global_settings
settings.configure(
# Minimal django settings
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'TEST_NAME': ':memory:',
},
},
MIDDLEWARE_CLASSES=global_settings.MIDDLEWARE_CLASSES,
INSTALLED_APPS=['etcd_settings'],
DJES_DEV_PARAMS=None,
DJES_REQUEST_GETTER=None,
DJES_ENV='dev',
DJES_ETCD_DETAILS=None,
DJES_WSGI_FILE=None
# DJES_ETCD_DETAILS=dict(host='localhost', port=4000, protocol='http',
# prefix='/config/my-django-app')
)
if hasattr(django, 'setup'):
django.setup()
try:
from django.test.runner import DiscoverRunner as Runner
except ImportError:
from django.test.simple import DjangoTestSuiteRunner as Runner
test_runner = Runner(verbosity=1)
return test_runner.run_tests(['tests'])
def _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,
MIDDLEWARE_CLASSES=self.MIDDLEWARE_CLASSES,
ROOT_URLCONF='helpdesk.tests.urls',
STATIC_URL='/static/',
TEMPLATES=self.TEMPLATES
)
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
django.setup()
failures = test_runner.run_tests(self.apps)
if failures:
sys.exit(failures)
def test_add_arguments_debug_mode(self):
parser = ArgumentParser()
DiscoverRunner.add_arguments(parser)
ns = parser.parse_args([])
self.assertFalse(ns.debug_mode)
ns = parser.parse_args(["--debug-mode"])
self.assertTrue(ns.debug_mode)
def runtests(*test_args):
from django.test.runner import DiscoverRunner
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DiscoverRunner(verbosity=1, interactive=True)
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def run_tests():
"""Run the test suite."""
import django
from django.test.runner import DiscoverRunner
django.setup()
test_runner = DiscoverRunner(verbosity=2, interactive=False)
failures = test_runner.run_tests(['.'])
sys.exit(bool(failures))
def runtests(*test_args, **kwargs):
if not test_args:
test_args = ['djangobb_forum']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DiscoverRunner(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(options={}):
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
django.setup()
setup_test_environment()
test_runner = DiscoverRunner(**options)
failures = test_runner.run_tests(['django_elect'])
sys.exit(failures)
def runtests(*args):
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
testrunner = DjangoTestRunner()
if not args:
args = None
failures = testrunner.run_tests(args)
sys.exit(failures)
def setUpModule():
if django is None:
raise unittest.SkipTest(SKIPTEST_TEXT)
setup_test_environment()
global DJANGO_RUNNER
global DJANGO_RUNNER_STATE
DJANGO_RUNNER = DiscoverRunner()
DJANGO_RUNNER_STATE = DJANGO_RUNNER.setup_databases()
def setUpModule():
django_test_utils.setup_test_environment()
runner = DjangoTestSuiteRunner()
runner_state = runner.setup_databases()
test_state.update({
'runner': runner,
'runner_state': runner_state,
})
def setup():
from django.test.runner import DiscoverRunner
global test_runner
global old_config
test_runner = DiscoverRunner()
test_runner.setup_test_environment()
old_config = test_runner.setup_databases()
def runtests():
setup_test_environment()
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
runner = DiscoverRunner(verbosity=1, interactive=True, failfast=False)
failures = runner.run_tests(())
sys.exit(failures)
def runtests(*test_args, **kwargs):
if not test_args:
test_args = ['countries_field']
django.setup()
test_runner = DiscoverRunner(**kwargs)
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ["fixture_generator.tests"]
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
setup()
runner = DiscoverRunner(verbosity=2, interactive=True, failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def run_tests(*test_args):
# Run tests
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(test_args)
if failures:
sys.exit(failures)
def runtests(*test_args):
# Setup settings
if not settings.configured:
settings.configure(**test_settings.__dict__)
setup()
test_runner = TestRunner(verbosity=1)
failures = test_runner.run_tests(['dpaste'])
if failures:
sys.exit(failures)
def run_tests():
# Modify path
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
# Run tests
test_runner = DiscoverRunner(verbosity=2)
failures = test_runner.run_tests(['tests'])
sys.exit(failures)
def test_setup_aliased_default_database(self):
"""
Test that setup_datebases() doesn't fail when 'default' is aliased
"""
tested_connections = db.ConnectionHandler({"default": {"NAME": "dummy"}, "aliased": {"NAME": "dummy"}})
with mock.patch("django.test.utils.connections", new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
def runtests():
if not settings.configured:
settings.configure(**DEFAULT_SETTINGS)
django.setup()
test_runner = DiscoverRunner(verbosity=1, interactive=True, failfast=False)
failures = test_runner.run_tests(['tests'])
sys.exit(bool(failures))
def test_setup_databases(self):
"""
Test that setup_databases() doesn't fail with dummy database backend.
"""
tested_connections = db.ConnectionHandler({})
with mock.patch("django.test.utils.connections", new=tested_connections):
runner_instance = DiscoverRunner(verbosity=0)
old_config = runner_instance.setup_databases()
runner_instance.teardown_databases(old_config)
def runtests(*test_args):
# Setup settings
if not settings.configured:
from memcache_status.tests.testapp import settings as TEST_SETTINGS
settings.configure(**TEST_SETTINGS.__dict__)
setup()
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(['memcache_status'])
if failures:
sys.exit(failures)
def run_tests():
print("Running tests against %s database." % db)
#from django.test.simple import DjangoTestSuiteRunner
#test_runner = DjangoTestSuiteRunner(verbosity=1, failfast=False)
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1, failfast=False)
failures = test_runner.run_tests(['django_database_constraints', ])
if failures: #pragma no cover
sys.exit(failures)
def runtests():
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
django.setup()
runner = DiscoverRunner(verbosity=1, interactive=True,
failfast=bool(os.environ.get('FAILFAST')))
failures = runner.run_tests(())
sys.exit(failures)
settings.configure(
DEBUG=True,
DATABASES={'default': {
'ENGINE': 'django.db.backends.sqlite3',
}},
INSTALLED_APPS=('django.contrib.auth', 'django.contrib.contenttypes',
'django.contrib.sessions', 'django.contrib.admin',
'django_databrowse'),
MIDDLEWARE_CLASSES=[],
ROOT_URLCONF='test_urls',
TEMPLATES=[{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.contrib.auth.context_processors.auth',
]
}
}])
from django.test.runner import DiscoverRunner
django.setup()
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests([
'django_databrowse',
])
if failures:
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = [default_test_args]
runner = DjangoTestSuiteRunner(failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
# -*- encoding: utf-8 -*-
from __future__ import unicode_literals
from django.conf import settings as django_settings
from django.core.management import call_command
from django.test.runner import DiscoverRunner
from .fixtures import *
from .toolbox import Configuration
assert fixtures_registered # Just to prevent IDE from import removal on optimization.
runner = DiscoverRunner(interactive=False, verbosity=0)
setup_databases = runner.setup_databases
teardown_databases = runner.teardown_databases
def pytest_runtest_setup(item):
# todo optional db initialization
item.old_config = setup_databases()
def pytest_runtest_teardown(item, nextitem):
unset = {}
old_config = getattr(item, 'old_config', unset)
if old_config is unset:
# _teardown will suddenly work even if no _setup has occured
# e.g. in case of mark.skipif
return
def test_overridable_get_test_runner_kwargs(self):
self.assertIsInstance(DiscoverRunner().get_test_runner_kwargs(), dict)
def test_dotted_test_module(self):
count = DiscoverRunner().build_suite(
['test_runner_apps.sample.tests_sample'], ).countTestCases()
self.assertEqual(count, 4)
def test_overridable_test_suite(self):
self.assertEqual(DiscoverRunner().test_suite, TestSuite)
def test_dotted_test_class_vanilla_unittest(self):
count = DiscoverRunner().build_suite(
["test_discovery_sample.tests_sample.TestVanillaUnittest"],
).countTestCases()
self.assertEqual(count, 1)
def test_overridable_test_loader(self):
self.assertEqual(DiscoverRunner().test_loader, defaultTestLoader)
def test_overridable_test_runner(self):
self.assertEqual(DiscoverRunner().test_runner, TextTestRunner)
'odontotheme',
))
import django
django.setup()
from opal.core import application
class Application(application.OpalApplication):
pass
try:
sys.argv.remove('--failfast')
failfast = True
except ValueError:
failfast = False
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1, failfast=failfast)
if len(sys.argv) == 2:
failures = test_runner.run_tests([
sys.argv[-1],
])
else:
failures = test_runner.run_tests([
'odontotheme',
])
if failures:
sys.exit(failures)
class SetupDatabasesTests(unittest.TestCase):
def setUp(self):
self.runner_instance = DiscoverRunner(verbosity=0)
def test_setup_aliased_databases(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
},
'other': {
'ENGINE': 'django.db.backends.dummy',
'NAME': 'dbname',
}
})
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
old_config = self.runner_instance.setup_databases()
self.runner_instance.teardown_databases(old_config)
mocked_db_creation.return_value.destroy_test_db.assert_called_once_with(
'dbname', 0, False)
def test_destroy_test_db_restores_db_name(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': settings.DATABASES[db.DEFAULT_DB_ALIAS]["ENGINE"],
'NAME': 'xxx_test_database',
},
})
# Using the real current name as old_name to not mess with the test suite.
old_name = settings.DATABASES[db.DEFAULT_DB_ALIAS]["NAME"]
with mock.patch('django.db.connections', new=tested_connections):
tested_connections['default'].creation.destroy_test_db(old_name,
verbosity=0,
keepdb=True)
self.assertEqual(
tested_connections['default'].settings_dict["NAME"], old_name)
def test_serialization(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
},
})
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=True, keepdb=False)
def test_serialized_off(self):
tested_connections = db.ConnectionHandler({
'default': {
'ENGINE': 'django.db.backends.dummy',
'TEST': {
'SERIALIZE': False
},
},
})
with mock.patch(
'django.db.backends.dummy.base.DatabaseWrapper.creation_class'
) as mocked_db_creation:
with mock.patch('django.test.utils.connections',
new=tested_connections):
self.runner_instance.setup_databases()
mocked_db_creation.return_value.create_test_db.assert_called_once_with(
verbosity=0, autoclobber=False, serialize=False, keepdb=False)
def __init__(self, on_run_suite):
django.setup()
DiscoverRunner.__init__(self)
self.on_run_suite = on_run_suite
def test_discovery_on_package(self):
count = DiscoverRunner().build_suite(
["test_discovery_sample.tests"],
).countTestCases()
self.assertEqual(count, 1)
def test_empty_test_case(self):
count = DiscoverRunner().build_suite(
["test_discovery_sample.tests_sample.EmptyTestCase"],
).countTestCases()
self.assertEqual(count, 0)
def test_pattern(self):
count = DiscoverRunner(
pattern="*_tests.py",
).build_suite(["test_discovery_sample"]).countTestCases()
self.assertEqual(count, 1)
def test_empty_test_case(self):
count = DiscoverRunner().build_suite(
['test_runner_apps.sample.tests_sample.EmptyTestCase'
], ).countTestCases()
self.assertEqual(count, 0)
def run_tests(reverse=False):
sys.stdout.write(
"\nRunning spirit test suite, using settings %(settings)r\n\n" %
{"settings": os.environ['DJANGO_SETTINGS_MODULE']})
return DiscoverRunner(reverse=reverse).run_tests([])
def test_faulthandler_disabled(self, mocked_enable):
with mock.patch('faulthandler.is_enabled', return_value=False):
DiscoverRunner(enable_faulthandler=False)
mocked_enable.assert_not_called()
def test_buffer_with_parallel(self):
msg = ('You cannot use -b/--buffer with parallel tests; pass '
'--parallel=1 to use it.')
with self.assertRaisesMessage(ValueError, msg):
DiscoverRunner(buffer=True, parallel=2)
def test_init_debug_mode(self):
runner = DiscoverRunner()
self.assertFalse(runner.debug_mode)
def setUp(self):
self.runner_instance = DiscoverRunner(verbosity=0)
def test_dotted_test_module(self):
count = DiscoverRunner().build_suite(
["test_discovery_sample.tests_sample"],
).countTestCases()
self.assertEqual(count, 6)
#!/usr/bin/env python
import os
import sys
import django
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'tests.settings')
django.setup()
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=2)
failures = test_runner.run_tests(['tests.base'])
if failures:
sys.exit(failures)
'django.contrib.admin',
'tabbed_admin',
'tabbed_admin.tests'
)
)
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)
try:
# Django < 1.7
from django.core.management import setup_environ
setup_environ(settings)
failures = test_runner.run_tests(['tabbed_admin'])
except:
# Django >= 1.7
import django
django.setup()
failures = test_runner.run_tests(['tabbed_admin'])
if failures:
sys.exit(failures)
def test_faulthandler_enabled_fileno(self, mocked_enable):
# sys.stderr that is not an actual file.
with mock.patch('faulthandler.is_enabled',
return_value=False), captured_stderr():
DiscoverRunner(enable_faulthandler=True)
mocked_enable.assert_called()
def test_pattern(self):
count = DiscoverRunner(pattern="*_tests.py", ).build_suite(
['test_runner_apps.sample']).countTestCases()
self.assertEqual(count, 1)
def test_file_path(self):
with change_cwd(".."):
count = DiscoverRunner().build_suite(
['test_runner_apps/sample/'], ).countTestCases()
self.assertEqual(count, 5)
def test_dotted_test_class_django_testcase(self):
count = DiscoverRunner().build_suite(
['test_runner_apps.sample.tests_sample.TestDjangoTestCase'
], ).countTestCases()
self.assertEqual(count, 1)
def test_dotted_test_method_django_testcase(self):
count = DiscoverRunner().build_suite(
["test_discovery_sample.tests_sample.TestDjangoTestCase.test_sample"],
).countTestCases()
self.assertEqual(count, 1)
def before_all(context):
django.setup()
context.test_runner = DiscoverRunner()
context.test_runner.setup_test_environment()
context.browser = Browser('chrome', headless=True)