def complete_active_iteration(self, force_stop=False):
logger.info('completea active iteration.')
if not self.is_iteration_running():
logger.error('No active iteration found to complete.')
return
logger.log_result_info_status(self._stc_result_object)
self._active_iteration_info = ActiveIterationInfo()
self.load_from_stc_object(self._active_iteration_info)
self._active_iteration_status = ActiveIterationStatus()
self.load_from_stc_object(self._active_iteration_status)
if force_stop is True:
self._active_iteration_status.exec_status = EnumExecStatus.stopped
else:
self._active_iteration_status.exec_status = EnumExecStatus.completed
self._active_iteration_info._end_time = result_utils.get_current_time_string()
result = self.generate_iteration_verdict()
if result:
self._active_iteration_status.verdict = result['verdict']
self._active_iteration_info.result_file = result['resultFile']
self._active_iteration_info.set_data_class(self._active_iteration_info,
EnumDataClass.iteration_result)
self._active_iteration_info.set_data_format(self._active_iteration_info,
EnumDataFormat.none)
else:
self._active_iteration_status.verdict = EnumVerdict.none
self._active_iteration_info.set_data_class(self._active_iteration_info,
EnumDataClass.iteration_result)
self._active_iteration_info.set_data_format(self._active_iteration_info,
EnumDataFormat.none)
self.save_active_iteration_data()
self.reset_active_iteration_data()
logger.info('completea active iteration completed.')
def generate_iteration_verdict(self):
logger.info('Generate iteration verdict.')
jsonResults = self.get_from_stc_collection_property_as_dict('JsonResults')
if jsonResults and len(jsonResults) >= 0:
return self.generate_iteration_result_file(jsonResults)
else:
return {}
def generate_iteration_result_file(self, results):
logger.info('Generate Iteration result file.')
iteration = Iteration(self._active_iteration_info.run_time_data,
self._stc_result_object,
results,
self._active_iteration_status.run_time_data,)
return iteration.generate_report()
def get_last_iteration_info_status(iterator_handle):
logger.info('Get last iteration info for iterator:' + str(iterator_handle))
result = iterator_utils.get_iterator_result_no_leaf_check(iterator_handle)
if result is None:
return None
iterator = Iterator(iterator_handle, result)
return iterator.get_last_iteration_data()
def end_test(force_stop=False):
logger.info('end test. Force stop:' + str(force_stop))
# end all iterators if required.
start_test_if_required()
end_all_iterators(force_stop)
test_result = TestResult()
test_result.end_test(force_stop)
logger.debug('end test completed.')
def create_new_iterator(self):
logger.info('Create new iterator.')
self._stc_result_object = iterator_utils.create_iterator_result()
self.set_stc_object(self.stc_property_Iterator, str(self._iterator_handle))
self._info = IteratorInfo(self._iterator_param)
self._status = Status(EnumExecStatus.created)
self.commit_info_status()
logger.debug('Create new iterator completed.')
logger.log_result_info_status(self._stc_result_object)
def add_provider_result_to_root(dict_data):
"""Add provider result to test object.
Try to create one and continue if test does not exist.
"""
logger.info('Add provider result to root.')
# make sure test in created and running. If not do that first.
start_test_if_required()
test_result = TestResult()
dict_data = result_utils.insert_report_group_if_not_defined(dict_data)
test_result.add_provider_data(dict_data)
def complete_iteration():
logger.info('Complete iteration.')
itr_result_obj = iterator_utils.get_leaf_iterator()
if itr_result_obj is None:
logger.error('There is no iterator running to complete iteration.')
return
logger.debug_result_object_info(itr_result_obj)
iterator = Iterator(0, itr_result_obj)
iterator.complete_active_iteration()
logger.debug('Complete iteration completed.')
def generate_report_file(report_name, data):
filename = os.path.join(CTestResultSettingExt.GetResultDbBaseDirectory(), report_name)
logger.info("Saving file:" + filename)
if not os.path.exists(os.path.dirname(filename)):
os.makedirs(os.path.dirname(filename))
f = open(filename, "w")
f.write(json.dumps(data, separators=(',', ':'), sort_keys=False))
f.close()
CFileManager.AddFile(filename, 'RESULT')
return filename
def set_iterator_current_value(iterator_handle,
iterator_param,
value,
iteration_id):
log_string = 'Set iterator values. Iterator handle:' + str(iterator_handle) + ', param:' +\
str(iterator_param) + ', value:' + str(value) + ', iteration_id:' + str(iteration_id)
logger.info(log_string)
start_test_if_required()
end_inner_iterator_if_required(iterator_handle)
iterator = Iterator(iterator_handle, None, iterator_param)
iterator.start_next_iteration(value, iteration_id)
logger.debug('Set iterator values completed.')
def add_provider_result(dict_data):
"""Add provider result to active result object.
It is leaf iterator result object in case of iterative test.
Do not throw error if result object does not exist.
Try to create one and continue.
"""
logger.info('Add provider result.')
# make sure test in created and running. If not do that first.
start_test_if_required()
result = iterator_utils.get_active_result_object()
logger.debug_result_object_info(result)
dict_data = result_utils.insert_report_group_if_not_defined(dict_data)
result_obj.add_provider_data(result, dict_data)
def start_next_iteration(self, value, iteration_id):
logger.info('start next iteration.')
# make sure no active iteration running.
if self.is_iteration_running():
logger.warning('Complete iteration call missing for previous iteration.')
self.complete_active_iteration()
self._active_iteration_info = ActiveIterationInfo(value,
iteration_id,
self._iterator_param)
self._active_iteration_info._start_time = result_utils.get_current_time_string()
self._active_iteration_status = ActiveIterationStatus(EnumExecStatus.running)
self.commit_active_info_status()
logger.debug('start next iteration completed.')
logger.log_result_info_status(self._stc_result_object)
def save_active_iteration_data(self):
"""Convert from Active iteration data to Iteration data
"""
logger.info('Save active iteration data.')
child_data = self.get_from_stc_as_dict(self.stc_property_child_iterator_data)
if child_data:
self._active_iteration_info.set_data_format(self._active_iteration_info,
EnumDataFormat.group)
result = self._active_iteration_info.run_time_data
result[self.get_data_dict_name()] = result_utils.wrap_data_as_single_group(child_data)
else:
result = self._active_iteration_info.run_time_data
result[Status.get_dict_name()] = self._active_iteration_status.run_time_data
self.append_stc_object_collection(
self.stc_property_completed_data,
json.dumps(result, separators=(',', ':'), sort_keys=False))
logger.debug('Save active iteration data completed.')
def complete(self, force_stop):
logger.info('Complete - End iterator.')
if self.is_iteration_running():
logger.warning('Complete iteration call missing before end iterator.')
self.complete_active_iteration(force_stop)
self.load_all_iterator_data()
if force_stop is True:
self._status.exec_status = EnumExecStatus.stopped
else:
self._status.exec_status = EnumExecStatus.completed
self._status.verdict = EnumVerdict.none
self._info.set_data_format(self._info, EnumDataFormat.group)
self._info.set_data_class(self._info, EnumDataClass.iterator_result)
iteratorData = self._info.run_time_data
iteratorData[self._status.dict_name] = self._status.run_time_data
allData = self.get_from_stc_collection_property_as_dict(self.stc_property_completed_data)
iteratorData[self.get_data_dict_name()] = result_utils.wrap_data_as_single_group(allData)
self._stc_result_object.MarkDelete()
logger.debug('Complete - End iterator completed.')
return iteratorData
def end_iterator(force_stop=False):
logger.info('End iteration.')
itr_result_obj = iterator_utils.get_leaf_iterator()
if itr_result_obj is None:
logger.error('There is no iterator running to end iterator.')
return
iterator = Iterator(0, itr_result_obj)
data = iterator.complete(force_stop)
parentIterator = iterator_utils.get_leaf_iterator_no_throw()
if parentIterator is None:
logger.info('Adding iteration result to Test.')
data[pc.STATUS][pc.APPLY_VERDICT] = True
test_result = TestResult()
test_result.add_provider_data(data)
else:
logger.info('Adding iteration result to parent iterator.')
logger.debug_result_object_info(itr_result_obj)
parent_itr = Iterator(0, parentIterator)
parent_itr.add_child_iterator_data(data)
logger.debug('End iteration completed')
def test_get_formatted_drilldown_data_and_more():
verdict = True
verdictText = 'Not available'
displayName = "My display name"
pass_text = "my pass text"
applyVerdictToSum = False
viewName = 'MyTestDrv'
displays = ['First', 'Second']
report_group = pc.HIGHEST_PRIORITY_REPORT_GROUP
drilldowndataObjects = []
drilldowndata = {}
drilldowndata[pc.SUMMARIZATION_OBJECT] = 'Port.Name'
drilldowndata[pc.COLUMN_DISPLAY_NAMES] = displays
resultviewdata1 = [1, 2]
resultviewdata2 = [3, 4]
resultviewdataList = [resultviewdata1, resultviewdata2]
drilldowndata[pc.ROW] = resultviewdataList
drilldowndataObjects.append(drilldowndata)
drilldowndata = {}
drilldowndata[pc.SUMMARIZATION_OBJECT] = 'Project.Name'
drilldowndata[pc.COLUMN_DISPLAY_NAMES] = displays
resultviewdata = [4, 6]
resultviewdataList = [resultviewdata]
drilldowndata[pc.ROW] = resultviewdataList
drilldowndataObjects.append(drilldowndata)
formatted_data = drv_utils.get_formatted_drilldown_data(drilldowndataObjects)
provider_data = p.get_table_drv_drilldown_data(viewName,
verdict,
verdictText,
applyVerdictToSum,
formatted_data,
report_group,
displayName,
pass_text,
"")
assert provider_data is not None
info = provider_data[pc.INFO]
status = provider_data[pc.STATUS]
data = provider_data[pc.DATA]
logger.info(json.dumps(provider_data, separators=(',', ':'), sort_keys=False))
assert provider_data[pc.CLASS] == EnumDataClass.table_drv_drilldown
assert provider_data[pc.DATA_FORMAT] == EnumDataFormat.table
# verify info
assert info[pc.RESULT_VIEW_NAME] == viewName
assert info[pc.SUMMARIZATION_OBJECT] == 'Project.Name'
assert info[pc.REPORT_GROUP] == pc.HIGHEST_PRIORITY_REPORT_GROUP
assert info[pc.DISPLAY_NAME] == displayName
# verify status
assert status[pc.VERDICT] == EnumVerdict.passed
assert status[pc.VERDICT_TEXT] == pass_text
assert status[pc.EXEC_STATUS] == EnumExecStatus.completed
assert status[pc.APPLY_VERDICT] == applyVerdictToSum
assert len(data[pc.COLUMN_DISPLAY_NAMES]) == 2
assert data[pc.COLUMN_DISPLAY_NAMES][0] == displays[0]
assert data[pc.COLUMN_DISPLAY_NAMES][1] == displays[1]
rows = data[pc.ROW]
assert len(rows) == 1
assert len(rows[0]) == 2
assert rows[0][0] == 4
assert rows[0][1] == 6
assert (pc.LINKS in data) is True
# verify drilldown results
data = data[pc.LINKS]
assert len(data) == 1
data = data[0]
data[pc.TAG] = 'Port.Name'
assert (pc.LINK_DATA in data) is True
data = data[pc.LINK_DATA]
assert data[pc.CLASS] == EnumDataClass.drill_down_results
assert data[pc.DATA_FORMAT] == EnumDataFormat.table
assert data[pc.INFO][pc.SUMMARIZATION_OBJECT] == 'Port.Name'
data = data[pc.DATA]
assert len(data[pc.COLUMN_DISPLAY_NAMES]) == 2
assert data[pc.COLUMN_DISPLAY_NAMES][0] == displays[0]
assert data[pc.COLUMN_DISPLAY_NAMES][1] == displays[1]
rows = data[pc.ROW]
assert len(rows) == 2
assert len(rows[0]) == 2
assert rows[0][0] == 1
assert rows[0][1] == 2
assert rows[1][0] == 3
assert rows[1][1] == 4
assert (pc.LINKS in data) is False
def create_test():
logger.info('Create methodology test.')
test_result = TestResult()
test_result.create_test()
logger.debug('Create test completed.')
def start_test():
logger.info('Start test')
test_result = TestResult()
test_result.start_test()
logger.debug('Start test completed')
def add_child_iterator_data(self, data):
logger.info('Add child iterator data.')
json_data = json.dumps(data, separators=(',', ':'), sort_keys=False)
self.set_stc_object(self.stc_property_child_iterator_data, json_data)
logger.debug('Add child iterator data completed.')
def add_data_to_test_info(dict_data):
logger.info('Adding data to test report info')
start_test_if_required()
test_result = TestResult()
test_result.add_info_data(dict_data)
