def _should_skip_on_failure(self, test, skip_on_failure_tags,
critical_tags):
critical_pattern = TagPatterns(critical_tags)
if critical_pattern and critical_pattern.match(test.tags):
return False
skip_on_fail_pattern = TagPatterns(skip_on_failure_tags)
return skip_on_fail_pattern and skip_on_fail_pattern.match(test.tags)
def _skip_on_failure(self):
critical_pattern = TagPatterns(self._critical_tags)
if critical_pattern and critical_pattern.match(self._test.tags):
return False
skip_on_fail_pattern = TagPatterns(self._skip_on_failure_tags)
return skip_on_fail_pattern and \
skip_on_fail_pattern.match(self._test.tags)
def _skip_on_failure(self):
tags = self._test.tags
critical_pattern = TagPatterns(self._critical_tags)
critical = not critical_pattern or critical_pattern.match(tags)
skip_on_fail_pattern = TagPatterns(self._skip_on_failure_tags)
skip_on_fail = skip_on_fail_pattern and skip_on_fail_pattern.match(
tags)
return not critical or skip_on_fail
def _filter_keywords(keywords: List[KeywordDoc], include: str,
exclude: str) -> List[KeywordDoc]:
"""
Filters out keywords based on their tags.
:param keywords: list of KeywordDoc objects
:param include: include pattern
:param exclude: exclude pattern
:return: list of filtered KeywordDoc objects
"""
included_keywords = ([
kw for kw in keywords if TagPatterns(include).match(kw.tags)
] if include != "" else [kw for kw in keywords])
filtered_keywords = ([
kw for kw in included_keywords
if not TagPatterns(exclude).match(kw.tags)
] if exclude != "" else [kw for kw in included_keywords])
return filtered_keywords
def __init__(self, output, settings):
self.result = None
self._output = output
self._settings = settings
self._variables = VariableScopes(settings)
self._suite = None
self._suite_status = None
self._executed_tests = None
self._skipped_tags = TagPatterns(settings.skipped_tags)
def __init__(self, output, settings):
self.result = None
self._output = output
self._settings = settings
self._variables = VariableScopes(settings)
self._suite = None
self._suite_status = None
self._executed = [NormalizedDict(ignore='_')]
self._skipped_tags = TagPatterns(settings.skip)
def __init__(self, flatten):
if not is_list_like(flatten):
flatten = [flatten]
patterns = [p[4:] for p in flatten if p[:4].lower() == 'tag:']
self._matcher = TagPatterns(patterns)
def _skip_on_failure(self):
tags = list(self._skip_on_failure_tags or []) + ['robot:skip-on-failure']
return TagPatterns(tags).match(self._test.tags)
def visit_test(self, test):
settings = self._settings
if TagPatterns("robot:exclude").match(test.tags):
return
if test.name in self._executed_tests:
self._output.warn(
test_or_task(
f"Multiple {{test}}s with name '{test.name}' executed in "
f"suite '{self._suite.longname}'.", settings.rpa))
self._executed_tests[test.name] = True
result = self._suite.tests.create(self._resolve_setting(test.name),
self._resolve_setting(test.doc),
self._resolve_setting(test.tags),
self._get_timeout(test),
test.lineno,
starttime=get_timestamp())
self._context.start_test(result)
self._output.start_test(ModelCombiner(test, result))
status = TestStatus(self._suite_status, result,
settings.skip_on_failure, settings.rpa)
if status.exit:
self._add_exit_combine()
result.tags.add('robot:exit')
if status.passed:
if not test.name:
status.test_failed(
test_or_task('{Test} name cannot be empty.', settings.rpa))
elif not test.body:
status.test_failed(
test_or_task('{Test} contains no keywords.', settings.rpa))
elif TagPatterns('robot:skip').match(test.tags):
status.test_skipped(
test_or_task("{Test} skipped using 'robot:skip' tag.",
settings.rpa))
elif self._skipped_tags.match(test.tags):
status.test_skipped(
test_or_task(
"{Test} skipped using '--skip' command line option.",
settings.rpa))
self._run_setup(test.setup, status, result)
if status.passed:
try:
BodyRunner(self._context,
templated=bool(test.template)).run(test.body)
except PassExecution as exception:
err = exception.earlier_failures
if err:
status.test_failed(error=err)
else:
result.message = exception.message
except ExecutionStatus as err:
status.test_failed(error=err)
elif status.skipped:
status.test_skipped(status.message)
else:
status.test_failed(status.message)
result.status = status.status
result.message = status.message or result.message
with self._context.test_teardown(result):
self._run_teardown(test.teardown, status, result)
if status.passed and result.timeout and result.timeout.timed_out():
status.test_failed(result.timeout.get_message())
result.message = status.message
if status.skip_on_failure_after_tag_changes:
result.message = status.message or result.message
result.status = status.status
result.endtime = get_timestamp()
failed_before_listeners = result.failed
self._output.end_test(ModelCombiner(test, result))
if result.failed and not failed_before_listeners:
status.failure_occurred()
self._context.end_test(result)
def __init__(self, includes, excludes):
self._tag_pattern_includes = TagPatterns(
includes.split()) if includes.split() else None
self._tag_pattern_excludes = TagPatterns(excludes.split())
def _skip_on_failure(self):
return (self._test.tags.robot('skip-on-failure')
or self._skip_on_failure_tags and TagPatterns(
self._skip_on_failure_tags).match(self._test.tags))
