def run(self):
import lzw
doctest.testmod(lzw)
utests = defaultTestLoader.loadTestsFromName(TEST_MODULE_NAME)
urunner = TextTestRunner(verbosity=2)
urunner.run(utests)
if self.runslow:
utests = defaultTestLoader.loadTestsFromName(SLOW_TEST_MODULE_NAME)
urunner = TextTestRunner(verbosity=2)
urunner.run(utests)
def run(self):
import dominus
success = doctest.testmod(dominus).failed == 0
utests = defaultTestLoader.loadTestsFromName(TEST_MODULE_NAME)
urunner = TextTestRunner(verbosity=2)
success &= urunner.run(utests).wasSuccessful()
if self.runslow:
utests = defaultTestLoader.loadTestsFromName(SLOW_TEST_MODULE_NAME)
urunner = TextTestRunner(verbosity=2)
success &= urunner.run(utests).wasSuccessful()
if not success:
raise distutils.errors.DistutilsError('Test failure')
def run(self):
import lzw
success = doctest.testmod(lzw).failed == 0
utests = defaultTestLoader.loadTestsFromName(TEST_MODULE_NAME)
urunner = TextTestRunner(verbosity=2)
success &= urunner.run(utests).wasSuccessful()
if self.runslow:
utests = defaultTestLoader.loadTestsFromName(SLOW_TEST_MODULE_NAME)
urunner = TextTestRunner(verbosity=2)
success &= urunner.run(utests).wasSuccessful()
if not success:
raise distutils.errors.DistutilsError('Test failure')
def run_tests(options, args):
arg = args[0]
module_name = arg
if module_name.endswith('.py'):
module_name = module_name[:-3]
class _runner(object):
def __new__(cls, *args, **kawrgs):
return DatabaseTestRunner(database_path=options.db, runid=options.runid, module_name=module_name, verbosity=options.verbosity)
if options.db:
import unittest
unittest.TextTestRunner = _runner
import test_support
test_support.BasicTestRunner = _runner
sys.argv = args
globals()['__file__'] = arg
if os.path.exists(arg):
execfile(arg, globals())
else:
test = defaultTestLoader.loadTestsFromName(arg)
result = _runner().run(test)
sys.exit(not result.wasSuccessful())
def suite():
suite = doctest.DocFileSuite(
'test_loader.py',
'test_views.py')
suite.addTest(defaultTestLoader.loadTestsFromName(
'yui_loader.tests.test_middleware'))
return suite
def run_tests(options, args):
arg = args[0]
module_name = arg
if module_name.endswith(".py"):
module_name = module_name[:-3]
class _runner(object):
def __new__(cls, *args, **kawrgs):
return DatabaseTestRunner(
database_path=options.db, runid=options.runid, module_name=module_name, verbosity=options.verbosity
)
if options.db:
try:
from unittest import runner
except ImportError:
pass
else:
runner.TextTestRunner = _runner
import unittest
unittest.TextTestRunner = _runner
import test_support
test_support.BasicTestRunner = _runner
sys.argv = args
if os.path.exists(arg):
execfile_as_main(arg)
else:
test = defaultTestLoader.loadTestsFromName(arg)
result = _runner().run(test)
sys.exit(not result.wasSuccessful())
def run_tests(options, args):
if len(args) != 1:
sys.exit('--record requires exactly one test module to run')
arg = args[0]
module_name = arg
if module_name.endswith('.py'):
module_name = module_name[:-3]
class _runner(object):
def __new__(cls, *args, **kawrgs):
return DatabaseTestRunner(database_path=options.db, runid=options.runid, module_name=module_name, verbosity=options.verbosity)
if options.db:
import unittest
unittest.TextTestRunner = _runner
import test_support
test_support.BasicTestRunner = _runner
if os.path.exists(arg):
sys.argv = args
saved_globals = {'__file__': __file__}
try:
globals()['__file__'] = arg
# QQQ this makes tests reported as if they are from __main__ and screws up warnings location
execfile(arg, globals())
finally:
globals().update(saved_globals)
else:
test = defaultTestLoader.loadTestsFromName(arg)
result = _runner().run(test)
sys.exit(not result.wasSuccessful())
def run_tests(self):
from unittest import TextTestRunner, defaultTestLoader as loader
result = TextTestRunner().run(
loader.loadTestsFromName('tests.{0}'.format(
self.test_suite).strip('. ')))
return exit(0) if not (result.failures + result.errors) else exit(1)
def test_suite():
suite = defaultTestLoader.loadTestsFromName(__name__)
suite.addTest(
ztc.FunctionalDocFileSuite(
'browser.txt', package='collective.usernamelogger',
test_class=FunctionalTestCase, optionflags=optionflags)
)
return suite
def suite():
"""Unit test suite; run by testing 'repository.tests.suite'"""
from unittest import defaultTestLoader, TestSuite
return TestSuite(
[defaultTestLoader.loadTestsFromName(__name__+'.'+test_name)
for test_name in __all__]
)
def test_suite():
suite = defaultTestLoader.loadTestsFromName(__name__)
suite.addTest(
ztc.FunctionalDocFileSuite('browser.txt',
package='collective.usernamelogger',
test_class=FunctionalTestCase,
optionflags=optionflags))
return suite
def run_aiida_db_tests(tests_to_run, verbose=False):
"""
Run all tests specified in tests_to_run.
Return the list of test results.
"""
# Empty test suite that will be populated
test_suite = TestSuite()
actually_run_tests = []
num_tests_expected = 0
# To avoid adding more than once the same test
# (e.g. if you type both db and db.xxx)
found_modulenames = set()
for test in set(tests_to_run):
try:
modulenames = get_db_test_list()[test]
except KeyError:
if verbose:
print >> sys.stderr, "Unknown DB test {}... skipping".format(
test)
continue
actually_run_tests.append(test)
for modulename in modulenames:
if modulename not in found_modulenames:
try:
test_suite.addTest(
test_loader.loadTestsFromName(modulename))
except AttributeError as exception:
try:
import importlib
import traceback
importlib.import_module(modulename)
except ImportError as exception:
print >> sys.stderr, (
"[CRITICAL] The module '{}' has an import error and the tests cannot be run:\n{}"
.format(modulename,
traceback.format_exc(exception)))
sys.exit(1)
found_modulenames.add(modulename)
num_tests_expected = test_suite.countTestCases()
if verbose:
print >> sys.stderr, (
"DB tests that will be run: {} (expecting {} tests)".format(
",".join(actually_run_tests), num_tests_expected))
results = unittest.TextTestRunner(failfast=False,
verbosity=2).run(test_suite)
else:
results = unittest.TextTestRunner(failfast=False).run(test_suite)
if verbose:
print "Run tests: {}".format(results.testsRun)
return results
def run_tests(self):
from unittest import TextTestRunner, defaultTestLoader as loader
result = TextTestRunner().run(
loader.loadTestsFromName(
'tests.{0}'.format(self.test_suite).strip('. ')
)
)
return exit(0) if not (result.failures + result.errors) else exit(1)
def test_suite():
import doctest
from unittest import defaultTestLoader
suite = defaultTestLoader.loadTestsFromName(__name__)
return unittest.TestSuite([
suite,
doctest.DocTestSuite('nti.externalization.integer_strings'),
])
def run():
suite = TestSuite()
for test in TEST_MODULES:
try:
mod = __import__(test, globals(), locals(), ['suite'])
suitefn = getattr(mod, 'suite')
suite.addTest(suitefn())
except (ImportError, AttributeError):
suite.addTest(defaultTestLoader.loadTestsFromName(test))
TextTestRunner().run(suite)
def get_test_suite():
"""Return the set of tests suitable for the current Python version"""
test_suite = defaultTestLoader.loadTestsFromNames(
("beeline.test_beeline", "beeline.test_internal", "beeline.test_trace")
)
if contextvars:
async_suite = defaultTestLoader.loadTestsFromName("beeline.test_async")
test_suite.addTest(async_suite)
return test_suite
def make_suite(prefix='', extra=()):
tests = TESTS + extra
test_names = list(prefix + x for x in tests)
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromNames(test_names))
for name in OPTIONAL_TESTS:
test_name = prefix + name
try:
suite.addTest(defaultTestLoader.loadTestsFromName(test_name))
except (ImportError, AttributeError):
print >> sys.stderr, "### Disabled test '%s', dependency not found" % name
return suite
def make_suite(prefix='', extra=()):
tests = TESTS + extra
test_names = list(prefix + x for x in tests)
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromNames(test_names))
for name in OPTIONAL_TESTS:
test_name = prefix + name
try:
suite.addTest(defaultTestLoader.loadTestsFromName(test_name))
except (ImportError, AttributeError):
sys.stderr.write("### Disabled test '%s', dependency not found\n" % name)
return suite
def test_suite():
import doctest
from unittest import defaultTestLoader
suite = defaultTestLoader.loadTestsFromName(__name__)
return unittest.TestSuite([
suite,
doctest.DocTestSuite(
'nti.externalization.datetime',
setUp=doctest_setUp,
tearDown=doctest_tearDown,
),
])
def make_suite(prefix='', extra=(), force_all=False):
tests = TESTS + extra
test_names = list(prefix + x for x in tests)
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromNames(test_names))
for name in OPTIONAL_TESTS:
test_name = prefix + name
try:
suite.addTest(defaultTestLoader.loadTestsFromName(test_name))
except (ImportError, AttributeError):
if force_all:
# If force_all, don't let us skip tests
raise ImportError('Could not load test module %s and force_all is enabled.' % test_name)
sys.stderr.write("### Disabled test '%s', dependency not found\n" % name)
return suite
def make_suite(prefix='', extra=(), force_all=False):
tests = TESTS + extra
test_names = list(prefix + x for x in tests)
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromNames(test_names))
for name in OPTIONAL_TESTS:
test_name = prefix + name
try:
suite.addTest(defaultTestLoader.loadTestsFromName(test_name))
except (ImportError, AttributeError):
if force_all:
# If force_all, don't let us skip tests
raise ImportError('Could not load test module %s and force_all is enabled.' % test_name)
sys.stderr.write("### Disabled test '%s', dependency not found\n" % name)
return suite
def worker_main():
global DB
if killpg:
try:
os.setpgrp()
except AttributeError:
pass
path = sys.argv[1]
verbosity = int(os.environ['testrunner_verbosity'])
test_id = int(os.environ['testrunner_test_id'])
run_id = os.environ['testrunner_run_id']
db_name = os.environ.get('testrunner_db')
if db_name:
DB = sqlite3.connect(db_name)
DEFAULT_PARAMS['testcase'] = {'run_id': run_id,
'test_id': test_id}
class _runner(object):
def __new__(cls, *args, **kawrgs):
return DatabaseTestRunner(verbosity=verbosity)
if DB:
try:
from unittest import runner
except ImportError:
pass
else:
runner.TextTestRunner = _runner
import unittest
unittest.TextTestRunner = _runner
import test_support
test_support.BasicTestRunner = _runner
sys.argv = sys.argv[1:]
if os.path.exists(path):
execfile_as_main(path)
else:
test = defaultTestLoader.loadTestsFromName(path)
result = _runner().run(test)
sys.exit(not result.wasSuccessful())
def get_test_suite():
"""Return the set of tests suitable for the current Python version"""
test_suite = defaultTestLoader.loadTestsFromNames((
"beeline.test_beeline",
"beeline.test_internal",
"beeline.test_trace",
"beeline.patch.test_requests",
"beeline.middleware.awslambda.test_awslambda",
"beeline.middleware.django.test_django",
"beeline.middleware.bottle.test_bottle",
"beeline.middleware.flask.test_flask",
"beeline.middleware.werkzeug.test_werkzeug",
))
if contextvars:
async_suite = defaultTestLoader.loadTestsFromName("beeline.test_async")
test_suite.addTest(async_suite)
return test_suite
def run_aiida_db_tests(tests_to_run, verbose=False):
"""
Run all tests specified in tests_to_run.
Return the list of test results.
"""
# Empty test suite that will be populated
test_suite = TestSuite()
actually_run_tests = []
num_tests_expected = 0
# To avoid adding more than once the same test
# (e.g. if you type both db and db.xxx)
found_modulenames = set()
for test in set(tests_to_run):
try:
modulenames = get_db_test_list()[test]
except KeyError:
if verbose:
print >> sys.stderr, "Unknown DB test {}... skipping".format(
test)
continue
actually_run_tests.append(test)
for modulename in modulenames:
if modulename not in found_modulenames:
test_suite.addTest(test_loader.loadTestsFromName(modulename))
found_modulenames.add(modulename)
num_tests_expected = test_suite.countTestCases()
if verbose:
print >> sys.stderr, (
"DB tests that will be run: {} (expecting {} tests)".format(
",".join(actually_run_tests), num_tests_expected))
results = unittest.TextTestRunner(failfast=False).run(test_suite)
if verbose:
print "Run tests: {}".format(results.testsRun)
return results
def main():
# list of test modules
test_modules = ['testIntegrationUtilities',
'testPureAbsorberProblem',
'testPureScatteringProblem',
'testDiffusionProblem',
'testSSConvergence',
'testTransientSource',
'testRadTransient',
'testRadSpatialConvergence',
'testCreateMMSSourceFunctions',
'testHydroUniformIC']
# add all tests modules to suite
suite = TestSuite()
for test_module in test_modules:
suite.addTest(defaultTestLoader.loadTestsFromName(test_module))
# run suite
TextTestRunner(verbosity=2).run(suite)
if options.host:
test_config.HOST_NAME = options.host
if options.username:
test_config.USERNAME = options.username
if options.password:
test_config.PASSWORD = options.password
if options.password:
test_config.SECRET = options.secret
test_config.memcache = options.memcache == "1"
test_config.SERVER_BASE = "%s://%s" % (test_config.SCHEME,
test_config.SERVER_NAME)
tests = args
any_problems = False
if len(tests) > 0:
results = []
runner = TextTestRunner(verbosity=3)
for test in tests:
test = defaultTestLoader.loadTestsFromName(test,
module=server_tests)
results.append(runner.run(test))
else:
results = run()
for result in results:
if len(result.failures + result.errors) > 0:
sys.exit(1)
sys.exit(0)
from unittest import TestSuite, TextTestRunner, defaultTestLoader
test_modules = [
'databases.mongo_instance_test', 'services.convert_service_test.py',
'services.file_service_test'
]
suite = TestSuite()
for test_module in test_modules:
try:
module = __import__(test_module, globals(), locals(), ['suite'])
suite_function = getattr(module, 'suite')
suite.addTest(suite_function())
except (ImportError, AttributeError):
suite.addTest(defaultTestLoader.loadTestsFromName(test_module))
TextTestRunner().run(suite)
def test_suite():
if hasLinguaPlone():
return defaultTestLoader.loadTestsFromName(__name__)
else:
return TestSuite()
def test_suite():
from unittest import defaultTestLoader as loader
return loader.loadTestsFromName("tests.main")
def test_suite():
from unittest import defaultTestLoader as loader
return loader.loadTestsFromName("tests.itemsearch")
def test_suite():
if hasSchemaExtender():
return defaultTestLoader.loadTestsFromName(__name__)
else:
return TestSuite()
#!/usr/bin/env python3
import unittest as ut
from unittest import defaultTestLoader as loader
import pkgutil
import os, sys
TEST_DIR = os.path.abspath(os.path.dirname(__file__))
ROOT_DIR = os.path.abspath(os.path.join(TEST_DIR, os.pardir))
sys.path.append(ROOT_DIR)
if __name__ == "__main__":
suites = []
for _, name, _ in pkgutil.iter_modules([TEST_DIR]):
if not name.startswith('test'):
continue
suites.append(loader.loadTestsFromName(name))
runner = ut.TextTestRunner(verbosity=2)
for suite in suites:
runner.run(suite)
def test_suite():
if pingSolr():
return defaultTestLoader.loadTestsFromName(__name__)
else:
return TestSuite()
def test_suite():
return defaultTestLoader.loadTestsFromName(__name__)
def test_suite():
from unittest import TestSuite, defaultTestLoader
if pingSolr():
return defaultTestLoader.loadTestsFromName(__name__)
else:
return TestSuite()
def test_suite():
if pingSolr():
return defaultTestLoader.loadTestsFromName(__name__)
else:
return TestSuite()
"""
Test runner which uses unittest ``discover`` method to find all
tests within ``cauliflower.testsuite`` and run them.
"""
import sys
import argparse
# TODO: try to import unittest2 for python2.4-2.6 backward compatibility
from unittest import TextTestRunner, defaultTestLoader
TESTSUITE_DIR = 'testsuite'
if __name__ == '__main__':
parser = argparse.ArgumentParser(description="Yes! It runs the test in testsuite")
parser.add_argument('--test', help="which test to run (dotted test path)")
args = parser.parse_args()
test = args.test
# needs to discover before accessing specific tests
test_suite = defaultTestLoader.discover(TESTSUITE_DIR)
if test is not None:
path = '.'.join((TESTSUITE_DIR, test))
test_suite = defaultTestLoader.loadTestsFromName(path)
TextTestRunner(verbosity=1).run(test_suite)
def test_suite():
from unittest import defaultTestLoader as loader
return loader.loadTestsFromName("tests.authentication")
from unittest import defaultTestLoader
from utilities import config
from utilities import runners
import sys
# SELECT TEST RUNNER
if config.report:
test_runner = runners.html_test_runner
else:
test_runner = runners.text_test_runner
# SELECT TEST SUITE
if config.scope is not None:
test_suite = defaultTestLoader.loadTestsFromName(config.scope)
else:
test_suite = defaultTestLoader.discover("./tests/", "*_tests.py")
# RUN TESTS
test_results = test_runner.run(test_suite)
if not test_results.wasSuccessful():
sys.exit(-1)
def test_suite():
if hasSchemaExtender():
return defaultTestLoader.loadTestsFromName(__name__)
else:
return TestSuite()
def test_suite():
from unittest import defaultTestLoader as loader
return loader.loadTestsFromName("tests.authentication")
def test_suite():
return defaultTestLoader.loadTestsFromName(__name__)
or module_name.startswith('apispec')
or module_name.startswith('aiohttp')):
del sys.modules[module_name]
cov = coverage.Coverage(data_file=data_file, data_suffix=True, config_file=False,
branch=True, source=['ipv8'], include=['*'], omit=["ipv8/test/*", "ipv8_service.py"])
cov.exclude('pass')
cov.start()
for test_path in test_paths:
print("Measuring coverage for", test_path)
output_stream = StringIO()
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromName(test_path))
reporter = TextTestRunner(stream=output_stream, failfast=True)
test_result = reporter.run(suite)
error_string = ''.join([repr(error) for error in test_result.errors])
assert len(test_result.errors) == 0,\
"ERROR: UNIT TESTS FAILED, PLEASE FIX BEFORE RUNNING COVERAGE:\n%s\n%s" % (output_stream.getvalue(),
error_string)
output_stream.close()
cov.stop()
print("Generating HTML report")
cov.html_report(directory='coverage')
print("Aggregating package stats")
total_numbers = {} # Package name -> (Numbers: package coverage stats, dict: files per coverage bin)
def test_suite():
from unittest import defaultTestLoader
return defaultTestLoader.loadTestsFromName(__name__)
def suite():
return defaultTestLoader.loadTestsFromName('pyomgidl.reader.tests')
def test_suite():
if hasLinguaPlone():
return defaultTestLoader.loadTestsFromName(__name__)
else:
return TestSuite()
def test_suite():
from unittest import defaultTestLoader as loader
return loader.loadTestsFromName("tests.licensekey")
def suite():
return defaultTestLoader.loadTestsFromName('pyomgidl.reader.tests')
if options.host:
test_config.HOST_NAME = options.host
if options.username:
test_config.USERNAME = options.username
if options.password:
test_config.PASSWORD = options.password
if options.password:
test_config.SECRET = options.secret
test_config.memcache = options.memcache == "1"
test_config.SERVER_BASE = "%s://%s" % (test_config.SCHEME,
test_config.SERVER_NAME)
tests = args
any_problems = False
if len(tests) > 0:
results = []
runner = TextTestRunner(verbosity=3)
for test in tests:
test = defaultTestLoader.loadTestsFromName(test,
module=server_tests)
results.append(runner.run(test))
else:
results = run()
for result in results:
if len(result.failures + result.errors) > 0:
sys.exit(1)
sys.exit(0)
def test_suite():
from unittest import defaultTestLoader
return defaultTestLoader.loadTestsFromName(__name__)
def test_suite():
from unittest import TestSuite, defaultTestLoader
if pingSolr():
return defaultTestLoader.loadTestsFromName(__name__)
else:
return TestSuite()
