def uid(self):
"""
Unique identifier of self.
"""
if not self._uid:
self._uid = uuid4()
return self._uid
def __init__(
self,
target=None,
module=None,
path=None,
args=None,
kwargs=None,
uid=None,
rerun=0,
weight=0,
):
self._target = target
self._module = module
self._path = path or ""
self._args = args or tuple()
self._kwargs = kwargs or dict()
self._uid = uid or strings.uuid4()
self._aborted = False
self._max_rerun_limit = (self.MAX_RERUN_LIMIT if
rerun > self.MAX_RERUN_LIMIT else int(rerun))
self._assign_for_rerun = 0
self._executors = OrderedDict()
self.priority = -weight
if self._max_rerun_limit < 0:
raise ValueError("Value of `rerun` cannot be negative.")
elif self._max_rerun_limit > self.MAX_RERUN_LIMIT:
warnings.warn("Value of `rerun` cannot exceed {}".format(
self.MAX_RERUN_LIMIT))
self._max_rerun_limit = self.MAX_RERUN_LIMIT
def __init__(self,
name,
description=None,
uid=None,
entries=None,
parent_uids=None):
self.name = name
self.description = description
self.uid = uid or strings.uuid4()
self.entries = entries or []
self.logs = []
self.logger = create_logging_adapter(report=self)
# parent_uids are a list of the UIDs of all parents of this entry in
# the report tree. The UIDs are stored with the most distant parent
# first and the immediate parent last. For example, an entry with
# parent "A" and grand-parent "B" will have parent_uids = ["B", "A"].
# This allows any entry to be quickly looked up and updated in the
# report tree.
if parent_uids is None:
self.parent_uids = []
else:
self.parent_uids = parent_uids
def reset_uid(self, uid=None):
"""
Reset uid of test report and all of its children, it can be useful
when need to generate global unique id for each report entry before
saving, by default strings in standard UUID format will be applied.
"""
self.uid = uid or strings.uuid4()
for entry in self:
if isinstance(entry, (Report, ReportGroup)):
entry.reset_uid()
self.build_index()
def __init__(self,
task=None,
result=None,
status=False,
reason=None,
follow=None):
self._task = task
self._result = result
self._status = status
self._reason = reason
self._follow = follow
self._uid = strings.uuid4()
def logger(self):
"""logger object"""
# Define logger as a property instead of self.logger directly.
# This is to workaround a python2 issue that logger object cannot be
# pickled/deepcopied, but we need to do that for task target which
# could be a multitest object.
if self._logger:
return self._logger
self._logger = logging.getLogger(".".join(
[LOGGER_NAME, self.__class__.__name__,
uuid4()[-8:]]))
return self._logger
def _append_temporary_task_result(self, task_result):
"""If a task should rerun, append the task result already fetched."""
test_report = task_result.result.report
uid = task_result.task.uid()
if uid not in self._task_retries_cnt:
return
postfix = " => Run {}".format(task_result.task.reassign_cnt)
test_report.name = "{}{}".format(test_report.name, postfix)
test_report.uid = "{}{}".format(test_report.uid, postfix)
test_report.category = ReportCategories.TASK_RERUN
test_report.status_override = "xfail"
new_uuid = strings.uuid4()
self._results[new_uuid] = task_result
self.parent._tests[new_uuid] = self.cfg.name
def emit(self, record):
if hasattr(record, "report_obj_id"):
report = REPORT_MAP.get(record.report_obj_id)
if report is not None:
created = datetime.datetime.utcfromtimestamp(
record.created).replace(tzinfo=tzutc())
report.logs.append({
"message": self.format(record),
"levelname": record.levelname,
"levelno": record.levelno,
"created": created,
"funcName": record.funcName,
"lineno": record.lineno,
"uid": strings.uuid4(),
})
def add_resource(self, resource, uid=None):
"""
Adds a :py:class:`resource <testplan.common.entity.base.Resource>`
in the runnable environment.
:param resource: Resource to be added.
:type resource: Subclass of
:py:class:`~testplan.common.entity.base.Resource`
:param uid: Optional input resource uid.
:type uid: ``str`` or ``NoneType``
:return: Resource uid assigned.
:rtype: ``str``
"""
resource.parent = self
resource.cfg.parent = self.cfg
return self.resources.add(resource, uid=uid or uuid4())
def _append_temporary_task_result(self, task_result):
"""If a task should rerun, append the task result already fetched."""
test_report = task_result.result.report
uid = task_result.task.uid()
if uid not in self._task_retries_cnt:
return
postfix = f" => Run {task_result.task.reassign_cnt}"
test_report.name = f"{test_report.name}{postfix}"
test_report.uid = f"{test_report.uid}{postfix}"
test_report.category = ReportCategories.TASK_RERUN
test_report.status_override = "xfail"
new_uuid = strings.uuid4()
self._results[new_uuid] = task_result
self.parent._tests[new_uuid] = self.cfg.name
self.record_execution(new_uuid)
def post(self):
save_exports = request.json
with ihandler.report_mutex:
for exporter in ihandler.exporters:
if exporter.name in save_exports.get("exporters", []):
export_result = {
"time": time.time(),
"name": exporter.name,
"uid": strings.uuid4(),
}
try:
export_path = exporter.export(ihandler.report)
export_result["success"] = True
export_result["message"] = export_path
except Exception:
export_result["success"] = False
export_result["message"] = traceback.format_exc()
export_history.append(export_result)
return {"history": export_history}
def _merge_reports(self, test_report_lookup):
"""
Merge report of MultiTest parts into test runner report.
Return True if all parts are found and can be successfully merged.
Format of test_report_lookup:
{
'report_uid_1': [
(True, report_1_part_1), (True, report_1_part_2), ...
],
'report_uid_2': [
(True, report_2_part_1), (False, report_2_part_2), ...
],
...
}
"""
merge_result = True
for uid, result in test_report_lookup.items():
placeholder_report = self._result.test_report.get_by_uid(uid)
num_of_parts = 0
part_indexes = set()
merged = False
with placeholder_report.logged_exceptions():
for run, report in result:
if num_of_parts and num_of_parts != report.part[1]:
raise ValueError(
"Cannot merge parts for child report with"
" `uid`: {uid}, invalid parameter of part"
" provided.".format(uid=uid))
elif report.part[0] in part_indexes:
raise ValueError(
"Cannot merge parts for child report with"
" `uid`: {uid}, duplicate MultiTest parts"
" had been scheduled.".format(uid=uid))
else:
part_indexes.add(report.part[0])
num_of_parts = report.part[1]
if run:
if isinstance(run, Exception):
raise run
else:
placeholder_report.merge(report, strict=False)
else:
raise MergeError(
"Cannot merge parts for child report with"
" `uid`: {uid}, at least one part (index:{part})"
" didn't run.".format(uid=uid,
part=report.part[0]))
else:
if len(part_indexes) < num_of_parts:
raise MergeError(
"Cannot merge parts for child report with"
" `uid`: {uid}, not all MultiTest parts"
" had been scheduled.".format(uid=uid))
merged = True
# If fail to merge sibling reports, clear the placeholder report
# but keep error logs, sibling reports will be appended at the end.
if not merged:
placeholder_report.entries = []
placeholder_report._index = {}
placeholder_report.status_override = Status.ERROR
for _, report in result:
report.name = "{} - part({}/{})".format(
report.name, report.part[0], report.part[1])
report.uid = strings.uuid4() # considered as error report
self._result.test_report.append(report)
merge_result = (merge_result
and placeholder_report.status != Status.ERROR)
return merge_result
def uid(self):
"""Provide mandatory .uid() task method."""
return strings.uuid4()
def reset_uid(self, uid=None):
"""
Reset uid of the report, it can be useful when need to generate
a global unique id instead of the current one.
"""
self.uid = uid or strings.uuid4()
