def _tests_1_7(self): """ Fire up the Django test suite developed for version 1.7 and up """ INSTALLED_APPS, settings_test = self.get_custom_settings() settings.configure( DEBUG=True, DATABASES=self.get_database(), MIDDLEWARE_CLASSES=( "django.middleware.common.CommonMiddleware", "django.middleware.csrf.CsrfViewMiddleware", ), INSTALLED_APPS=self.INSTALLED_APPS + INSTALLED_APPS + self.apps, **settings_test ) try: # Django <= 1.8 from django.test.simple import DjangoTestSuiteRunner test_runner = DjangoTestSuiteRunner(verbosity=1) except ImportError: # Django >= 1.8 from django.test.runner import DiscoverRunner test_runner = DiscoverRunner(verbosity=1) import django django.setup() failures = test_runner.run_tests(self.apps, verbosity=1) if failures: sys.exit(failures)
def setup(): DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': ':memory:' } } INSTALLED_APPS = [ 'django.contrib.auth', 'django.contrib.contenttypes', 'compat', 'compat.tests.test_app', ] if django.VERSION < (1, 7): INSTALLED_APPS.append('compat.tests') MIDDLEWARE_CLASSES = [] if django.VERSION < (1, 7): MIDDLEWARE_CLASSES.append('django.middleware.transaction.TransactionMiddleware') from django.conf import settings if not settings.configured: settings.configure( INSTALLED_APPS=INSTALLED_APPS, DATABASES=DATABASES, ROOT_URLCONF='compat.tests.urls', MIDDLEWARE_CLASSES = MIDDLEWARE_CLASSES, )
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(): # 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 _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': '', } }, SHIBBOLETH_LOGIN_URL = 'https://your_domain.edu/Shibboleth.sso/Login', SHIBBOLETH_LOGOUT_URL = 'https://your_domain.edu/Shibboleth.sso/Logout', LOGIN_URL = '/shib/login/', INSTALLED_APPS = self.INSTALLED_APPS + self.apps, ROOT_URLCONF = 'shib.urls', ) try: django.setup() except AttributeError: #before django 1.6 this was not necessary pass from django.test.simple import DjangoTestSuiteRunner failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1) if failures: sys.exit(failures)
def pytest_configure(): global _SETTINGS try: import django from django.conf import settings settings.configure(POOL_OF_RAMOS=POOL_OF_RAMOS) django.setup() _SETTINGS = settings except ImportError: try: import os os.environ.setdefault('SIMPLE_SETTINGS', 'conftest') from simple_settings import settings settings.configure(POOL_OF_RAMOS=POOL_OF_RAMOS) _SETTINGS = settings except ImportError: import ramos ramos.configure(pools=POOL_OF_RAMOS)
def runtests(): settings.configure( # App-specific setttings here ) # settings must be configured for this import to work from django.test.runner import DiscoverRunner DiscoverRunner(interactive=False, failfast=False).run_tests(['django_auth_lti'])
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 __init__(self, commands, verbose=False, **kwargs): self._commands = commands self._parser = argparse.ArgumentParser() self._verbose = verbose if not settings.configured: settings.configure() self._templates_dir = "%s/templates" % os.path.dirname(__file__)
def run(self): import django from django.conf import settings from django.core.management import call_command settings.configure( DATABASES={ 'default': { 'NAME': ':memory:', 'ENGINE': 'django.db.backends.sqlite3', }, }, INSTALLED_APPS=( 'django.contrib.auth', 'django.contrib.contenttypes', 'emailengine', 'emailengine.tests', ), TEMPLATES=[ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', # noqa: E501 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', # noqa: E501 'django.template.context_processors.request', ], }, }, ], ), django.setup() call_command('test', 'emailengine')
def run(self): from django.conf import settings settings.configure(DATABASES={'default': {'NAME': ':memory:', 'ENGINE': 'django.db.backends.sqlite3'}}, INSTALLED_APPS=('jsonfield',)) from django.core.management import call_command call_command('test', 'jsonfield')
def django_email_backend(request): from django.conf import settings logger.debug('django_email_backend...') settings.configure(EMAIL_BACKEND='django.core.mail.backends.filebased.EmailBackend', EMAIL_FILE_PATH='tmp-emails') from django.core.mail import get_connection return get_connection()
def _new_tests(self): """ Fire up the Django test suite developed for version 1.2 """ settings.configure( DEBUG=True, DATABASES={ "default": { "ENGINE": "django.db.backends.sqlite3", "NAME": os.path.join(self.DIRNAME, "database.db"), "USER": "", "PASSWORD": "", "HOST": "", "PORT": "", } }, INSTALLED_APPS=self.INSTALLED_APPS + self.apps, FACEBOOK_REALTIME_VERIFY_TOKEN="EJEgWVcZCyx7NNoKT83xbxrKPy0sQPYZBZCkEZAm31PPoOoHojlTHPhGgZDAA", ROOT_URLCONF="urlstest", ) from django.test.simple import DjangoTestSuiteRunner failures = DjangoTestSuiteRunner().run_tests(self.apps, verbosity=1) if failures: sys.exit(failures)
def setup_fake_django(): from django.conf import settings import os settings.configure( TEMPLATE_LOADERS=('django.template.loaders.filesystem.Loader',), TEMPLATE_DIRS=(os.path.join(os.path.dirname(__file__), '..', 'templates'),), )
def pytest_configure(): import django from django.conf import settings 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", TEMPLATE_LOADERS=( "django.template.loaders.filesystem.Loader", "django.template.loaders.app_directories.Loader", ), 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", ), INSTALLED_APPS=( "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.sites", "django.contrib.messages", "django.contrib.staticfiles", "tests", ), PASSWORD_HASHERS=("django.contrib.auth.hashers.MD5PasswordHasher",), ) try: import oauth_provider # NOQA import oauth2 # NOQA except ImportError: pass else: settings.INSTALLED_APPS += ("oauth_provider",) try: if django.VERSION >= (1, 8): # django-oauth2-provider does not support Django1.8 raise ImportError import provider # NOQA except ImportError: pass else: settings.INSTALLED_APPS += ("provider", "provider.oauth2") try: import django django.setup() except AttributeError: pass
def InitializeTemplates(self): if not settings.configured: settings.configure(DEBUG=False, TEMPLATE_DEBUG=False, TEMPLATE_DIRS=(os.path.abspath(os.path.join(os.path.dirname(__file__),'..','templates')), self.results_dir, os.path.join(self.results_dir,"templates")) )
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 runtests(): if not settings.configured: # Configure test environment settings.configure( DATABASES={ 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': ':memory:' } }, SITE_ID=1, INSTALLED_APPS=( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.admin', 'password_session', ), AUTHENTICATION_BACKENDS = ( 'django.contrib.auth.backends.ModelBackend', ), MIDDLEWARE_CLASSES = ( 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'password_session.middleware.CheckPasswordHash', ), ROOT_URLCONF = 'password_session.tests.test_urls', LANGUAGES = ( ('en', 'English'), ), ) failures = call_command('test', 'password_session', interactive=False, failfast=False, verbosity=2) sys.exit(bool(failures))
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 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', 'zerorpc_api', ), # Django replaces this, but it still wants it. *shrugs* DATABASES = { 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': '/tmp/django_login.db', } }, MEDIA_ROOT = '/tmp/django_test_media/', ROOT_URLCONF = '', DEBUG = True, TEMPLATE_DEBUG = True, STRIPE_TEST_SECRET_API_KEY = 'SECRET_API_KEY', STRIPE_TEST_PUBLIC_API_KEY = 'PUBLIC_API_KEY', ) #call_command('syncdb') # Fire off the tests call_command('test', 'zerorpc_api')
def main(): settings.configure( DATABASES={ 'default': { 'ENGINE': 'django.db.backends.sqlite3', } }, ROOT_URLCONF='acme_challenge.urls', INSTALLED_APPS=( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.admin', 'acme_challenge',) ) django.setup() try: # Django <= 1.8 from django.test.simple import DjangoTestSuiteRunner test_runner = DjangoTestSuiteRunner(verbosity=1) except ImportError: # Django >= 1.8 from django.test.runner import DiscoverRunner test_runner = DiscoverRunner(verbosity=1) failures = test_runner.run_tests(['acme_challenge']) if failures: sys.exit(failures)
def establish_settings(): '''Sets up the Django settings (in lieu of DJANGO_SETTINGS_MODULE)''' defaults = dict( INSTALLED_APPS = ['baseboard', ], CACHE_BACKEND = "dummy://", DATABASE_ENGINE = "sqlite3", DATABASE_NAME = ":memory:", TEST_DATABASE_CHARSET = 'utf8', TEST_DATABASE_COLLATION = 'utf8_unicode_ci', ROOT_URLCONF = 'baseboard.urls', BASEBOARD_CREDENTIALS = { 'https://foo.basecamphq.com/': ('username1', 'password1') }, ) import os __previous_settings_module = os.environ['DJANGO_SETTINGS_MODULE'] os.environ['DJANGO_SETTINGS_MODULE'] = '' from django.conf import settings try: settings.configure(**defaults) except RuntimeError: for key, value in defaults.items(): __overriden_settings[key] = value setattr(settings, key, value)
def pytest_configure(): settings.configure( ROOT_URLCONF = 'conftest', MIDDLEWARE_CLASSES = [ 'conftest.InjectTestUser' ], )
def setup(cls, options=None, args=None, **kwargs): """Adds Django initialisation .. warning:: The Django system can only be initialised once, so you can only ever setup one class that uses DjangoApp as a base. In practice, subsequent calls to setup will simply ignore the Django configuration step, ignoring any debug setting and template directory locations. This restriction may be removed in future versions as this area of Django appears to be evolving.""" super(DjangoApp, cls).setup(options, args, **kwargs) if options: cls.debug = options.debug dsettings = cls.settings.setdefault('DjangoApp', {}) template_urls = dsettings.setdefault('template_dirs', ['templates']) template_paths = [] for t in template_urls: template_paths.append(cls.resolve_setup_path(t)) if not DjangoApp.configured: settings.configure( DEBUG=cls.debug, TEMPLATE_DEBUG=cls.debug, TEMPLATE_DIRS=template_paths) django.setup() DjangoApp.configured = True else: logging.warning("DjangoApp: setup ignored for %s" % cls.__name__) cls.template_dirs = template_paths
def pytest_configure(config): where_am_i = os.path.dirname(os.path.abspath(__file__)) if not settings.configured: settings.configure( DATABASE_ENGINE='sqlite3', DATABASES={ 'default': { 'NAME': ':memory:', 'ENGINE': 'django.db.backends.sqlite3', 'TEST_NAME': ':memory:', }, }, DATABASE_NAME=':memory:', TEST_DATABASE_NAME=':memory:', INSTALLED_APPS=INSTALLED_APPS, ROOT_URLCONF='', DEBUG=False, SITE_ID=1, BROKER_HOST="localhost", BROKER_PORT=5672, BROKER_USER="******", BROKER_PASSWORD="******", BROKER_VHOST="/", SENTRY_ALLOW_ORIGIN='*', CELERY_ALWAYS_EAGER=True, TEMPLATE_DEBUG=True, TEMPLATE_DIRS=[os.path.join(where_am_i, 'tests', 'contrib', 'django', 'templates')], ALLOWED_HOSTS=['*'], )
def run_tests(self): from django.conf import settings db_engine = os.environ.get('DJANGO_DB_ENGINE', 'sqlite') if db_engine == 'mysql': db_settings = { 'ENGINE': 'django.db.backends.mysql', 'NAME': os.environ['DJANGO_DB_NAME'], 'USER': os.environ['DJANGO_DB_USER'], } elif db_engine == 'postgres': db_settings = { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': os.environ['DJANGO_DB_NAME'], 'USER': os.environ['DJANGO_DB_USER'], } elif db_engine == 'sqlite': db_settings = { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': os.path.join(self.DIRNAME, 'database.db'), } else: raise ValueError("Unknown DB engine: %s" % db_engine) # Common settings. settings.configure( DEBUG=True, DATABASES={'default': db_settings}, CACHES={'default': {'BACKEND': 'django.core.cache.backends.dummy.DummyCache'}}, INSTALLED_APPS=self.APPS) import django import pytest django.setup() sys.exit(pytest.main(["tests/"]))
def runtests(): parser = optparse.OptionParser() parser.add_option('--verbosity', dest='verbosity', default='1') parser.add_option('--coverage', dest='coverage', default='2') parser.add_option('--DATABASE_ENGINE', dest='DATABASE_ENGINE', default='sqlite3') parser.add_option('--DATABASE_NAME', dest='DATABASE_NAME', default='') parser.add_option('--DATABASE_USER', dest='DATABASE_USER', default='') parser.add_option('--DATABASE_PASSWORD', dest='DATABASE_PASSWORD', default='') parser.add_option('--DATABASE_HOST', dest='DATABASE_HOST', default='') parser.add_option('--DATABASE_PORT', dest='DATABASE_PORT', default='') options, args = parser.parse_args() dboptions = {} if options.DATABASE_ENGINE == 'mysql': dboptions = { "init_command": "SET storage_engine=INNODB," "character_set_connection=utf8," "collation_connection=utf8_unicode_ci"} if not options.DATABASE_NAME and options.DATABASE_ENGINE != 'sqlite3': options.DATABASE_NAME = 'treebeard' if not settings.configured: settings.configure( DATABASE_ENGINE=options.DATABASE_ENGINE, DATABASE_NAME=options.DATABASE_NAME, DATABASE_USER=options.DATABASE_USER, DATABASE_PASSWORD=options.DATABASE_PASSWORD, DATABASE_HOST=options.DATABASE_HOST, DATABASE_PORT=options.DATABASE_PORT, DATABASE_OPTIONS=dboptions, INSTALLED_APPS=[ 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.admin', 'treebeard', 'treebeard.tests']) covlevel = int(options.coverage) if covlevel: current_dir = os.path.dirname(os.path.abspath(__file__)) if covlevel == 2: branch = True else: branch = False cov = coverage.coverage(branch=branch, include=[current_dir + '/treebeard/*.py'], omit=[current_dir + '/treebeard/numconv.py', current_dir + '/treebeard/tests/*']) cov.load() cov.start() if not args: args = ['tests'] call_command('test', verbosity=options.verbosity, *args) if covlevel: cov.stop() cov.save()
def configure_settings(): """ Configures settings for manage.py and for run_tests.py. """ if not settings.configured: # Determine the database settings depending on if a test_db var is set in CI mode or not test_db = os.environ.get('DB', None) if test_db is None: db_config = { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'NAME': 'ambition_test', 'USER': '******', 'PASSWORD': '', 'HOST': 'db', 'TEST': { 'CHARSET': 'UTF8', } } elif test_db == 'postgres': db_config = { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'USER': '******', 'NAME': 'activatable_model', } elif test_db == 'sqlite': db_config = { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': 'activatable_model', } else: raise RuntimeError('Unsupported test DB {0}'.format(test_db)) travis_ci = os.environ.get('TRAVIS_CI', None) if travis_ci: db_config.update( { 'ENGINE': 'django.db.backends.postgresql_psycopg2', 'USER': '******', 'NAME': 'activatable_model', } ) settings.configure( TEST_RUNNER='django_nose.NoseTestSuiteRunner', NOSE_ARGS=['--nocapture', '--nologcapture', '--verbosity=1'], MIDDLEWARE_CLASSES={}, DATABASES={ 'default': db_config, }, INSTALLED_APPS=( 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.admin', 'activatable_model', 'activatable_model.tests', ), ROOT_URLCONF='activatable_model.urls', DEBUG=False, )
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 create_project(): # Put mezzanine.conf in INSTALLED_APPS so call_command can find # our command, settings.configure() settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + ['mezzanine.bin'] argv = sys.argv[:1] + ['mezzanine_project'] + sys.argv[1:] management.execute_from_command_line(argv)
import django.dispatch djshutdown = django.dispatch.Signal() djshutdown.send('system') sys.exit(0) signal.signal(signal.SIGINT, sigint_handler) settings.configure( DEBUG=True, SECRET_KEY='CD8FF4C1-7E6C-4E45-922D-C796271F2345', ROOT_URLCONF=sys.modules[__name__], SETTINGS_MODULE= '', # Added to avoid a KeyError during shutdown on the bad template test. TEMPLATES=[ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'APP_DIRS': True, 'DIRS': [ os.path.join(os.path.dirname(__file__), 'templates'), ] }, ]) def home(request): title = 'hello' content = 'Django-Django-Test' template = loader.get_template('hello.html') context = { 'title': title,