def configure(self, options): '''configure before testing''' self.test_options = options if options.xunit: try: from xmlrunner import XMLTestRunner except ImportError: raise Exception("unittest-xml-reporting not installed") self.runner = XMLTestRunner(stream=sys.stderr, \ verbosity=2, output=options.xunit) else: self.runner = unittest.TextTestRunner(stream=sys.stderr, \ verbosity=2) if options.manifest: fbname, fext = os.path.splitext(os.path.basename(options.manifest)) assert fbname == "manifest" or fext == ".manifest", \ "Please specify file name like xxx.manifest or manifest.xxx" self.tclist = self.__get_tc_from_manifest(options.manifest) if options.tests: tcs = [t[0:-3] if t.endswith(".py") else t[0:-1] \ if t.endswith("/") else t for t in options.tests] self.tclist.extend([tc.replace("/", ".") for tc in tcs]) if options.logdir: logdir = self._get_log_dir(options.logdir) self.log_handler = LogHandler(logdir) try: self.context.def_timeout = int(options.timeout) except ValueError: print "timeout need an integer value" raise
def createTestRunner(): opts, _ = getopt(sys.argv[1:], '', ['xml=']) for o, v in opts: if o == '--xml': from xmlrunner import XMLTestRunner return XMLTestRunner(output=open(v, 'wb')) return TextTestRunner()
def run(self): # pylint: disable=E0202 """ invoked by the command """ tests = unittest.TestLoader().discover('src/test', pattern='test*.py') result = XMLTestRunner(output='test-reports').run(tests) if result.wasSuccessful(): return 0 return 1
def test_main(args=[]): test_classes = [ PingTest, LookupUsersTest, NamespaceTest, BlockChains, Prices, NamesOwnedTest, NameHistoryTest, AuthInternal, BlockChainsInternal, Zonefiles, WalletInternal, NodeInternal ] test_map = {} for t in test_classes: test_map[t.__name__] = t with test_support.captured_stdout() as out: try: test_support.run_unittest(PingTest) except Exception as e: traceback.print_exc(file=sys.stdout) out = out.getvalue() if out[-3:-1] != "OK": print(out) print( "Failure of the ping test means the rest of the unit tests will " + "fail. Is the blockstack api daemon running? (did you run " + "`blockstack api start`)") sys.exit(1) if len(args) == 1 and args[0] == "--list": print("Tests supported: ") for testname in test_map.keys(): print(testname) return test_runner = test_support.run_unittest if "--xunit-path" in args: ainx = args.index("--xunit-path") del args[ainx] from xmlrunner import XMLTestRunner test_runner = XMLTestRunner(output=args[ainx]).run del args[ainx] if "--api_password" in args: ainx = args.index("--api_password") del args[ainx] global API_PASSWORD API_PASSWORD = args[ainx] del args[ainx] if len(args) == 0 or args[0] == "--all": args = [testname for testname in test_map.keys()] test_suite = unittest.TestSuite() for test_name in args: test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase( test_map[test_name])) result = test_runner(test_suite) if result: # test_support.run_unittest returns None if result.wasSuccessful(): sys.exit(0) else: sys.exit(1)
def self_valid(): self_test_suite = unittest.TestSuite() self_test_suite.addTests( loader.loadTestsFromTestCase(TestCheckOpiFormatMethods)) runner = XMLTestRunner(output=os.path.join(logs_dir, "check_opi_format"), stream=sys.stdout) return runner.run(self_test_suite).wasSuccessful()
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. from xmlrunner import XMLTestRunner tests = TestLoader().discover('tests', pattern='test_*.py') runner = XMLTestRunner(output='reports') result = runner.run(tests) exit(0 if result.wasSuccessful() else 1)
def run_self_tests(reports_path): """ Runs our own unit tests. :return: True if all tests passed, False otherwise """ print("Running self-tests...") suite = unittest.TestLoader().discover(os.path.join("util", "test_utils")) return XMLTestRunner(output=str(reports_path), stream=sys.stdout).run(suite).wasSuccessful()
def run_instrument_tests(inst_name, reports_path): """ Runs the test suite :param inst_name: The name of the instrument to run tests on, used to sort the test reports folder into instrument-specific reports :param reports_path: The path to store test reports :return: True if the tests passed, false otherwise """ suite = unittest.TestSuite() loader = unittest.TestLoader() for case in [ ScriptingDirectoryTests, GlobalsTests, VersionTests, ConfigurationsSingleTests, ComponentsSingleTests ]: suite.addTests(loader.loadTestsFromTestCase(case)) # Add configs test suite a dynamic number of times with an argument of the config name. # unittest's test loader is unable to take arguments to test classes by default so have # to use the getTestCaseNames() syntax and explicitly add the argument ourselves. try: configs = ConfigurationUtils( Settings.config_repo_path).get_configurations_as_list() components = ComponentUtils( Settings.config_repo_path).get_configurations_as_list() synoptics = SynopticUtils( Settings.config_repo_path).get_synoptics_filenames() except IOError as e: print( "Failed to build tests for instrument {}: exception occured while generating tests." .format(inst_name)) traceback.print_exc(e) return False for config in configs: suite.addTests([ ConfigurationsTests(test, config) for test in loader.getTestCaseNames(ConfigurationsTests) ]) for component in components: suite.addTests([ ComponentsTests(test, component) for test in loader.getTestCaseNames(ComponentsTests) ]) for synoptic in synoptics: suite.addTests([ SynopticTests(test, synoptic) for test in loader.getTestCaseNames(SynopticTests) ]) runner = XMLTestRunner(output=str(os.path.join(reports_path, inst_name)), stream=sys.stdout) return runner.run(suite).wasSuccessful()
def discover_and_run_tests(test_dir, f_pattern, out_dir): loader = unittest.TestLoader() tests = loader.discover(start_dir=test_dir, pattern=f_pattern, top_level_dir='.') runner = XMLTestRunner( output=out_dir, stream=sys.stdout, outsuffix=datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S-%f")) runner.run(tests)
def main(): if not os.path.isfile('run_tests.py'): os.chdir(SCRIPT_DIR) runner = XMLTestRunner(verbosity=2, output='results') tests = unittest.TestSuite() tests.addTest(test_arguments.ArgumentsTest()) result = runner.run(tests) if result.wasSuccessful(): return 0 else: return 1
def run_tests(): # type: () -> None """Run all the tests.""" # my-py's typeshed does not have defaultTestLoader and TestLoader type information so suppresss # my-py type information. all_tests = unittest.defaultTestLoader.discover(start_dir="tests") # type: ignore runner = XMLTestRunner(verbosity=2, failfast=False, output='results') result = runner.run(all_tests) sys.exit(not result.wasSuccessful())
def run_tests(device_name='', use_xmlrunner=False): """ Executes the unit tests specified by the test suite. This should be called from CMake. """ test_result = unittest.TestResult() if use_xmlrunner and 'XMLTestRunner' in globals(): test_runner = XMLTestRunner(verbosity=2) else: test_runner = unittest.TextTestRunner(verbosity=2) test_result = test_runner.run(get_test_suite(device_name)) return test_result
def run_tests_on_pages(reports_path, pages, wiki_dir, highest_issue_num, test_class): suite = unittest.TestSuite() loader = unittest.TestLoader() # Add spelling test suite a dynamic number of times with an argument of the page name. # unittest's test loader is unable to take arguments to test classes by default so have # to use the getTestCaseNames() syntax and explicitly add the argument ourselves. for page in pages: suite.addTests([test_class(test, IGNORED_ITEMS, (page, pages, wiki_dir, highest_issue_num)) for test in loader.getTestCaseNames(test_class)]) runner = XMLTestRunner(output=str(reports_path), stream=sys.stdout) return runner.run(suite).wasSuccessful()
def main(args): """ Main function which runs the tests and generate the result file. :return: result value for the CI environments :rtype: int """ # Print header tstart = time.time() log.info("Start ESCAPE tests") log.info("-" * 70) if args.timeout: log.info("Set kill timeout for test cases: %ds\n" % args.timeout) # Create overall test suite test_suite = create_test_suite(tests_dir=CWD, show_output=args.show_output, run_only_tests=args.testcases, kill_timeout=args.timeout, standalone=args.standalone) sum_test_cases = test_suite.countTestCases() log.info("-" * 70) log.info("Read %d test cases" % sum_test_cases) # Run test suite in the specific context results = None if args.verbose: output_context_manager = Tee(filename=REPORT_FILE) else: output_context_manager = open(REPORT_FILE, 'w', buffering=0) with output_context_manager as output: # Create the Runner class which runs the test cases collected in a # TestSuite object if args.failfast: log.info("Using failfast mode!") test_runner = XMLTestRunner(output=output, verbosity=2, failfast=args.failfast) try: # Run the test cases and collect the results if sum_test_cases: results = test_runner.run(test_suite) except KeyboardInterrupt: log.warning("\nReceived KeyboardInterrupt! " "Abort running main test suite...") # Print footer log.info("-" * 70) delta = time.time() - tstart log.info("Total elapsed time: %s sec" % timedelta(seconds=delta)) log.info("-" * 70) log.info("End ESCAPE tests") # Evaluate results values return results.wasSuccessful() if results is not None else False
def main(): from unittest import TestLoader, TestSuite from xmlrunner import XMLTestRunner import db_checks suites = [ TestLoader().loadTestsFromTestCase(db_checks.Test), ] tests_results_dir = "test-reports-python" result = XMLTestRunner(output=tests_results_dir).run(TestSuite(suites)) if not result.wasSuccessful(): sys.exit(1)
def main(args): """ Main function which runs the tests and generate the result file. :return: result value for the CI environments :rtype: int """ # Print header log.info("Start ESCAPE test") log.info("-" * 70) if args.timeout: log.info("Set kill timeout for test cases: %ds\n" % args.timeout) # Create overall test suite test_suite = create_test_suite(tests_dir=CWD, show_output=args.show_output, run_only_tests=args.testcases, kill_timeout=args.timeout, standalone=args.standalone) sum_test_cases = test_suite.countTestCases() log.info("-" * 70) log.info("Read %d test cases" % sum_test_cases) if not sum_test_cases: # Footer log.info("-" * 70) log.info("End ESCAPE test") return 0 # Run test suite in the specific context results = [] if args.verbose: output_context_manager = Tee(filename=REPORT_FILE) else: output_context_manager = open(REPORT_FILE, 'w', buffering=0) with output_context_manager as output: # Create the Runner class which runs the test cases collected in a # TestSuite object test_runner = XMLTestRunner(output=output, verbosity=2, failfast=args.failfast) try: # Run the test cases and collect the results results.append(test_runner.run(test_suite)) except KeyboardInterrupt: log.warning( "\n\nReceived KeyboardInterrupt! Abort running test suite...") # Evaluate results values was_success = all(map(lambda res: res.wasSuccessful(), results)) # Print footer log.info("-" * 70) log.info("End ESCAPE test") return 0 if was_success else 1
def main(): if not os.path.isfile('run_tests.py'): print('Please execute from a `tests` directory!') return 1 else: runner = XMLTestRunner(verbosity=2, output='results') # tests = unittest.TestLoader().discover('.', pattern='test*.py') tests = unittest.TestSuite() tests.addTest(test_scenarios.RequestsTesingUsingScenarios()) tests.addTest(test_arguments.ArgumentsTest()) result = runner.run(tests) if result.wasSuccessful(): return 0 else: return 1
def test_main(args=[]): test_classes = [ PingTest, LookupUsersTest, NamespaceTest, BlockChains, Prices, NamesOwnedTest, NameHistoryTest, AuthInternal, BlockChainsInternal, Zonefiles, WalletInternal, NodeInternal ] test_map = {} for t in test_classes: test_map[t.__name__] = t test_runner = unittest.TextTestRunner(verbosity=2).run if "--xunit-path" in args: ainx = args.index("--xunit-path") del args[ainx] from xmlrunner import XMLTestRunner test_runner = XMLTestRunner(output=args[ainx]).run del args[ainx] if len(args) == 1 and args[0] == "--list": print("Tests supported: ") for testname in test_map.keys(): print(testname) return if "--api_password" in args: ainx = args.index("--api_password") del args[ainx] global API_PASSWORD API_PASSWORD = args[ainx] del args[ainx] if len(args) == 0 or args[0] == "--all": args = [testname for testname in test_map.keys()] test_suite = unittest.TestSuite() for test_name in args: test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase( test_map[test_name])) result = test_runner(test_suite) if result: # test_support.run_unittest returns None if result.wasSuccessful(): sys.exit(0) else: sys.exit(1)
def main(argv): """ Runs the test files through the xml runner :param argv: List of command line arguments """ if len(argv) != 2: raise ValueError("Usage: testrunner <path-to-test-file>") pathname = argv[1] if not os.path.exists(pathname): raise ValueError("Test file not found '{}'".format(pathname)) if not os.path.isfile(pathname): raise ValueError("Test path '{}' is not a file".format(pathname)) # Add the directory of the test to the Python path dirname = os.path.dirname(pathname) # if the directory ends with 'tests' add the parent directory as well # this is used in the external project PyStoG sys.path.insert(0, dirname) if os.path.split(dirname)[-1] == 'tests': sys.path.insert(1, os.path.split(dirname)[0]) # Load the test and copy over any module variables so that we have # the same environment defined here test_module = imp.load_source(module_name(pathname), pathname) test_module_globals = dir(test_module) this_globals = globals() for key in test_module_globals: this_globals[key] = getattr(test_module, key) # create runner & execute runner = XMLTestRunner(output='.', outsuffix='', resultclass=result_class(pathname)) unittest.main( module=test_module, # We've processed the test source so don't let unittest try to reparse it # This forces it to load the tests from the supplied module argv=(argv[0], ), testRunner=runner, # these make sure that some options that are not applicable # remain hidden from the help menu. failfast=False, buffer=False, catchbreak=False)
def main(useXMLRunner=True): # load hard-coded tests # unitsuite = unittest.makeSuite(UnitTests) # modelsuite = unittest.makeSuite(ModelTests) funsuite = unittest.makeSuite(FunctionalTests) # combine and run tests # alltests = unittest.TestSuite([unitsuite, modelsuite, funsuite]) alltests = unittest.TestSuite([funsuite]) if useXMLRunner: stream = file("testresults.xml", "w") runner = XMLTestRunner(stream) result = runner.run(alltests) stream.close() else: runner = unittest.TextTestRunner(verbosity=2) result = runner.run(alltests) return result
def main(): ''' Test main function entry ''' # Read command line arguments opts = parse_options() host = opts.host is_create = opts.create_template report_format = opts.report_format token = opts.token path = os.getcwd() if is_create: create_example(path) print("Create template successfully") sys.exit() # Log file configuration log_dir = PATH(os.path.join(path, 'log')) if not os.path.exists(log_dir): os.mkdir(log_dir) log_filename = str(time.strftime("%Y%m%d%H%M%S", time.localtime())) + '.log' log_path = PATH(os.path.join(log_dir, log_filename)) log_init(PATH(log_path)) # Use case, configuration import case_dir = PATH(os.path.join(path, 'case/yaml')) config_file = PATH(os.path.join(path, 'config/config.yaml')) if host and (host == 'test'): config_file = PATH(os.path.join(path, 'config/test_config.yaml')) testcase_id_list = loading_data(case_dir, config_file, token) script_dir = PATH(os.path.join(path, 'case/script')) script_file = PATH(os.path.join(script_dir, 'test_allcase.py')) create_script(script_file, testcase_id_list) # Generate test report suit = unittest.TestSuite() discover = unittest.defaultTestLoader.discover(script_dir, pattern='test_*') for i in discover: suit.addTest(i) runner = HTMLTestRunner(output='reports') if report_format and (report_format == 'xml' or report_format == 'XML'): runner = XMLTestRunner(output='reports') runner.run(suit)
def run_tests(argv, env, coverage, junit_xml): print('running tests...') if coverage: omissions = [os.path.join(root, '*') for root in VENDORED_ROOTS] # TODO: Drop the explicit pydevd omit once we move the subtree. omissions.append(os.path.join('ptvsd', 'pydevd', '*')) ver = 3 if sys.version_info < (3, ) else 2 omissions.append(os.path.join('ptvsd', 'reraise{}.py'.format(ver))) args = [ sys.executable, '-m', 'coverage', 'run', # We use --source instead of "--include ptvsd/*". '--source', 'ptvsd', '--omit', ','.join(omissions), '-m', 'unittest', ] + argv[1:] assert 'PYTHONPATH' not in env env['PYTHONPATH'] = os.pathsep.join(VENDORED_ROOTS) rc = subprocess.call(args, env=env) if rc != 0: print('...coverage failed!') sys.exit(rc) print('...done') elif junit_xml: from xmlrunner import XMLTestRunner # noqa os.environ.update(env) verbosity = 1 if '-v' in argv or '--verbose' in argv: verbosity = 2 with open(junit_xml, 'wb') as output: unittest.main( testRunner=XMLTestRunner(output=output, verbosity=verbosity), module=None, argv=argv, ) else: os.environ.update(env) unittest.main(module=None, argv=argv)
def run(self): # Installing required packages, running egg_info and build_ext are # part of normal operation for setuptools.command.test.test if self.distribution.install_requires: self.distribution.fetch_build_eggs( self.distribution.install_requires) if self.distribution.tests_require: self.distribution.fetch_build_eggs(self.distribution.tests_require) if self.xunit_output: if sys.version_info[:2] == (2, 6): self.distribution.fetch_build_eggs( ["unittest-xml-reporting>=1.14.0,<2.0.0a0"]) else: self.distribution.fetch_build_eggs(["unittest-xml-reporting"]) self.run_command('egg_info') build_ext_cmd = self.reinitialize_command('build_ext') build_ext_cmd.inplace = 1 self.run_command('build_ext') # Construct a TextTestRunner directly from the unittest imported from # test (this will be unittest2 under Python 2.6), which creates a # TestResult that supports the 'addSkip' method. setuptools will by # default create a TextTestRunner that uses the old TestResult class, # resulting in DeprecationWarnings instead of skipping tests under 2.6. from test import unittest, PymongoTestRunner, test_cases if self.test_suite is None: all_tests = unittest.defaultTestLoader.discover(self.test_module) suite = unittest.TestSuite() suite.addTests( sorted(test_cases(all_tests), key=lambda x: x.__module__)) else: suite = unittest.defaultTestLoader.loadTestsFromName( self.test_suite) if self.xunit_output: from xmlrunner import XMLTestRunner runner = XMLTestRunner(verbosity=2, failfast=self.failfast, output=self.xunit_output) else: runner = PymongoTestRunner(verbosity=2, failfast=self.failfast) result = runner.run(suite) sys.exit(not result.wasSuccessful())
def run_tests(test_reports_path=DEFAULT_TEST_LOCATION): """ Runs the test suite Args: test_reports_path: Path to test reports Returns: True if the tests passed, false otherwise """ loader = unittest.TestLoader() suite = unittest.TestSuite() for case in [ DeviceInfoGeneratorTests, GuiUtilsTests, SystemPathTests, FileSystemUtilsTests ]: suite.addTests(loader.loadTestsFromTestCase(case)) return XMLTestRunner(output=str(os.path.join(test_reports_path)), stream=sys.stdout).run(suite).wasSuccessful()
def runtests(): suite = unittest.defaultTestLoader.loadTestsFromNames([ 'tests.unit.avs_result_test', 'tests.unit.cvv_result_test', 'tests.unit.credit_card_tests', 'tests.unit.gateways.authorize_net_tests', 'tests.unit.gateways.bogus_tests', 'tests.unit.gateways.braintree_blue_tests', 'tests.unit.gateways.braintree_orange_tests', 'tests.unit.gateways.cybersource_tests', 'tests.unit.gateways.payflow_tests', 'tests.unit.gateways.paymentech_orbital_tests', ]) if os.environ.get('XML_OUTPUT', False): from xmlrunner import XMLTestRunner runner = XMLTestRunner() else: runner = unittest.TextTestRunner(verbosity=1, descriptions=False) result = runner.run(suite).wasSuccessful() exit_code = 0 if result else 1 sys.exit(exit_code)
def _run_test_case(self, suits): """ run test case """ if self.debug is False: for filename in os.listdir(os.getcwd()): if filename == "reports": break else: os.mkdir(os.path.join(os.getcwd(), "reports")) if self.report is None: now = time.strftime("%Y_%m_%d_%H_%M_%S") report_path = os.path.join(os.getcwd(), "reports", now + "_result.html") BrowserConfig.report_path = report_path else: report_path = os.path.join(os.getcwd(), "reports", self.report) with (open(report_path, 'wb')) as fp: log.info(seldom_str) if report_path.split(".")[-1] == "xml": runner = XMLTestRunner(output=fp) runner.run(suits) else: runner = HTMLTestRunner(stream=fp, title=self.title, description=self.description) runner.run(suits, rerun=self.rerun, save_last_run=self.save_last_run) log.info("generated html file: file:///{}".format(report_path)) webbrowser.open_new("file:///{}".format(report_path)) else: runner = unittest.TextTestRunner(verbosity=2) log.info( "A run the test in debug mode without generating HTML report!") log.info(seldom_str) runner.run(suits)
def _run_test_case(self, suits): """ run test case """ if self.debug is False: for filename in os.listdir(os.getcwd()): if filename == "reports": break else: os.mkdir(os.path.join(os.getcwd(), "reports")) if (self.report is None) and (BrowserConfig.REPORT_PATH is not None): report_path = BrowserConfig.REPORT_PATH else: report_path = BrowserConfig.REPORT_PATH = os.path.join( os.getcwd(), "reports", self.report) with (open(report_path, 'wb')) as fp: if report_path.split(".")[-1] == "xml": runner = XMLTestRunner(output=fp) runner.run(suits) else: runner = HTMLTestRunner(stream=fp, title=self.title, description=self.description) runner.run(suits, rerun=self.rerun, save_last_run=self.save_last_run) log.printf("generated html file: file:///{}".format(report_path)) log.printf("generated log file: file:///{}".format( BrowserConfig.LOG_PATH)) webbrowser.open_new("file:///{}".format(report_path)) else: runner = unittest.TextTestRunner(verbosity=2) runner.run(suits) log.printf( "A run the test in debug mode without generating HTML report!")
suite.addTest( TC_3405_Consult_the_legal_notices_from_my_account_my_preferences_in_opt_in( "test")) suite.addTest( TC_3409_T015215_Active_tracking_from_my_account_set_opl_in_parameter( "test")) suite.addTest( TC_3396_T015183_consult_recommendation_implicite_profile_in_opt_in_mode_csa4_5( "test")) suite.addTest( TC_2982_T014407_change_the_audio_version_of_a_program_on_toolbox_ip_stream( "test")) suite.addTest(TC_10906_T016034_Consult_a_no_rented_paid_vod("test")) suite.addTest( TC_3221_T016765_When_record_is_in_progress_zap_to_another_program( "test")) suite.addTest( TC_3464_3468_T015841_sound_level_on_live_access_T015845_sound_level_on_live_zapping( "test")) suite.addTest(TC_3368_T014506_consult_prepaid_account("test")) suite.addTest(TC_9802_T999999_Auto_select_summary_option("test")) suite.addTest(TC_9798_T000000_Auto_Display_and_Use_Zapping_Banner("test")) runner = XMLTestRunner(createAndGetXmlDirPath()) result = runner.run(suite) writeTsSummaryToFiles(result) if not result.wasSuccessful(): exit(1) exit()
import unittest from xmlrunner import XMLTestRunner import os import sys loader = unittest.TestLoader() tests = loader.discover( os.path.dirname( os.path.realpath(__file__)), pattern="*Test.py") fail_on_error = "--fail-on-error" in sys.argv runner = XMLTestRunner() result = runner.run(tests) if fail_on_error and len(result.failures + result.errors) > 0: sys.exit(1)
import sys import unittest from os.path import dirname from xmlrunner import XMLTestRunner from mycroft.configuration import ConfigurationManager __author__ = 'seanfitz, jdorleans' fail_on_error = "--fail-on-error" in sys.argv ConfigurationManager.load_local(['mycroft.ini']) tests = unittest.TestLoader().discover(dirname(__file__), "*.py") runner = XMLTestRunner("./build/report/tests") result = runner.run(tests) if fail_on_error and len(result.failures + result.errors) > 0: sys.exit(1)