def test(): # Run a Single Test Case suite = unittest.TestSuite() suite.addTests(unittest.TestLoader().loadTestsFromName( "test_Grover.Test_Grover.test_grover2")) runner = TextTestRunner(verbosity=2) runner.run(suite)
def test(): # Run all test cases case_dir = ".\\" discover = unittest.defaultTestLoader.discover(case_dir, pattern="test_*.py", top_level_dir=None) runner = TextTestRunner(verbosity=2) runner.run(discover)
def main() -> None: args = parse_args() suite = defaultTestLoader.discover(_tests_, top_level_dir=_parent_, pattern=args.pattern) runner = TextTestRunner( verbosity=args.verbosity, failfast=args.fail, buffer=args.buffer, ) installHandler() runner.run(suite)
def run(self): global THIS_PATH, PKG_DIR, TEST_DIR sys.path.insert(0, PKG_DIR) suite = TestSuite() loaded = unittest.defaultTestLoader.discover(TEST_DIR, pattern='*Test.py') for all_test_suite in loaded: for test_suite in all_test_suite: suite.addTests(test_suite) runner = TextTestRunner(verbosity = 2) runner.run(suite)
def run_test_suite(test_suite, title=u'测试', description='', export_file=None): ''' 运行test suite @param export_file: if export_file is not None, then run the html test runner to dump test report @return: text test result ''' if export_file is None: runner = TextTestRunner() return runner.run(suite) else: fp = file(export_file, "wb") runner = HTMLTestRunner.HTMLTestRunner(stream=fp, title=title, description=description) text_result = runner.run(suite) return text_result
def run_tests(self): # If we perform this input at the top of the file, we get an # import error because we need to load this file to discover # dependenices. tests = TestLoader().discover("tests", pattern="test_*.py") runner = TextTestRunner() result = runner.run(tests) exit(0 if result.wasSuccessful() else 1)
def invoked(self, ns): # Load tests selected on command line tests = ns.suite_loader() # Use standard unittest runner, it has somewhat annoying way of # displaying test progress but is well-known and will do for now. runner = TextTestRunner(verbosity=ns.verbosity, failfast=ns.fail_fast) result = runner.run(tests) # Forward the successfulness of the test suite as the exit code return 0 if result.wasSuccessful() else 1
def invoked(self, ns): # Use standard unittest runner, it has somewhat annoying way of # displaying test progress but is well-known and will do for now. runner = TextTestRunner(verbosity=ns.verbosity, failfast=ns.fail_fast) loader = TestLoader() # Discover all integration tests tests = loader.discover(get_plainbox_dir(), pattern="integration_*.py") result = runner.run(tests) # Forward the successfulness of the test suite as the exit code return 0 if result.wasSuccessful() else 1
def run(self, test): result_test = TextTestRunner.run(self, test) try: if self.extension["requested"]: self.result["stop_test"] = datetime.now() self.result["tests"] = result_test.result use_readable_format(self.result) self.ext_class.generate_document(self.config_file, self.result, result_test, **self.kwdict) except Exception, e: print_exception() print "Problem to execute the extension [%s]" % e
def run_tests(): out_stream = StringIO() runner = TextTestRunner(resultclass=TestResultWithSuccess, stream=out_stream) suite = unittest.TestSuite() suite.addTest(unittest.makeSuite(DatabaseIntegrityTests)) suite.addTest(unittest.makeSuite(ModelTests)) suite.addTest(unittest.makeSuite(RouteTests)) suite.addTest(unittest.makeSuite(RouteUtilityTests)) suite.addTest(unittest.makeSuite(SearchTests)) suite.addTest(unittest.makeSuite(SearchResultClassTests)) result = runner.run(suite) return (result, out_stream)
def run(self, ns): # If asked to, re-execute without locale if ns.reexec and sys.platform != 'win32': self._reexec_without_locale() if isinstance(self.loader, str): suite = defaultTestLoader.loadTestsFromName(self.loader) else: suite = self.loader() # Use standard unittest runner, it has somewhat annoying way of # displaying test progress but is well-known and will do for now. runner = TextTestRunner(verbosity=ns.verbosity, failfast=ns.fail_fast) result = runner.run(suite) # Forward the successfulness of the test suite as the exit code return 0 if result.wasSuccessful() else 1
def main() -> int: args = _parse_args() suite = defaultTestLoader.discover( str(_TESTS), top_level_dir=str(_TOP_LV.parent), pattern=args.pattern ) runner = TextTestRunner( verbosity=args.verbosity, failfast=args.fail, buffer=args.buffer, ) installHandler() r = runner.run(suite) return not r.wasSuccessful()
def runtests(failfast, quiet, verbose, buffer, integration_config, integration_git_server, integration_git_staging, tests): verbosity = 1 if quiet: verbosity = 0 if verbose: verbosity = 2 if integration_config is not None: config = ConfigParser() config.readfp(integration_config) else: config = None runner = TextTestRunner(verbosity=verbosity, failfast=failfast, buffer=buffer) ran = False if tests in ("all", "all_unit"): ran = True runner.run(all_unittests) if tests in unit_tests: ran = True runner.run(unit_tests[tests]) if tests in integration_tests: ran = True test_class = integration_tests[tests] suite = unittest.TestSuite() for name in unittest.TestLoader().getTestCaseNames(test_class): test = test_class(name) configure_integration_test(test, config, integration_git_server, integration_git_staging) suite.addTest(test) runner.run(suite) if not ran: # TODO: Try to instantiate specific test try: suite = unittest.TestLoader().loadTestsFromName(tests) runner.run(suite) except AttributeError, ae: print "Unknown test: %s" % tests
def main() -> int: args = _parse_args() suite = defaultTestLoader.discover(normcase(_TESTS), top_level_dir=normcase(_ROOT), pattern="*.py") names = {*_names(args.paths)} tests = (test for test in _tests(suite) if not names or test.__module__ in names) runner = TextTestRunner( verbosity=args.verbosity, failfast=args.fail, buffer=args.buffer, ) installHandler() r = runner.run(TestSuite(tests)) return not r.wasSuccessful()
self.logInfo("Step 4 - Click on 'Log in' button") self.login(self.browser, self.username, self.password) self.logInfo("Step 5 - Select Content > Article Manager") self.navigateMenu(self.browser, "Content>Article Manager") self.logInfo("Step 6 - Click on 'New' icon of the top right toolbar ") self.logInfo("Step 7 - Enter a title on 'Title' text field ") self.logInfo("Step 8 - Select an item from the 'Category' dropdown list ") self.logInfo("Step 9 - Enter value on 'Article Text' text area ") self.logInfo("Step 10 - Select 'Public' item from the 'Access' dropdown list ") self.logInfo("Step 11 - Click on 'Save & Close' icon of the top right toolbar ") self.createNewArticleByButton(self.browser, self.title, self.category, self.text, self.option, self.status, self.insert, self.access) self.logInfo("Step 12 - Verify the article is saved successfully") #VP: 1. "Article successfully saved" message is displayed self.checkMessageDisplay(self.browser, "Article successfully saved") #VP: 2. Created article is displayed on the articles table self.checkArticleCreated(self.browser, self.title) #VP: 3. The Access Level of the article is displayed as 'Public' self.checkAccessLevelValue(self.browser, self.title, "Access", "Public") #VP: 4. Created article's information is displayed correctly self.checkArticleInformation(self.browser, self.title, self.title, self.category, self.text, self.access) if __name__ == '__main__': tests = ["test_TC07ArticleChangeStatus", "test_TC08ArticleChangeFeature", "test_TC09ArticleCreateWithAccessLevel"] suite = unittest.TestSuite(map(Ex05Article, tests)) runner = TextTestRunner() runner.run(suite)
def __init__(self, discovery_dir='.', discovery_pattern='test*.py', output_file='test_results.html', silent=False, verbosity=2): test_groups = {} loader = TestLoader() groups_data = {} summary_data = { 'discovery_dir' : discovery_dir, 'discovery_pattern' : discovery_pattern, 'num_groups' : 0, 'num_groups_fail' : 0, 'num_groups_pass' : 0, 'num_tests' : 0, 'num_tests_fail' : 0, 'num_tests_pass' : 0, 'num_tests_skip' : 0, 'raw_log' : '' } # Discovery tests from specified directory tests = loader.discover(discovery_dir, discovery_pattern) # Group tests by file for group in tests: group_name = None for suite in group: # Determine group name if hasattr(suite, '_testMethodName'): test_groups[suite._testMethodName] = group else: for test in suite: test_groups[inspect.getmodule(test).__name__] = group break # Run tests for each group for group_name, tests in test_groups.items(): raw_log = StringIO() runner = TextTestRunner(stream=TestRunner.StreamRouter(raw_log, silent), verbosity=verbosity) result = runner.run(tests) # Index errors by test class errors = {} for error in result.errors: errors['{0}.{1}'.format(error[0].__class__.__name__, error[0]._testMethodName)] = error[1] # Marshall/record data group_data = { 'tests' : [] } group_data['tests_errored'] = len(result.errors) group_data['tests_passed'] = result.testsRun - group_data['tests_errored'] group_data['tests_skipped'] = len(result.skipped) group_data['tests_run'] = result.testsRun summary_data['num_groups'] += 1 summary_data['num_tests'] += group_data['tests_run'] + group_data['tests_skipped'] summary_data['num_tests_fail'] += group_data['tests_errored'] summary_data['num_tests_pass'] += group_data['tests_passed'] summary_data['num_tests_skip'] += group_data['tests_skipped'] summary_data['raw_log'] += raw_log.getvalue() if group_data['tests_errored'] > 0: summary_data['num_groups_fail'] += 1 else: summary_data['num_groups_pass'] += 1 # Detailed test data for suite in tests: cls_name = suite.__class__.__name__ if cls_name == 'ModuleImportFailure' or cls_name == 'LoadTestsFailure': # Record loader failure group_data['tests'].append({ 'name' : suite._testMethodName, 'status' : 'fail', 'description' : errors['{0}.{1}'.format(suite.__class__.__name__, suite._testMethodName)] }) else: for t in suite: signature = '{0}.{1}'.format(t.__class__.__name__, t._testMethodName) test_data = {'name' : '{0}.{1}'.format(group_name, signature)} if signature in errors: test_data['status'] = 'fail' test_data['description'] = errors[signature] else: test_data['description'] = ''; test_data['status'] = 'pass' group_data['tests'].append(test_data) groups_data[group_name] = group_data # Write results if summary_data['num_tests'] > 0: results.PageBuilder(groups_data, summary_data).generate_html(output_file) print 'Results available at {0}'.format(os.path.realpath(output_file)) else: print 'No tests run; no results to publish.'
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import unittest from unittest.runner import TextTestRunner from tests.fromJsonToHdl_test import FromJsonToHdlTC def main_test_suite(): suite = unittest.TestSuite() tcs = [ FromJsonToHdlTC, ] for tc in tcs: suite.addTest(unittest.makeSuite(tc)) return suite suite = main_test_suite() if __name__ == "__main__": runner = TextTestRunner(verbosity=3) runner.run(suite)
#!/usr/bin/env python3 from unittest.loader import TestLoader from unittest.runner import TextTestRunner if __name__ == '__main__': loader = TestLoader() runner = TextTestRunner() suites = loader.discover("nrf5_cmake", "*.py", ".") runner.run(suites)
#! /usr/bin/python # -*- coding: utf-8 -*- """Discover all tests (except the ones inside test_fa.py) and run them.""" from unittest import defaultTestLoader from unittest.runner import TextTestRunner import config if __name__ == '__main__': config.LANG = 'en' tests = defaultTestLoader.discover('.', '*_test.py') runner = TextTestRunner() runner.run(tests)
def run_tests(self): tests = TestLoader().discover("tests", pattern="test_*.py") runner = TextTestRunner() result = runner.run(tests) exit(0 if result.wasSuccessful() else 1)
from unittest import TestLoader from unittest.runner import TextTestRunner test_loader = TestLoader() tests = test_loader.discover('src/mousetrap') test_runner = TextTestRunner() test_runner.run(tests)
BASE_DIR = os.path.dirname(os.path.abspath(__file__)) test_loader = TestLoader() test_runner = TextTestRunner() os.environ['CELERY_CONFIG_MODULE'] = 'pmworker.config.test' setup_logging() parser = argparse.ArgumentParser() parser.add_argument('-p', '--pattern', default='test*py', help='Test files pattern.') args = parser.parse_args() if args.pattern.endswith('py'): discovery_pattern = args.pattern else: discovery_pattern = args.pattern + "*" tests = test_loader.discover(start_dir=BASE_DIR, pattern=discovery_pattern) result = test_runner.run(tests) if not result.wasSuccessful(): sys.exit(1)
def run(self, test): """Stores the total count of test cases, then calls super impl""" self.total_test_cases = test.countTestCases() return TextTestRunner.run(self, test)