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