def main(self, datasources, **options): settings = RobotSettings(options) LOGGER.register_console_logger(**settings.console_output_config) LOGGER.info('Settings:\n%s' % unic(settings)) builder = TestSuiteBuilder(settings['SuiteNames'], extension=settings.extension, rpa=settings.rpa) suite = builder.build(*datasources) settings.rpa = builder.rpa suite.configure(**settings.suite_config) if settings.pre_run_modifiers: suite.visit( ModelModifier(settings.pre_run_modifiers, settings.run_empty_suite, LOGGER)) with pyloggingconf.robot_handler_enabled(settings.log_level): old_max_error_lines = text.MAX_ERROR_LINES text.MAX_ERROR_LINES = settings.max_error_lines try: result = suite.run(settings) finally: text.MAX_ERROR_LINES = old_max_error_lines LOGGER.info("Tests execution ended. Statistics:\n%s" % result.suite.stat_message) if settings.log or settings.report or settings.xunit: writer = ResultWriter( settings.output if settings.log else result) writer.write_results(settings.get_rebot_settings()) return result.return_code
def TestSuiteFactory(datasources, **options): settings = RobotSettings(options) if isinstance(datasources, basestring): datasources = [datasources] suite = TestSuiteBuilder().build(*datasources) suite.configure(**settings.suite_config) return suite
def TestSuiteFactory(datasources, **options): settings = RobotSettings(options) if is_string(datasources): datasources = [datasources] suite = TestSuiteBuilder(process_curdir=False).build(*datasources) suite.configure(**settings.suite_config) return suite
def execute_robot( kernel: DisplayKernel, code: str, data: TestCaseString, listeners: list, silent: bool, ): # Build builder = TestSuiteBuilder() data.source = os.getcwd() # allow Library and Resource from CWD work suite = builder._build_suite(data) suite._name = "Jupyter" # Run display_id = str(uuid.uuid4()) if suite.tests: with TemporaryDirectory() as path: reply = run_robot_suite(kernel, suite, listeners, silent, display_id, path) else: last_code = getattr(kernel, "_last_code", "") if code == last_code: setattr(kernel, "_last_code", "") else: inject_ipywidgets(kernel, code, data, listeners, silent, display_id) setattr(kernel, "_last_code", code) reply = {"status": "ok", "execution_count": kernel.execution_count} return reply
def execute_ipywidget( kernel: DisplayKernel, data: TestCaseString, listeners: list, silent: bool, display_id: str, name, arguments, values, ): header = getattr(data.testcase_table, "name", "Tasks") or "Tasks" table = f"""\ *** {header} *** {name} {name} {' '.join([values[a[1]] for a in arguments])} """ data.testcase_table.tests.clear() data.populate(table) # Build builder = TestSuiteBuilder() data.source = os.getcwd() # allow Library and Resource from CWD work suite = builder._build_suite(data) suite._name = "Jupyter" with TemporaryDirectory() as path: run_robot_suite(kernel, suite, listeners, silent, display_id, path, widget=True)
def execute_run(self, suite_list, extensions, include_suites, robot_arg_dict): """ Sources a series of test suites and then makes the RPC call to the slave to execute the robot run. :param suite_list: List of paths to test suites or directories containing test suites :type suite_list: list :param extensions: String that filters the accepted files extensions for test suites :type extensions: str :param include_suites: List of strings that filter suites to include :type include_suites: list :param robot_arg_dict: Dictionary of arguments that will be passed to robot.run on the remote host :type robot_arg_dict: dict :return: Dictionary containing stdout/err, log html, output xml, report html, return code :rtype: dict """ # Use robot to resolve all of the test suites suite_list = [os.path.normpath(p) for p in suite_list] logger.debug('Suite List: ' + str(suite_list)) # Let robot do the heavy lifting in parsing the test suites builder = TestSuiteBuilder(include_suites, extension=extensions) suite = builder.build(*suite_list) # Now iterate the suite's family tree, pull out the suites with test cases and resolve their dependencies. # Package them up into a dictionary that can be serialized self._package_suite_hierarchy(suite) # Make the RPC logger.info('Connecting to: ' + self._address) response = self._client.execute_robot_run(self._suites, self._dependencies, robot_arg_dict, self._debug) return response
def build(self, name="Untitled Test Suite"): """ Build a test suite """ # pylint: disable=W0212 self.suite = TestSuiteBuilder()._build_suite(self.test_data) self.suite._name = name return self
def main(self, datasources, **options): settings = RobotSettings(options) LOGGER.register_console_logger(**settings.console_output_config) LOGGER.info('Settings:\n%s' % unic(settings)) if settings['WarnOnSkipped'] is not None: LOGGER.error("Option '--warnonskippedfiles is deprecated and " "has no effect.") builder = TestSuiteBuilder(settings['SuiteNames'], extension=settings.extension, rpa=settings.rpa) suite = builder.build(*datasources) settings.rpa = builder.rpa suite.configure(**settings.suite_config) if settings.pre_run_modifiers: suite.visit( ModelModifier(settings.pre_run_modifiers, settings.run_empty_suite, LOGGER)) with pyloggingconf.robot_handler_enabled(settings.log_level): result = suite.run(settings) LOGGER.info("Tests execution ended. Statistics:\n%s" % result.suite.stat_message) if settings.log or settings.report or settings.xunit: writer = ResultWriter( settings.output if settings.log else result) writer.write_results(settings.get_rebot_settings()) return result.return_code
def setUp(self): self.resource_dir = os.path.join(os.path.dirname(__file__), 'rf_client_test_resources') builder = TestSuiteBuilder() parent_suite = builder.build(self.resource_dir) self.ts1 = parent_suite.suites[1] self.test_obj = RemoteFrameworkClient('127.0.0.1')
def test__variable_kw__pass(): suite = TestSuiteBuilder().build( os.path.join(path, 'fixtures/robot/variable.robot')) result = suite.run(output=None, variablefile=os.path.join(path, 'fixtures/robot/common.py')) assert result.return_code == 0
def do_execute(self, code, silent, store_history=True, user_expressions=None, allow_stdin=False): # Support %%python module ModuleName cell magic match = re.match('^%%python module ([a-zA-Z_]+)', code) if match is not None: module = match.groups()[0] return self.do_execute_python( code[len('%%python module {0:s}'.format(module)):], module, silent, store_history, user_expressions, allow_stdin) # Populate data = TestCaseString() try: for historical in self.robot_history: data.populate(historical) data.testcase_table.tests.clear() data.populate(code) except Exception as e: if not silent: self.send_error({ 'ename': e.__class__.__name__, 'evalue': str(e), 'traceback': list(format_exc().splitlines()), }) return { 'status': 'error', 'ename': e.__class__.__name__, 'evalue': str(e), 'traceback': list(format_exc().splitlines()), } # Build builder = TestSuiteBuilder() suite = builder._build_suite(data) suite._name = 'Jupyter' # Run if suite.tests: reply = self.run_robot_suite(suite, silent) else: reply = { 'status': 'ok', 'execution_count': self.execution_count, } # Save history if reply['status'] == 'ok': self.robot_history.append(code) return reply
def get_suite_testcases(self, test_suite_path): """ parse test case name from robot test suite :param test_suite_path: :return: test names list """ settings = RobotSettings() builder = TestSuiteBuilder(settings['SuiteNames'], settings['RunEmptySuite']) data = builder._parse(test_suite_path) tests = [test.name for test in data.testcase_table.tests] print('\n'.join(tests)) return tests
def Run(self, path, **options): debug = options.pop('debug', self.debug) # post processed options settings = RobotSettings(**options) builder = TestSuiteBuilder() suite = builder.build(path) with self._context: runner = Runner(self._output, settings) suite.visit(runner) result = runner.result if debug and result.return_code: reraise(*self._output._last_fail_exc) return TestResult(runner.result, **options)
def main(self, datasources, **options): settings = RobotSettings(options) LOGGER.register_console_logger(**settings.console_logger_config) LOGGER.info('Settings:\n%s' % unicode(settings)) suite = TestSuiteBuilder(settings['SuiteNames'], settings['WarnOnSkipped'], settings['RunEmptySuite']).build(*datasources) suite.configure(**settings.suite_config) result = suite.run(settings) LOGGER.info("Tests execution ended. Statistics:\n%s" % result.suite.stat_message) if settings.log or settings.report or settings.xunit: writer = ResultWriter(settings.output if settings.log else result) writer.write_results(settings.get_rebot_settings()) return result.return_code
def main(self, datasources, **options): settings = RobotSettings(options) LOGGER.register_console_logger(**settings.console_output_config) LOGGER.info('Settings:\n%s' % unicode(settings)) suite = TestSuiteBuilder(settings['SuiteNames'], settings['WarnOnSkipped']).build(*datasources) suite.configure(**settings.suite_config) if settings.pre_run_modifiers: suite.visit(ModelModifier(settings.pre_run_modifiers, settings.run_empty_suite, LOGGER)) with pyloggingconf.robot_handler_enabled(settings.log_level): result = suite.run(settings) LOGGER.info("Tests execution ended. Statistics:\n%s" % result.suite.stat_message) if settings.log or settings.report or settings.xunit: writer = ResultWriter(settings.output if settings.log else result) writer.write_results(settings.get_rebot_settings()) return result.return_code
def build_suite(code: str, cell_history: Dict[str, str]): # Init data = TestCaseString() data.source = os.getcwd() # allow Library and Resource from CWD work # Populate history, but ignore tests for historical in cell_history.values(): data.populate(historical) data.testcase_table.tests.clear() # Populate current data.populate(code) # Wrap up builder = TestSuiteBuilder() suite = builder._build_suite(data) suite._name = "Jupyter" return suite
def main(self, data_sources, **options): settings = RobotSettings(options) LOGGER.register_console_logger(**settings.console_output_config) LOGGER.info("Settings:\n%s" % unic(settings)) suite = TestSuiteBuilder(settings['SuiteNames'], settings['WarnOnSkipped'], settings['Extension']).build(*data_sources) suite.configure(**settings.suite_config) self._support_python_path(options) self._split_tests(suite) # 递归,找到所有的tests, 写入self.long_names self._assert_data_source( data_sources) # 只取第一个DataSource, 写入self.data_source self._assert_test_count() # 如果没有要测试的, 直接退出, 返回码: 1 self.output_dir = settings['OutputDir'] self.clean_output_dir() # 删掉主要输出目录下所有东东, 类似rm -rf self.output_dir self.log_debug_info(options) p_num = (int(options['processes']) if 'processes' in options else 2 * cpu_count()) start_time, end_time = self.parallel_run(options, p_num) self.merge_report(start_time, end_time)
def _runTest(self, parsed, **options): settings = RobotSettings(options) LOGGER.register_console_logger(width=settings['MonitorWidth'], colors=settings['MonitorColors'], markers=settings['MonitorMarkers'], stdout=settings['StdOut'], stderr=settings['StdErr']) LOGGER.info('Settings:\n%s' % six.text_type(settings)) suite = TestSuiteBuilder( settings['SuiteNames'], settings['WarnOnSkipped'], settings['RunEmptySuite'])._build_suite(parsed) suite.configure(**settings.suite_config) result = suite.run(settings) LOGGER.info("Tests execution ended. Statistics:\n%s" % result.suite.statistics.message) rc = result.return_code if settings.log or settings.report or settings.xunit: writer = ResultWriter(settings.output if settings.log else result) writer.write_results(settings.get_rebot_settings()) return rc
def main(self, datasources, **options): for key, value in options.items(): if not value: options.pop(key) settings = RobotSettings(options) LOGGER.register_console_logger(**settings.console_output_config) LOGGER.info('Settings:\n%s' % unic(settings)) suite = TestSuiteBuilder(settings['SuiteNames'], settings['WarnOnSkipped'], settings['Extension']).build(*datasources) suite.configure(**settings.suite_config) data_sources = '"' + '" "'.join(datasources) + '"' logFolder = settings['OutputDir'] if options.has_key('processes'): p_num = int(options['processes']) else: p_num = 2 * cpu_count() #默认两倍cpu核数 longname = [] testnames = self._split_tests(suite, longname) #递归,找到所有的tests extra_options_cmd = self.unresolve_options(options) #运行前先清理环境,主要是把一些Output文件和图片文件清除 self.clear_env(logFolder) #生成并行运行命令并运行 self.parallel_run(testnames, logFolder, data_sources, extra_options_cmd, p_num) #合并报告 rebotCommand = 'rebot --outputdir "' + logFolder + '" --merge "' + logFolder + '/*_Output.xml"' print(rebotCommand) merge_proc = subprocess.Popen(rebotCommand, shell=True) merge_proc.communicate()
def _runTest(self, parsed, **options): settings = RobotSettings(options) output_config = getattr( settings, 'console_output_config', { 'width': getattr(settings, 'console_width', 78), 'colors': getattr(settings, 'console_colors', 'AUTO'), 'markers': getattr(settings, 'console_markers', 'AUTO'), 'stdout': settings['StdOut'], 'stderr': settings['StdErr'] }) LOGGER.register_console_logger(**output_config) LOGGER.info('Settings:\n%s' % six.text_type(settings)) suite = TestSuiteBuilder( settings['SuiteNames'], settings['WarnOnSkipped'])._build_suite(parsed) suite.configure(**settings.suite_config) result = suite.run(settings) LOGGER.info("Tests execution ended. Statistics:\n%s" % result.suite.statistics.message) rc = result.return_code if settings.log or settings.report or settings.xunit: writer = ResultWriter(settings.output if settings.log else result) writer.write_results(settings.get_rebot_settings()) return rc
__author__ = 'teemu kanstren' from robot.running import TestSuiteBuilder from robot.api import ResultWriter from io import StringIO #https://robot-framework.readthedocs.io/en/3.0/autodoc/robot.running.html suite = TestSuiteBuilder().build("./include.robot") stdout = StringIO() result = suite.run(output="test_output.xml", include="*crit", stdout=stdout) ResultWriter("test_output.xml").write_results(report='report.html', log="log.html") output = stdout.getvalue() print(output)
def build(*paths): paths = [normpath(join(DATADIR, p)) for p in paths] suite = TestSuiteBuilder().build(*paths) assert_true(isinstance(suite, TestSuite)) assert_equal(suite.source, paths[0] if len(paths) == 1 else None) return suite
def setUp(self): self.suite = TestSuiteBuilder().build(MISC_DIR)
def test__enforce_validation(): suite = TestSuiteBuilder().build(os.path.join(os.getcwd(), 'tests', 'fixtures', 'robot', 'context_only.robot')) result = suite.run(output=None, variablefile=os.path.join('fixtures/robot/common.py')) assert result.statistics.total.all.failed > 0
def build(path): return TestSuiteBuilder().build(join(DATADIR, path))
from robot.running import TestSuiteBuilder from robot.model import SuiteVisitor class TestCasesFinder(SuiteVisitor): def __init__(self): self.tests = [] def visit_test(self, test): self.tests.append(test) if __name__ == "__main__": builder = TestSuiteBuilder() testsuite = builder.build('./') finder = TestCasesFinder() testsuite.visit(finder) for test in finder.tests: print(test)
from robot.running import TestSuiteBuilder suite = TestSuiteBuilder().build("./google_search.robot") result = suite.run()
def test__address__pass(): suite = TestSuiteBuilder().build(os.path.join(os.getcwd(), 'app2.robot')) result = suite.run(output=None) assert result.return_code == 0
__author__ = 'teemu kanstren' from robot.running import TestSuiteBuilder from robot.api import ResultWriter #https://robot-framework.readthedocs.io/en/3.0/autodoc/robot.running.html suite = TestSuiteBuilder().build("./noncritical.robot") result = suite.run(output="test_output.xml", noncritical="*crit") ResultWriter("test_output.xml").write_results(report='report.html', log="log.html")
def setUp(self): path = os.path.normpath( os.path.join(__file__, '..', '..', '..', 'atest', 'testdata', 'misc')) self.suite = TestSuiteBuilder().build(path)