def run_tests():
"""
Use the Django test runner to run the tests.
"""
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner(verbosity=2)
runner.run_tests(None)
def run_tests(test_labels,
verbosity=1,
interactive=True,
failfast=False,
extra_tests=None):
import warnings
warnings.warn(
'The run_tests() test runner has been deprecated in favor of DjangoTestSuiteRunner.',
PendingDeprecationWarning)
selenium_server = ServerThread(
["java", "-jar", "lib/selenium/selenium-server.jar"])
selenium_server.start()
if settings.SELENIUM_URL == "http://localhost:8001":
dev_server = ServerThread(["python", "manage.py", "runserver", "8001"])
dev_server.start()
time.sleep(5)
test_runner = DjangoTestSuiteRunner(verbosity=verbosity,
interactive=interactive,
failfast=failfast)
for browser in settings.SELENIUM_BROWSERS:
settings.SELENIUM_BROWSER = browser
test_runner.run_tests(test_labels, extra_tests=extra_tests)
selenium_server.stop()
if settings.SELENIUM_URL == "http://localhost:8001":
dev_server.stop()
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 _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 main():
# Configure python path
parent = os.path.dirname(os.path.abspath(__file__))
if not parent in sys.path:
sys.path.insert(0, parent)
# Discover tests
os.environ['DJANGO_SETTINGS_MODULE'] = 'djedi.tests.settings'
unittest.defaultTestLoader.discover('djedi')
import django
if hasattr(django, "setup"):
django.setup()
# Run tests
if django.VERSION < (1, 7):
from django.test.simple import DjangoTestSuiteRunner as TestRunner
else:
from django.test.runner import DiscoverRunner as TestRunner
runner = TestRunner(verbosity=1, interactive=True, failfast=False)
exit_code = runner.run_tests(['djedi'])
sys.exit(exit_code)
def run_tests(verbosity, *test_args):
if not test_args:
test_args = ['url_tracker']
test_runner = DjangoTestSuiteRunner(verbosity=verbosity)
num_failures = test_runner.run_tests(test_args)
if num_failures:
sys.exit(num_failures)
def main():
settings.configure(
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'nicedit',
),
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
},
},
ROOT_URLCONF='nicedit.urls',
MEDIA_ROOT=os.path.join(os.path.dirname(__file__), 'app_media'),
SITE_ID=1,
)
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests([
'nicedit',
])
if failures:
sys.exit(failures)
def runtests():
verbose_level = 1
args = sys.argv[1:]
if '-v' in args:
index = args.index('-v')
_ = args.pop(index)
verbose_level = int(args.pop(index))
if args:
test_labels = ["model_mommy.%s" % arg for arg in args]
else:
test_labels = ['model_mommy']
try:
from django.test.simple import run_tests
result = run_tests(test_labels, verbose_level, True)
sys.exit(result)
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_suite = DjangoTestSuiteRunner(verbose_level, True)
result = test_suite.run_tests(test_labels)
sys.exit(result)
def run_tests(verbosity, *test_args):
test_runner = DjangoTestSuiteRunner(verbosity=verbosity)
if not test_args:
test_args = ['oscar']
num_failures = test_runner.run_tests(test_args)
if num_failures:
sys.exit(num_failures)
def run_tests(verbosity, *test_args):
test_runner = DjangoTestSuiteRunner(verbosity=verbosity)
if not test_args:
test_args = ['oscar']
num_failures = test_runner.run_tests(test_args)
if num_failures:
sys.exit(num_failures)
def main():
settings.configure(
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
}
},
ROOT_URLCONF='acme_challenge.urls',
INSTALLED_APPS=(
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.admin',
'acme_challenge',)
)
django.setup()
try:
# Django <= 1.8
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
except ImportError:
# Django >= 1.8
from django.test.runner import DiscoverRunner
test_runner = DiscoverRunner(verbosity=1)
failures = test_runner.run_tests(['acme_challenge'])
if failures:
sys.exit(failures)
def runtests(*test_args):
"""Setup and run django-password-policies test suite.
This still uses the old django.test.simple.DjangoTestSuiteRunner for
compatibility reasons with older Django versions and because of the
abstract base classes which shouldn't be considered as tests, but are
discovered by the newer django.test.runner.DiscoverRunner.
"""
os.environ['DJANGO_SETTINGS_MODULE'] = 'password_policies.tests.settings'
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
try:
django.setup()
except AttributeError:
# Access one setting to trigger the initialization of the settings as
# workaround for older Django versions
settings.INSTALLED_APPS
try:
from django.test.runner import DiscoverRunner
potential_test_args = ['password_policies.tests']
except ImportError:
from django.test.simple import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(interactive=False)
potential_test_args = ['password_policies']
else:
test_runner = DiscoverRunner(interactive=False)
if not test_args:
test_args = potential_test_args
failures = test_runner.run_tests(test_args)
sys.exit(bool(failures))
def runtests(*test_args):
if not test_args:
test_args = ['blog']
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True, failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def test_runner_with_coverage(test_labels, verbosity=1, interactive=True,
failfast=None, extra_tests=[]):
"""
Custom test runner. Follows the django.test.simple.run_tests() interface.
"""
# Start code coverage before anything else if necessary
if hasattr(settings, 'COVERAGE_MODULES'):
cov = coverage.coverage()
cov.use_cache(0) # Do not cache any of the coverage.py stuff
cov.start()
test_runner = DjangoTestSuiteRunner(verbosity=verbosity,
interactive=interactive,
failfast=failfast)
test_results = test_runner.run_tests(test_labels, extra_tests=extra_tests)
# Stop code coverage after tests have completed
if hasattr(settings, 'COVERAGE_MODULES'):
cov.stop()
print ''
print '-------------------------------------------------------------------'
print ' Unit Test Code Coverage Results'
print '-------------------------------------------------------------------'
coverage_modules = []
for module in settings.COVERAGE_MODULES:
coverage_modules.append(
__import__(module, globals(), locals(), [''])
)
cov.report(coverage_modules, show_missing=1)
cov.html_report(coverage_modules, directory='coverage_report')
print '-------------------------------------------------------------------'
return test_results
def runtests():
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner(verbosity=1,
interactive=True,
failfast=False)
failures = runner.run_tests(['tests'])
sys.exit(failures)
def test_runner_with_coverage(test_labels,
verbosity=1,
interactive=True,
failfast=None,
extra_tests=[]):
"""
Custom test runner. Follows the django.test.simple.run_tests() interface.
"""
# Start code coverage before anything else if necessary
if hasattr(settings, 'COVERAGE_MODULES'):
cov = coverage.coverage()
cov.use_cache(0) # Do not cache any of the coverage.py stuff
cov.start()
test_runner = DjangoTestSuiteRunner(verbosity=verbosity,
interactive=interactive,
failfast=failfast)
test_results = test_runner.run_tests(test_labels, extra_tests=extra_tests)
# Stop code coverage after tests have completed
if hasattr(settings, 'COVERAGE_MODULES'):
cov.stop()
print ''
print '-------------------------------------------------------------------'
print ' Unit Test Code Coverage Results'
print '-------------------------------------------------------------------'
coverage_modules = []
for module in settings.COVERAGE_MODULES:
coverage_modules.append(__import__(module, globals(), locals(), ['']))
cov.report(coverage_modules, show_missing=1)
cov.html_report(coverage_modules, directory='coverage_report')
print '-------------------------------------------------------------------'
return test_results
def runtests(*test_args):
if not test_args:
test_args = ['pro', 'standard', 'ipn']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests(test_args, verbosity=1, interactive=True)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ["dialogos"]
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests():
from django.test.simple import DjangoTestSuiteRunner
dtsr = DjangoTestSuiteRunner(verbosity=1,
interactive=True,
failfast=False)
failures = dtsr.run_tests(['django_unique_submission'])
sys.exit(failures)
def runtests(*test_args):
test_args = test_args or ['testapp']
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=2, interactive=True,
failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
test_args = test_args or ["tests"]
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True, failfast=bool(os.environ.get("FAILFAST")))
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(args=None):
try:
from django.test.simple import DjangoTestSuiteRunner
except ImportError:
from django.test import DjangoTestSuiteRunner
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests(['census', ])
sys.exit(failures)
def runtests(*test_args):
test_args = test_args or ['testapp']
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True,
failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ["dialogos"]
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
suite = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = suite.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ["tests"]
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=2, interactive=True, failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['django_measurement']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ["linkcheck"]
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def runtests(*args, **kwargs):
dts = DjangoTestSuiteRunner(
verbosity=kwargs.get('verbosity', 1),
interactive=kwargs.get('interactive', False),
failfast=kwargs.get('failfast')
)
failures = dts.run_tests(*args)
sys.exit(failures)
def runtests(*args):
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
testrunner = DjangoTestSuiteRunner()
if not args:
args = None
failures = testrunner.run_tests(args)
sys.exit(failures)
def runtests():
django.setup()
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests(['khipu'], verbosity=1, interactive=True)
if failures:
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['django_measurement']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = runner.run_tests(test_args)
sys.exit(failures)
def run_tests(*test_args):
from django.test.simple import DjangoTestSuiteRunner
if not test_args:
test_args = ['main']
tests_runner = DjangoTestSuiteRunner(
verbosity=1, interactive=True, failfast=False)
failures = tests_runner.run_tests(test_args)
sys.exit(failures)
def run_tests(self):
"""
Fire up the Django test suite developed for version 1.2
"""
apps = [app for app in self.apps]
apps += ['%s.tests' % app for app in self.apps]
settings.configure(
DATABASES={
'default': {
'ENGINE': 'django.contrib.gis.db.backends.spatialite',
'NAME': os.path.join(self.DIRNAME, 'database.db'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
},
CACHES={
'default': {
'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
'LOCATION': 'my_cache_table',
}
},
INSTALLED_APPS=self.INSTALLED_APPS + tuple(apps),
STATIC_ROOT='.',
STATIC_URL='/static/',
ROOT_URLCONF='mapentity.tests.urls',
MEDIA_URL='/media/',
MEDIA_URL_SECURE='/media_secure/',
MEDIA_ROOT='/tmp/',
MIDDLEWARE_CLASSES=(
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.locale.LocaleMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'mapentity.middleware.AutoLoginMiddleware'),
TEMPLATE_CONTEXT_PROCESSORS=(
"django.contrib.auth.context_processors.auth",
"django.core.context_processors.debug",
"django.core.context_processors.i18n",
"django.core.context_processors.media",
"django.core.context_processors.static",
"django.core.context_processors.tz",
"django.contrib.messages.context_processors.messages",
"django.core.context_processors.request",
"mapentity.context_processors.settings",
),
TEMPLATE_DIRS=(os.path.join(self.DIRNAME, 'mapentity'), ),
SRID=3857,
COMPRESS_ENABLED=False,
TEST=True)
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner()
failures = runner.run_tests(self.apps, verbosity=1)
if failures: # pragma: no cover
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['updown']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args, **kwargs):
if not test_args:
test_args = ['prodready']
test_runner = DjangoTestSuiteRunner(
verbosity=kwargs.get('verbosity', 1),
interactive=kwargs.get('interactive', False),
failfast=kwargs.get('failfast'))
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def runtests(*args):
test_runner = DjangoTestSuiteRunner(interactive=False)
failures = test_runner.run_tests(
args or [
'autofixture',
'autofixture_tests',
],
verbosity=1, interactive=True)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['lockdown']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['ajaxtoolkit']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
testrunner = DjangoTestSuiteRunner()
failures = testrunner.run_tests(test_args, verbosity=1,
interactive='--no-input' not in sys.argv)
sys.exit(failures)
def runtests(*test_args):
test_args = test_args or ['tests']
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True,
failfast=bool(os.environ.get('FAILFAST')))
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args, **kwargs):
if not test_args:
test_args = ['prodready']
test_runner = DjangoTestSuiteRunner(verbosity=kwargs.get('verbosity', 1),
interactive=kwargs.get(
'interactive', False),
failfast=kwargs.get('failfast'))
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def run_tests(*test_args):
from django.test.simple import DjangoTestSuiteRunner
if not test_args:
test_args = ['main']
tests_runner = DjangoTestSuiteRunner(verbosity=1,
interactive=True,
failfast=False)
failures = tests_runner.run_tests(test_args)
sys.exit(failures)
def run_tests():
# Modify path
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
# Run tests
test_runner = DjangoTestSuiteRunner(verbosity=2)
failures = test_runner.run_tests(['tests'])
sys.exit(failures)
def run_tests():
# Modify path
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
# Run tests
test_runner = DjangoTestSuiteRunner(verbosity=2)
failures = test_runner.run_tests(["tests"])
sys.exit(failures)
def run_tests():
"""
Use the Django test runner to run the tests.
Sets the return code to the number of failed tests.
"""
import sys
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner()
sys.exit(runner.run_tests(["analytical"]))
def run_tests(*test_args):
from django.test.simple import DjangoTestSuiteRunner
if not test_args:
test_args = ["main", "simple", "rpc"]
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
tests_runner = DjangoTestSuiteRunner(verbosity=1, interactive=True, failfast=False)
failures = tests_runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args, **kwargs):
setup_test_environment()
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=kwargs.get('verbosity', 1),
interactive=kwargs.get(
'interactive', False),
failfast=kwargs.get('failfast'))
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def run_tests(*test_args, **kwargs):
if not test_args:
test_args = ["tests"]
test_runner = DjangoTestSuiteRunner(
verbosity=kwargs.get("verbosity", 1),
interactive=kwargs.get("interactive", False),
failfast=kwargs.get("failfast")
)
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def run_tests():
"""
Use the Django test runner to run the tests.
Sets the return code to the number of failed tests.
"""
import sys
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner()
sys.exit(runner.run_tests(["analytical"]))
def run_tests(*test_args):
from django.test.simple import DjangoTestSuiteRunner
# if not test_args:
# test_args = ['main', 'simple', 'rpc']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
tests_runner = DjangoTestSuiteRunner(verbosity=1,
interactive=True,
failfast=False)
failures = tests_runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args, **kwargs):
if not test_args:
test_args = ['parsley']
parent = dirname(abspath(__file__))
sys.path.insert(0, parent)
test_runner = DjangoTestSuiteRunner(verbosity=kwargs.get('verbosity', 1),
interactive=kwargs.get(
'interactive', False),
failfast=kwargs.get('failfast'))
failures = test_runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['testapp']
sys.path.insert(0, join(dirname(abspath(__file__)), 'tests'))
try:
django.setup()
except AttributeError:
pass
runner = TestSuiteRunner(verbosity=1, interactive=True, failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
setup_test_environment()
parent = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, parent)
from django.test.simple import DjangoTestSuiteRunner
runner = DjangoTestSuiteRunner(verbosity=1, interactive=True,
failfast=False)
failures = runner.run_tests(test_args)
sys.exit(failures)
def runtests(*test_args):
from django.test.simple import DjangoTestSuiteRunner
from django import VERSION
if VERSION[0] >= 1 and VERSION[1] >= 7:
from django import setup
setup() # New Django 1.7 app registry
test_runner = DjangoTestSuiteRunner(verbosity=1)
failures = test_runner.run_tests([
'dpaste',
])
if failures:
sys.exit(failures)
def _runtests(host, port, password=None):
from django.test.simple import DjangoTestSuiteRunner
client = Redis(host, port)
try:
client.config_set('requirepass', password)
except ResponseError:
client = Redis(host, port, password=password)
client.config_set('requirepass', password)
runner = DjangoTestSuiteRunner(verbosity=options.verbosity,
interactive=True,
failfast=False)
failures = runner.run_tests(['testapp'])
def run_tests(self):
"""
Fire up the Django test suite
"""
settings.configure(
DEBUG=True,
DATABASES={
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(self.DIRNAME, 'database.db'),
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
},
LOGGING={
'version': 1,
'formatters': {
'simple': {
'format':
'%(levelname)s %(asctime)s %(name)s %(message)s'
}
},
'handlers': {
'console': {
'class': 'logging.StreamHandler',
'formatter': 'simple'
}
},
'loggers': {
'screamshot': {
'handlers': ['console'],
'level': 'DEBUG'
}
}
},
INSTALLED_APPS=self.INSTALLED_APPS + self.apps)
if VERSION >= (1, 7):
import django
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(self.apps)
if failures: # pragma: no cover
sys.exit(failures)
def runtests(*test_args):
if not test_args:
test_args = ['userprofiles']
parent = os.path.join(
os.path.dirname(os.path.abspath(__file__)),
"..",
"..",
)
sys.path.insert(0, parent)
runner = DjangoTestSuiteRunner()
failures = runner.run_tests(test_args, verbosity=1, interactive=True)
sys.exit(failures)
