def _add_result(self, test, trace=None): uuid = uuid4() test = TestSummaryResult(**test) test_result = allure_TestResult(name=test.test_name, uuid=uuid) # test_result.status = self.allure_status(test.test_status) test_result.status = self.allure_status(test.test_status) test_result.fullName = test_result.name test_result.historyId = md5(test_result.fullName) test_result.statusDetails = StatusDetails(message=test.test_message, trace=trace) self.allure_logger.schedule_test(uuid, test_result) self.allure_logger.attach_data(uuid4(), 'aaa', name="request_result", attachment_type="text/plain", extension="txt") self.allure_logger.attach_data(uuid4(), json.dumps(test.test_dict, cls=ComplexEncoder, indent=4, sort_keys=True, ensure_ascii=False), name="case_dict", attachment_type="application/json", extension="json") self.allure_logger.close_test(uuid)
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) 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 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_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 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 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) 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 _report_messages(self, messages): has_trace = BuiltIn().get_variable_value("${LOG LEVEL}") in ( RobotLogLevel.DEBUG, RobotLogLevel.TRACE) attachment = "" for message, next_message in zip_longest(messages, messages[1:]): name = message.get('message') level = message.get('level') message_format = FAIL_MESSAGE_FORMAT if level in RobotLogLevel.CRITICAL_LEVELS else LOG_MESSAGE_FORMAT if level == RobotLogLevel.FAIL: self._current_msg = name or self._current_msg self._current_tb = next_message.get( "message" ) if has_trace and next_message else self._current_tb if len(messages) > MAX_STEP_MESSAGE_COUNT: attachment += message_format.format(level=level, message=name.replace( '\n', '<br>')) else: with self.lifecycle.start_step() as step: step.name = name step.start = step.stop = get_message_time( message.get("timestamp")) step.status = Status.FAILED if level in RobotLogLevel.CRITICAL_LEVELS else Status.PASSED self.lifecycle.stop_step() if attachment: self.lifecycle.attach_data(uuid=uuid4(), body=attachment, name='Keyword Log', attachment_type=AttachmentType.HTML)
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 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_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 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 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 create_message_steps(self, parent_uuid, *steps): for step, level in steps: uuid = uuid4() self.reporter.start_step(parent_uuid=parent_uuid, uuid=uuid, step=TestStepResult(**step)) self.reporter.stop_step(uuid=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_before_fixture(self, parent_uuid=None, uuid=None): fixture = TestBeforeResult() parent = self._get_item(uuid=parent_uuid, item_type=TestResultContainer) if parent: parent.befores.append(fixture) self._items[uuid or uuid4()] = fixture yield fixture
def attach_file(self, source, name, attachment_type, extension): """attach file to allure report""" self.allure_logger.attach_file( uuid4(), source, name=name, attachment_type=attachment_type, extension=extension, )
def attach_data(self, body, name, attachment_type, extension): """attach data to allure report""" self.allure_logger.attach_data( uuid4(), body, name=name, attachment_type=attachment_type, extension=extension, )
def __init__(self, default_test_suite_name=None, default_parent_test_suite_name=None, default_sub_suite_name=None): self.allure_logger = AllureReporter() self._cache = ItemCache() self.default_test_suite_name = default_test_suite_name self.default_parent_test_suite_name = default_parent_test_suite_name self.default_sub_suite_name = default_sub_suite_name self.container_uuid=str(uuid4()) self.current_testcase_container_uuid = None self.parent_test_listener = 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 __init__(self, title, params, display_params=True, display_context=True): self.title = title self.params = params self.uuid = uuid4() self.display_params = display_params self.display_context = display_context
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_step(self, step): self.current_step_uuid = uuid4() name = u'{keyword} {title}'.format(keyword=step.keyword, title=step.name) parent_uuid = self.current_before_uuid or self.current_scenario_uuid allure_step = TestStepResult(name=name, start=now()) self.logger.start_step(parent_uuid, 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: table = [','.join(step.table.headings)] [table.append(','.join(list(row))) for row in step.table.rows] self.logger.attach_data(uuid4(), '\n'.join(table), name='.table', attachment_type=AttachmentType.CSV)
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 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 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 _attach_adcm_url(request: SubRequest, adcm: ADCM): """Attach ADCM URL link to the Allure Report for the further access""" attachment_name = "ADCM URL" reporter = allure_reporter(request.config) if reporter: test_result = reporter.get_test(uuid=None) reporter.attach_data( uuid=uuid4(), body=adcm.url, name=attachment_name, extension="text", parent_uuid=test_result.uuid, ) else: allure.attach( body=adcm.url, name=attachment_name, extension="text", )
def __init__( self, title, params, display_params=True, params_separator=', ', derepresent_params=False, display_context=True, translations=( (':--(', ':--)'), (':--/', ':--D'), ), ): self.maybe_title = title self.params = params self.uuid = uuid4() self.display_params = display_params self.params_separator = params_separator self.derepresent_params = derepresent_params self.display_context = display_context self.translations = translations
def _attach_adcm_logs(request: SubRequest, adcm: ADCM): """Gather /adcm/data/ form the ADCM container and attach it to the Allure Report""" file_name = f"ADCM Log {request.node.name}_{time.time()}" reporter = allure_reporter(request.config) if reporter: test_result = reporter.get_test(uuid=None) with gather_adcm_data_from_container(adcm) as data: reporter.attach_data( uuid=uuid4(), body=data, name=f"{file_name}.tgz", extension="tgz", parent_uuid=test_result.uuid, ) else: with gather_adcm_data_from_container(adcm) as data: allure.attach( body=data, name=f"{file_name}.tgz", extension="tgz", )
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 before_scenario(context, scenario): context.case_uuid = uuid4() context.testcase = TestResult( uuid=context.case_uuid, start=now(), fullName=scenario.name) context.allure.schedule_test(context.case_uuid, context.testcase) context.logger.debug("user data: {}".format(context.config.userdata)) # behave -D BROWSER=chrome if 'BROWSER' in context.config.userdata.keys(): if context.config.userdata['BROWSER'] is None: BROWSER = DEFAULT_BROWSER else: BROWSER = context.config.userdata['BROWSER'] else: BROWSER = DEFAULT_BROWSER if BROWSER == 'chrome': context.browser = webdriver.Chrome() elif BROWSER == 'firefox': context.browser = webdriver.Firefox() elif BROWSER == 'safari': context.browser = webdriver.Safari() elif BROWSER == 'ie': context.browser = webdriver.Ie() elif BROWSER == 'opera': context.browser = webdriver.Opera() elif BROWSER == 'phantomjs': context.browser = webdriver.PhantomJS() else: context.logger.error("Browser you entered: " + BROWSER + " is invalid value") context.browser.maximize_window() context.browser.implicitly_wait(5) context.logger.debug(">> scenario '{}'".format(scenario.name))
def attach_data(self, body, name, attachment_type, extension): self.logger.attach_data(uuid4(), body, name=name, attachment_type=attachment_type, extension=extension)
def push(self, _id): return self._items.setdefault(str(_id), uuid4())
def __init__(self, title, params): self.title = title self.params = params self.uuid = uuid4()
def __init__(self, fixture_function, parent_uuid=None, name=None): self._fixture_function = fixture_function self._parent_uuid = parent_uuid self._name = name if name else fixture_function.__name__ self._uuid = uuid4() self.parameters = None
def __init__(self, _test, context): self._test = _test self._uuid = uuid4() self.context = context self.parameters = None
def attach_file(self, source, name, attachment_type, extension): self.logger.attach_file(uuid4(), source, name=name, attachment_type=attachment_type, extension=extension)