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)