def pytest_runtest_setup(self, item):
if not self._cache.get(item.nodeid):
uuid = self._cache.push(item.nodeid)
test_result = TestResult(name=item.name, uuid=uuid, start=now(), stop=now())
self.allure_logger.schedule_test(uuid, test_result)
yield
uuid = self._cache.get(item.nodeid)
test_result = self.allure_logger.get_test(uuid)
for fixturedef in _test_fixtures(item):
group_uuid = self._cache.get(fixturedef)
if not group_uuid:
group_uuid = self._cache.push(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.name = allure_name(item, params)
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()])
def pytest_fixture_setup(self, fixturedef, request):
fixture_name = fixturedef.argname
container_uuid = self._cache.get(fixturedef)
if not container_uuid:
container_uuid = self._cache.push(fixturedef)
container = TestResultContainer(uuid=container_uuid)
self.allure_logger.start_group(container_uuid, container)
self.allure_logger.update_group(container_uuid, start=now())
before_fixture_uuid = uuid4()
before_fixture = TestBeforeResult(name=fixture_name, start=now())
self.allure_logger.start_before_fixture(container_uuid, before_fixture_uuid, before_fixture)
outcome = yield
self.allure_logger.stop_before_fixture(before_fixture_uuid,
stop=now(),
status=get_outcome_status(outcome),
statusDetails=get_outcome_status_details(outcome))
finalizers = getattr(fixturedef, '_finalizers', [])
for index, finalizer in enumerate(finalizers):
name = '{fixture}::{finalizer}'.format(fixture=fixturedef.argname,
finalizer=getattr(finalizer, "__name__", index))
finalizers[index] = allure_commons.fixture(finalizer, parent_uuid=container_uuid, name=name)
def pytest_runtest_call(self, item):
uuid = self._cache.get(item.nodeid)
test_result = self.allure_logger.get_test(uuid)
if test_result:
test_result.start = now()
yield
if test_result:
test_result.stop = now()
def stop_fixture(self, parent_uuid, uuid, name, exc_type, exc_val, exc_tb):
if name in FIXTURES:
self.logger.stop_before_fixture(uuid=uuid,
stop=now(),
status=get_status(exc_val),
statusDetails=get_status_details(
exc_type, exc_val, exc_tb))
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 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 start_new_keyword(self, name, attributes):
uuid = uuid4()
parent_uuid = self.stack[-1]
step_name = '{} = {}'.format(attributes.get('assign')[0], name) if attributes.get('assign') else name
args = {
'name': step_name,
'description': attributes.get('doc'),
'parameters': utils.get_allure_parameters(attributes.get('args')),
'start': now()
}
keyword_type = attributes.get('type')
last_item = self.reporter.get_last_item()
if keyword_type in RobotKeywordType.FIXTURES and not isinstance(last_item, TestStepResult):
if isinstance(last_item, TestResult):
parent_uuid = self.stack[-2]
if keyword_type == RobotKeywordType.SETUP:
self.reporter.start_before_fixture(parent_uuid, uuid, TestBeforeResult(**args))
elif keyword_type == RobotKeywordType.TEARDOWN:
self.reporter.start_after_fixture(parent_uuid, uuid, TestAfterResult(**args))
self.stack.append(uuid)
return
self.stack.append(uuid)
self.reporter.start_step(parent_uuid=parent_uuid,
uuid=uuid,
step=TestStepResult(**args))
def end_current_keyword(self, name, attributes):
uuid = self.stack.pop()
if uuid in self.items_log:
keyword_logs = self.items_log.pop(uuid)
if len(keyword_logs) < self.MAX_STEP_MESSAGE_COUNT:
self.create_message_steps(uuid, *keyword_logs)
else:
self.reporter.attach_data(
uuid=uuid4(),
body=self.format_keyword_logs_to_attachment(*keyword_logs),
name='Keyword Log',
attachment_type=AttachmentType.HTML)
args = {
'uuid': uuid,
'status': utils.get_allure_status(attributes.get('status')),
'stop': now()
}
keyword_type = attributes.get('type')
parent_item = self.reporter.get_last_item()
if keyword_type in RobotKeywordType.FIXTURES and not isinstance(
parent_item, TestStepResult):
if keyword_type == RobotKeywordType.SETUP:
self.reporter.stop_before_fixture(**args)
return
elif keyword_type == RobotKeywordType.TEARDOWN:
self.reporter.stop_after_fixture(**args)
return
self.reporter.stop_step(**args)
def start_step(self, uuid, title, params):
parameters = [
Parameter(name=name, value=value)
for name, value in params.items()
]
step = TestStepResult(name=title, start=now(), parameters=parameters)
self.allure_logger.start_step(None, uuid, step)
def stop_behave_step(self, result):
status = step_status(result)
status_details = step_status_details(result)
self.logger.stop_step(self.current_step_uuid,
stop=now(),
status=status,
statusDetails=status_details)
def stop_scenario(self, scenario):
should_run = (scenario.should_run_with_tags(self.behave_config.tags)
and scenario.should_run_with_name_select(
self.behave_config))
should_drop_skipped_by_option = scenario.status == 'skipped' and not self.behave_config.show_skipped
should_drop_excluded = self.hide_excluded and (
scenario.skip_reason == TEST_PLAN_SKIP_REASON or not should_run)
if should_drop_skipped_by_option or should_drop_excluded:
self.logger.drop_test(self.current_scenario_uuid)
else:
status = scenario_status(scenario)
status_details = scenario_status_details(scenario)
self.flush_steps()
test_result = self.logger.get_test(self.current_scenario_uuid)
test_result.stop = now()
test_result.status = status
test_result.statusDetails = status_details
self.logger.close_test(self.current_scenario_uuid)
self.current_step_uuid = None
self.group_context.append_test(self.current_scenario_uuid)
self.group_context.exit()
self.current_scenario_uuid = None
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 start_new_keyword(self, name, attributes):
uuid = uuid4()
parent_uuid = self.stack[-1]
step_name = '{} = {}'.format(
attributes.get('assign')[0],
name) if attributes.get('assign') else name
args = {
'name': step_name,
'description': attributes.get('doc'),
'parameters': utils.get_allure_parameters(attributes.get('args')),
'start': now()
}
keyword_type = attributes.get('type')
last_item = self.reporter.get_last_item()
if keyword_type in RobotKeywordType.FIXTURES and not isinstance(
last_item, TestStepResult):
if isinstance(last_item, TestResult):
parent_uuid = self.stack[-2]
if keyword_type == RobotKeywordType.SETUP:
self.reporter.start_before_fixture(parent_uuid, uuid,
TestBeforeResult(**args))
elif keyword_type == RobotKeywordType.TEARDOWN:
self.reporter.start_after_fixture(parent_uuid, uuid,
TestAfterResult(**args))
self.stack.append(uuid)
return
self.stack.append(uuid)
self.reporter.start_step(parent_uuid=parent_uuid,
uuid=uuid,
step=TestStepResult(**args))
def start_step(self, parent_uuid=None, uuid=None):
parent = self._get_item(uuid=parent_uuid, item_type=ExecutableItem)
step = TestStepResult()
step.start = now()
parent.steps.append(step)
self._items[uuid or uuid4()] = step
yield step
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.fullName = get_fullname(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 start_step(self, uuid, title, params):
"""start step"""
step_data = StepData()
self._cache.push(step_data, uuid)
parameters = [Parameter(name=name, value=value) for name, value in params.items()]
step = TestStepResult(name=title, start=now(), parameters=parameters)
self.allure_logger.start_step(None, uuid, step)
def before_scenario(self, _, scenario):
uuid = scenario_history_id(scenario)
test_case = TestResult(uuid=uuid, start=now())
test_case.name = scenario_name(scenario)
test_case.historyId = scenario_history_id(scenario)
self.allure_lifecycle.schedule_test(uuid, test_case)
def start_step(self, uuid, title, params):
with self.lifecycle.start_step() as step:
step.name = title
step.start = now()
step.parameters = [
Parameter(name=name, value=value)
for name, value in params.items()
]
def start_fixture(self, parent_uuid, uuid, name, parameters):
parameters = [Parameter(name=param_name, value=param_value) for param_name, param_value in parameters.items()]
if name in FIXTURES and not self.fixture_context:
group = TestResultContainer(uuid=uuid4())
self.logger.start_group(group.uuid, group)
self.fixture_context.append(group)
if name in BEFORE_FIXTURES:
fixture = TestBeforeResult(name=name, start=now(), parameters=parameters)
for group in self.fixture_context:
self.logger.start_before_fixture(group.uuid, uuid, fixture)
elif name in AFTER_FIXTURES:
fixture = TestAfterResult(name=name, start=now(), parameters=parameters)
for group in self.fixture_context:
self.logger.start_after_fixture(group.uuid, uuid, fixture)
def stop_step(self, uuid, exc_type, exc_val, exc_tb):
status = Status.PASSED
if exc_type is not None:
if exc_type == pytest.skip.Exception:
status = Status.SKIPPED
else:
status = Status.FAILED
self.allure_logger.stop_step(uuid, stop=now(), status=status)
def start_step(self, uuid, title, params):
def truncate(x):
if len(x) > 200:
return x[:180] + " ... " + x[-15:]
return x
parameters = [Parameter(name=name, value=truncate(value)) for name, value in params.items()]
step = TestStepResult(name=title, start=now(), parameters=parameters)
self.allure_logger.start_step(None, uuid, step)
def start_new_test(self, name, attributes):
uuid = uuid4()
self.reporter.get_last_item(TestResultContainer).children.append(uuid)
self.stack.append(uuid)
test_case = TestResult(uuid=uuid,
historyId=md5(attributes.get('longname')),
name=name,
fullName=attributes.get('longname'),
start=now())
self.reporter.schedule_test(uuid, test_case)
def stop_scenario(self, scenario):
status = scenario_status(scenario)
status_details = scenario_status_details(scenario)
self.logger.update_test(self.current_scenario_uuid,
stop=now(),
status=status,
statusDetails=status_details)
self.logger.close_test(self.current_scenario_uuid)
self.current_scenario_uuid = None
self.current_step_uuid = None
def start_new_test(self, name, attributes):
uuid = uuid4()
self.reporter.get_last_item(TestResultContainer).children.append(uuid)
self.stack.append(uuid)
test_case = TestResult(uuid=uuid,
historyId=md5(attributes.get('longname')),
name=name,
fullName=attributes.get('longname'),
start=now())
self.reporter.schedule_test(uuid, test_case)
def start_test(self, name, attributes):
uuid = uuid4()
with self.lifecycle.schedule_test_case(uuid=uuid) as test_result:
long_name = attributes.get('longname')
test_result.name = name
test_result.fullName = long_name
test_result.historyId = md5(long_name)
test_result.start = now()
for container in self.lifecycle.containers():
container.children.append(uuid)
def start_new_group(self, name, attributes):
uuid = uuid4()
self.set_suite_link(attributes.get('metadata'), uuid)
if self.stack:
parent_suite = self.reporter.get_last_item(TestResultContainer)
parent_suite.children.append(uuid)
self.stack.append(uuid)
suite = TestResultContainer(uuid=uuid,
name=name,
description=attributes.get('doc'),
start=now())
self.reporter.start_group(uuid, suite)
def start_new_group(self, name, attributes):
uuid = uuid4()
self.set_suite_link(attributes.get('metadata'), uuid)
if self.stack:
parent_suite = self.reporter.get_last_item(TestResultContainer)
parent_suite.children.append(uuid)
self.stack.append(uuid)
suite = TestResultContainer(uuid=uuid,
name=name,
description=attributes.get('doc'),
start=now())
self.reporter.start_group(uuid, suite)
def start_behave_step(self, step):
self.current_step_uuid = uuid4()
name = u'{keyword} {title}'.format(keyword=step.keyword, title=step.name)
allure_step = TestStepResult(name=name, start=now())
self.logger.start_step(None, self.current_step_uuid, allure_step)
if step.text:
self.logger.attach_data(uuid4(), step.text, name='.text', attachment_type=AttachmentType.TEXT)
if step.table:
self.logger.attach_data(uuid4(), step_table(step), name='.table', attachment_type=AttachmentType.CSV)
def pytest_fixture_setup(self, fixturedef, request):
fixture_name = fixturedef.argname
container_uuid = self._cache.get(fixturedef)
if not container_uuid:
container_uuid = self._cache.set(fixturedef)
container = TestResultContainer(uuid=container_uuid)
self.allure_logger.start_group(container_uuid, container)
self.allure_logger.update_group(container_uuid, start=now())
before_fixture_uuid = uuid4()
before_fixture = TestBeforeResult(name=fixture_name, start=now())
self.allure_logger.start_before_fixture(container_uuid, before_fixture_uuid, before_fixture)
yield
self.allure_logger.stop_before_fixture(before_fixture_uuid, stop=now())
for index, finalizer in enumerate(fixturedef._finalizer or ()):
name = u'{fixture}::{finalizer}'.format(fixture=fixturedef.argname, finalizer=finalizer.__name__)
fixturedef._finalizer[index] = allure_commons.fixture(finalizer, parent_uuid=container_uuid, name=name)
def test_duration(allured_testdir, snipped):
allured_testdir.testdir.makepyfile("""
def test_duration_example():
{snipped}
""".format(snipped=snipped))
timestamp = now()
allured_testdir.run_with_allure()
assert_that(
allured_testdir.allure_report,
has_test_case(
"test_duration_example",
all_of(has_entry("start", greater_than(timestamp)),
has_entry("stop", greater_than(timestamp)))))
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.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 stop_test(self, parent_uuid, uuid, name, context, exc_type, exc_val, exc_tb):
scenario = context['scenario']
self.flush_steps()
status = scenario_status(scenario)
status_details = scenario_status_details(scenario)
self.logger.update_test(uuid, stop=now(), status=status, statusDetails=status_details)
self.logger.close_test(uuid)
self.current_step_uuid = None
for group in self.fixture_context.exit():
group.children.append(uuid)
self.logger.stop_group(group.uuid)
self.execution_context.exit()
self.execution_context.append(uuid)
def start(self):
if self.reporter is None:
return
self.test_uuid = uuid4()
self.test_case = TestResult(uuid=self.test_uuid, start=now())
self.test_case.fullname = self.job.fullname
self._build_testcase_name()
if self.job.description is not None:
self.test_case.description = self.job.description
self.reporter.schedule_test(self.test_uuid, self.test_case)
pass
def test_duration(allured_testdir, snipped):
allured_testdir.testdir.makepyfile("""
def test_duration_example():
{snipped}
""".format(snipped=snipped))
timestamp = now()
allured_testdir.run_with_allure()
assert_that(allured_testdir.allure_report,
has_test_case("test_duration_example",
all_of(
has_entry("start", greater_than(timestamp)),
has_entry("stop", greater_than(timestamp))
))
)
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 after_step(context, step):
context.logger.debug(">>> step '{}' {}".format(step.name, step.status))
if step.status == "passed":
my_status = Status.PASSED
elif step.status == "skipped":
my_status = Status.SKIPPED
elif step.status == "undefined":
my_status = Status.BROKEN
else:
my_status = Status.FAILED
noww = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
context.logger.debug(f"take step Screenshot-{noww}")
context.allure.attach_data(
context.current_step_uuid,
context.browser.get_screenshot_as_png(),
name=f"Screenshot-step-{noww}", attachment_type=AttachmentType.PNG)
context.allure.stop_step(context.current_step_uuid, stop=now(), status=my_status)
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)
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(self.current_scenario_uuid, test_case)
def stop_step(self, uuid, exc_type, exc_val, exc_tb):
"""stop step"""
step_data = self._cache.get(uuid)
out = sys.stdout.getvalue()
sys.stdout.close()
if len(out) != 0:
self.attach_data(out, "STDOUT", AttachmentType.TEXT, "txt")
sys.stdout = step_data.prev_stdout
err = sys.stderr.getvalue()
sys.stderr.close()
if len(err) != 0:
self.attach_data(err, "STDERR", AttachmentType.TEXT, "txt")
sys.stderr = step_data.prev_stderr
self.allure_logger.stop_step(
uuid,
stop=now(),
status=get_status(exc_val),
statusDetails=get_status_details(exc_type, exc_val, exc_tb),
)
def stop_scenario(self, scenario):
if scenario.status == 'skipped' and not self.behave_config.show_skipped:
self.logger.drop_test(self.current_scenario_uuid)
else:
status = scenario_status(scenario)
status_details = scenario_status_details(scenario)
self.flush_steps()
test_result = self.logger.get_test(self.current_scenario_uuid)
test_result.stop = now()
test_result.status = status
test_result.statusDetails = status_details
self.logger.close_test(self.current_scenario_uuid)
self.current_step_uuid = None
for group in self.fixture_context.exit():
group.children.append(self.current_scenario_uuid)
self.logger.stop_group(group.uuid)
self.execution_context.exit()
self.execution_context.append(self.current_scenario_uuid)
self.current_scenario_uuid = None
def end_current_keyword(self, name, attributes):
uuid = self.stack.pop()
if uuid in self.items_log:
self.reporter.attach_data(uuid=uuid4(),
body=self.items_log.pop(uuid).replace('\n', '<br>'),
name='Keyword Log',
attachment_type=AttachmentType.HTML)
args = {
'uuid': uuid,
'status': utils.get_allure_status(attributes.get('status')),
'stop': now()
}
keyword_type = attributes.get('type')
parent_item = self.reporter.get_last_item()
if keyword_type in RobotKeywordType.FIXTURES and not isinstance(parent_item, TestStepResult):
if keyword_type == RobotKeywordType.SETUP:
self.reporter.stop_before_fixture(**args)
return
elif keyword_type == RobotKeywordType.TEARDOWN:
self.reporter.stop_after_fixture(**args)
return
self.reporter.stop_step(**args)
def test_with_fixture_finalizer_duration(allured_testdir, snipped):
allured_testdir.testdir.makepyfile("""
import pytest
@pytest.fixture
def fixture(request):
def finalizer():
{snipped}
request.addfinalizef(finalizer)
def test_with_fixture_finalizer_duration(fixture):
pass
""".format(snipped=snipped))
timestamp = now()
allured_testdir.run_with_allure()
assert_that(allured_testdir.allure_report,
has_test_case("test_with_fixture_finalizer_duration",
all_of(
has_entry("start", greater_than(timestamp)),
has_entry("stop", greater_than(timestamp))
))
)
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 stop_fixture(self, parent_uuid, uuid, name, exc_type, exc_val, exc_tb):
self.allure_logger.stop_after_fixture(uuid,
stop=now(),
status=get_status(exc_val),
statusDetails=get_status_details(exc_type, exc_val, exc_tb))
def start_fixture(self, parent_uuid, uuid, name):
after_fixture = TestAfterResult(name=name, start=now())
self.allure_logger.start_after_fixture(parent_uuid, uuid, after_fixture)
def stop_behave_step(self, result):
status = step_status(result)
status_details = step_status_details(result)
self.logger.stop_step(self.current_step_uuid, stop=now(), status=status, statusDetails=status_details)
def start_step(self, uuid, title, params):
parameters = [Parameter(name=name, value=value) for name, value in params.items()]
step = TestStepResult(name=title, start=now(), parameters=parameters)
self.logger.start_step(None, uuid, step)
def stop_step(self, uuid, exc_type, exc_val, exc_tb):
self.logger.stop_step(uuid,
stop=now(),
status=get_status(exc_val),
statusDetails=get_status_details(exc_type, exc_val, exc_tb))
def stop_after_fixture(self, uuid, **kwargs):
self._update_item(uuid, **kwargs)
fixture = self._items.pop(uuid)
fixture.stop = now()
def pytest_fixture_post_finalizer(self, fixturedef):
yield
if hasattr(fixturedef, 'cached_result') and self._cache.get(fixturedef):
container_uuid = self._cache.pop(fixturedef)
self.allure_logger.stop_group(container_uuid, stop=now())
def stop_fixture(self, parent_uuid, uuid, name, exc_type, exc_val, exc_tb):
if name in FIXTURES:
self.logger.stop_before_fixture(uuid=uuid,
stop=now(),
status=get_status(exc_val),
statusDetails=get_status_details(exc_type, exc_val, exc_tb))
def stop_current_group(self):
uuid = self.stack.pop()
self.remove_suite_link(uuid)
self.reporter.stop_group(uuid, stop=now())
def pytest_runtest_protocol(self, item, nextitem):
uuid = self._cache.push(item.nodeid)
test_result = TestResult(name=item.name, uuid=uuid, start=now(), stop=now())
self.allure_logger.schedule_test(uuid, test_result)
yield
