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