def run_tests():
if not os.environ.get("DJANGO_SETTINGS_MODULE", False):
setup_django_settings()
import django
from django.conf import settings
from django.test.utils import get_runner
if django.VERSION[1] >= 7: # Django 1.7.x or above
django.setup()
runner = get_runner(settings,"django.test.runner.DiscoverRunner")
else:
runner = get_runner(settings,"django.test.simple.DjangoTestSuiteRunner")
test_suite = runner(verbosity=2, interactive=True, failfast=False)
return test_suite.run_tests(["django_comments_xtd"])
def run():
"""Run the unittests."""
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True)
failures = test_runner.run_tests(['user_map'])
sys.exit(bool(failures))
def run_tests():
os.environ['DJANGO_SETTINGS_MODULE'] = 'simple_contact.tests.test_settings'
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner()
failures = test_runner.run_tests(["simple_contact.tests"])
sys.exit(bool(failures))
def main():
os.environ['DJANGO_SETTINGS_MODULE'] = 'tests.settings'
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner()
failures = test_runner.run_tests(["tests"])
sys.exit(bool(failures))
def main(verbosity=1, failfast=False, test_labels=None):
verbosity = int(verbosity)
if not test_labels:
test_labels = ["filer"]
with temp_dir() as STATIC_ROOT:
with temp_dir() as MEDIA_ROOT:
with temp_dir() as FILE_UPLOAD_TEMP_DIR:
# from django import VERSION
# use_tz = VERSION[:2] >= (1, 4)
use_tz = False
warnings.filterwarnings(
"error", r"DateTimeField received a naive datetime", RuntimeWarning, r"django\.db\.models\.fields"
)
configure(
ROOT_URLCONF="test_urls",
STATIC_ROOT=STATIC_ROOT,
MEDIA_ROOT=MEDIA_ROOT,
FILE_UPLOAD_TEMP_DIR=FILE_UPLOAD_TEMP_DIR,
USE_TZ=use_tz,
)
from django.conf import settings
from django.test.utils import get_runner
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=verbosity, interactive=False, failfast=failfast)
failures = test_runner.run_tests(test_labels)
sys.exit(failures)
def django_tests(verbosity, interactive, failfast, test_labels):
from django.conf import settings
state = setup(verbosity, test_labels)
# Add tests for invalid models apps.
extra_tests = []
for module_dir, module_name in get_invalid_modules():
module_label = '.'.join([module_dir, module_name])
if not test_labels or module_name in test_labels:
extra_tests.append(InvalidModelTestCase(module_label))
try:
# Invalid models are not working apps, so we cannot pass them into
# the test runner with the other test_labels
test_labels.remove(module_name)
except ValueError:
pass
# If GeoDjango is used, add it's tests that aren't a part of
# an application (e.g., GEOS, GDAL, Distance objects).
if geodjango(settings):
from django.contrib.gis.tests import geodjango_suite
extra_tests.append(geodjango_suite(apps=False))
# Run the test suite, including the extra validation tests.
from django.test.utils import get_runner
if not hasattr(settings, 'TEST_RUNNER'):
settings.TEST_RUNNER = 'django.test.simple.DjangoTestSuiteRunner'
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=verbosity, interactive=interactive, failfast=failfast)
failures = test_runner.run_tests(test_labels, extra_tests=extra_tests)
teardown(state)
return failures
def django_tests(verbosity, interactive, failfast, test_labels):
from django.conf import settings
state = setup(verbosity, test_labels)
extra_tests = []
# Run the test suite, including the extra validation tests.
from django.test.utils import get_runner
if not hasattr(settings, 'TEST_RUNNER'):
settings.TEST_RUNNER = 'django.test.runner.DiscoverRunner'
TestRunner = get_runner(settings)
test_runner = TestRunner(
verbosity=verbosity,
interactive=interactive,
failfast=failfast,
)
# Catch warnings thrown in test DB setup -- remove in Django 1.9
with warnings.catch_warnings():
warnings.filterwarnings(
'ignore',
"Custom SQL location '<app_label>/models/sql' is deprecated, "
"use '<app_label>/sql' instead.",
PendingDeprecationWarning
)
failures = test_runner.run_tests(
test_labels or get_installed(), extra_tests=extra_tests)
teardown(state)
return failures
def django_tests(verbosity, interactive, failfast, keepdb, reverse, test_labels, debug_sql):
state = setup(verbosity, test_labels)
extra_tests = []
if test_labels and 'postgres_tests' in test_labels and connection.vendor != 'postgres':
if verbosity >= 2:
print("Removed postgres_tests from tests as we're not running with PostgreSQL.")
test_labels.remove('postgres_tests')
# Run the test suite, including the extra validation tests.
if not hasattr(settings, 'TEST_RUNNER'):
settings.TEST_RUNNER = 'django.test.runner.DiscoverRunner'
TestRunner = get_runner(settings)
test_runner = TestRunner(
verbosity=verbosity,
interactive=interactive,
failfast=failfast,
keepdb=keepdb,
reverse=reverse,
debug_sql=debug_sql,
)
failures = test_runner.run_tests(
test_labels or get_installed(),
extra_tests=extra_tests,
)
teardown(state)
return failures
def main():
# Dynamically configure the Django settings with the minimum necessary to
# get Django running tests
settings.configure(
INSTALLED_APPS=[
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.admin',
'django.contrib.sessions',
'django_enumfield',
'django_enumfield.tests',
],
# Django replaces this, but it still wants it. *shrugs*
DATABASE_ENGINE='django.db.backends.sqlite3',
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
}
},
MEDIA_ROOT='/tmp/django_enums/',
MEDIA_PATH='/media/',
ROOT_URLCONF='django_enumfield.tests.urls',
DEBUG=True,
TEMPLATE_DEBUG=True,
)
from django.test.utils import get_runner
test_runner = get_runner(settings)(verbosity=2, interactive=True)
failures = test_runner.run_tests(['django_enumfield'])
sys.exit(failures)
def django_tests(verbosity, interactive, failfast, keepdb, reverse,
test_labels, debug_sql, parallel, tags, exclude_tags):
state = setup(verbosity, test_labels, parallel)
extra_tests = []
# Run the test suite, including the extra validation tests.
if not hasattr(settings, 'TEST_RUNNER'):
settings.TEST_RUNNER = 'django.test.runner.DiscoverRunner'
TestRunner = get_runner(settings)
test_runner = TestRunner(
verbosity=verbosity,
interactive=interactive,
failfast=failfast,
keepdb=keepdb,
reverse=reverse,
debug_sql=debug_sql,
parallel=actual_test_processes(parallel),
tags=tags,
exclude_tags=exclude_tags,
)
failures = test_runner.run_tests(
test_labels or get_installed(),
extra_tests=extra_tests,
)
teardown(state)
return failures
def runtests():
if hasattr(django, 'setup'):
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True, failfast=False)
failures = test_runner.run_tests(['scribbler', ])
sys.exit(failures)
def main():
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
if not settings.configured:
settings.configure(
INSTALLED_APPS=('django.contrib.auth', 'django.contrib.contenttypes', APP_NAME),
DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3'}},
ROOT_URLCONF = 'sitetree.tests',
MIDDLEWARE_CLASSES=global_settings.MIDDLEWARE_CLASSES, # Prevents Django 1.7 warning.
TEMPLATE_CONTEXT_PROCESSORS=tuple(global_settings.TEMPLATE_CONTEXT_PROCESSORS) + (
'django.core.context_processors.request',
)
)
try: # Django 1.7 +
from django import setup
setup()
except ImportError:
pass
from django.test.utils import get_runner
runner = get_runner(settings)()
failures = runner.run_tests((APP_NAME,))
sys.exit(failures)
def main():
from django.conf import settings
settings.configure(
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:'
}
},
INSTALLED_APPS = [
'cache_tagging.django_cache_tagging',
],
MIDDLEWARE_CLASSES = [
'cache_tagging.django_cache_tagging.middleware.TransactionMiddleware',
],
TEST_RUNNER = 'django.test.simple.DjangoTestSuiteRunner',
TEMPLATE_DIRS = [],
DEBUG = True,
TEMPLATE_DEBUG = True,
ROOT_URLCONF = 'runtests',
)
from cache_tagging.django_cache_tagging import autodiscover
autodiscover()
# Run the test suite, including the extra validation tests.
from django.test.utils import get_runner
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=False, failfast=False)
failures = test_runner.run_tests(['django_cache_tagging'])
sys.exit(failures)
def runtests(tests=('mezzanine_organizations',)):
"""
Takes a list as first argument, enumerating the apps and specific testcases
that should be executed. The syntax is the same as for what you would pass
to the ``django-admin.py test`` command.
Examples::
# run the default test suite
runtests()
# only run the tests from application ``mezzanine_organizations``
runtests(['mezzanine_organizations'])
# only run testcase class ``UnauthorizedListPagesPageAuthGroupTest``
# from app ``mezzanine_organizations``
runtests(['mezzanine_organizations.UnauthorizedListPagesPageAuthGroupTest'])
# run all tests from application ``mezzanine_page_auth`` and the test
# named ``test_register`` on the
# ``mezzanine_organizations.UnauthorizedListPagesPageAuthGroupTest``
# testcase.
runtests(['mezzanine_organizations.UnauthorizedListPagesPageAuthGroupTest.
test_unauthorized_list_pages_with_user_with_one_group''])
"""
#print(settings.TEST_RUNNER)
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True)
failures = test_runner.run_tests(tests)
sys.exit(bool(failures))
def main():
try:
django.setup()
except AttributeError:
pass
TestRunner = get_runner(settings)
test_runner = TestRunner()
if len(sys.argv) == 2:
test_case = '.' + sys.argv[1]
elif len(sys.argv) == 1:
test_case = ''
else:
print(usage())
sys.exit(1)
test_module_name = 'unsubscribe.tests'
if django.VERSION[0] == 1 and django.VERSION[1] < 6:
test_module_name = 'tests'
failures = test_runner.run_tests(
[test_module_name + test_case], verbosity=1, interactive=True)
sys.exit(failures)
def runtests():
os.environ["DJANGO_SETTINGS_MODULE"] = "example.settings"
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner()
failures = test_runner.run_tests(["django_fields.tests"])
sys.exit(bool(failures))
def main():
current_dir = os.path.dirname(__file__)
app_name = os.path.basename(current_dir)
sys.path.insert(0, os.path.join(current_dir, '..'))
if not settings.configured:
settings.configure(
INSTALLED_APPS=('django.contrib.auth', 'django.contrib.contenttypes', app_name),
DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3'}},
MIDDLEWARE_CLASSES=global_settings.MIDDLEWARE_CLASSES, # Prevents Django 1.7 warning.
ROOT_URLCONF='sitemessage.tests',
STATIC_URL='static/'
)
try: # Django 1.7 +
from django import setup
setup()
except ImportError:
pass
from django.test.utils import get_runner
runner = get_runner(settings)()
failures = runner.run_tests((app_name,))
sys.exit(failures)
def run_tests(settings):
from django.test.utils import get_runner
TestRunner = get_runner(settings)
test_runner = TestRunner(interactive=False)
failures = test_runner.run_tests(['greenfan'])
return failures
def runtests():
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True)
if hasattr(django, 'setup'):
django.setup()
failures = test_runner.run_tests(['rest_auth'])
sys.exit(bool(failures))
def main():
sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
if not settings.configured:
settings.configure(
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'etc', APP_NAME
),
DATABASES={'default': {'ENGINE': 'django.db.backends.sqlite3'}},
MIDDLEWARE_CLASSES=(
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
),
ROOT_URLCONF = 'sitegate.tests',
)
try: # Django 1.7 +
from django import setup
setup()
except ImportError:
pass
from django.test.utils import get_runner
runner = get_runner(settings)()
failures = runner.run_tests((APP_NAME,))
sys.exit(failures)
def handle(self, *test_labels, **options):
from django.conf import settings
from django.test.utils import get_runner
verbosity = int(options.get("verbosity", 1))
interactive = options.get("interactive", True)
failfast = options.get("failfast", False)
TestRunner = get_runner(settings)
if hasattr(TestRunner, "func_name"):
# Pre 1.2 test runners were just functions,
# and did not support the 'failfast' option.
import warnings
warnings.warn(
"Function-based test runners are deprecated. Test runners should be classes with a run_tests() method.",
DeprecationWarning,
)
failures = TestRunner(test_labels, verbosity=verbosity, interactive=interactive)
else:
test_runner = TestRunner(verbosity=verbosity, interactive=interactive, failfast=failfast)
failures = test_runner.run_tests(test_labels)
if failures:
sys.exit(bool(failures))
def main():
settings.configure(
INSTALLED_APPS=[
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.admin',
'django.contrib.sessions',
'nscms',
'nscms.contrib.newsletter',
],
DATABASE_ENGINE='django.db.backends.sqlite3',
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
}
},
MEDIA_ROOT='/tmp/nscms_test_media/',
MEDIA_URL='/media/',
STATIC_URL="/static/",
ROOT_URLCONF='nscms.tests.urls',
DEBUG=True,
TEMPLATE_DEBUG=True,
)
from django.test.utils import get_runner
test_runner = get_runner(settings)(verbosity=2, interactive=True)
failures = test_runner.run_tests(['nscms', 'newsletter'])
sys.exit(failures)
def run():
import sys
from django.test.utils import get_runner
runner = get_runner(settings)()
failures = runner.run_tests(('django_plim',))
sys.exit(failures)
def django_tests(verbosity, interactive, failfast, keepdb, reverse, test_labels):
state = setup(verbosity, test_labels)
extra_tests = []
# Run the test suite, including the extra validation tests.
if not hasattr(settings, 'TEST_RUNNER'):
settings.TEST_RUNNER = 'django.test.runner.DiscoverRunner'
TestRunner = get_runner(settings)
test_runner = TestRunner(
verbosity=verbosity,
interactive=interactive,
failfast=failfast,
keepdb=keepdb,
reverse=reverse,
)
# Catch warnings thrown in test DB setup -- remove in Django 1.9
with warnings.catch_warnings():
warnings.filterwarnings(
'ignore',
"Custom SQL location '<app_label>/models/sql' is deprecated, "
"use '<app_label>/sql' instead.",
RemovedInDjango19Warning
)
warnings.filterwarnings(
'ignore',
'initial_data fixtures are deprecated. Use data migrations instead.',
RemovedInDjango19Warning
)
failures = test_runner.run_tests(
test_labels or get_installed(), extra_tests=extra_tests)
teardown(state)
return failures
def runtests():
test_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, test_dir)
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',
'gargoyle',
'experiments',),
ROOT_URLCONF='experiments.urls',
)
from django.test.utils import get_runner
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, failfast=False)
failures = test_runner.run_tests(['experiments.tests', ])
sys.exit(bool(failures))
def runtests():
"""Find and run tests for cc-django-jw-sample."""
setup()
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True)
failures = test_runner.run_tests([])
sys.exit(failures)
def runtests():
if django.VERSION[:2] >= (1, 7):
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True, failfast=False)
failures = test_runner.run_tests(['popolo', ])
sys.exit(failures)
def satchless_tests(verbosity, interactive, failfast, tested_apps):
from django.conf import settings
failures = 0
from django.test.utils import get_runner
if not hasattr(settings, 'TEST_RUNNER'):
settings.TEST_RUNNER = 'django.test.simple.DjangoTestSuiteRunner'
TestRunner = get_runner(settings)
settings_state = setup(verbosity, tested_apps)
modules_names = []
for test_label in tested_apps:
if '.' in test_label:
modules_names.append(test_label.rsplit('.', 1)[1])
else:
modules_names.append(test_label)
if hasattr(TestRunner, 'func_name'):
# Pre 1.2 test runners were just functions,
# and did not support the 'failfast' option.
import warnings
warnings.warn(
'Function-based test runners are deprecated. Test runners should'
' be classes with a run_tests() method.',
DeprecationWarning
)
failures += TestRunner(modules_names, verbosity=verbosity,
interactive=interactive)
else:
test_runner = TestRunner(verbosity=verbosity, interactive=interactive,
failfast=failfast)
failures += test_runner.run_tests(modules_names)
teardown(settings_state)
return failures
def run_tests():
"""Wrapper for ./setup.py test"""
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "intranet.settings")
django.setup()
test_runner = get_runner(settings)()
failures = test_runner.run_tests([])
sys.exit(failures)
def runtests():
os.environ["DJANGO_SETTINGS_MODULE"] = "{{app_name}}_proj.settings"
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner()
failures = test_runner.run_tests([], verbosity=1, interactive=True)
sys.exit(bool(failures))
def django_tests(
verbosity,
interactive,
failfast,
keepdb,
reverse,
test_labels,
debug_sql,
parallel,
tags,
exclude_tags,
test_name_patterns,
start_at,
start_after,
pdb,
buffer,
timing,
shuffle,
):
if parallel in {0, "auto"}:
max_parallel = get_max_test_processes()
else:
max_parallel = parallel
if verbosity >= 1:
msg = "Testing against Django installed in '%s'" % os.path.dirname(
django.__file__)
if max_parallel > 1:
msg += " with up to %d processes" % max_parallel
print(msg)
process_setup_args = (verbosity, start_at, start_after, test_labels)
test_labels, state = setup_run_tests(*process_setup_args)
# Run the test suite, including the extra validation tests.
if not hasattr(settings, "TEST_RUNNER"):
settings.TEST_RUNNER = "django.test.runner.DiscoverRunner"
if parallel in {0, "auto"}:
# This doesn't work before django.setup() on some databases.
if all(conn.features.can_clone_databases
for conn in connections.all()):
parallel = max_parallel
else:
parallel = 1
TestRunner = get_runner(settings)
TestRunner.parallel_test_suite.process_setup = setup_run_tests
TestRunner.parallel_test_suite.process_setup_args = process_setup_args
test_runner = TestRunner(
verbosity=verbosity,
interactive=interactive,
failfast=failfast,
keepdb=keepdb,
reverse=reverse,
debug_sql=debug_sql,
parallel=parallel,
tags=tags,
exclude_tags=exclude_tags,
test_name_patterns=test_name_patterns,
pdb=pdb,
buffer=buffer,
timing=timing,
shuffle=shuffle,
)
failures = test_runner.run_tests(test_labels)
teardown_run_tests(state)
return failures
def get_test_runner(**options):
"""Returns the currently used django test runner (configured)"""
from django.conf import settings
from django.test.utils import get_runner
return get_runner(settings, options.get('testrunner'))()
def run_tests(*test_args):
"""
Run `rests` tests. Use `test_args` to specify which tests to run,
otherwise, all will be run.
"""
from django.conf import settings
# This tells django the settings to use for the tests - a stand-in
# for using a `settings.py` file.
settings.configure(
DEBUG_PROPAGATE_EXCEPTIONS=True,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:'
}
},
SITE_ID=1,
SECRET_KEY='not very secret in tests',
USE_I18N=True,
USE_L10N=True,
STATIC_URL='/static/',
ROOT_URLCONF='tests.urls',
TEMPLATES=[
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'APP_DIRS': True,
'OPTIONS': {
"debug": True, # We want template errors to raise
}
},
],
MIDDLEWARE=(
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
),
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.staticfiles',
'rest_framework',
'rest_framework.authtoken',
'rests',
'tests',
),
PASSWORD_HASHERS=('django.contrib.auth.hashers.MD5PasswordHasher', ),
)
if not test_args:
test_args = ['tests']
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner()
failures = test_runner.run_tests(test_args)
sys.exit(bool(failures))
def runtests():
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner()
failures = test_runner.run_tests(['tests'])
sys.exit(bool(failures))
def run_tests():
django.setup()
test_runner_class = get_runner(settings)
test_runner = test_runner_class(verbosity=1, interactive=True)
failures = test_runner.run_tests([])
sys.exit(bool(failures))
#!/usr/bin/env python
import os
import sys
import django
from django.conf import settings
from django.test.utils import get_runner
if __name__ == "__main__":
os.environ['DJANGO_SETTINGS_MODULE'] = 'tests.test_settings'
django.setup()
failures = TestRunner = get_runner(settings)().run_tests(["tests", "gdpr"])
sys.exit(bool(failures))
def run_tests(**kwargs):
os.environ['DJANGO_SETTINGS_MODULE'] = 'starwarsdemo.settings.test'
django.setup()
test_runner_class = get_runner(settings)
runner = test_runner_class(**kwargs)
return runner.run_tests([])
def main():
conf = {
"DEBUG": True,
"TEMPLATE_DEBUG": True,
"INSTALLED_APPS": [
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.sites",
"django.contrib.flatpages",
"viewlet",
"viewlet.tests",
],
"MIDDLEWARE_CLASSES": [
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.common.CommonMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
],
"MEDIA_ROOT": "/tmp/viewlet/media",
"STATIC_ROOT": "/tmp/viewlet/static",
"MEDIA_URL": "/media/",
"STATIC_URL": "/static/",
"ROOT_URLCONF": "viewlet.tests.urls",
"SECRET_KEY": "iufoj=mibkpdz*%bob952x(%49rqgv8gg45k36kjcg76&-y5=!",
"TEMPLATE_CONTEXT_PROCESSORS": [
"django.core.context_processors.request",
],
"TEMPLATES": [
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"APP_DIRS": True,
"DIRS": (os.path.join(ROOT, "template_dir"),),
"OPTIONS": {
"debug": True,
"context_processors": [
"django.contrib.auth.context_processors.auth",
"django.template.context_processors.request",
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
],
},
}
],
"JINJA2_TEMPLATES": [
{
"BACKEND": "django.template.backends.jinja2.Jinja2",
"APP_DIRS": True,
"DIRS": (
os.path.join(ROOT, "template_dir"),
os.path.join(ROOT, "templates"), # or change app_dirname
),
"OPTIONS": {
"extensions": [
"viewlet.loaders.jinja2_loader.ViewletExtension",
],
},
}
],
"JINJA2_ENVIRONMENT_OPTIONS": {"optimized": False}, # Coffin config
"JINJA_CONFIG": {"autoescape": True}, # Jingo config
}
conf["MIDDLEWARE"] = conf.pop("MIDDLEWARE_CLASSES")
conf.pop("TEMPLATE_DEBUG")
conf.pop("TEMPLATE_CONTEXT_PROCESSORS")
conf.update(
DATABASES={
"default": {
"ENGINE": "django.db.backends.sqlite3",
"NAME": ":memory:",
}
}
)
conf.update(
CACHES={"default": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache"}}
)
settings.configure(**conf)
django.setup()
from django.test.utils import get_runner
test_runner = get_runner(settings)(verbosity=2, interactive=True)
failures = test_runner.run_tests(["viewlet"])
sys.exit(failures)
from __future__ import absolute_import
from django.conf import settings
from django.test.simple import DjangoTestSuiteRunner
from django.test.utils import get_runner
# Dynamically retrieve the test runner class for this project.
TestRunnerClass = get_runner(settings, None)
class TestDiscoverer(TestRunnerClass):
"""A Django test runner that prints out all the test that will be run.
Doesn't actually run any of the tests.
"""
def run_tests(self, test_labels, extra_tests=None, **kwargs):
for test in self.build_suite([]):
# Django 1.6 introduce the new-style test runner.
# If that test runner is in use, we use the full test name.
# If we're still using a pre 1.6-style runner, we need to
# drop out all everything between the app name and the test module.
if issubclass(TestRunnerClass, DjangoTestSuiteRunner):
parts = test.id().split('.')
tests_index = parts.index('tests')
print '%s.%s.%s' % (parts[tests_index - 1], parts[-2],
parts[-1])
else:
print test.id()
return 0
def runtests():
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True, failfast=False)
failures = test_runner.run_tests(['django_seed', ])
sys.exit(failures)
def django_tests(verbosity, interactive, failfast, test_labels):
from django.conf import settings
old_installed_apps = settings.INSTALLED_APPS
old_root_urlconf = getattr(settings, "ROOT_URLCONF", "")
old_template_dirs = settings.TEMPLATE_DIRS
old_use_i18n = settings.USE_I18N
old_login_url = settings.LOGIN_URL
old_language_code = settings.LANGUAGE_CODE
old_middleware_classes = settings.MIDDLEWARE_CLASSES
# Redirect some settings for the duration of these tests.
settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS
settings.ROOT_URLCONF = 'urls'
settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR),)
settings.USE_I18N = True
settings.LANGUAGE_CODE = 'en'
settings.LOGIN_URL = '/accounts/login/'
settings.MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.common.CommonMiddleware',
)
settings.SITE_ID = 1
# For testing comment-utils, we require the MANAGERS attribute
# to be set, so that a test email is sent out which we catch
# in our tests.
settings.MANAGERS = ("*****@*****.**",)
# Load all the ALWAYS_INSTALLED_APPS.
# (This import statement is intentionally delayed until after we
# access settings because of the USE_I18N dependency.)
from django.db.models.loading import get_apps, load_app
get_apps()
# Load all the test model apps.
test_labels_set = set([label.split('.')[0] for label in test_labels])
for model_dir, model_name in get_test_models():
model_label = '.'.join([model_dir, model_name])
# if the model was named on the command line, or
# no models were named (i.e., run all), import
# this model and add it to the list to test.
if not test_labels or model_name in test_labels_set:
if verbosity >= 2:
print "Importing model %s" % model_name
mod = load_app(model_label)
if mod:
if model_label not in settings.INSTALLED_APPS:
settings.INSTALLED_APPS.append(model_label)
# Add tests for invalid models.
extra_tests = []
for model_dir, model_name in get_invalid_models():
model_label = '.'.join([model_dir, model_name])
if not test_labels or model_name in test_labels:
extra_tests.append(InvalidModelTestCase(model_label))
try:
# Invalid models are not working apps, so we cannot pass them into
# the test runner with the other test_labels
test_labels.remove(model_name)
except ValueError:
pass
# Run the test suite, including the extra validation tests.
from django.test.utils import get_runner
if not hasattr(settings, 'TEST_RUNNER'):
settings.TEST_RUNNER = 'django.test.simple.DjangoTestSuiteRunner'
TestRunner = get_runner(settings)
if hasattr(TestRunner, 'func_name'):
# Pre 1.2 test runners were just functions,
# and did not support the 'failfast' option.
import warnings
warnings.warn(
'Function-based test runners are deprecated. Test runners should be classes with a run_tests() method.',
PendingDeprecationWarning
)
failures = TestRunner(test_labels, verbosity=verbosity, interactive=interactive,
extra_tests=extra_tests)
else:
test_runner = TestRunner(verbosity=verbosity, interactive=interactive, failfast=failfast)
failures = test_runner.run_tests(test_labels, extra_tests=extra_tests)
if failures:
sys.exit(bool(failures))
# Restore the old settings.
settings.INSTALLED_APPS = old_installed_apps
settings.ROOT_URLCONF = old_root_urlconf
settings.TEMPLATE_DIRS = old_template_dirs
settings.USE_I18N = old_use_i18n
settings.LANGUAGE_CODE = old_language_code
settings.LOGIN_URL = old_login_url
settings.MIDDLEWARE_CLASSES = old_middleware_classes
"""Verify log can be successfully retrieved and response has certain properties.
The HttpResponse and its content are returned so that tests may do further
assertions."""
response = self.get_log(log_name, view_type=view_type, data=data)
content = response_content(response)
# Should always succeed
self.assertEqual(response.status_code, 200)
if expected_content:
# Should be exactly this content
# (if not provided, caller is expected to do custom verification)
self.assertEqual(content, expected_content)
# Content-Length is optional, but if present, must be correct
if test_content_length or ('Content-Length' in response):
self.assertEqual(response['Content-Length'], str(len(content)))
return response, content
def get_log(self, log_name, view_type='log', data={}):
url = '/task/{0}/{1}/{2}'.format(TASK_ID, view_type, log_name)
return self.client.get(url, data)
if __name__ == '__main__':
TestRunner = get_runner(django.conf.settings)
test_runner = TestRunner()
failures = test_runner.run_tests([__name__])
sys.exit(bool(failures))
"propagate": True,
}
}
}
)
django.setup()
class Item(models.Model):
name = models.CharField(max_length=255, default="foo", blank=True)
class Meta:
app_label = __name__
class Test(TestCase):
def test_it(self):
from django.test.utils import CaptureQueriesContext
from django.db import connections
with CaptureQueriesContext(connections["default"]):
Item(name="foo").save()
if __name__ == "__main__":
from django.apps import apps
for config in apps.get_app_configs():
config.models_module = __name__
factory = get_runner(settings)
test_runner = factory()
status = test_runner.run_tests([__name__])
def runtests():
django.setup()
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True)
failures = test_runner.run_tests(['sw_logger'])
sys.exit(bool(failures))
#!/usr/bin/env python
import os
import sys
import django
if __name__ == "__main__":
os.environ['DJANGO_SETTINGS_MODULE'] = 'tests.test_settings'
from django.conf import settings
from django.test.utils import get_runner
try:
django.setup()
except AttributeError:
# setup() call is needed for django 1.7+
pass
TestRunner = get_runner(settings)
test_runner = TestRunner()
failures = test_runner.run_tests(["tests"])
sys.exit(bool(failures))
def run_tests(): django.setup() sys.exit(bool(get_runner(settings)(verbosity=1, interactive=True).run_tests(['testproject.testapp.tests'])))
def run_tests():
cls = get_runner(settings)
runner = cls()
failures = runner.run_tests(['tests'])
sys.exit(failures)
def runtests():
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=1, interactive=True)
failures = test_runner.run_tests(['your_app'])
sys.exit(bool(failures))
dest='interactive',
default=True,
help='Tells Django to NOT prompt the user for input of any kind.',
)
parser.add_argument(
'--failfast',
action='store_true',
dest='failfast',
default=False,
help='Tells Django to stop running the test suite after first failed test.',
)
try:
subprocess.check_call(
['yarn', 'build'],
env={**os.environ, 'NODE_ENV': 'development', 'NO_HMR': '1'},
)
except subprocess.SubprocessError:
# maybe failed because the modules aren't installed
subprocess.check_call(['yarn', '--frozen-lockfile', '--production'])
subprocess.check_call(
['yarn', 'build'],
env={**os.environ, 'NODE_ENV': 'development', 'NO_HMR': '1'},
)
TestRunner = get_runner(settings, 'xmlrunner.extra.djangotestrunner.XMLTestRunner')
TestRunner.add_arguments(parser)
parsed = parser.parse_args(sys.argv[1:])
test_runner = TestRunner(**parsed.__dict__)
failures = test_runner.run_tests(parsed.args or ['tests'])
sys.exit(bool(failures))
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/
"""
sys.exc_clear()
os.environ["DJANGO_SETTINGS_MODULE"] = "django.conf.global_settings"
from django.conf import global_settings
global_settings.INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.sessions',
'django.contrib.contenttypes',
's3_folder_storage',
)
if django.VERSION > (1, 2):
global_settings.DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_PATH, 'connpass.sqlite'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
}
else:
global_settings.DATABASE_ENGINE = "sqlite3"
global_settings.DATABASE_NAME = ":memory:"
global_settings.MIDDLEWARE_CLASSES = (
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'beproud.django.authutils.middleware.AuthMiddleware',
)
# custom settings for tests
global_settings.DEFAULT_FILE_STORAGE = 's3_folder_storage.s3.DefaultStorage'
global_settings.DEFAULT_S3_PATH = "media"
global_settings.STATICFILES_STORAGE = 's3_folder_storage.s3.StaticStorage'
global_settings.STATIC_S3_PATH = "static"
# requires some envifonment variables
global_settings.AWS_ACCESS_KEY_ID = os.environ.get('AWS_ACCESS_KEY_ID',
None)
global_settings.AWS_SECRET_ACCESS_KEY = os.environ.get(
'AWS_SECRET_ACCESS_KEY', None)
global_settings.AWS_STORAGE_BUCKET_NAME = os.environ.get(
'AWS_STORAGE_BUCKET_NAME', None)
global_settings.MEDIA_ROOT = '/%s/' % global_settings.DEFAULT_S3_PATH
global_settings.MEDIA_URL = 'https://s3.amazonaws.com/%s/media/' % global_settings.AWS_STORAGE_BUCKET_NAME
global_settings.STATIC_ROOT = "/%s/" % global_settings.STATIC_S3_PATH
global_settings.STATIC_URL = 'https://s3.amazonaws.com/%s/static/' % global_settings.AWS_STORAGE_BUCKET_NAME
global_settings.ADMIN_MEDIA_PREFIX = global_settings.STATIC_URL + 'admin/'
# global_settings.DEFAULT_FILE_STORAGE = 'backends.s3boto.S3BotoStorage'
# global_settings.AWS_IS_GZIPPED = True
global_settings.SECRET_KEY = "blahblah"
from django.test.utils import get_runner
test_runner = get_runner(global_settings)
if django.VERSION > (1, 7):
print "running 1.7+ tests"
django.setup()
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner()
failures = test_runner.run_tests([
's3_folder_storage',
])
elif django.VERSION > (1, 2):
test_runner = test_runner()
failures = test_runner.run_tests([
's3_folder_storage',
])
else:
failures = test_runner([
's3_folder_storage',
], verbosity=1)
sys.exit(failures)
def runtests():
runner = get_runner(settings)(verbosity=1, interactive=True)
sys.exit(bool(runner.run_tests(('tests', ))))
def runtests(verbosity=1, interactive=True):
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=verbosity, interactive=interactive)
django.setup()
failures = test_runner.run_tests([])
sys.exit(bool(failures))
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/
"""
os.environ["DJANGO_SETTINGS_MODULE"] = "django.conf.global_settings"
from django.conf import global_settings
global_settings.SECRET_KEY = 'snakeoil'
global_settings.INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'beproud.django.commons.tests.test_shortcuts.shortcuts_app',
'beproud.django.commons.tests.models.base',
'beproud.django.commons.tests.models.fields',
'beproud.django.commons',
)
global_settings.DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
}
# For MySQL
# NOTE: Django < 1.7 の場合は bpcommons データベースは存在しないとダメ
#global_settings.DATABASES = {
# 'default': {
# 'ENGINE': 'django.db.backends.mysql',
# 'NAME': 'bpcommons',
# 'USER': '******',
# 'PASSWORD': '******',
# 'HOST': '<host>,
# #'PORT': '',
# }
#}
global_settings.ROOT_URLCONF = 'beproud.django.commons.tests.urls'
if django.VERSION > (1, 7):
django.setup()
from django.test.utils import get_runner
test_runner = get_runner(global_settings)
if django.VERSION > (1, 6):
# See: https://docs.djangoproject.com/en/1.6/topics/testing/overview/#running-tests
tests = ['beproud.django.commons']
else:
tests = ['commons']
test_runner = test_runner(interactive=False)
failures = test_runner.run_tests(tests)
sys.exit(failures)
#!/usr/bin/env python
import osimport sysimport djangofrom django.conf import settings
def delete_migrations(): from os.path import exists, abspath, dirname, join migrations_dir = join( dirname(abspath(__file__)), 'django_enumfield', 'tests', 'migrations') if exists(migrations_dir): os.system('rm -r ' + migrations_dir)
def main(): import warnings warnings.filterwarnings('error', category=DeprecationWarning)
delete_migrations()
if not settings.configured: # Dynamically configure the Django settings with the minimum necessary to # get Django running tests settings.configure( INSTALLED_APPS=[ 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.admin', 'django.contrib.sessions', 'django_enumfield', 'django_enumfield.tests', ], # Django replaces this, but it still wants it. *shrugs* DATABASE_ENGINE='django.db.backends.sqlite3', DATABASES={ 'default': { 'ENGINE': 'django.db.backends.sqlite3', } }, MEDIA_ROOT='/tmp/django_enums/', MEDIA_PATH='/media/', ROOT_URLCONF='django_enumfield.tests.urls', DEBUG=True, TEMPLATE_DEBUG=True, )
# Compatibility with Django 1.7's stricter initialization if hasattr(django, 'setup'): django.setup()
from django.test.utils import get_runner test_runner = get_runner(settings)(verbosity=2, interactive=True) if '--failfast' in sys.argv: test_runner.failfast = True
failures = test_runner.run_tests(['django_enumfield'])
delete_migrations()
sys.exit(failures)
if __name__ == '__main__': main()
#!/usr/bin/env python
from __future__ import annotations
import os
import sys
import django
from django.conf import settings as django_settings
from django.test.utils import get_runner
if __name__ == "__main__":
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'CharGenNG.settings')
import CharGenNG.settings as settings
settings.TESTING_MODE = True
settings.LOGGING = {}
# May modify settings!
django.setup()
TestRunner = get_runner(django_settings)
test_runner = TestRunner(verbosity=2)
failures = test_runner.run_tests(None)
sys.exit(bool(failures))
def runtests():
TestRunner = get_runner(settings)
test_runner = TestRunner(verbosity=0, interactive=False)
failures = test_runner.run_tests(['sugar'])
sys.exit(bool(failures))
def runtests():
settings = configure_settings()
settings.TEST_RUNNER='django.test.runner.DiscoverRunner'
django.setup()
runner = get_runner(settings)
sys.exit(runner.run_tests(['test.test_app']))
def run_tests(test_args, verbosity, interactive):
runner = get_runner(settings)()
return runner.run_tests(test_args)
def main():
print("Running tests for Python {} and Django {}".format(
_format_version(sys.version_info[:3]),
_format_version(django.VERSION[:3])))
import warnings
# Ignore deprecation warning caused by Django on 3.7 + 2.0
is_py37_django20 = sys.version_info[:2] == (
3, 7) and django.VERSION[:2] == (2, 0)
module = r"(?!django).*" if is_py37_django20 else ""
warnings.filterwarnings("error",
module=module,
category=DeprecationWarning)
delete_migrations()
if not settings.configured:
# Dynamically configure the Django settings with the minimum necessary to
# get Django running tests
settings.configure(
INSTALLED_APPS=[
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.admin",
"django.contrib.sessions",
"django.contrib.messages",
"django_enumfield",
"django_enumfield.tests",
],
TEMPLATES=[{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [],
"APP_DIRS": True,
"OPTIONS": {
"context_processors": [
"django.contrib.auth.context_processors.auth",
"django.contrib.messages.context_processors.messages",
]
},
}],
# Django replaces this, but it still wants it. *shrugs*
DATABASE_ENGINE="django.db.backends.sqlite3",
DATABASES={"default": {
"ENGINE": "django.db.backends.sqlite3"
}},
MEDIA_ROOT="/tmp/django_enums/",
MEDIA_PATH="/media/",
ROOT_URLCONF="django_enumfield.tests.urls",
DEBUG=True,
TEMPLATE_DEBUG=True,
MIDDLEWARE_CLASSES=[],
MIDDLEWARE=[
"django.contrib.sessions.middleware.SessionMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
],
)
# Compatibility with Django 1.7's stricter initialization
if hasattr(django, "setup"):
django.setup()
from django.test.utils import get_runner
test_runner = get_runner(settings)(verbosity=2, interactive=True)
if "--failfast" in sys.argv:
test_runner.failfast = True
failures = test_runner.run_tests(["django_enumfield"])
delete_migrations()
sys.exit(failures)
'django.contrib.messages.middleware.MessageMiddleware',
),
'DEBUG': False,
'SHOW_TOOLBAR': False,
'DEBUG_TOOLBAR_PANELS': (
'permissionsx.contrib.django_debug_toolbar.PermissionsPanel',
),
'DEBUG_TOOLBAR_CONFIG': {
'INTERCEPT_REDIRECTS': False,
'SHOW_TOOLBAR_CALLBACK': 'permissionsx.tests.utils.show_toolbar',
},
'TEMPLATE_DIRS': (
os.path.join(os.path.abspath(os.path.dirname(__file__)), 'templates'),
os.path.join(os.path.abspath(os.path.dirname(__file__)), 'tests/templates'),
),
'ROOT_URLCONF': 'permissionsx.tests.urls',
}
settings.configure(**configure_settings)
from django.test.utils import get_runner
if django.VERSION >= (1, 7):
django.setup()
test_runner = get_runner(settings)
failures = test_runner(
verbosity=1,
interactive=False,
failfast=False).run_tests(['tests'])
sys.exit(failures)
