def __init__(self, junit_file=None):
""" Constructor """
self.junit_file = junit_file
self.html_template = "{0}{1}Reporting{1}html_results_template.html"\
.format(Tools.__path__[0], os.sep)
self.junit_root = xml_Utils.getRoot(self.junit_file)
self.html_root = xml_Utils.getRoot(self.html_template)
self.table = getElementWithTagAttribValueMatch(self.html_root, "table",
"name",
"ResultsSummaryTable")
self.html_results_path = self._get_html_resultspath()
self.html_results_dir = os.path.dirname(self.html_results_path)
def generate_html(self, junitObj, givenPath, is_final):
""" build the html givenPath: added this feature in case of later down the line calling from outside junit
file ( no actual use as of now )
"""
if junitObj:
self.junit_file = junitObj
self.junit_root = xml_Utils.getRoot(self.junit_file)
if givenPath:
self.givenPath = givenPath
self.set_line_objs()
html = ''
for item in self.lineObjs:
html += item.html
html = self.merge_html(html)
if is_final is True:
html += '<div class="complete"></div>'
elem_file = open(self.get_path(), 'w')
elem_file.write(html)
elem_file.close()
katana = katana_interface_class.KatanaInterface()
katana.send_file(self.get_path(), '/execution/updateHtmlResult')
if is_final is True:
katana.end_comunication()
self.lineObjs = []
print_info("++++ Results Summary ++++")
print_info("Open the Results summary file given below in a browser to "
"view results summary for this execution")
print_info("Results sumary file: {0}".format(self.get_path()))
print_info("+++++++++++++++++++++++++")
def generate_html(self, junitObj, givenPath):
""" build the html givenPath: added this feature in case of later down the line calling from outside junit
file ( no actual use as of now )
"""
if junitObj:
self.junit_file = junitObj
self.junit_root = xml_Utils.getRoot(self.junit_file)
if givenPath:
self.givenPath = givenPath
self.set_line_objs()
html = ''
for item in self.lineObjs:
html += item.html
html = self.merge_html(html)
elem_file = open(self.get_path(), 'w')
elem_file.write(html)
elem_file.close()
self.lineObjs = []
print_info("++++ Results Summary ++++")
print_info("Open the Results summary file given below in a browser to "
"view results summary for this execution")
print_info("Results sumary file: {0}".format(self.get_path()))
print_info("+++++++++++++++++++++++++")
def split_kwargs_on_tag_equalto(kwargs, datafile, browser):
"""
This function splits kwargs on tag=
If the value is an xpath, then it follows the xpath and returns the value
Else, if is it a singular tag name, then it searched for a tag with that
name under the current <browser>
"""
idf_data_dict = {}
final_dict = {}
for element in kwargs:
if isinstance(kwargs[element],str) and kwargs[element] is not None and\
kwargs[element] is not False:
if kwargs[element].startswith("tag") and "=" in kwargs[element]:
temp_list = kwargs[element].split("=")
temp_var = temp_list[1]
for i in range(2, len(temp_list)):
temp_var = temp_var + "=" + temp_list[i]
temp_var = temp_var.strip()
if "/" in temp_var:
root = xml_Utils.getRoot(datafile)
idf_data_dict[element] = root.find(temp_var).text
else:
if browser.get(temp_var, None) is None:
if browser.find(temp_var) is not None:
idf_data_dict[element] = browser.find(
temp_var).text
else:
idf_data_dict[element] = browser.get(temp_var, None)
else:
final_dict[element] = kwargs[element]
else:
final_dict[element] = kwargs[element]
return final_dict, idf_data_dict
def get_response_file(testdatafile):
"""
Build the response dict with response tag name and response text
"""
from Framework.Utils.xml_Utils import getRoot, getElementListWithSpecificXpath
tmp_list = getElementListWithSpecificXpath(testdatafile, "./global/response_file")
response_file = tmp_list[0].text if tmp_list != [] else ""
response_dict = {}
cmd_specific_response_dict = {}
if response_file != "":
root = getRoot(response_file)
# Parse global responses
responses = root.find("responses")
if responses is not None:
for resp in responses:
resp_name = resp.tag
resp_text = resp.get("text", "")
if resp_name in response_dict:
pNote("A response with tag name {} has been created before with value: {}"
"Please rename with a different tag name".\
format(resp_name, response_dict[resp_name]))
else:
response_dict[resp_name] = resp_text
else:
pNote("Unable to find responses, please put all responses inside a responses tag",
"ERROR")
# Parse cmd specific responses
cmd_specific_response_dict = get_cmd_specific_response_file(root)
else:
pNote("Unable to retrieve response file from testdata file, please put the path in"
" response_file tag inside global section of the testdata file", "ERROR")
MockUtils.cli_Utils.response_dict = response_dict
MockUtils.cli_Utils.cmd_specific_response_dict = cmd_specific_response_dict
def add_html_result_to_mongodb(self, input_xml):
""" To add case/suite/project results as a document to MongoDB
database collections, here collection names are case/suite/project """
root = xml_Utils.getRoot(input_xml)
file_type = self.get_file_type(root)
results_dict = self.get_html_results(file_type, root)
coll_dict = {
'case': 'case_html_results',
'suite': 'suite_html_results',
'project': 'project_html_results'
}
collection = self.db[coll_dict.get(file_type)]
# create a new document with _id as case/suite/project name
if collection.find({'_id': results_dict['name']}).count() == 0:
collection.insert({'_id': results_dict['name']})
collection.update({'_id': results_dict['name']},
{'$push': {
'results': results_dict
}})
print_info("Successfully added html results in MongoDB database")
def iron_claw_warrior_xml_files(filepath):
"""Validate Warrior xml files (Testcase/Testsuite/Project) against
their xsd schema files """
try:
root = xml_Utils.getRoot(filepath)
except ElementTree.ParseError, err:
print_error("PARSING ERROR:{0}".format(err))
return False
def iron_claw_warrior_xml_files(filepath):
"""Validate Warrior xml files (Testcase/Testsuite/Project) against
their xsd schema files """
try:
root = xml_Utils.getRoot(filepath)
except ElementTree.ParseError as err:
print_error("PARSING ERROR:{0}".format(err))
return False
ironclaw_object = IronClaw()
if root.tag == 'Testcase':
result = ironclaw_object.testcase_prerun(filepath)
if root.tag == 'TestSuite':
result = ironclaw_object.testsuite_prerun(filepath, root)
if root.tag == 'Project':
result = ironclaw_object.project_prerun(filepath, root)
return result
def project_prerun(self, project_filepath, root):
"""Executes prerun of a project file """
print('\n')
print_info('+' * 40)
print_debug("Validating Project xml")
print_info('+' * 40)
project_xsd_fullpath = self.xsd_dir + os.sep + 'warrior_project.xsd'
project_status = self.xml_to_xsd_validation(project_filepath,
project_xsd_fullpath)
if project_status:
check_files_dict = self.check_proj_results_logsdir(
project_filepath)
for testsuite in root.iter('Testsuite'):
testsuite_path_rel = testsuite_utils.get_path_from_xmlfile(
testsuite)
testsuite_path = file_Utils.getAbsPath(
testsuite_path_rel, os.path.dirname(project_filepath))
if os.path.isfile(testsuite_path):
print('\n')
print_info("Testsuite_path: {0}, Testsuite"\
"file exists...".format(testsuite_path))
ts_root = xml_Utils.getRoot(testsuite_path)
tsuite_status = self.testsuite_prerun(
testsuite_path, ts_root, check_files_dict)
else:
print('\n')
tsuite_status = False
print_error('testsuite_path: {0},\
Testsuite file does not exist'.format(
testsuite_path))
print_info('SUITE STATUS: {0}'.format('FAILED'))
project_status &= tsuite_status
else:
print_error("Incorrect xml format")
time.sleep(5)
print('\n')
status = testcase_Utils.convertLogic(project_status)
print_info('PROJECT STATUS: {0}ED'.format(status))
return project_status
def smart_analyze(prompt, testdatafile=None):
"""
retrieve the correspond smart testdata file for smart cmd
from either Tools/connection or testcase testdata file
:param prompt:
The string that will be analyzed in order to find the device system
:param testdatafile:
optional arg to provide a pre-defined device system in the test datafile
:return:
the smart datafile that contains the smart cmd to be sent
"""
system_name = None
if testdatafile is not None:
# when the testdatafile is a dictionary - this happens only when
# the testdatafile is taken from database server
if isinstance(testdatafile, dict):
db_td_obj = database_utils_class.\
create_database_connection('dataservers', testdatafile.get('td_system'))
root = db_td_obj.get_tdblock_as_xmlobj(testdatafile)
db_td_obj.close_connection()
else:
root = xml_Utils.getRoot(testdatafile)
system_name = data_Utils._get_global_var(root, "system_name")
con_settings_dir = Tools.__path__[0] + os.sep + 'connection' + os.sep
con_settings = con_settings_dir + "connect_settings.xml"
if system_name is not None:
sys_elem = xml_Utils.getElementWithTagAttribValueMatch(
con_settings, "system", "name", system_name.text)
if sys_elem is None or sys_elem.find("testdata") is None:
return None
else:
system_list = xml_Utils.getElementListWithSpecificXpath(
con_settings, "system[search_string]")
for sys_elem in system_list:
if sys_elem.find("search_string").text in prompt and sys_elem.find(
"testdata") is not None:
return con_settings_dir + sys_elem.find("testdata").text
return None
return con_settings_dir + sys_elem.find("testdata").text
def add_xml_result_to_mongodb(self, input_xml):
""" To add case xml results as a document to the MongoDB database
collection - 'case' """
root = xml_Utils.getRoot(input_xml)
collection = self.db['case_xml_results']
results_dict = self.get_details_from_case_xml_element(root)
case_name = os.path.basename(os.path.splitext(input_xml)[0])
# create a new document with _id as case_xml_results
if collection.find({'_id': case_name}).count() == 0:
collection.insert({'_id': case_name})
collection.update({'_id': case_name},
{'$push': {
'results': results_dict
}})
print_info("Successfully added case xml results in MongoDB database")
def get_robot_xml_files(input_list):
"""
Find robot xml files from the list of files.
:Arguments:
1. input_list(list) - list of file names
:Return:
1. output_list(list) - list of robot xml files
"""
output_list = []
if input_list:
for filename in input_list:
try:
root = xml_Utils.getRoot(filename)
if root.tag == 'robot':
output_list.append(filename)
except Exception:
print_warning("{} is not a valid xml file".format(filename))
return output_list
def write_live_results(self, junitObj, givenPath, is_final):
""" build the html givenPath: added this feature in case of later down the line calling from outside junit
file ( no actual use as of now )
"""
if junitObj:
self.junit_file = junitObj
self.junit_root = xml_Utils.getRoot(self.junit_file)
if givenPath:
self.givenPath = givenPath
self.set_line_objs()
html = ''
for item in self.lineObjs:
html += item.html
if is_final is True:
#html += '<div class="complete"></div>'
pass
live_html_dict = data_Utils.get_object_from_datarepository(
'live_html_dict', verbose=False)
if live_html_dict:
livehtmllocn = live_html_dict['livehtmllocn']
live_html_iter = live_html_dict['iter']
self.create_live_table(html, livehtmllocn, live_html_iter)
html = self.merge_html(html)
elem_file = open(self.get_path(), 'w')
elem_file.write(html)
elem_file.close()
self.lineObjs = []
if is_final is True:
print_info("++++ Results Summary ++++")
print_info(
"Open the Results summary file given below in a browser to "
"view results summary for this execution")
print_info("Results sumary file: {0}".format(self.get_path()))
print_info("+++++++++++++++++++++++++")
def create_failing_kw_json(self):
"""Create a json file each failing keyword """
status = False
result_filename = file_Utils.getNameOnly(os.path.basename(
self.xmlfile))
tc_name = result_filename.split("_results")[0]
#tc_name = file_Utils.getNameOnly(os.path.basename(self.xmlfile))
#tree = xml_Utils.get_tree_from_file(self.xmlfile)
tree = xml_Utils.getRoot(self.xmlfile)
data_filepath = tree.find("Datafile").text
failed = 0
#get_tc_details_frm_resultxml
keyword_list = tree.findall("Keyword")
if len(keyword_list) == 0:
print_error(
'No Keywords found in resultfile of testcase {0}'.format(
tc_name))
status = False
else:
for keyword in tree.findall("Keyword"):
fail_list = []
if keyword.find("KeywordStatus").text.upper() in [
'FAIL', 'EXCEPTION', 'ERROR'
]:
step_num = keyword.find("Step").get('step_num')
kw_resultfile = keyword.find("Resultfile").text
kw_resultfile_nameonly = file_Utils.getNameOnly(
os.path.basename(kw_resultfile))
failed += 1
#addd testcase details to json of failed keyowrds
fail_list.append({'tc_name': tc_name})
fail_list.append({'step_num': str(step_num)})
fail_list.append(
{'testcase_filepath': str(self.testcase_filepath)})
fail_list.append({'data_filepath': str(data_filepath)})
fail_list.append({'defectsdir': str(self.defectsdir)})
fail_list.append({'logsdir': str(self.logsdir)})
fail_list.append({'resultfile': str(self.resultfile)})
for node in keyword.iter():
text = self._get_text_forjson(node)
if text:
fail_list.append({node.tag: text})
else:
continue
if len(fail_list) > 0:
json_file_name = "{0}{1}{2}_{3}.json".format(
self.defectsdir, os.sep, tc_name,
kw_resultfile_nameonly)
# json_file_name = self.defectsdir + os.sep + tc_name +\
# '_step-'+str(step_num)+'_' + keyword.text +'.json'
j_file = open(json_file_name, 'w')
j_file.write(json.dumps(fail_list, indent=4))
j_file.close()
status = True
if failed == 0:
print_warning(
"There are no failed keywords in the testcase result xml file"
)
status = False
return status
def __init__(self, junit_file=None):
""" init function"""
self.junit_file = junit_file
self.html_template = "{0}{1}reporting{1}html_results_template.html" \
.format(Tools.__path__[0], os.sep)
self.junit_root = xml_Utils.getRoot(self.junit_file)
