def _create_handlers(self, libinst):
success, failure, details = self._get_reporting_methods()
handlers = utils.NormalizedDict(ignore=['_'])
for name in self._get_handler_names(libinst):
err_pre = "Adding keyword '%s' to library '%s' failed: " % (
name, self.name)
try:
method = self._get_handler_method(self._libinst, name)
success("Got handler method '%s'" % (name))
except TypeError:
failure(err_pre + 'Not a method or function')
continue
except:
err_msg, err_details = utils.get_error_details()
failure(err_pre + 'Getting handler method failed: ' + err_msg)
details('Details:\n%s' % err_details)
continue
try:
handlers[name] = self._create_handler(name, method)
success("Created keyword '%s'" % handlers[name].name)
except:
err_msg, err_details = utils.get_error_details()
failure(err_pre + 'Creating keyword failed: ' + err_msg)
details('Details:\n%s' % err_details)
return handlers
def _get_message(self, record):
try:
return record.getMessage(), None
except:
message = "Failed to log following message properly: %s" % utils.unic(record.msg)
error = "\n".join(utils.get_error_details())
return message, error
def call_method(self, method, *args):
try:
method(*args)
except:
message, details = get_error_details()
LOGGER.error("Calling listener method '%s' of listener '%s' "
"failed: %s" % (method.__name__, self.name, message))
LOGGER.info("Details:\n%s" % details)
def _raise_creating_instance_failed(self):
msg, details = get_error_details()
if self.positional_args or self.named_args:
args = self.positional_args + ["%s=%s" % item for item in self.named_args.items()]
args_text = "arguments %s" % seq2str2(args)
else:
args_text = "no arguments"
raise DataError("Initializing test library '%s' with %s failed: %s\n%s" % (self.name, args_text, msg, details))
def visit_suite(self, suite):
for visitor in self._visitors:
try:
suite.visit(visitor)
except:
message, details = get_error_details()
LOGGER.error("Executing pre-run visitor '%s' failed: %s\n%s"
% (type_name(visitor), message, details))
def _get_message(self, record):
try:
return self.format(record), None
except:
message = 'Failed to log following message properly: %s' \
% safe_str(record.msg)
error = '\n'.join(get_error_details())
return message, error
def _get_message(self, record):
try:
return record.getMessage(), None
except:
message = 'Failed to log following message properly: %s' \
% utils.unic(record.msg)
error = '\n'.join(utils.get_error_details())
return message, error
def _get_message(self, record):
try:
return record.getMessage(), None
except:
message = 'Failed to log following message properly: %s' \
% unic(record.msg)
error = '\n'.join(get_error_details())
return message, error
def _report_adding_keyword_failed(self, name, message=None, details=None,
level=None):
if not message:
message, details = get_error_details()
LOGGER.write("Adding keyword '%s' to library '%s' failed: %s"
% (name, self.name, message), level or self._failure_level)
if details:
LOGGER.debug('Details:\n%s' % details)
def _report_adding_keyword_failed(self, name, message=None, details=None, level=None):
if not message:
message, details = get_error_details()
LOGGER.write(
"Adding keyword '%s' to library '%s' failed: %s" % (name, self.name, message), level or self._failure_level
)
if details:
LOGGER.debug("Details:\n%s" % details)
def call_method(self, method, *args):
try:
method(*args)
except:
message, details = utils.get_error_details()
LOGGER.error("Calling listener method '%s' of listener '%s' "
"failed: %s" % (method.__name__, self.name, message))
LOGGER.info("Details:\n%s" % details)
def _get_handler_method(self, libcode, name):
try:
method = getattr(libcode, name)
except:
message, details = get_error_details()
raise DataError('Getting handler method failed: %s' % message,
details)
self._validate_handler_method(method)
return method
def _raise_creating_instance_failed(self):
msg, details = utils.get_error_details()
if self.positional_args:
args = "argument%s %s" % (utils.plural_or_not(self.positional_args),
utils.seq2str(self.positional_args))
else:
args = "no arguments"
raise DataError("Creating an instance of the test library '%s' with %s "
"failed: %s\n%s" % (self.name, args, msg, details))
def call_method(self, method, *args):
if self.is_java:
args = [self._to_map(a) if isinstance(a, dict) else a for a in args]
try:
method(*args)
except:
message, details = utils.get_error_details()
LOGGER.error("Calling listener method '%s' of listener '%s' failed: %s"
% (method.__name__, self.name, message))
LOGGER.info("Details:\n%s" % details)
def call_method(self, method, *args):
if self.is_java:
args = [self._to_map(a) if isinstance(a, dict) else a for a in args]
try:
method(*args)
except:
message, details = utils.get_error_details()
LOGGER.error("Calling listener method '%s' of listener '%s' failed: %s"
% (method.__name__, self.name, message))
LOGGER.info("Details:\n%s" % details)
def _raise_creating_instance_failed(self):
msg, details = get_error_details()
if self.positional_args or self.named_args:
args = self.positional_args \
+ ['%s=%s' % item for item in self.named_args]
args_text = 'arguments %s' % seq2str2(args)
else:
args_text = 'no arguments'
raise DataError("Initializing test library '%s' with %s failed: %s\n%s"
% (self.name, args_text, msg, details))
def _raise_creating_instance_failed(self):
msg, details = utils.get_error_details()
if self.positional_args:
args = "argument%s %s" % (utils.plural_or_not(
self.positional_args), utils.seq2str(self.positional_args))
else:
args = "no arguments"
raise DataError(
"Creating an instance of the test library '%s' with %s "
"failed: %s\n%s" % (self.name, args, msg, details))
def _close_listener(self, listener):
method = (getattr(listener, 'close', None) or
getattr(listener, '_close', None))
try:
if method:
method()
except:
message, details = get_error_details()
name = getattr(listener, '__name__', None) or type_name(listener)
self.report_error("Calling method '%s' of listener '%s' failed: %s"
% (method.__name__, name, message), details)
def visit_suite(self, suite):
for visitor in self._visitors:
try:
suite.visit(visitor)
except:
message, details = get_error_details()
self._log_error("Executing model modifier '%s' failed: %s\n%s"
% (type_name(visitor), message, details))
if not (suite.test_count or self._empty_suite_ok):
raise DataError("Suite '%s' contains no tests after model "
"modifiers." % suite.name)
def visit_suite(self, suite):
for visitor in self._visitors:
try:
suite.visit(visitor)
except:
message, details = get_error_details()
self._log_error("Executing model modifier '%s' failed: %s\n%s"
% (type_name(visitor), message, details))
if not (suite.test_count or self._empty_suite_ok):
raise DataError("Suite '%s' contains no tests after model "
"modifiers." % suite.name)
def _close_listener(self, listener):
method = (getattr(listener, 'close', None) or
getattr(listener, '_close', None))
try:
if method:
method()
except:
message, details = get_error_details()
name = getattr(listener, '__name__', None) or type_name(listener)
LOGGER.error("Calling method '%s' of listener '%s' failed: %s"
% (method.__name__, name, message))
LOGGER.info("Details:\n%s" % details)
def __call__(self, args):
if self.called:
return
try:
ListenerMethod.called = True
self.method(*args)
except:
message, details = get_error_details()
LOGGER.error("Calling method '%s' of listener '%s' failed: %s"
% (self.method.__name__, self.listener_name, message))
LOGGER.info("Details:\n%s" % details)
finally:
ListenerMethod.called = False
def _import_listeners(self, listener_data):
listeners = []
for name, args in listener_data:
try:
listeners.append(_ListenerProxy(name, args))
except:
message, details = utils.get_error_details()
if args:
name += ':' + ':'.join(args)
LOGGER.error("Taking listener '%s' into use failed: %s"
% (name, message))
LOGGER.info("Details:\n%s" % details)
return listeners
def _import_listeners(self, listener_data):
listeners = []
for name, args in listener_data:
try:
listeners.append(_ListenerProxy(name, args))
except:
message, details = utils.get_error_details()
if args:
name += ':' + ':'.join(args)
LOGGER.error("Taking listener '%s' into use failed: %s" %
(name, message))
LOGGER.info("Details:\n%s" % details)
return listeners
def __call__(self, args):
if self.called:
return
try:
ListenerMethod.called = True
self.method(*args)
except:
message, details = get_error_details()
LOGGER.error("Calling method '%s' of listener '%s' failed: %s" %
(self.method.__name__, self.listener_name, message))
LOGGER.info("Details:\n%s" % details)
finally:
ListenerMethod.called = False
def _set_cli_vars(settings):
for path, args in settings['VariableFiles']:
try:
GLOBAL_VARIABLES.set_from_file(path, args)
except:
msg, details = utils.get_error_details()
LOGGER.error(msg)
LOGGER.info(details)
for varstr in settings['Variables']:
try:
name, value = varstr.split(':', 1)
except ValueError:
name, value = varstr, ''
GLOBAL_VARIABLES['${%s}' % name] = value
def _set_cli_vars(settings):
for path, args in settings['VariableFiles']:
try:
GLOBAL_VARIABLES.set_from_file(path, args)
except:
msg, details = utils.get_error_details()
LOGGER.error(msg)
LOGGER.info(details)
for varstr in settings['Variables']:
try:
name, value = varstr.split(':', 1)
except ValueError:
name, value = varstr, ''
GLOBAL_VARIABLES['${%s}' % name] = value
def _create_handlers(self, libinst):
success, failure, details = self._get_reporting_methods()
handlers = utils.NormalizedDict(ignore=['_'])
for name in self._get_handler_names(libinst):
err_pre = "Adding keyword '%s' to library '%s' failed: " % (name, self.name)
try:
method = self._get_handler_method(self._libinst, name)
success("Got handler method '%s'" % (name))
except TypeError:
failure(err_pre + 'Not a method or function')
continue
except:
err_msg, err_details = utils.get_error_details()
failure(err_pre + 'Getting handler method failed: ' + err_msg)
details('Details:\n%s' % err_details)
continue
try:
handlers[name] = self._create_handler(name, method)
success("Created keyword '%s'" % handlers[name].name)
except:
err_msg, err_details = utils.get_error_details()
failure(err_pre + 'Creating keyword failed: ' + err_msg)
details('Details:\n%s' % err_details)
return handlers
def _set_cli_variables(self, settings):
for path, args in settings.variable_files:
try:
path = find_file(path, file_type='Variable file')
self.set_from_file(path, args)
except:
msg, details = get_error_details()
LOGGER.error(msg)
LOGGER.info(details)
for varstr in settings.variables:
try:
name, value = varstr.split(':', 1)
except ValueError:
name, value = varstr, ''
self['${%s}' % name] = value
def _set_cli_variables(self, settings):
for name, args in settings.variable_files:
try:
if name.lower().endswith(self._import_by_path_ends):
name = find_file(name, file_type='Variable file')
self.set_from_file(name, args)
except:
msg, details = get_error_details()
LOGGER.error(msg)
LOGGER.info(details)
for varstr in settings.variables:
try:
name, value = varstr.split(':', 1)
except ValueError:
name, value = varstr, ''
self['${%s}' % name] = value
def __call__(self, args):
if self.called:
return
try:
ListenerMethod.called = True
self.method(*args)
except TimeoutError:
# Propagate possible timeouts:
# https://github.com/robotframework/robotframework/issues/2763
raise
except:
message, details = get_error_details()
LOGGER.error("Calling method '%s' of listener '%s' failed: %s"
% (self.method.__name__, self.listener_name, message))
LOGGER.info("Details:\n%s" % details)
finally:
ListenerMethod.called = False
def __call__(self, args):
if self.called:
return
try:
ListenerMethod.called = True
self.method(*args)
except TimeoutError:
# Propagate possible timeouts:
# https://github.com/robotframework/robotframework/issues/2763
raise
except:
message, details = get_error_details()
LOGGER.error("Calling method '%s' of listener '%s' failed: %s" %
(self.method.__name__, self.listener_name, message))
LOGGER.info("Details:\n%s" % details)
finally:
ListenerMethod.called = False
def _create_handlers(self, libcode):
try:
names = self._get_handler_names(libcode)
except:
message, details = get_error_details()
raise DataError("Getting keyword names from library '%s' failed: %s"
% (self.name, message), details)
for name in names:
method = self._try_to_get_handler_method(libcode, name)
if method:
handler, embedded = self._try_to_create_handler(name, method)
if handler:
try:
self.handlers.add(handler, embedded)
except DataError as err:
self._adding_keyword_failed(handler.name, err)
else:
self.logger.debug("Created keyword '%s'" % handler.name)
def process_output(self, path):
set_suite_variable = BuiltIn().set_suite_variable
if not path or path.upper() == 'NONE':
set_suite_variable('$SUITE', None)
logger.info("Not processing output.")
return
path = path.replace('/', os.sep)
try:
logger.info("Processing output '%s'." % path)
result = Result(root_suite=NoSlotsTestSuite())
ExecutionResultBuilder(path).build(result)
except:
set_suite_variable('$SUITE', None)
msg, details = utils.get_error_details()
logger.info(details)
raise RuntimeError('Processing output failed: %s' % msg)
set_suite_variable('$SUITE', process_suite(result.suite))
set_suite_variable('$STATISTICS', result.statistics)
set_suite_variable('$ERRORS', process_errors(result.errors))
def _create_handlers(self, libcode):
try:
names = self._get_handler_names(libcode)
except:
message, details = get_error_details()
raise DataError("Getting keyword names from library '%s' failed: %s"
% (self.name, message), details)
for name in names:
method = self._try_to_get_handler_method(libcode, name)
if method:
handler, embedded = self._try_to_create_handler(name, method)
if handler:
try:
self.handlers.add(handler, embedded)
except DataError as err:
LOGGER.error("Error in test library '%s': "
"Creating keyword '%s' failed: %s"
% (self.name, handler.name, err.message))
else:
LOGGER.debug("Created keyword '%s'" % handler.name)
def process_output(self, path, validate=None):
set_suite_variable = BuiltIn().set_suite_variable
if not path or path.upper() == 'NONE':
set_suite_variable('$SUITE', None)
logger.info("Not processing output.")
return
path = path.replace('/', os.sep)
if validate is None:
validate = os.getenv('ATEST_VALIDATE_OUTPUT', False)
if utils.is_truthy(validate):
self._validate_output(path)
try:
logger.info("Processing output '%s'." % path)
result = Result(root_suite=NoSlotsTestSuite())
ExecutionResultBuilder(path).build(result)
except:
set_suite_variable('$SUITE', None)
msg, details = utils.get_error_details()
logger.info(details)
raise RuntimeError('Processing output failed: %s' % msg)
result.visit(ProcessResults())
set_suite_variable('$SUITE', result.suite)
set_suite_variable('$STATISTICS', result.statistics)
set_suite_variable('$ERRORS', result.errors)
def _report_adding_keyword_failed(self, name):
msg, details = get_error_details()
self._log_failure("Adding keyword '%s' to library '%s' failed: %s" % (name, self.name, msg))
if details:
self._log_failure_details("Details:\n%s" % details)
def _report_adding_keyword_failed(self, name):
msg, details = get_error_details()
self._log_failure("Adding keyword '%s' to library '%s' failed: %s" %
(name, self.name, msg))
if details:
self._log_failure_details('Details:\n%s' % details)
def _execute_impl(code: str,
suite: TestSuite,
defaults: TestDefaults = TestDefaults(),
stdout=None,
stderr=None,
listeners=[],
drivers=[],
outputdir=None,
interactive_keywords=True,
logger=None):
# This will help raise runtime exceptions
traceback = []
LOGGER.register_error_listener(
lambda: traceback.extend(get_error_details()))
# Clear selector completion highlights
for driver in yield_current_connection(
drivers, SeleniumConnectionsListener.NAMES + ["jupyter"]):
try:
clear_selector_highlights(driver)
except BrokenOpenConnection:
close_current_connection(drivers, driver)
if logger is not None:
logger.debug("Compiling code: \n%s", code)
# Copy keywords/variables/libraries in case of failure
imports = get_items_copy(suite.resource.imports)
variables = get_items_copy(suite.resource.variables)
keywords = get_items_copy(suite.resource.keywords)
# Compile AST
model = get_model(
StringIO(code),
data_only=False,
curdir=os.getcwd().replace("\\", "\\\\"),
)
ErrorReporter(code).visit(model)
SettingsBuilder(suite, defaults).visit(model)
SuiteBuilder(suite, defaults).visit(model)
# Strip variables/keyword duplicates
strip_duplicate_items(suite.resource.variables)
strip_duplicate_items(suite.resource.keywords)
for listener in listeners:
# Notify suite variables to the listener
if isinstance(listener, GlobalVarsListener):
listener.suite_vars = [
var.name for var in suite.resource.variables
]
new_imports = [
item for item in get_items_copy(suite.resource.imports)
if item not in imports
]
for new_import in new_imports:
new_import.source = suite.source
new_variables = [
item for item in get_items_copy(suite.resource.variables)
if item not in variables
]
for new_variable in new_variables:
new_variable.source = suite.source
# If there is no test, allow the user to interact with defined keywords by providing widgets
new_keywords = [
item for item in get_items_copy(suite.resource.keywords)
if item not in keywords
]
for new_keyword in new_keywords:
new_keyword.actual_source = suite.source
if not suite.tests and new_keywords and interactive_keywords:
return None, [
get_interactive_keyword(
suite,
keyword,
# stdout=stdout, stderr=stderr,
listeners=[
listener for listener in listeners
if not isinstance(listener, StatusEventListener)
],
drivers=drivers,
logger=logger) for keyword in new_keywords
]
# Set default streams
# By default stdout is no-op
if stdout is None:
stdout = NoOpStream()
if logger is not None:
logger.debug("Executing code")
# Execute suite
result = suite.run(outputdir=outputdir,
stdout=stdout,
stderr=stderr,
listener=listeners)
if len(traceback) != 0:
# Reset keywords/variables/libraries
set_items(suite.resource.imports, imports)
set_items(suite.resource.variables, variables)
set_items(suite.resource.keywords, keywords)
clean_items(suite.tests)
error_msg = '\n'.join(traceback)
if logger is not None:
logger.debug("Execution error: %s", error_msg)
raise TestSuiteError(error_msg)
for listener in listeners:
if isinstance(listener, RobotKeywordsIndexerListener):
listener.import_from_suite_data(suite)
# Detect RPA
suite.rpa = get_rpa_mode(model)
report = None
if suite.tests:
report = generate_report(suite, outputdir)
# Remove tests run so far,
# this is needed so that we don't run them again in the next execution
clean_items(suite.tests)
return result, report
def _create_handlers(self, libinst):
#if self.name == 'RemoteB': pdb.set_trace()
success, failure, details = self._get_reporting_methods()
handlers = utils.NormalizedDict(ignore=['_'])
for name in self._get_handler_names(libinst):
err_pre = "Adding keyword '%s' to library '%s' failed: " % (
name, self.name)
try:
method = self._get_handler_method(libinst, name)
success("Got handler method '%s'" % (name))
except TypeError, err:
failure(err_pre + utils.unic(err))
continue
except:
err_msg, err_details = utils.get_error_details()
failure(err_pre + 'Getting handler method failed: ' + err_msg)
details('Details:\n%s' % err_details)
continue
try:
handlers[name] = self._create_handler(name, method)
success("Created keyword '%s'" % handlers[name].name)
# Create the 'intended failure' handler
FAILURE_PREFIX = 'failed_'
handlers[FAILURE_PREFIX + name] = self._create_handler(
name, _func_inverter(method))
success("Created keyword '%s'" %
handlers[FAILURE_PREFIX + name].name)
except:
err_msg, err_details = utils.get_error_details()
def _instantiate_listener_class(self, listener, args):
try:
return listener(*args)
except:
raise DataError('Creating instance failed: %s\n%s'
% utils.get_error_details())
