def execute_iterative_parallel_testcases(system_list,
testcase_list,
suite_repository,
data_repository,
from_project,
tc_parallel=True,
auto_defects=False):
"""Takes a list of systems as input and executes the testcases in parallel by
creating separate process of testcase_driver for each of these systems """
jobs_list = []
output_q = None
for system in system_list:
target_module = sequential_testcase_driver.main
#args_list = [testcase_list, suite_repository, data_repository, from_project,
# auto_defects, system, tc_parallel]
tc_args_dict = OrderedDict([("testcase_list", testcase_list),
("suite_repository", suite_repository),
("data_repository", data_repository),
("from_project", from_project),
("auto_defects", auto_defects),
("system", system),
("tc_parallel", tc_parallel),
("output_q", output_q)])
process, jobs_list, output_q = create_and_start_process_with_queue(
target_module, tc_args_dict, jobs_list, output_q)
print_debug("process: {0}".format(process))
for job in jobs_list:
job.join()
result_list = get_results_from_queue(output_q)
tc_status_list = []
tc_name_list = []
tc_impact_list = []
tc_duration_list = []
# Get the junit object of each testcase, extract the information from it and combine with testsuite junit object
tc_junit_list = []
# Suite results
for result in result_list:
# Case results
for val in range(len(result[0])):
tc_status_list.append(result[0][val])
tc_name_list.append(result[1])
tc_impact_list.append(result[2][val])
tc_duration_list.append(result[3][val])
tc_junit_list.append(result[4][val])
# parallel testcases generate multiple testcase junit result files
# each files log the result for one testcase and not intergrated
# update testsuite junit result file with individual testcase result files
update_ts_junit_resultfile(suite_repository['wt_junit_object'],
tc_junit_list)
testsuite_status = Utils.testcase_Utils.compute_status_using_impact(
tc_status_list, tc_impact_list)
return testsuite_status
def execute_iterative_parallel(step_list, data_repository, tc_status,
system_list):
"""Takes a list of steps as input and executes them in parallel by
creating separate process of step_driver for each of these steps """
jobs_list = []
output_q = None
for system_name in system_list:
target_module = testcase_steps_execution.main
#args_list = [step_list, data_repository, system_name, True]
args_dict = OrderedDict([
("step_list", step_list),
("data_repository", data_repository),
("system_name", system_name),
("kw_parallel", True),
("output_q", output_q),
])
process, jobs_list, output_q = create_and_start_process_with_queue(
target_module, args_dict, jobs_list, output_q)
print_debug("process: {0}".format(process))
for job in jobs_list:
job.join()
result_list = get_results_from_queue(output_q)
system_status_list = []
system_resultfile_list = []
step_impact_list = []
tc_junit_list = []
for result in result_list:
step_status_list = result[0]
kw_resultfile_list = result[1]
system_name = result[2]
step_impact_list = result[3]
tc_junit_list.append(result[4])
system_status = testcase_Utils.compute_status_using_impact(
step_status_list, step_impact_list)
system_resultfile = testcase_Utils.compute_system_resultfile(
kw_resultfile_list, data_repository['wt_resultsdir'], system_name)
system_status_list.append(system_status)
system_resultfile_list.append(system_resultfile)
tc_status = Utils.testcase_Utils.compute_status_without_impact(
system_status_list)
# parallel keywords generate multiple keyword junit result files
# each files log the result for one keyword and not intergrated
# update testcase junit result file with individual keyword result files
data_repository['wt_junit_object'] = update_tc_junit_resultfile(
data_repository['wt_junit_object'], tc_junit_list,
data_repository['wt_tc_timestamp'])
print_debug("Updating Testcase result file...")
Utils.testcase_Utils.append_result_files(data_repository['wt_resultfile'],
system_resultfile_list)
return tc_status
def execute_parallel_testsuites(testsuite_list,
project_repository,
data_repository,
auto_defects=False,
ts_parallel=True):
"""Takes a list of suites as input and executes them in parallel by
creating separate process of testsuite_driver for each of these suite """
jobs_list = []
output_q = None
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']
jiraproj = data_repository["jiraproj"]
for testsuite in testsuite_list:
target_module = testsuite_driver.main
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)
testsuite_impact = Utils.testcase_Utils.get_impact_from_xmlfile(
testsuite)
data_repository['wt_ts_impact'] = testsuite_impact
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
tc_args_dict = OrderedDict([("testsuite_filepath", 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),
("output_q", output_q),
("ts_parallel", ts_parallel)])
process, jobs_list, output_q = create_and_start_process_with_queue(
target_module, tc_args_dict, jobs_list, output_q)
print_debug("process: {0}".format(process))
for job in jobs_list:
job.join()
result_list = get_results_from_queue(output_q)
ts_status_list = []
ts_impact_list = []
ts_timestamp_list = []
# Get the junit object of each suite, extract the information from it
# and combine with project junit object
ts_junit_list = []
for result in result_list:
ts_status_list.append(result[0])
ts_impact_list.append(result[1])
ts_timestamp_list.append(result[2])
ts_junit_list.append(result[3])
for i in range(len(ts_junit_list)):
ts_junit_list[i].update_attr(
"impact", impact_dict.get(ts_impact_list[i].upper()), "ts",
ts_timestamp_list[i])
# onerror is not applicable for parallel execution
ts_junit_list[i].update_attr("onerror", "N/A", "ts",
ts_timestamp_list[i])
# parallel suites generate multiple suite junit result files
# each files log the result for one suite and not integrated
# update project junit result file with individual suite result files
data_repository['wt_junit_object'] = update_pj_junit_resultfile(
data_repository['wt_junit_object'], ts_junit_list)
project_status = Utils.testcase_Utils.compute_status_using_impact(
ts_status_list, ts_impact_list)
return project_status
def execute_parallel_testcases(testcase_list,
suite_repository,
data_repository,
from_project,
tc_parallel=True,
auto_defects=False,
iter_ts_sys=None):
"""Takes a list of testcase as input and executes them in parallel by
creating separate process of testcase_driver for each of these testcase """
jobs_list = []
output_q = None
suite = suite_repository['suite_name']
testsuite_filepath = suite_repository['testsuite_filepath']
suite_error_action = suite_repository['def_on_error_action']
jiraproj = data_repository["jiraproj"]
testsuite_dir = os.path.dirname(testsuite_filepath)
for testcase in testcase_list:
target_module = testcase_driver.main
tc_rel_path = testsuite_utils.get_path_from_xmlfile(testcase)
if tc_rel_path is not None:
tc_path = Utils.file_Utils.getAbsPath(tc_rel_path, testsuite_dir)
else:
tc_path = str(tc_rel_path)
tc_runtype = testsuite_utils.get_runtype_from_xmlfile(testcase)
tc_impact = Utils.testcase_Utils.get_impact_from_xmlfile(testcase)
tc_context = Utils.testcase_Utils.get_context_from_xmlfile(testcase)
suite_step_data_file = testsuite_utils.get_data_file_at_suite_step(
testcase, suite_repository)
tc_onError_action = Utils.xml_Utils.get_attributevalue_from_directchildnode(
testcase, 'onError', 'action')
tc_onError_action = tc_onError_action if tc_onError_action else suite_error_action
if suite_step_data_file is not None:
data_file = Utils.file_Utils.getAbsPath(suite_step_data_file,
testsuite_dir)
data_repository[tc_path] = data_file
data_repository['wt_tc_impact'] = tc_impact
# instead of using args_list, we need to use an ordered dict
# for tc args because intially q will be none and
# we need to cange it after creating a new q
# then we need to maintain the position of arguments
# before calling the testcase driver main function.
tc_args_dict = OrderedDict([("tc_path", tc_path),
("data_repository", data_repository),
("tc_context", tc_context),
("tc_runtype", tc_runtype),
("tc_parallel", tc_parallel),
("auto_defects", auto_defects),
("suite", suite),
("tc_onError_action", tc_onError_action),
("iter_ts_sys", iter_ts_sys),
("output_q", output_q),
("jiraproj", jiraproj)])
process, jobs_list, output_q = create_and_start_process_with_queue(
target_module, tc_args_dict, jobs_list, output_q)
print_debug("process: {0}".format(process))
for job in jobs_list:
job.join()
result_list = get_results_from_queue(output_q)
tc_status_list = []
tc_name_list = []
tc_impact_list = []
tc_duration_list = []
# Get the junit object of each testcase, extract the information from it and combine with testsuite junit object
tc_junit_list = []
for result in result_list:
tc_status_list.append(result[0])
tc_name_list.append(result[1])
tc_impact_list.append(result[2])
tc_duration_list.append(result[3])
tc_junit_list.append(result[4])
# parallel testcases generate multiple testcase junit result files
# each files log the result for one testcase and not intergrated
# update testsuite junit result file with individual testcase result files
data_repository['wt_junit_object'] = update_ts_junit_resultfile(
data_repository['wt_junit_object'], tc_junit_list)
testsuite_status = Utils.testcase_Utils.compute_status_using_impact(
tc_status_list, tc_impact_list)
return testsuite_status