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 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()
""" 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)
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(): from unittest import defaultTestLoader as loader return loader.loadTestsFromName("tests.licensekey")