def start_scenario(self, scenario):
self.current_scenario_uuid = uuid4()
self.fixture_context.enter()
self.execution_context.enter()
self.execution_context.append(self.current_scenario_uuid)
test_case = TestResult(uuid=self.current_scenario_uuid, start=now())
test_case.name = scenario_name(scenario)
test_case.historyId = scenario_history_id(scenario)
test_case.description = '\n'.join(scenario.description)
test_case.parameters = scenario_parameters(scenario)
issue_pattern = self.behave_config.userdata.get(
'AllureFormatter.issue_pattern', None)
link_pattern = self.behave_config.userdata.get(
'AllureFormatter.link_pattern', None)
test_case.links.extend(
scenario_links(scenario,
issue_pattern=issue_pattern,
link_pattern=link_pattern))
test_case.labels.extend(scenario_labels(scenario))
test_case.labels.append(
Label(name=LabelType.FEATURE, value=scenario.feature.name))
test_case.labels.append(Label(name=LabelType.FRAMEWORK,
value='behave'))
test_case.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
self.logger.schedule_test(self.current_scenario_uuid, test_case)
def stop_current_test(self, name, attributes):
uuid = self.stack.pop()
test = self.reporter.get_test(uuid)
test.status = utils.get_allure_status(attributes.get('status'))
test.labels.extend(utils.get_allure_suites(attributes.get('longname')))
test.labels.extend(allure_tags(attributes))
for label_type in (LabelType.EPIC, LabelType.FEATURE, LabelType.STORY):
test.labels.extend(allure_labels(attributes, label_type))
for link_type in (LinkType.ISSUE, LinkType.TEST_CASE, LinkType.LINK):
test.links.extend(allure_links(attributes, link_type))
test.labels.append(Label(name=LabelType.THREAD, value=self.pool_id))
test.labels.append(Label(name=LabelType.HOST, value=host_tag()))
test.labels.append(
Label(name=LabelType.FRAMEWORK, value='robotframework'))
test.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
test.statusDetails = StatusDetails(message=attributes.get('message'),
trace=self.get_traceback_message())
test.description = attributes.get('doc')
last_link = list(self.links.values())[-1] if self.links else None
if attributes.get(Severity.CRITICAL, 'no') == 'yes':
test.labels.append(
Label(name=LabelType.SEVERITY, value=Severity.CRITICAL))
if last_link:
test.links.append(Link(LinkType.LINK, last_link, 'Link'))
test.stop = now()
self.reporter.close_test(uuid)
def start_scenario(self, scenario):
self.current_scenario_uuid = uuid4()
test_case = TestResult(uuid=self.current_scenario_uuid, start=now())
test_case.name = scenario_name(scenario)
test_case.historyId = scenario_history_id(scenario)
test_case.description = '\n'.join(scenario.description)
labels = []
feature_label = Label(name=LabelType.FEATURE.value,
value=scenario.feature.name)
severity = (Label(name=LabelType.SEVERITY.value,
value=scenario_severity(scenario).value))
labels.append(feature_label)
labels.append(severity)
labels += [
Label(name=LabelType.TAG.value, value=tag)
for tag in scenario_tags(scenario)
]
test_case.parameters = scenario_parameters(scenario)
test_case.labels = labels
self.logger.schedule_test(self.current_scenario_uuid, test_case)
self.update_group()
def start_test(self, name, uuid, context):
"""start test"""
test_result = TestResult(name=name, uuid=uuid, start=now(), stop=now())
test_result.status = context.status
if self.default_test_suite_name:
test_result.labels.append(Label(name=LabelType.SUITE, value=self.default_test_suite_name))
if self.default_parent_test_suite_name:
test_result.labels.append(Label(name=LabelType.PARENT_SUITE, value=self.default_parent_test_suite_name))
if self.default_sub_suite_name:
test_result.labels.append(Label(name=LabelType.SUB_SUITE, value=self.default_sub_suite_name))
test_result.labels.append(Label(name=LabelType.FRAMEWORK, value="ArangoDB Release Test Automation"))
self.allure_logger.schedule_test(uuid, test_result)
self._cache.push(test_result, uuid)
for label in context.labels:
test_result.labels.append(label)
self.allure_logger.update_group(self.container_uuid, children=uuid)
parent = self.parent_test_listener
while parent:
parent.allure_logger.update_group(parent.container_uuid, children=uuid)
parent = parent.parent_test_listener
self.current_testcase_container_uuid = str(uuid4())
container = TestResultContainer(uuid=self.current_testcase_container_uuid, name=name)
self._cache.push(container, self.current_testcase_container_uuid)
self.allure_logger.start_group(self.current_testcase_container_uuid, container)
self.allure_logger.update_group(self.current_testcase_container_uuid, start=now())
self.allure_logger.update_group(self.current_testcase_container_uuid, children=uuid)
def start_test(self, parent_uuid, uuid, name, parameters, context):
scenario = context['scenario']
self.fixture_context.enter()
self.execution_context.enter()
self.execution_context.append(uuid)
test_case = TestResult(uuid=uuid, start=now())
test_case.name = scenario_name(scenario)
test_case.historyId = scenario_history_id(scenario)
test_case.description = '\n'.join(scenario.description)
test_case.parameters = scenario_parameters(scenario)
test_case.labels.extend([
Label(name=LabelType.TAG, value=tag)
for tag in scenario_tags(scenario)
])
test_case.labels.append(
Label(name=LabelType.SEVERITY,
value=scenario_severity(scenario).value))
test_case.labels.append(
Label(name=LabelType.FEATURE, value=scenario.feature.name))
test_case.labels.append(Label(name=LabelType.FRAMEWORK,
value='behave'))
test_case.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
self.logger.schedule_test(uuid, test_case)
def done(self, status: Status, job_log=None):
if self.reporter is None:
return
self.test_case.status = status
self.test_case.labels.append(
Label(name=LabelType.FRAMEWORK, value=self.job.tool))
self.test_case.labels.append(
Label(name=LabelType.HOST, value=socket.gethostname()))
self.test_case.parameters.append(
Parameter(name="TOOL", value=self.job.tool))
for l in self.job.labels:
self.test_case.labels.append(Label(name=l[0], value=l[1]))
for p in self.job.parameters:
self.test_case.parameters.append(Parameter(name=p[0], value=p[1]))
# Record the run variables as test parameters
for k, v in self.job.runvars.items():
self.test_case.parameters.append(Parameter(name=k, value=v))
# Record the seed as a test parameter
self.test_case.parameters.append(
Parameter(name="SEED", value=str(self.job.seed)))
if job_log is not None:
self.reporter.attach_file(uuid4(), job_log, "job.log")
for a in self.job.attachments:
pass
self.test_case.stop = now()
self.reporter.close_test(self.test_uuid)
pass
def pytest_runtest_protocol(self, item, nextitem):
uuid = self._cache.set(item.nodeid)
for fixturedef in _test_fixtures(item):
group_uuid = self._cache.get(fixturedef)
if not group_uuid:
group_uuid = self._cache.set(fixturedef)
group = TestResultContainer(uuid=group_uuid)
self.allure_logger.start_group(group_uuid, group)
self.allure_logger.update_group(group_uuid, children=uuid)
test_case = TestResult(name=item.name, uuid=uuid)
self.allure_logger.schedule_test(uuid, test_case)
yield
test_case.labels += [
Label(name, value) for name, value in allure_labels(item)
]
test_case.links += [
Link(link_type, url, name)
for link_type, url, name in allure_links(item)
]
test_case.labels += [
Label(LabelType.TAG, value) for value in pytest_markers(item)
]
test_case.fullName = allure_full_name(item.nodeid)
test_case.historyId = md5(test_case.fullName)
test_case.labels.append(Label('package', allure_package(item.nodeid)))
uuid = self._cache.pop(item.nodeid)
self.allure_logger.close_test(uuid)
def pytest_runtest_teardown(self, item):
yield
uuid = self._cache.get(item.nodeid)
test_result = self.allure_logger.get_test(uuid)
test_result.labels.extend([
Label(name=name, value=value)
for name, value in allure_labels(item)
])
test_result.labels.extend([
Label(name=LabelType.TAG, value=value)
for value in pytest_markers(item)
])
test_result.labels.extend([
Label(name=LabelType.TAG, value=value)
for value in pytest_markers(item)
])
test_result.labels.extend([
Label(name=name, value=value)
for name, value in allure_suite_labels(item)
])
test_result.labels.append(Label(name=LabelType.HOST, value=self._host))
test_result.labels.append(
Label(name=LabelType.THREAD, value=self._thread))
test_result.labels.append(
Label(name=LabelType.FRAMEWORK, value='pytest'))
test_result.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
test_result.labels.append(
Label(name='package', value=allure_package(item)))
test_result.links.extend([
Link(link_type, url, name)
for link_type, url, name in allure_links(item)
])
def parse_tag(tag, issue_pattern=None, link_pattern=None):
"""
>>> parse_tag("blocker")
Label(name='severity', value='blocker')
>>> parse_tag("allure.issue:http://example.com/BUG-42")
Link(type='issue', url='http://example.com/BUG-42', name='http://example.com/BUG-42')
>>> parse_tag("allure.link.home:http://qameta.io")
Link(type='link', url='http://qameta.io', name='home')
>>> parse_tag("allure.suite:mapping")
Label(name='suite', value='mapping')
>>> parse_tag("allure.suite:mapping")
Label(name='suite', value='mapping')
>>> parse_tag("allure.label.owner:me")
Label(name='owner', value='me')
>>> parse_tag("foo.label:1")
Label(name='tag', value='foo.label:1')
>>> parse_tag("allure.foo:1")
Label(name='tag', value='allure.foo:1')
"""
sep = allure_tag_sep(tag)
schema, value = islice(chain(tag.split(sep, 1), [None]), 2)
prefix, kind, name = islice(chain(schema.split('.'), [None], [None]), 3)
if tag in [severity for severity in Severity]:
return Label(name=LabelType.SEVERITY, value=tag)
if prefix == TAG_PREFIX and value is not None:
if __is(kind, LinkType):
if issue_pattern and kind == "issue" and not value.startswith(
"http"):
value = issue_pattern.format(value)
if link_pattern and kind == "link" and not value.startswith(
"http"):
value = link_pattern.format(value)
return Link(type=kind, name=name or value, url=value)
if __is(kind, LabelType):
return Label(name=kind, value=value)
if kind == "id":
return Label(name=LabelType.ID, value=value)
if kind == "label" and name is not None:
return Label(name=name, value=value)
return Label(name=LabelType.TAG, value=tag)
def _build_testcase_name(self):
elems = self.job.fullname.split('.')
if len(elems) > 4:
# When we more elements in the qualified name than
# will fit in the PARENT::SUITE::SUBSUITE scheme.
#
# We do a bit of middle compression to maximize
# readability.
collapse_root = True
if collapse_root:
# Collapse leaf elements
root = ""
for i, e in enumerate(elems[:-4]):
if i > 0:
root += "."
root += e
# print("root=%s suite=%s sub_suite=%s" % (root, elems[-3], elems[-2]))
self.test_case.labels.append(
Label(name=LabelType.PARENT_SUITE, value=root))
self.test_case.labels.append(
Label(name=LabelType.SUITE, value=elems[-3]))
self.test_case.labels.append(
Label(name=LabelType.SUB_SUITE, value=elems[-2]))
self.test_case.name = elems[-1]
else:
# Collapse leaf elements
self.test_case.labels.append(
Label(name=LabelType.PARENT_SUITE, value=elems[0]))
self.test_case.labels.append(
Label(name=LabelType.SUITE, value=elems[1]))
self.test_case.labels.append(
Label(name=LabelType.SUB_SUITE, value=elems[2]))
subsuite = ""
for i, e in enumerate(elems[3:]):
if i > 0:
subsuite += "."
subsuite += e
self.test_case.name = subsuite
else:
self.test_case.labels.append(
Label(name=LabelType.PARENT_SUITE, value=elems[0]))
if len(elems) > 1:
self.test_case.labels.append(
Label(name=LabelType.SUITE, value=elems[1]))
if len(elems) > 2:
self.test_case.labels.append(
Label(name=LabelType.SUB_SUITE, value=elems[2]))
self.test_case.name = self.job.name
def pytest_bdd_before_scenario(self, request, feature, scenario):
uuid = get_uuid(request.node.nodeid)
full_name = get_full_name(feature, scenario)
name = get_name(request.node, scenario)
with self.lifecycle.schedule_test_case(uuid=uuid) as test_result:
test_result.fullName = full_name
test_result.name = name
test_result.start = now()
test_result.labels.append(Label(name=LabelType.HOST, value=self.host))
test_result.labels.append(Label(name=LabelType.THREAD, value=self.thread))
test_result.labels.append(Label(name=LabelType.FRAMEWORK, value="pytest-bdd"))
test_result.labels.append(Label(name=LabelType.LANGUAGE, value=platform_label()))
test_result.labels.append(Label(name=LabelType.FEATURE, value=feature.name))
test_result.parameters = get_params(request.node)
finalizer = partial(self._scenario_finalizer, scenario)
request.node.addfinalizer(finalizer)
def _record_suite_labels(self, test_result, test_index, test_data, job):
tool_id = None
index_match = WORKFLOW_INDEX_MATCH.match(test_index)
if "tool_id" in test_data:
tool_id = test_data["tool_id"]
test_result.labels.append(
Label(name=LabelType.PARENT_SUITE, value=tool_id))
elif "tool_id" in job:
tool_id = job["tool_id"]
test_result.labels.append(
Label(name=LabelType.PARENT_SUITE, value=tool_id))
elif index_match:
test_result.labels.append(
Label(name=LabelType.PARENT_SUITE, value=index_match.group(1)))
if "tool_version" in test_data:
test_result.labels.append(
Label(name=LabelType.SUITE, value=test_data["tool_version"]))
elif "tool_version" in job:
test_result.labels.append(
Label(name=LabelType.SUITE, value=job["tool_version"]))
if "test_index" in test_data:
test_result.labels.append(
Label(name=LabelType.SUB_SUITE,
value=str(test_data["test_index"])))
elif index_match:
test_result.labels.append(
Label(name=LabelType.SUB_SUITE, value=index_match.group(2)))
return tool_id
def startTest(self, event):
if self.is_registered():
with self.lifecycle.schedule_test_case() as test_result:
test_result.name = name(event)
test_result.start = timestamp_millis(event.startTime)
test_result.fullName = fullname(event)
test_result.testCaseId = md5(test_result.fullName)
test_result.historyId = md5(event.test.id())
test_result.labels.extend(labels(event.test))
test_result.labels.append(
Label(name=LabelType.HOST, value=self._host))
test_result.labels.append(
Label(name=LabelType.THREAD, value=self._thread))
test_result.labels.append(
Label(name=LabelType.FRAMEWORK, value='nose2'))
test_result.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
test_result.parameters = params(event)
def get_allure_suites(longname):
"""
>>> get_allure_suites('Suite1.Test')
[Label(name='suite', value='Suite1')]
>>> get_allure_suites('Suite1.Suite2.Test') # doctest: +NORMALIZE_WHITESPACE
[Label(name='suite', value='Suite1'), Label(name='subSuite', value='Suite2')]
>>> get_allure_suites('Suite1.Suite2.Suite3.Test') # doctest: +NORMALIZE_WHITESPACE
[Label(name='parentSuite', value='Suite1'),
Label(name='suite', value='Suite2'),
Label(name='subSuite', value='Suite3')]
"""
labels = []
suites = longname.split('.')
if len(suites) > 3:
labels.append(Label(LabelType.PARENT_SUITE, suites.pop(0)))
labels.append(Label(LabelType.SUITE, suites.pop(0)))
if len(suites) > 1:
labels.append(Label(LabelType.SUB_SUITE, '.'.join(suites[:-1])))
return labels
def allure_labels(attributes, prefix):
tags = attributes.get('tags', ())
def is_label(label):
return label.startswith("{label}:".format(label=prefix))
def label_value(label):
return label.split(':')[1] or 'unknown'
return [Label(name=prefix, value=label_value(tag)) for tag in tags if is_label(tag)]
def stop_current_test(self, name, attributes):
uuid = self.stack.pop()
test = self.reporter.get_test(uuid)
test.status = utils.get_allure_status(attributes.get('status'))
test.labels.extend(utils.get_allure_suites(attributes.get('longname')))
test.labels.extend(utils.get_allure_tags(attributes.get('tags')))
test.labels.append(utils.get_allure_thread(self.pool_id))
test.labels.append(Label(LabelType.HOST, value=host_tag()))
test.labels.append(
Label(name=LabelType.FRAMEWORK, value='robotframework'))
test.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
test.statusDetails = StatusDetails(message=attributes.get('message'))
test.description = attributes.get('doc')
last_link = list(self.links.values())[-1] if self.links else None
if last_link:
test.links.append(Link(LinkType.LINK, last_link, 'Link'))
test.stop = now()
self.reporter.close_test(uuid)
def pytest_runtest_protocol(self, item, nextitem):
uuid = self._cache.set(item.nodeid)
for fixturedef in _test_fixtures(item):
group_uuid = self._cache.get(fixturedef)
if not group_uuid:
group_uuid = self._cache.set(fixturedef)
group = TestResultContainer(uuid=group_uuid)
self.allure_logger.start_group(group_uuid, group)
self.allure_logger.update_group(group_uuid, children=uuid)
test_case = TestResult(name=item.name, uuid=uuid)
self.allure_logger.schedule_test(uuid, test_case)
if hasattr(item, 'function'):
test_case.description = item.function.__doc__
yield
test_case.labels.extend([
Label(name=name, value=value)
for name, value in allure_labels(item)
])
test_case.labels.extend([
Label(name=LabelType.TAG, value=value)
for value in pytest_markers(item)
])
test_case.labels.append(Label(name=LabelType.FRAMEWORK,
value='pytest'))
test_case.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
test_case.links += [
Link(link_type, url, name)
for link_type, url, name in allure_links(item)
]
test_case.fullName = allure_full_name(item.nodeid)
test_case.historyId = md5(test_case.fullName)
test_case.labels.append(Label('package', allure_package(item.nodeid)))
uuid = self._cache.pop(item.nodeid)
self.allure_logger.close_test(uuid)
def stop_test(self, _, attributes, messages):
self._report_messages(messages)
if 'skipped' in [tag.lower() for tag in attributes['tags']]:
attributes['status'] = RobotStatus.SKIPPED
with self.lifecycle.update_test_case() as test_result:
test_result.stop = now()
test_result.description = attributes.get('doc')
test_result.status = get_allure_status(attributes.get('status'))
test_result.labels.extend(
get_allure_suites(attributes.get('longname')))
test_result.labels.append(
Label(name=LabelType.FRAMEWORK, value='robotframework'))
test_result.labels.append(
Label(name=LabelType.LANGUAGE, value=self._platform))
test_result.labels.append(
Label(name=LabelType.HOST, value=self._host))
test_result.labels.append(
Label(name=LabelType.THREAD, value=pool_id()))
test_result.labels.extend(allure_tags(attributes))
test_result.statusDetails = StatusDetails(
message=self._current_msg or attributes.get('message'),
trace=self._current_tb)
if attributes.get('critical') == 'yes':
test_result.labels.append(
Label(name=LabelType.SEVERITY, value=Severity.CRITICAL))
for label_type in (LabelType.EPIC, LabelType.FEATURE,
LabelType.STORY):
test_result.labels.extend(allure_labels(
attributes, label_type))
for link_type in (LinkType.ISSUE, LinkType.TEST_CASE,
LinkType.LINK):
test_result.links.extend(allure_links(attributes, link_type))
self._current_tb, self._current_msg = None, None
def _record_suite_labels(self, test_result, test_data, job):
tool_id = None
if "tool_id" in test_data:
tool_id = test_data["tool_id"]
test_result.labels.append(
Label(name=LabelType.PARENT_SUITE, value=tool_id))
elif "tool_id" in job:
tool_id = job["tool_id"]
test_result.labels.append(
Label(name=LabelType.PARENT_SUITE, value=tool_id))
if "tool_version" in test_data:
test_result.labels.append(
Label(name=LabelType.SUITE, value=test_data["tool_version"]))
elif "tool_version" in job:
test_result.labels.append(
Label(name=LabelType.SUITE, value=job["tool_version"]))
if "test_index" in test_data:
test_result.labels.append(
Label(name=LabelType.SUB_SUITE,
value=str(test_data["test_index"])))
return tool_id
def start_test(self, parent_uuid, uuid, name, parameters, context):
scenario = context['scenario']
self.fixture_context.enter()
self.execution_context.enter()
self.execution_context.append(uuid)
test_case = TestResult(uuid=uuid, start=now())
test_case.name = scenario_name(scenario)
test_case.historyId = scenario_history_id(scenario)
test_case.description = '\n'.join(scenario.description)
labels = []
feature_label = Label(name=LabelType.FEATURE.value, value=scenario.feature.name)
severity = (Label(name=LabelType.SEVERITY.value, value=scenario_severity(scenario).value))
labels.append(feature_label)
labels.append(severity)
labels += [Label(name=LabelType.TAG.value, value=tag) for tag in scenario_tags(scenario)]
test_case.parameters = scenario_parameters(scenario)
test_case.labels = labels
self.logger.schedule_test(uuid, test_case)
def start_scenario(self, scenario):
self.current_scenario_uuid = uuid4()
self.group_context.enter()
test_case = TestResult(uuid=self.current_scenario_uuid, start=now())
test_case.name = scenario_name(scenario)
test_case.fullName = get_fullname(scenario)
test_case.historyId = scenario_history_id(scenario)
test_case.description = '\n'.join(scenario.description)
test_case.parameters = scenario_parameters(scenario)
test_case.links.extend(
scenario_links(scenario,
issue_pattern=self.issue_pattern,
link_pattern=self.link_pattern))
test_case.labels.extend(scenario_labels(scenario))
test_case.labels.append(
Label(name=LabelType.FEATURE, value=scenario.feature.name))
test_case.labels.append(Label(name=LabelType.FRAMEWORK,
value='behave'))
test_case.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
self.logger.schedule_test(self.current_scenario_uuid, test_case)
def pytest_runtest_protocol(self, item, nextitem):
uuid = self._cache.set(item.nodeid)
for fixturedef in _test_fixtures(item):
group_uuid = self._cache.get(fixturedef)
if not group_uuid:
group_uuid = self._cache.set(fixturedef)
group = TestResultContainer(uuid=group_uuid)
self.allure_logger.start_group(group_uuid, group)
self.allure_logger.update_group(group_uuid, children=uuid)
params = item.callspec.params if hasattr(item, 'callspec') else {}
test_result = TestResult(name=allure_name(item, params), uuid=uuid)
test_result.description = allure_description(item)
test_result.descriptionHtml = allure_description_html(item)
test_result.fullName = allure_full_name(item)
test_result.historyId = md5(test_result.fullName)
test_result.parameters.extend([
Parameter(name=name, value=represent(value))
for name, value in params.items()
])
self.allure_logger.schedule_test(uuid, test_result)
yield
test_result.labels.extend([
Label(name=name, value=value)
for name, value in allure_labels(item)
])
test_result.labels.extend([
Label(name=LabelType.TAG, value=value)
for value in pytest_markers(item)
])
test_result.labels.append(Label(name=LabelType.HOST, value=self._host))
test_result.labels.append(
Label(name=LabelType.THREAD, value=self._thread))
test_result.labels.append(
Label(name=LabelType.FRAMEWORK, value='pytest'))
test_result.labels.append(
Label(name=LabelType.LANGUAGE, value=platform_label()))
test_result.labels.append(
Label(name='package', value=allure_package(item)))
test_result.links.extend([
Link(link_type, url, name)
for link_type, url, name in allure_links(item)
])
uuid = self._cache.pop(item.nodeid)
self.allure_logger.close_test(uuid)
def labels(test):
def _get_attrs(obj, keys):
pairs = set()
for key in keys:
values = getattr(obj, key, ())
for value in (values, ) if type(values) == str else values:
pairs.add((key, value))
return pairs
keys = ALLURE_LABELS
pairs = _get_attrs(test, keys)
if hasattr(test, "_testFunc"):
pairs.update(_get_attrs(test._testFunc, keys))
elif hasattr(test, "_testMethodName"):
test_method = getattr(test, test._testMethodName)
pairs.update(_get_attrs(test_method, keys))
return [Label(name=name, value=value) for name, value in pairs]
def add_label(self, label_type, labels):
test_result = self.allure_logger.get_test(None)
for label in labels if test_result else ():
test_result.labels.append(Label(label_type, label))
def scenario_labels(scenario):
tags = scenario.feature.tags + scenario.tags
default_labels = [Label(name=LabelType.SEVERITY, value=Severity.NORMAL)]
parsed = [parse_tag(item) for item in tags]
return labels_set(
list(filter(lambda x: isinstance(x, Label), default_labels + parsed)))
def get_allure_thread(pool_id):
return Label(LabelType.THREAD, 'Thread #{number}'.format(number=pool_id))
def get_allure_tags(tags):
return [Label(LabelType.TAG, tag) for tag in tags]
def add_label(self, label_type, labels):
for label in labels:
self.allure_logger.update_test(None,
labels=Label(label_type, label))
def allure_tags(attributes):
return [
Label(LabelType.TAG, tag) for tag in attributes.get('tags', ())
if not allure_tag_sep(tag)
]
def add_label(self, label_type, labels):
with self.lifecycle.update_test_case() as case:
for label in labels if case else ():
case.labels.append(Label(label_type, label))
