コード例 #1
0
    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)
コード例 #2
0
    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)
コード例 #3
0
ファイル: listener.py プロジェクト: ashtonhong/allure-python
    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)
コード例 #4
0
 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)
コード例 #5
0
    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)
コード例 #6
0
 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))
コード例 #7
0
    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)
コード例 #8
0
    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)
コード例 #9
0
    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)
コード例 #10
0
ファイル: lifecycle.py プロジェクト: Aryanrocky20/POM_Optum
 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
コード例 #11
0
 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)
コード例 #12
0
    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)
コード例 #13
0
    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
コード例 #14
0
 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))
コード例 #15
0
 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)
コード例 #16
0
ファイル: listener.py プロジェクト: nattster/allure-python
    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()
コード例 #17
0
ファイル: lifecycle.py プロジェクト: Aryanrocky20/POM_Optum
 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
コード例 #18
0
 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,
     )
コード例 #19
0
 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,
     )
コード例 #20
0
 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
コード例 #21
0
 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)
コード例 #22
0
 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)
コード例 #23
0
 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
コード例 #24
0
    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)
コード例 #25
0
 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)
コード例 #26
0
 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)
コード例 #27
0
ファイル: listener.py プロジェクト: nattster/allure-python
    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)
コード例 #28
0
    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
コード例 #29
0
    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)
コード例 #30
0
    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)
コード例 #31
0
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",
        )
コード例 #32
0
 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
コード例 #33
0
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",
            )
コード例 #34
0
 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)
コード例 #35
0
 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)
コード例 #36
0
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))
コード例 #37
0
 def attach_data(self, body, name, attachment_type, extension):
     self.logger.attach_data(uuid4(), body, name=name, attachment_type=attachment_type, extension=extension)
コード例 #38
0
 def push(self, _id):
     return self._items.setdefault(str(_id), uuid4())
コード例 #39
0
 def __init__(self, title, params):
     self.title = title
     self.params = params
     self.uuid = uuid4()
コード例 #40
0
 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
コード例 #41
0
 def __init__(self, _test, context):
     self._test = _test
     self._uuid = uuid4()
     self.context = context
     self.parameters = None
コード例 #42
0
 def attach_file(self, source, name, attachment_type, extension):
     self.logger.attach_file(uuid4(), source, name=name, attachment_type=attachment_type, extension=extension)