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)
