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 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 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 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 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 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)
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)
