def execute_step(self, current_step_number, go_to_step_number):
"""
This function executes the determined step - step_num (integer index) from the step_list.
This function is called either from the while loop (normal execution) in function
execute_steps() or from a for loop (invoked execution)
"""
self.current_step = self.step_list[current_step_number]
#store loop iter number in data repository
loop_iter_number = self.current_step.get("loop_iter_number", None)
Utils.data_Utils.update_datarepository(
{"loop_iter_number": loop_iter_number})
# Incrementing current_step_number for printing purposes.
self.current_step_number = current_step_number + 1
self.go_to_step_number = go_to_step_number
# execute steps
# Decide whether or not to execute keyword
# First decide if this step should be executed in this iteration
if not self.go_to_step_number or self.go_to_step_number == str(
self.current_step_number):
# get Exectype information
self.run_current_step, self.current_triggered_action = \
exec_type_driver.main(self.current_step, skip_invoked=self.skip_invoked)
if not self.run_current_step:
return self._report_step_as_not_run()
if not self.go_to_step_number or self.go_to_step_number == str(
self.current_step_number):
self.step_status = self._execute_current_step()
else:
# Skip because of goto
return self._skip_because_of_goto()
runmode, value, runmode_timer = \
common_execution_utils.get_runmode_from_xmlfile(self.current_step)
retry_type, retry_cond, retry_cond_value, retry_value, retry_interval = \
common_execution_utils.get_retry_from_xmlfile(self.current_step)
if runmode is not None:
return self._execute_runmode_step(runmode_timer, runmode,
self.step_status, value)
elif retry_type is not None:
return self._execute_retry_type_step(retry_type, retry_cond,
retry_cond_value,
retry_interval, retry_value)
else:
return self._execute_step_otherwise(self.step_status)
def execute_sequential_testsuites(testsuite_list, project_repository,
data_repository, auto_defects):
""" Executes suites in a project sequentially """
suite_cntr = 0
goto_testsuite = False
ts_status_list = []
ts_impact_list = []
impact_dict = {"IMPACT": "Impact", "NOIMPACT": "No Impact"}
project_error_action = project_repository['def_on_error_action']
project_filepath = project_repository['project_filepath']
project_dir = os.path.dirname(project_filepath)
wp_results_execdir = project_repository['wp_results_execdir']
wp_logs_execdir = project_repository['wp_logs_execdir']
project_error_value = project_repository['def_on_error_value']
jiraproj = data_repository['jiraproj']
pj_junit_object = data_repository['wt_junit_object']
while suite_cntr < len(testsuite_list):
testsuite = testsuite_list[suite_cntr]
suite_cntr += 1
testsuite_rel_path = testsuite_utils.get_path_from_xmlfile(testsuite)
if testsuite_rel_path is not None:
testsuite_path = Utils.file_Utils.getAbsPath(
testsuite_rel_path, project_dir)
else:
testsuite_path = str(testsuite_rel_path)
print_info("\n")
print_debug("<<<< Starting execution of Test suite: {0}>>>>".format(
testsuite_path))
action, testsuite_status = exec_type_driver.main(testsuite)
testsuite_impact = Utils.testcase_Utils.get_impact_from_xmlfile(
testsuite)
testsuite_name = Utils.file_Utils.getFileName(testsuite_path)
testsuite_nameonly = Utils.file_Utils.getNameOnly(testsuite_name)
ts_onError_action = Utils.xml_Utils.get_attributevalue_from_directchildnode(
testsuite, 'onError', 'action')
ts_onError_action = ts_onError_action if ts_onError_action else project_error_action
if Utils.file_Utils.fileExists(testsuite_path):
if not goto_testsuite and action is True:
testsuite_result = testsuite_driver.main(
testsuite_path,
data_repository=data_repository,
from_project=True,
auto_defects=auto_defects,
jiraproj=jiraproj,
res_startdir=wp_results_execdir,
logs_startdir=wp_logs_execdir,
ts_onError_action=ts_onError_action)
testsuite_status = testsuite_result[0]
elif goto_testsuite and goto_testsuite == str(suite_cntr)\
and action is True:
testsuite_result = testsuite_driver.main(
testsuite_path,
data_repository=data_repository,
from_project=True,
auto_defects=auto_defects,
jiraproj=jiraproj,
res_startdir=wp_results_execdir,
logs_startdir=wp_logs_execdir,
ts_onError_action=ts_onError_action)
goto_testsuite = False
testsuite_status = testsuite_result[0]
else:
msg = print_info(
'skipped testsuite: {0} '.format(testsuite_path))
tmp_timestamp = str(
Utils.datetime_utils.get_current_timestamp())
time.sleep(2)
pj_junit_object.create_testsuite(
location=os.path.dirname(testsuite_path),
name=testsuite_nameonly,
timestamp=tmp_timestamp,
**pj_junit_object.init_arg())
pj_junit_object.update_attr("status", "SKIPPED", "ts",
tmp_timestamp)
pj_junit_object.update_attr("skipped", "1", "pj",
tmp_timestamp)
pj_junit_object.update_count("suites", "1", "pj",
tmp_timestamp)
data_repository['testsuite_{}_result'.format(
suite_cntr)] = "SKIP"
pj_junit_object.update_attr(
"impact", impact_dict.get(testsuite_impact.upper()), "ts",
tmp_timestamp)
pj_junit_object.update_attr("onerror", "N/A", "ts",
tmp_timestamp)
pj_junit_object.output_junit(wp_results_execdir,
print_summary=False)
continue
else:
msg = print_error("Test suite does not exist in "
"provided path: {0}".format(testsuite_path))
testsuite_status = 'ERROR'
if goto_testsuite and goto_testsuite == str(suite_cntr):
goto_testsuite = False
elif goto_testsuite and goto_testsuite != str(suite_cntr):
data_repository['testsuite_{}_result'.format(
suite_cntr)] = "ERROR"
continue
goto_testsuite_num = onerror_driver.main(testsuite,
project_error_action,
project_error_value)
if goto_testsuite_num is False:
onerror = "Next"
elif goto_testsuite_num == "ABORT":
onerror = "Abort"
else:
onerror = "Goto:" + str(goto_testsuite_num)
pj_junit_object.update_attr("impact",
impact_dict.get(testsuite_impact.upper()),
"ts", data_repository['wt_ts_timestamp'])
pj_junit_object.update_attr("onerror", onerror, "ts",
data_repository['wt_ts_timestamp'])
string_status = {
"TRUE": "PASS",
"FALSE": "FAIL",
"ERROR": "ERROR",
"SKIP": "SKIP",
"RAN": "RAN"
}
if str(testsuite_status).upper() in string_status.keys():
data_repository['testsuite_{}_result'.format(suite_cntr)] = \
string_status[str(testsuite_status).upper()]
else:
print_error("unexpected testsuite status, default to exception")
data_repository['testsuite_%d_result' % suite_cntr] = "ERROR"
ts_status_list.append(testsuite_status)
ts_impact_list.append(testsuite_impact)
if testsuite_impact.upper() == 'IMPACT':
msg = "Status of the executed test suite impacts Project result"
elif testsuite_impact.upper() == 'NOIMPACT':
msg = "Status of the executed test suite does not impact project result"
print_debug(msg)
runmode, value, _ = common_execution_utils.get_runmode_from_xmlfile(
testsuite)
retry_type, retry_cond, retry_cond_value, retry_value,\
retry_interval = common_execution_utils.get_retry_from_xmlfile(testsuite)
if runmode is not None:
if testsuite.find("runmode") is not None and\
testsuite.find("runmode").get("attempt") is not None:
print_info("runmode attempt: {0}".format(
testsuite.find("runmode").get("attempt")))
# if runmode is 'ruf' & step_status is False, skip the repeated
# execution of same TC step and move to next actual step
if not project_error_value and runmode == "RUF" and\
testsuite_status is False:
goto_testsuite = str(value)
# if runmode is 'rup' & step_status is True, skip the repeated
# execution of same TC step and move to next actual step
elif runmode == "RUP" and testsuite_status is True:
goto_testsuite = str(value)
elif retry_type is not None:
if testsuite.find("retry") is not None and\
testsuite.find("retry").get("attempt") is not None:
print_info("retry attempt: {0}".format(
testsuite.find("retry").get("attempt")))
if retry_type.upper() == 'IF':
try:
if data_repository[retry_cond] == retry_cond_value:
condition_met = True
pNote("Wait for {0}sec before retrying".format(
retry_interval))
pNote("The given condition '{0}' matches the expected"
"value '{1}'".format(data_repository[retry_cond],
retry_cond_value))
time.sleep(int(retry_interval))
else:
condition_met = False
print_warning(
"The condition value '{0}' does not match with the expected "
"value '{1}'".format(data_repository[retry_cond],
retry_cond_value))
except KeyError:
print_warning(
"The given condition '{0}' do not exists in "
"the data repository".format(retry_cond_value))
condition_met = False
if condition_met is False:
goto_testsuite = str(retry_value)
else:
if retry_type.upper() == 'IF NOT':
try:
if data_repository[retry_cond] != retry_cond_value:
condition_met = True
pNote("Wait for {0}sec before "
"retrying".format(retry_interval))
pNote("The condition value '{0}' does not match "
"with the expected value '{1}'".format(
data_repository[retry_cond],
retry_cond_value))
time.sleep(int(retry_interval))
else:
condition_met = False
except KeyError:
condition_met = False
print_warning(
"The given condition '{0}' is not there "
"in the data repository".format(retry_cond_value))
if condition_met is False:
pNote("The given condition '{0}' matched with the "
"value '{1}'".format(data_repository[retry_cond],
retry_cond_value))
goto_testsuite = str(retry_value)
else:
if testsuite_status is False or testsuite_status == "ERROR" or\
testsuite_status == "EXCEPTION":
goto_testsuite = onerror_driver.main(testsuite,
project_error_action,
project_error_value)
if goto_testsuite in ['ABORT', 'ABORT_AS_ERROR']:
break
# when 'onError:goto' value is less than the current ts num,
# change the next iteration point to goto value
elif goto_testsuite and int(goto_testsuite) < suite_cntr:
suite_cntr = int(goto_testsuite) - 1
goto_testsuite = False
project_status = Utils.testcase_Utils.compute_status_using_impact(
ts_status_list, ts_impact_list)
return project_status
def _execute_step_list(self):
"""
"""
goto_stepnum = False
step_num = 0
while step_num < len(self.step_list):
index = step_num
step = self.step_list[step_num]
step_num += 1
self.system_executed = self._get_system_executed(index)
if self.stop_after_current_step:
break
# Decide whether or not to execute keyword
# First decide if this step should be executed in this iteration
if not goto_stepnum or goto_stepnum == str(step_num):
# get Exectype information
run_current_step, trigger_action = exec_type_driver.main(step)
if not run_current_step:
if trigger_action.upper() in ['ABORT', 'ABORT_AS_ERROR']:
if any([
self.iter_type_list[index] == "once_per_tc",
self.iter_type_list[index] == "end_of_tc"
]):
pNote("step exectype check failed, fail action is set to {0} and"
"step iter_type={1} hence aborting execution compeletely".\
format(trigger_action.upper(), self.iter_type_list[index]), "debug")
self.stop_after_current_iteration = True
self.stop_after_current_step = True
else:
pNote("step exectype check failed, fail action is set to {0} and"
"step iter_type={1} hence aborting execution for this system".\
format(trigger_action.upper(), self.iter_type_list[index]), "debug")
goto_stepnum = False
break
elif trigger_action.upper() in ['SKIP', 'NEXT']:
result = self._update_skip_results(
step, self.system_executed, step_num)
self.kw_resultfile_list.append(result[1])
continue
# when 'onError:goto' value is less than the current step num,
# change the next iteration point to goto value
elif trigger_action and int(trigger_action) < step_num:
result = self._update_skip_results(
step, self.system_executed, step_num)
self.kw_resultfile_list.append(result[1])
step_num = int(trigger_action) - 1
trigger_action = False
continue
# when there is no goto
if not goto_stepnum:
result = self._execute_step(self.system_executed, step_num,
index, goto_stepnum)
# when goto is triggered and matches the current step number
elif (goto_stepnum and goto_stepnum == str(step_num)):
result = self._execute_step(self.system_executed, step_num,
index, goto_stepnum)
goto_stepnum = False
# when goto is triggered and does not match current step... skip
elif goto_stepnum and goto_stepnum != str(step_num):
result = self._update_skip_results(step, self.system_executed,
step_num)
self.kw_resultfile_list.append(result[1])
continue
step_status = result[0]
kw_resultfile = result[1]
step_impact = result[2]
self._update_status_items(step_status, kw_resultfile, step_impact)
goto_stepnum, step_num = self._compute_runmode_goto_operations(
step, step_status, goto_stepnum, step_num)
if (goto_stepnum == 'ABORT'):
if any([
self.iter_type_list[index] == "once_per_tc",
self.iter_type_list[index] == "end_of_tc"
]):
pNote(
"step iter_type={0}, and onerror action=ABORT hence aborting execution"
"compeletely".format(self.iter_type_list[index]),
"debug")
self.stop_after_current_iteration = True
self.stop_after_current_step = True
goto_stepnum = False
break
return
def execute_steps(step_list, data_repository, system_name, parallel, queue):
"""
Take in a list of steps
iterate through each of them and decide if each should run (pre-run check)
get status and report to term and log
"""
default_error_action = data_repository['wt_def_on_error_action']
default_error_value = data_repository['wt_def_on_error_value']
goto_stepnum = False
kw_resultfile_list = []
step_status_list = []
step_impact_list = []
step_num = 0
if parallel is True:
system_console_log = get_system_console_log(
data_repository['wt_filename'], data_repository['wt_logsdir'],
'{0}_consoleLogs'.format(system_name))
while step_num < len(step_list):
step = step_list[step_num]
# execute steps
step_num += 1
run_current_step = False
# Decide whether or not to execute keyword
# First decide if this step should be executed in this iteration
if not goto_stepnum or goto_stepnum == str(step_num):
# get Exectype information
run_current_step, trigger_action = exec_type_driver.main(step)
if not run_current_step:
keyword = step.get('Keyword')
kw_resultfile = step_driver.get_keyword_resultfile(
data_repository, system_name, step_num, keyword)
Utils.config_Utils.set_resultfile(kw_resultfile)
Utils.testcase_Utils.pKeyword(keyword, step.get('Driver'))
Utils.testcase_Utils.reportStatus('Skip')
kw_resultfile_list.append(kw_resultfile)
data_repository['wt_junit_object'].update_count(
"skipped", "1", "tc", data_repository['wt_tc_timestamp'])
data_repository['wt_junit_object'].update_count(
"keywords", "1", "tc", data_repository['wt_tc_timestamp'])
kw_start_time = Utils.datetime_utils.get_current_timestamp()
step_impact = Utils.testcase_Utils.get_impact_from_xmlfile(
step)
impact_dict = {"IMPACT": "Impact", "NOIMPACT": "No Impact"}
data_repository['wt_junit_object'].add_keyword_result(
data_repository['wt_tc_timestamp'], step_num, keyword,
"SKIPPED", kw_start_time, "0", "skipped",
impact_dict.get(step_impact.upper()), "N/A")
data_repository['step_{}_result'.format(step_num)] = "SKIPPED"
if trigger_action.upper() in ['ABORT', 'ABORT_AS_ERROR']:
break
elif trigger_action.upper() in ['SKIP', 'NEXT']:
continue
# when 'onError:goto' value is less than the current step num,
# change the next iteration point to goto value
elif trigger_action and int(trigger_action) < step_num:
step_num = int(trigger_action) - 1
trigger_action = False
continue
if not goto_stepnum:
try:
result = step_driver.main(step, step_num, data_repository,
system_name)
step_status = result[0]
kw_resultfile = result[1]
step_impact = result[2]
except Exception, e:
print_error('unexpected error %s' % str(e))
step_status = False
kw_resultfile = None
step_impact = Utils.testcase_Utils.get_impact_from_xmlfile(
step)
print_error('unexpected error {0}'.format(
traceback.format_exc()))
elif goto_stepnum and goto_stepnum == str(step_num):
try:
result = step_driver.main(step, step_num, data_repository,
system_name)
step_status = result[0]
kw_resultfile = result[1]
step_impact = result[2]
except Exception, e:
print_error('unexpected error %s' % str(e))
step_status = False
kw_resultfile = None
step_impact = Utils.testcase_Utils.get_impact_from_xmlfile(
step)
print_error('unexpected error {0}'.format(
traceback.format_exc()))
