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 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_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 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)
