def finalize_test(self, sessionid):
'''shut_down testkit-stub'''
try:
self.testworker.finalize_test(sessionid)
except Exception as error:
LOGGER.error("[ Error: fail to close webapi http server, "
"error: %s ]" % error)
def __run_with_commodule(self, webapi_file):
"""run_with_commodule,Initialization,check status,get result"""
try:
# prepare test set list
test_xml_set_list = self.__split_xml_to_set(webapi_file)
# create temporary parameter
for test_xml_set in test_xml_set_list:
LOGGER.info("\n[ run set: %s ]" % test_xml_set)
# prepare the test JSON
self.__prepare_external_test_json(test_xml_set)
# init test here
init_status = self.__init_com_module(test_xml_set)
if not init_status:
continue
# send set JSON Data to com_module
self.testworker.run_test(
self.session_id, self.set_parameters)
while True:
time.sleep(1)
# check the test status ,if the set finished,get
# the set_result,and finalize_test
if self.__check_test_status():
set_result = self.testworker.get_test_result(
self.session_id)
# write_result to set_xml
self.__write_set_result(
test_xml_set, set_result)
# shut down server
self.finalize_test(self.session_id)
break
except IOError as error:
LOGGER.error(
"[ Error: fail to run webapi test xml, error: %s ]" % error)
def __write_file_result(self, set_result_xml, set_result):
"""write xml result file"""
result_file = set_result['resultfile']
try:
if self.rerun:
LOGGER.info("[ Web UI FW Unit Test Does not support rerun.\
Result should be N/A ]\n")
else:
test_tree = etree.parse(set_result_xml)
test_em = test_tree.getroot()
result_tree = etree.parse(result_file)
result_em = result_tree.getroot()
dubug_file = os.path.basename(set_result_xml)
dubug_file = os.path.splitext(dubug_file)[0] + '.dlog'
for result_suite in result_em.getiterator('suite'):
for result_set in result_suite.getiterator('set'):
for test_suite in test_em.getiterator('suite'):
for test_set in test_suite.getiterator('set'):
if result_set.get('name') == \
test_set.get('name'):
result_set.set("set_debug_msg", dubug_file)
test_suite.remove(test_set)
test_suite.append(result_set)
test_tree.write(set_result_xml)
os.remove(result_file)
LOGGER.info("[ cases result saved to resultfile ]\n")
except OSError as error:
traceback.print_exc()
LOGGER.error(
"[ Error: fail to write cases result, error: %s ]\n" % error)
def __prepare_result_file(self, testxmlfile, resultfile):
""" write the test_xml content to resultfile"""
try:
parse_tree = etree.parse(testxmlfile)
suiteparent = parse_tree.getroot()
no_test_definition = 1
if parse_tree.getiterator('test_definition'):
no_test_definition = 0
if no_test_definition:
suiteparent = etree.Element('test_definition')
suiteparent.tail = "\n"
for suite in parse_tree.getiterator('suite'):
suite.tail = "\n"
suiteparent.append(suite)
self.apply_filter(suiteparent)
try:
with open(resultfile, 'w') as output:
tree = etree.ElementTree(element=suiteparent)
tree.write(output)
except IOError as error:
LOGGER.error("[ Error: create filtered result file: %s failed,\
error: %s ]" % (resultfile, error))
except IOError as error:
LOGGER.error(error)
return False
def prepare_run(self, testxmlfile, resultdir=None):
"""
testxmlfile: target testxml file
execdir and resultdir: should be the absolute path since TRunner
is the common lib
"""
# resultdir is set to current directory by default
if not resultdir:
resultdir = os.getcwd()
ok_prepare = True
if ok_prepare:
try:
filename = testxmlfile
filename = os.path.splitext(filename)[0]
if platform.system() == "Linux":
filename = filename.split('/')[-2]
else:
filename = filename.split('\\')[-2]
if self.filter_rules["execution_type"] == ["manual"]:
resultfile = "%s.manual.xml" % filename
else:
resultfile = "%s.auto.xml" % filename
resultfile = JOIN(resultdir, resultfile)
if not EXISTS(resultdir):
os.mkdir(resultdir)
LOGGER.info("[ analysis test xml file: %s ]" % resultfile)
self.__prepare_result_file(testxmlfile, resultfile)
self.__split_test_xml(resultfile, resultdir)
except IOError as error:
LOGGER.error(error)
ok_prepare &= False
return ok_prepare
def __prepare_starup_parameters(self, testxml):
""" prepare_starup_parameters """
starup_parameters = {}
LOGGER.info("[ prepare_starup_parameters ]")
try:
parse_tree = etree.parse(testxml)
tsuite = parse_tree.getroot().getiterator('suite')[0]
tset = parse_tree.getroot().getiterator('set')[0]
if tset.get("launcher") is not None:
starup_parameters['test-launcher'] = tset.get("launcher")
else:
starup_parameters['test-launcher'] = tsuite.get("launcher")
starup_parameters['testsuite-name'] = tsuite.get("name")
starup_parameters['testset-name'] = tset.get("name")
starup_parameters['stub-name'] = self.stub_name
if self.external_test is not None:
starup_parameters['external-test'] = self.external_test
starup_parameters['debug'] = self.debug
starup_parameters['test_prefix'] = self.test_prefix
if self.rerun:
starup_parameters['rerun'] = self.rerun
if len(self.capabilities) > 0:
starup_parameters['capability'] = self.capabilities
except IOError as error:
LOGGER.error(
"[ Error: prepare starup parameters, error: %s ]" % error)
return starup_parameters
def write_json_result(set_result_xml, set_result):
''' fetch result form JSON'''
case_results = set_result["cases"]
try:
parse_tree = etree.parse(set_result_xml)
root_em = parse_tree.getroot()
dubug_file = os.path.basename(set_result_xml)
dubug_file = os.path.splitext(dubug_file)[0] + '.dlog'
for tset in root_em.getiterator('set'):
tset.set("set_debug_msg", dubug_file)
for tcase in tset.getiterator('testcase'):
for case_result in case_results:
if tcase.get("id") == case_result['case_id']:
tcase.set('result', case_result['result'].upper())
# Check performance test
if tcase.find('measurement') is not None:
for measurement in tcase.getiterator(
'measurement'):
if 'measures' in case_result:
m_results = case_result['measures']
for m_result in m_results:
if measurement.get('name') == \
m_result['name'] and 'value' in m_result:
measurement.set(
'value', m_result[
'value'])
if tcase.find("./result_info") is not None:
tcase.remove(tcase.find("./result_info"))
result_info = etree.SubElement(tcase, "result_info")
actual_result = etree.SubElement(
result_info, "actual_result")
actual_result.text = case_result['result'].upper()
start = etree.SubElement(result_info, "start")
end = etree.SubElement(result_info, "end")
stdout = etree.SubElement(result_info, "stdout")
stderr = etree.SubElement(result_info, "stderr")
if 'start_at' in case_result:
start.text = case_result['start_at']
if 'end_at' in case_result:
end.text = case_result['end_at']
if 'stdout' in case_result:
stdout.text = str2xmlstr(case_result['stdout'])
if 'stderr' in case_result:
stderr.text = str2xmlstr(case_result['stderr'])
parse_tree.write(set_result_xml)
LOGGER.info("[ cases result saved to resultfile ]\n")
except IOError as error:
traceback.print_exc()
LOGGER.error(
"[ Error: fail to write cases result, error: %s ]\n" % error)
def get_test_result(self, sessionid):
"""get the test result for a test set """
result = {}
if sessionid is None:
return result
try:
global TEST_SERVER_RESULT
LOCK_OBJ.acquire()
result = TEST_SERVER_RESULT
LOCK_OBJ.release()
except OSError, error:
LOGGER.error("[ Error: failed to get test result, error:%s ]\n" % error)
def __init_com_module(self, testxml):
"""
send init test to com_module
if webapi test,com_module will start testkit-stub
else com_module send the test case to devices
"""
starup_prms = self.__prepare_starup_parameters(testxml)
# init stub and get the session_id
session_id = self.testworker.init_test(starup_prms)
if session_id == None:
LOGGER.error("[ Error: Initialization Error]")
return False
else:
self.set_session_id(session_id)
return True
def replace_cdata(file_name):
""" replace some character"""
try:
abs_path = mktemp()
new_file = open(abs_path, 'w')
old_file = open(file_name)
for line in old_file:
line_temp = line.replace('<![CDATA', '<![CDATA')
new_file.write(line_temp.replace(']]>', ']]>'))
new_file.close()
old_file.close()
remove(file_name)
move(abs_path, file_name)
except IOError as error:
LOGGER.error("[ Error: fail to replace cdata in the result file, "
"error: %s ]\n" % error)
def get_version_info():
"""
get testkit tool version ,just read the version in VERSION file
VERSION file must put in /opt/testkit/lite/
"""
try:
config = ConfigParser.ConfigParser()
if platform.system() == "Linux":
config.read('/opt/testkit/lite/VERSION')
else:
version_file = os.path.join(sys.path[0], 'VERSION')
config.read(version_file)
version = config.get('public_version', 'version')
return version
except KeyError as error:
LOGGER.error(
"[ Error: fail to parse version info, error: %s ]\n" % error)
return ""
def get_capability(self, file_name):
"""get_capability from file """
capability_xml = file_name
capabilities = {}
try:
parse_tree = etree.parse(capability_xml)
root_em = parse_tree.getroot()
for tcap in root_em.getiterator('capability'):
capability = get_capability_form_node(tcap)
capabilities = dict(capabilities, **capability)
self.set_capability(capabilities)
return True
except IOError as error:
LOGGER.error(
"[ Error: fail to parse capability xml, error: %s ]" % error)
return False
def __splite_external_test(self, resultfile, test_file_name, resultdir):
"""select external_test"""
testsuite_dict_value_list = []
testsuite_dict_add_flag = 0
filename_diff = 1
parser = etree.parse(resultfile)
for tsuite in parser.getiterator('suite'):
root = etree.Element('test_definition')
suitefilename = os.path.splitext(resultfile)[0]
suitefilename += ".suite_%s.xml" % filename_diff
suitefilename = JOIN(resultdir, suitefilename)
tsuite.tail = "\n"
root.append(tsuite)
try:
with open(suitefilename, 'w') as output:
tree = etree.ElementTree(element=root)
tree.write(output)
except IOError as error:
LOGGER.error("[ Error: create filtered result file: %s failed,\
error: %s ]" % (suitefilename, error))
case_suite_find = etree.parse(
suitefilename).getiterator('testcase')
if case_suite_find:
if tsuite.get('launcher'):
if tsuite.get('launcher').find('WRTLauncher'):
self.__splite_core_test(suitefilename)
else:
testsuite_dict_value_list.append(suitefilename)
if testsuite_dict_add_flag == 0:
self.exe_sequence.append(test_file_name)
testsuite_dict_add_flag = 1
self.resultfiles.add(suitefilename)
else:
if self.filter_rules["execution_type"] == ["auto"]:
self.core_auto_files.append(suitefilename)
else:
self.core_manual_files.append(suitefilename)
self.resultfiles.add(suitefilename)
filename_diff += 1
if testsuite_dict_add_flag:
self.testsuite_dict[test_file_name] = testsuite_dict_value_list
def __merge_result_by_name(
self, result_set, total_set, result_suite, total_suite):
''' merge result select by name'''
if result_set.get('name') == total_set.get('name') \
and result_suite.get('name') == total_suite.get('name'):
if result_set.get('set_debug_msg'):
total_set.set("set_debug_msg", result_set.get('set_debug_msg'))
# set cases that doesn't have result in result \
# set to N/A
# append cases from result set to total set
result_case_iterator = result_set.getiterator(
'testcase')
if result_case_iterator:
# LOGGER.info("----[ suite: %s, set: %s, time: %s ]"
#% (result_suite.get('name'), result_set.get('name'),
# datetime.today().strftime("%Y-%m-%d_%H_%M_%S")))
for result_case in result_case_iterator:
try:
self.__count_result(result_case)
total_set.append(result_case)
except IOError as error:
LOGGER.error("[ Error: fail to append %s, error: %s ]"
% (result_case.get('id'), error))
def __check_test_status(self):
'''
get_test_status from com_module
check the status
if end ,return ture; else return False
'''
# check test running or end
# if the status id end return True ,else return False
session_status = self.testworker.get_test_status(self.session_id)
# session_status["finished"] == "0" is running
# session_status["finished"] == "1" is end
if not session_status == None:
if session_status["finished"] == "0":
progress_msg_list = session_status["msg"]
for line in progress_msg_list:
LOGGER.info(line)
return False
elif session_status["finished"] == "1":
return True
else:
LOGGER.error("[ session status error ,pls finalize test ]\n")
# return True to finished this set ,becasue server error
return True
def run(self):
"""run core tests"""
if self.cases_queue is None:
return
total_count = len(self.cases_queue)
current_idx = 0
manual_skip_all = False
result_list = []
global TEST_SERVER_STATUS, TEST_SERVER_RESULT
LOCK_OBJ.acquire()
TEST_SERVER_RESULT = {"cases": []}
TEST_SERVER_STATUS = {"finished": 0}
LOCK_OBJ.release()
for test_case in self.cases_queue:
current_idx += 1
expected_result = "0"
core_cmd = ""
time_out = None
measures = []
retmeasures = []
if "entry" in test_case:
core_cmd = test_case["entry"]
else:
LOGGER.info(
"[ Warnning: test script is empty,"
" please check your test xml file ]")
continue
if "expected_result" in test_case:
expected_result = test_case["expected_result"]
if "timeout" in test_case:
time_out = int(test_case["timeout"])
if "measures" in test_case:
measures = test_case["measures"]
LOGGER.info("\n[case] execute case:\nTestCase: %s\nTestEntry: %s\n"
"Expected Result: %s\nTotal: %s, Current: %s" % (
test_case['case_id'], test_case['entry'],
expected_result, total_count, current_idx))
LOGGER.info("[ execute test script,"
"this might take some time, please wait ]")
strtime = datetime.now().strftime(DATE_FORMAT_STR)
LOGGER.info("start time: %s" % strtime)
test_case["start_at"] = strtime
if self.exetype == 'auto':
return_code, stdout, stderr = shell_command_ext(
cmd=core_cmd, timeout=time_out, boutput=False)
if return_code is not None:
actual_result = str(return_code)
if actual_result == "timeout":
test_case["result"] = "BLOCK"
test_case["stdout"] = "none"
test_case["stderr"] = "none"
else:
if actual_result == expected_result:
test_case["result"] = "pass"
else:
test_case["result"] = "fail"
test_case["stdout"] = stdout
test_case["stderr"] = stderr
for item in measures:
ind = item['name']
fname = item['file']
if fname and os.path.exists(fname):
try:
config = ConfigParser.ConfigParser()
config.read(fname)
item['value'] = config.get(ind, 'value')
retmeasures.append(item)
except IOError, error:
LOGGER.error(
"[ Error: failed to parse value,"
" error: %s ]\n" % error)
test_case["measures"] = retmeasures
else:
test_case["result"] = "BLOCK"
test_case["stdout"] = "none"
test_case["stderr"] = "none"
elif self.exetype == 'manual':
# handle manual core cases
try:
# LOGGER.infopre-condition info
if "pre_condition" in test_case:
LOGGER.info("\n****\nPre-condition: %s\n ****\n"
% test_case[
'pre_condition'])
# LOGGER.infostep info
if "steps" in test_case:
for step in test_case['steps']:
LOGGER.info(
"********************\nStep Order: %s"
% step['order'])
LOGGER.info("Step Desc: %s" % step['step_desc'])
LOGGER.info(
"Expected: %s\n********************\n"
% step['expected'])
if manual_skip_all:
test_case["result"] = "N/A"
else:
while True:
test_result = raw_input(
'[ please input case result ] '
'(p^PASS, f^FAIL, b^BLOCK, n^Next, d^Done):')
if test_result.lower() == 'p':
test_case["result"] = "PASS"
break
elif test_result.lower() == 'f':
test_case["result"] = "FAIL"
break
elif test_result.lower() == 'b':
test_case["result"] = "BLOCK"
break
elif test_result.lower() == 'n':
test_case["result"] = "N/A"
break
elif test_result.lower() == 'd':
manual_skip_all = True
test_case["result"] = "N/A"
break
else:
LOGGER.info(
"[ Warning: you input: '%s' is invalid,"
" please try again ]" % test_result)
except IOError, error:
LOGGER.error(
"[ Error: fail to get core manual test step,"
" error: %s ]\n" % error)
def _web_test_exec(conn, server_url, test_web_app, exetype, cases_queue, result_obj):
"""function for running web tests"""
exetype = exetype.lower()
test_set_finished = False
err_cnt = 0
relaunch_cnt = 0
for test_group in cases_queue:
if test_set_finished:
break
ret = http_request(
get_url(server_url, "/set_testcase"), "POST", test_group, 30)
if ret is None:
LOGGER.error(
"[ set testcases timeout, please check device! ]")
result_obj.set_status(1)
break
if not conn.launch_app(test_web_app):
result_obj.set_status(1)
break
while True:
if result_obj.get_status() == 1:
test_set_finished = True
break
ret = http_request(
get_url(server_url, "/check_server_status"), "GET", {})
if ret is None:
err_cnt += 1
if err_cnt >= CNT_RETRY:
LOGGER.error(
"[ check server status time out, please check deivce! ]")
test_set_finished = True
result_obj.set_status(1)
break
else:
result_cases = ret.get("cases")
error_code = ret.get("error_code")
if error_code is not None:
if not conn.launch_app(test_web_app):
test_set_finished = True
result_obj.set_status(1)
break
if error_code == LAUNCH_ERROR:
relaunch_cnt += 1
if relaunch_cnt >= 3:
test_set_finished = True
result_obj.set_status(1)
break
elif error_code == BLOCK_ERROR:
relaunch_cnt = 0
else:
err_cnt = 0
relaunch_cnt = 0
if result_cases is not None and len(result_cases):
result_obj.extend_result(result_cases)
elif exetype == 'manual':
LOGGER.info(
"[ please execute manual cases ]\r\n")
if ret["finished"] == 1:
test_set_finished = True
result_obj.set_status(1)
break
elif ret["block_finished"] == 1:
break
time.sleep(2)
def _core_test_exec(conn, test_set_name, exetype, cases_queue, result_obj):
"""function for running core tests"""
exetype = exetype.lower()
total_count = len(cases_queue)
current_idx = 0
manual_skip_all = False
result_list = []
for test_case in cases_queue:
if result_obj.get_status() == 1:
break
current_idx += 1
core_cmd = ""
if "entry" in test_case:
core_cmd = test_case["entry"]
else:
LOGGER.info(
"[ Warnning: test script is empty,"
" please check your test xml file ]")
continue
expected_result = test_case.get('expected_result', '0')
time_out = int(test_case.get('timeout', '90'))
measures = test_case.get('measures', [])
retmeasures = []
LOGGER.info("\n[core test] execute case:\nTestCase: %s\n"
"TestEntry: %s\nExpected: %s\nTotal: %s, Current: %s"
% (test_case['case_id'], test_case['entry'],
expected_result, total_count, current_idx))
LOGGER.info("[ execute core test script, please wait ! ]")
strtime = datetime.now().strftime(DATE_FORMAT_STR)
LOGGER.info("start time: %s" % strtime)
test_case["start_at"] = strtime
if exetype == 'auto':
return_code, stdout, stderr = conn.shell_cmd_ext(
core_cmd, time_out, False)
if return_code is not None and return_code != "timeout":
test_case["result"] = "pass" if str(
return_code) == expected_result else "fail"
test_case["stdout"] = stdout
test_case["stderr"] = stderr
for item in measures:
ind = item['name']
fname = item['file']
if fname is None:
continue
tmpname = os.path.expanduser("~") + os.sep + "mea_tmp"
if conn.download_file(fname, tmpname):
try:
config = ConfigParser.ConfigParser()
config.read(tmpname)
item['value'] = config.get(ind, 'value')
retmeasures.append(item)
os.remove(tmpname)
except IOError as error:
LOGGER.error(
"[ Error: fail to parse value,"
" error:%s ]\n" % error)
test_case["measures"] = retmeasures
else:
test_case["result"] = "BLOCK"
test_case["stdout"] = stdout
test_case["stderr"] = stderr
elif exetype == 'manual':
# handle manual core cases
try:
# LOGGER.infopre-condition info
if "pre_condition" in test_case:
LOGGER.info("\n****\nPre-condition: %s\n ****\n"
% test_case['pre_condition'])
# LOGGER.infostep info
if "steps" in test_case:
for step in test_case['steps']:
LOGGER.info(
"********************\n"
"Step Order: %s" % step['order'])
LOGGER.info("Step Desc: %s" % step['step_desc'])
LOGGER.info(
"Expected: %s\n********************\n"
% step['expected'])
if manual_skip_all:
test_case["result"] = "N/A"
else:
while True:
test_result = raw_input(
'[ please input case result ]'
' (p^PASS, f^FAIL, b^BLOCK, n^Next, d^Done):')
if test_result.lower() == 'p':
test_case["result"] = "PASS"
break
elif test_result.lower() == 'f':
test_case["result"] = "FAIL"
break
elif test_result.lower() == 'b':
test_case["result"] = "BLOCK"
break
elif test_result.lower() == 'n':
test_case["result"] = "N/A"
break
elif test_result.lower() == 'd':
manual_skip_all = True
test_case["result"] = "N/A"
break
else:
LOGGER.info(
"[ Warnning: you input: '%s' is invalid,"
" please try again ]" % test_result)
except IOError as error:
LOGGER.info(
"[ Error: fail to get core manual test step,"
" error: %s ]\n" % error)
strtime = datetime.now().strftime(DATE_FORMAT_STR)
LOGGER.info("end time: %s" % strtime)
test_case["end_at"] = strtime
LOGGER.info("Case Result: %s" % test_case["result"])
result_list.append(test_case)
result_obj.extend_result(result_list, False)
result_obj.set_status(1)
def run(self):
"""run core tests"""
if self.cases_queue is None:
return
total_count = len(self.cases_queue)
current_idx = 0
manual_skip_all = False
global TEST_SERVER_STATUS, TEST_SERVER_RESULT
LOCK_OBJ.acquire()
TEST_SERVER_RESULT = {"cases": []}
TEST_SERVER_STATUS = {"finished": 0}
result_list = []
LOCK_OBJ.release()
for test_case in self.cases_queue:
current_idx += 1
expected_result = "0"
core_cmd = ""
time_out = None
measures = []
retmeasures = []
if "entry" in test_case:
core_cmd = "sdb -s %s shell '%s ; echo returncode=$?'" % (self.device_id, test_case["entry"])
else:
LOGGER.info("[ Warnning: test script is empty," " please check your test xml file ]")
continue
if "expected_result" in test_case:
expected_result = test_case["expected_result"]
if "timeout" in test_case:
time_out = int(test_case["timeout"])
if "measures" in test_case:
measures = test_case["measures"]
LOGGER.info(
"\n[case] execute case:\nTestCase: %s\nTestEntry: %s\n"
"Expected Result: %s\nTotal: %s, Current: %s"
% (test_case["case_id"], test_case["entry"], expected_result, total_count, current_idx)
)
LOGGER.info("[ execute test script," "this might take some time, please wait ]")
strtime = datetime.now().strftime(DATE_FORMAT_STR)
LOGGER.info("start time: %s" % strtime)
test_case["start_at"] = strtime
if self.exetype == "auto":
return_code, stdout, stderr = shell_command_ext(core_cmd, time_out, False)
if return_code is not None:
actual_result = str(return_code)
if actual_result == "timeout":
test_case["result"] = "BLOCK"
test_case["stdout"] = "none"
test_case["stderr"] = "none"
else:
if actual_result == expected_result:
test_case["result"] = "pass"
else:
test_case["result"] = "fail"
test_case["stdout"] = stdout
test_case["stderr"] = stderr
for item in measures:
ind = item["name"]
fname = item["file"]
if fname is None:
continue
tmpname = os.path.expanduser("~") + os.sep + "measure_tmp"
if _download_file(self.device_id, fname, tmpname):
try:
config = ConfigParser.ConfigParser()
config.read(tmpname)
item["value"] = config.get(ind, "value")
retmeasures.append(item)
os.remove(tmpname)
except IOError, error:
LOGGER.error("[ Error: fail to parse value," " error:%s ]\n" % error)
test_case["measures"] = retmeasures
else:
test_case["result"] = "BLOCK"
test_case["stdout"] = "none"
test_case["stderr"] = "none"
elif self.exetype == "manual":
# handle manual core cases
try:
# LOGGER.infopre-condition info
if "pre_condition" in test_case:
LOGGER.info("\n****\nPre-condition: %s\n ****\n" % test_case["pre_condition"])
# LOGGER.infostep info
if "steps" in test_case:
for step in test_case["steps"]:
LOGGER.info("********************\n" "Step Order: %s" % step["order"])
LOGGER.info("Step Desc: %s" % step["step_desc"])
LOGGER.info("Expected: %s\n********************\n" % step["expected"])
if manual_skip_all:
test_case["result"] = "N/A"
else:
while True:
test_result = raw_input(
"[ please input case result ]" " (p^PASS, f^FAIL, b^BLOCK, n^Next, d^Done):"
)
if test_result.lower() == "p":
test_case["result"] = "PASS"
break
elif test_result.lower() == "f":
test_case["result"] = "FAIL"
break
elif test_result.lower() == "b":
test_case["result"] = "BLOCK"
break
elif test_result.lower() == "n":
test_case["result"] = "N/A"
break
elif test_result.lower() == "d":
manual_skip_all = True
test_case["result"] = "N/A"
break
else:
LOGGER.info(
"[ Warnning: you input: '%s' is invalid," " please try again ]" % test_result
)
except IOError, error:
LOGGER.info("[ Error: fail to get core manual test step," " error: %s ]\n" % error)
def merge_resultfile(self, start_time, latest_dir):
""" merge_result_file """
mergefile = mktemp(suffix='.xml', prefix='tests.', dir=latest_dir)
mergefile = os.path.splitext(mergefile)[0]
mergefile = os.path.splitext(mergefile)[0]
mergefile = "%s.result" % BASENAME(mergefile)
mergefile = "%s.xml" % mergefile
mergefile = JOIN(latest_dir, mergefile)
end_time = datetime.today().strftime("%Y-%m-%d_%H_%M_%S")
LOGGER.info("\n[ test complete at time: %s ]" % end_time)
LOGGER.debug("[ start merging test result xml files, "\
"this might take some time, please wait ]")
LOGGER.debug("[ merge result files into %s ]" % mergefile)
root = etree.Element('test_definition')
root.tail = "\n"
totals = set()
# merge result files
resultfiles = self.resultfiles
totals = self.__merge_result(resultfiles, totals)
for total in totals:
result_xml = etree.parse(total)
for suite in result_xml.getiterator('suite'):
if suite.getiterator('testcase'):
suite.tail = "\n"
root.append(suite)
# print test summary
self.__print_summary()
# generate actual xml file
LOGGER.info("[ generate result xml: %s ]" % mergefile)
if self.skip_all_manual:
LOGGER.info("[ some results of core manual cases are N/A,"
"please refer to the above result file ]")
LOGGER.info("[ merge complete, write to the result file,"
" this might take some time, please wait ]")
# get useful info for xml
# add environment node
# add summary node
root.insert(0, get_summary(start_time, end_time))
root.insert(0, self.__get_environment())
# add XSL support to testkit-lite
declaration_text = """<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="testresult.xsl"?>\n"""
try:
with open(mergefile, 'w') as output:
output.write(declaration_text)
tree = etree.ElementTree(element=root)
tree.write(output, xml_declaration=False, encoding='utf-8')
except IOError as error:
LOGGER.error(
"[ Error: merge result file failed, error: %s ]" % error)
# change <![CDATA[]]> to <![CDATA[]]>
replace_cdata(mergefile)
# copy result to -o option
try:
if self.resultfile:
if os.path.splitext(self.resultfile)[-1] == '.xml':
if not os.path.exists(os.path.dirname(self.resultfile)):
if len(os.path.dirname(self.resultfile)) > 0:
os.makedirs(os.path.dirname(self.resultfile))
LOGGER.info("[ copy result xml to output file:"
" %s ]" % self.resultfile)
copyfile(mergefile, self.resultfile)
else:
LOGGER.info(
"[ Please specify and xml file for result output,"
" not:%s ]" % self.resultfile)
except IOError as error:
LOGGER.error("[ Error: fail to copy the result file to: %s,"
" please check if you have created its parent directory,"
" error: %s ]" % (self.resultfile, error))
def __prepare_external_test_json(self, resultfile):
"""Run external test"""
parameters = {}
xml_set_tmp = resultfile
# split set_xml by <case> get case parameters
LOGGER.debug("[ split xml: %s by <case> ]" % xml_set_tmp)
LOGGER.debug("[ this might take some time, please wait ]")
try:
parse_tree = etree.parse(xml_set_tmp)
root_em = parse_tree.getroot()
case_tmp = []
for tset in root_em.getiterator('set'):
case_order = 1
parameters.setdefault(
"casecount", str(len(tset.getiterator('testcase')))
)
parameters.setdefault("current_set_name", xml_set_tmp)
for tcase in tset.getiterator('testcase'):
case_detail_tmp = {}
step_tmp = []
parameters.setdefault(
"exetype", tcase.get('execution_type')
)
parameters.setdefault("type", tcase.get('type'))
case_detail_tmp.setdefault("case_id", tcase.get('id'))
case_detail_tmp.setdefault("purpose", tcase.get('purpose'))
case_detail_tmp.setdefault("order", str(case_order))
case_detail_tmp.setdefault("onload_delay", "3")
if tcase.find('description/test_script_entry') is not None:
tc_entry = tcase.find(
'description/test_script_entry').text
if not tc_entry:
tc_entry = ""
case_detail_tmp["entry"] = self.test_prefix + tc_entry
if tcase.find(
'description/test_script_entry').get('timeout'):
case_detail_tmp["timeout"] = tcase.find(
'description/test_script_entry'
).get('timeout')
if tcase.find(
'description/test_script_entry'
).get('test_script_expected_result'):
case_detail_tmp["expected_result"] = tcase.find(
'description/test_script_entry'
).get('test_script_expected_result')
for this_step in tcase.getiterator("step"):
step_detail_tmp = {}
step_detail_tmp.setdefault("order", "1")
step_detail_tmp["order"] = str(this_step.get('order'))
if this_step.find("step_desc") is not None:
text = this_step.find("step_desc").text
if text is not None:
step_detail_tmp["step_desc"] = text
if this_step.find("expected") is not None:
text = this_step.find("expected").text
if text is not None:
step_detail_tmp["expected"] = text
step_tmp.append(step_detail_tmp)
case_detail_tmp['steps'] = step_tmp
if tcase.find('description/pre_condition') is not None:
text = tcase.find('description/pre_condition').text
if text is not None:
case_detail_tmp["pre_condition"] = text
if tcase.find('description/post_condition') is not None:
text = tcase.find('description/post_condition').text
if text is not None:
case_detail_tmp['post_condition'] = text
if tcase.get('onload_delay') is not None:
case_detail_tmp[
'onload_delay'] = tcase.get('onload_delay')
# Check performance test
if tcase.find('measurement') is not None:
measures = tcase.getiterator('measurement')
measures_array = []
for measure in measures:
measure_json = {}
measure_json['name'] = measure.get('name')
measure_json['file'] = measure.get('file')
measures_array.append(measure_json)
case_detail_tmp['measures'] = measures_array
case_tmp.append(case_detail_tmp)
case_order += 1
parameters.setdefault("cases", case_tmp)
if self.bdryrun:
parameters.setdefault("dryrun", True)
self.set_parameters = parameters
except IOError as error:
LOGGER.error("[ Error: fail to prepare cases parameters, "
"error: %s ]\n" % error)
return False
return True
