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_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)
parameters = allure_parameters(fixturedef, request)
if parameters:
test_uuid = self._cache.get(request._pyfuncitem.nodeid)
parameters = Parameter(**parameters) if parameters else []
self.allure_logger.update_test(test_uuid, parameters=parameters)
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 pytest_runtest_setup(self, item):
uuid = self._cache.set(item.nodeid)
test_result = TestResult(name=item.name, uuid=uuid)
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.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.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 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 get_params(node):
if hasattr(node, 'callspec'):
params = node.callspec.params
return [
Parameter(name=name, value=value)
for name, value in params.items()
]
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 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 pytest_runtest_call(self, item):
uuid = self._cache.get(item.nodeid)
for name, value in item.callspec.params.items() if hasattr(item, 'callspec') else ():
self.allure_logger.update_test(uuid, parameters=Parameter(name, represent(value)))
self.allure_logger.update_test(uuid, start=now())
yield
self.allure_logger.update_test(uuid, stop=now())
def _override_allure_test_parameters(item: Function):
"""
Overrides all pytest parameters in allure report with test ID
"""
listener = _get_listener_by_item_if_present(item)
if listener:
test_result: TestResult = listener.allure_logger.get_test(None)
test_result.parameters = [Parameter(name="ID", value=item.callspec.id)]
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 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=allure_name(item), uuid=uuid)
self.allure_logger.schedule_test(uuid, test_case)
if hasattr(item, 'function'):
test_case.description = item.function.__doc__
yield
for name, value in item.callspec.params.items() if hasattr(
item, 'callspec') else ():
test_result = self.allure_logger.get_test(uuid)
if test_result:
test_result.parameters.append(Parameter(
name, represent(value)))
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.HOST, value=self._host))
test_case.labels.append(
Label(name=LabelType.THREAD, value=self._thread))
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)
test_case.historyId = md5(test_case.fullName)
test_case.labels.append(Label('package', allure_package(item)))
uuid = self._cache.pop(item.nodeid)
self.allure_logger.close_test(uuid)
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 scenario_parameters(scenario):
row = scenario._row
return [
Parameter(name=name, value=value)
for name, value in zip(row.headings, row.cells)
] if row else None
def _params(names, values):
return [
Parameter(name=name, value=represent(value))
for name, value in zip(names, values)
]
def scenario_parameters(scenario, browser):
row = scenario._row
return [Parameter(name=name, value=value) for name, value in zip(row.headings, row.cells)] if row else [
{"name": "browser", "value": browser}]
def get_allure_parameters(parameters):
return [
Parameter(name="arg{}".format(i + 1), value=param)
for i, param in enumerate(parameters)
]
