def get_setup_on_error(self, filepath):
"""Gets the setup on error value
from the wrapperfile.xml file """
setup_on_error_action = self.xml_utils().getChildAttributebyParentTag(filepath, 'Details',\
'setup_onError', 'action')
if setup_on_error_action is None or setup_on_error_action is False:
setup_on_error_action = 'abort'
elif setup_on_error_action is not None and setup_on_error_action is not False:
supported_values = ['next', 'abort']
if not str(setup_on_error_action).lower() in supported_values:
print_warning("unsupported option '{0}' provided for setup_onError"\
"action, supported values are {1}".format(setup_on_error_action,
supported_values))
print_info(
"Hence using default value for setup_onError action which is 'abort'"
)
setup_on_error_action = 'abort'
return setup_on_error_action
def get_defonerror_fromxml_file(self, filepath):
"""Gets the default on error value of a step/testcase/suite
from the testcase.xml/testsuite.xml/project.xml file """
def_on_error_action = self.xml_utils().getChildAttributebyParentTag(
filepath, 'Details', 'default_onError', 'action')
if def_on_error_action is None or def_on_error_action is False:
def_on_error_action = 'NEXT'
elif def_on_error_action is not None and def_on_error_action is not False:
supported_values = ['next', 'goto', 'abort', 'abort_as_error']
if not str(def_on_error_action).lower() in supported_values:
print_warning("unsupported option '{0}' provided for default_onError"\
"action, supported values are {1}".format(def_on_error_action,
supported_values))
print_info(
"Hence using default value for default_onError action which is 'next'"
)
def_on_error_action = 'NEXT'
return def_on_error_action
def execute_custom(datatype, runtype, driver, data_repository, step_list):
"""
Execute a custom testcase
"""
print_info("{0} {1}".format(datatype, runtype))
tc_status = False
if data_repository.has_key("suite_exectype") and\
data_repository["suite_exectype"].upper() == "ITERATIVE":
print_info(
"Testsuite execute type=iterative but the testcase datatype=custom. "
"All testcases in a iterative testsuite should have datatype=iterative, "
"Hence this testcase will be marked as failure.")
elif runtype.upper() == 'SEQUENTIAL_KEYWORDS' or runtype.upper(
) == 'PARALLEL_KEYWORDS':
tc_status = driver.main(step_list,
data_repository,
tc_status,
system_name=None)
else:
print_error("Unsuppored runtype found, please check testcase file")
return tc_status
def sub_from_varconfigfile(string, varconfigfile, start_pat="${", end_pat="}"):
""" """
try:
# when varconfigfile is an XMl object(root element) - this happens
# only when varconfigfile is taken from database server
if isinstance(varconfigfile, ElementTree.Element) is True:
cfg_elem_obj = ConfigurationElement("Varconfig_from_database",
start_pat, end_pat)
cfg_elem_obj.parse_data(varconfigfile, elem_type="xml_object")
else:
cfg_elem_obj = ConfigurationElement(varconfigfile, start_pat,
end_pat)
cfg_elem_obj.parse_data(varconfigfile)
newstring = cfg_elem_obj.expand_variables(string)
except TypeError as exception:
print_info(
"At least one of the variables in command string is not found in "
+ varconfigfile)
#print_exception(exception)
return False
return newstring
def store_in_repo(self, datavar, datavalue, type='str'):
"""For storing datavalue in datavar datarepository
:Argument:
datavar = var in data repository in which to store
this could be dot separated to store in nested fashion
i.e., if var is k1.k2.k3 then the data value would be
stored as a value in datarepository[k1][k2][k3]
datavalue = the value to be stored
type = type of datavalue (string/int/float)
"""
def get_dict_to_update(var, val):
"""
The function creates a dictionary with Variable and value. If Variable has "." seperated
keys then the value is updated at appropriate level of the nested dictionary.
:param var: Dictionary Key or Key seperated with "." for nested dict keys.
:param val: Value for the Key.
:return: Dictionary
"""
dic = {}
if '.' in var:
[key, value] = var.split('.', 1)
dic[key] = get_dict_to_update(value, val)
else:
dic[var] = val
return dic
if type == 'int':
value = int(datavalue)
elif type == 'float':
value = float(datavalue)
else:
value = datavalue
dict_to_update = get_dict_to_update(datavar, value)
update_datarepository(dict_to_update)
print_info("Value: {0} is stored in a Key:{1} of Warrior "
"data_repository ".format(datavalue, datavar))
return True
def testcase_prerun(self, tc_filepath, check_files_dict=None):
"""Executes prerun of a testcase file """
print('\n')
print_info('=' * 40)
print_debug("Validating Test case xml")
print_info('=' * 40)
testcase_xsd_fullpath = self.xsd_dir + os.sep + 'warrior_testcase.xsd'
#print_info("Test case_xsd_location: {0}".format(testcase_xsd_fullpath))
tc_status = self.xml_to_xsd_validation(tc_filepath,
testcase_xsd_fullpath)
if tc_status:
data_file_valid = self.check_tc_input_datafile(
tc_filepath, check_files_dict)
tc_status &= data_file_valid
steps_field_valid = self.check_steps(tc_filepath)
tc_status &= steps_field_valid
else:
print_error("Incorrect xml format")
time.sleep(5)
status = testcase_Utils.convertLogic(tc_status)
print_info('TC STATUS: {0}ED'.format(status))
return tc_status
def print_suite_details_to_console(suite_repository, testsuite_filepath,
junit_resultfile):
"""Prints the testsuite details to console """
print_info("\n\n$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ TESTSUITE-DETAILS "
"$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n")
print_info("Executing testsuite '{0}'".format(
suite_repository['suite_name'].strip()))
print_info("Title: {0}".format(suite_repository['suite_title'].strip()))
print_info("Results directory: %s" %
suite_repository['suite_execution_dir'])
report_suite_requirements(suite_repository, testsuite_filepath)
time.sleep(3)
def decide_overwrite_var(namespace):
"""options provided in cli get preference over the ones provided inside tests
"""
overwrite = {}
if namespace.datafile:
if namespace.datafile[0] != os.sep:
namespace.datafile = os.getcwd() + os.sep + namespace.datafile
overwrite['ow_datafile'] = namespace.datafile
#namespace for wrapperfile
if namespace.wrapperfile:
if namespace.wrapperfile[0] != os.sep:
namespace.wrapperfile = os.getcwd() + os.sep + namespace.wrapperfile
overwrite['ow_testwrapperfile'] = namespace.wrapperfile
if namespace.resultdir:
if namespace.resultdir[0] != os.sep:
namespace.resultdir = os.getcwd() + os.sep + namespace.resultdir
overwrite['ow_resultdir'] = namespace.resultdir
if namespace.logdir:
if namespace.logdir[0] != os.sep:
namespace.logdir = os.getcwd() + os.sep + namespace.logdir
overwrite['ow_logdir'] = namespace.logdir
if namespace.outputdir:
if namespace.outputdir[0] != os.sep:
namespace.outputdir = os.getcwd() + os.sep + namespace.outputdir
overwrite['ow_resultdir'] = namespace.outputdir
overwrite['ow_logdir'] = namespace.outputdir
if all([namespace.outputdir, any([namespace.resultdir, namespace.logdir])]):
print_error("outputdir shouldn't be used with resultdir or logdir")
exit(1)
if namespace.jobid:
settings_xml = Tools.__path__[0] + os.sep + 'w_settings.xml'
job_url = get_credentials(settings_xml, 'job_url', ['url'], 'Setting')
if job_url['url'] is not None:
url = job_url['url']
else:
print_info("jobid is specified but no job url found in w_settings")
print_info("Using jobid only in JUnit file")
url = ""
overwrite['jobid'] = url + str(namespace.jobid)
return overwrite
def __check_dir_exists(cls, filepath, dirtag):
""" Verify that the directory exists in the path provided.
Arguments:
1. filepath: file path will be parsed as input for checking
directories
2. dirtag: directory tag that used to get directory path
"""
dirt = xml_Utils.getChildTextbyParentTag(filepath, 'Details', dirtag)
directory = file_Utils.getAbsPath(dirt, os.path.dirname(filepath))
if directory is not False and directory is not None:
print_info("{0} path {1}".format(dirtag, directory))
if not os.path.exists(directory):
print_warning("Directory does not exist in location {0}."\
"\nWarrior framework will try to create the directory, if creation "\
"fails then default warriorspace will be used to collect logs/results"\
.format(directory))
else:
if dirtag is 'Resultsdir':
print_info(
"Default directory in Warriorspace will be used to collect results"
)
else:
print_info(
"Default directory in Warriorspace will be used to collect logs"
)
def update_jira_by_id(jiraproj, jiraid, exec_dir, status):
""" If jiraid is provided, upload the log and result file to jira """
if jiraid is not False:
jira_obj = Jira(jiraproj)
if jira_obj.status is True:
# Get the current jira issue status
issue_status = jira_obj.get_jira_issue_status(jiraid)
isReopend = False
# Reopen the jira issue if it is closed, to upload the execution logs
if issue_status and issue_status.lower() == "closed":
print_info("Reopening Jira issue '{0}' to upload warrior "
"execution logs".format(jiraid))
jira_obj.set_jira_issue_status(jiraid, "Reopened")
isReopend = True
# Upload execution logs
zip_file = shutil.make_archive(exec_dir, 'zip', exec_dir)
jira_obj.upload_logfile_to_jira_issue(jiraid, zip_file)
# Close the jira issue if it is reopened in the above if block
if isReopend is True:
print_info("Closing Jira issue '{0}' which was reopened "
"earlier".format(jiraid))
jira_obj.set_jira_issue_status(jiraid, "Closed")
# Update Jira issue based on warrior execution status
jira_obj.update_jira_issue(jiraid, status)
else:
print_info("jiraid not provided, will not update jira issue")
def create_defects(auto_defects, data_repository):
"""Creates the defects json files for the testcase executed
If auto_defects = True create bugs in jira for the associated project provided in jira
config file
"""
defect_obj = DefectsDriver(data_repository)
json_status = defect_obj.create_failing_kw_json()
if json_status:
if auto_defects:
print_info("auto-create defects ")
defects_json_list = defect_obj.get_defect_json_list()
if len(defects_json_list) == 0:
print_warning(
"No defect json files found in defects directory '{0}' of this "
"testcase".format(data_repository['wt_defectsdir']))
elif len(defects_json_list) > 0:
connect = defect_obj.connect_warrior_jira()
if connect is True:
defect_obj.create_jira_issues(defects_json_list)
else:
print_info("auto-create defects was Not requested")
def _check_property(self, element, **kwargs):
status = True
if element is not None:
attribute_name = kwargs.get('attribute_name')
property_name = kwargs.get('property_name')
attr_properties = element.get_attribute(attribute_name)
if attr_properties is not None:
if property_name in attr_properties:
print_info("{0} has a property called {1}. Verification "
"success!".format(attribute_name, property_name))
else:
print_error("{0} does not have a property called {1}. "
"Verification failed!".format(attribute_name,
property_name))
status = False
else:
print_error("Could not find attribute '{0}', hence could not "
"retrieve its properties.".format(attribute_name))
status = False
else:
status = False
return status
def suite_summary(self, junit_file):
""" To get the name, status and location of both test suite and test case"""
tree = xml_Utils.get_tree_from_file(self.junit_file)
file_type = self.get_file_type(junit_file)
for values in tree.iter('testsuite'):
suite_detail = values.attrib
suite_name = suite_detail.get('name')
suite_status = suite_detail.get('status')
suite_location = suite_detail.get('suite_location')
if suite_location != None:
print_info("{0:10}{1:50}{2:10}{3:30}".format(
"Suites", suite_name, suite_status, suite_location))
for value in tree.iter('testcase'):
testcase_details = value.attrib
testcase_status = testcase_details.get('status')
suite_name_from_tc = testcase_details.get('classname')
testcase_location = testcase_details.get('testcasefile_path')
testcase_name = testcase_details.get('name') + ".xml"
if suite_name == suite_name_from_tc:
print_info("{0:10}{1:50}{2:10}{3:30}".format(
"Testcase", testcase_name, testcase_status,
testcase_location))
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 getErrorHandlingParameters(node, def_on_error_action, def_on_error_value,
exec_type):
"""Takes a xml element at input and returns the values for on_error action , value
If no value is available in the node then returns the default values """
if exec_type:
exec_node = node.find('Execute')
def_on_error_action = 'NEXT'
def_on_error_value = ''
ex_rule_param = exec_node.find('Rule').attrib
action = ex_rule_param['Else']
if ex_rule_param['Else'].upper() == 'GOTO':
value = ex_rule_param['Elsevalue']
else:
value = ''
else:
action = Utils.xml_Utils.get_attributevalue_from_directchildnode(
node, 'onError', 'action')
value = Utils.xml_Utils.get_attributevalue_from_directchildnode(
node, 'onError', 'value')
if action is None or action is False:
action = def_on_error_action
elif action is not None and action is not False:
supported_values = ['next', 'goto', 'abort', 'abort_as_error']
action = str(action).strip()
if not action.lower() in supported_values:
print_warning(
"unsupported option '{0}' provided for onError action, supported values are {1}"
.format(action, supported_values))
print_info("Hence using default_onError action")
action = def_on_error_action
if value is None or value is False:
value = def_on_error_value
return action, value
def subscribe_to_topics(self, topics, **kwargs):
"""
Subscribe to list of specified topics.
Arguments:
topics(list): list of topic names to subscribe
pattern(list): list of topic name patterns to subscribe
listener(func): callback function
Returns:
result(bool) : False if exception occures, True otherwise
"""
pattern = kwargs.get("pattern", None)
listener = kwargs.get("listener", None)
print_info("subscribe to topics {}".format(topics))
try:
self.kafka_consumer.subscribe(topics=topics,
pattern=pattern,
listener=listener)
result = True
except KafkaError as exc:
print_error("Exception during subscribing to topics - {}".format(exc))
result = False
return result
def open_browser(self, browser_name='firefox', webdriver_remote_url=False,
desired_capabilities=None, binary=None, gecko_path=None,
**kwargs):
"""Open a browser session"""
profile_dir = kwargs.get('profile_dir', None)
if webdriver_remote_url:
print_debug("Opening browser '{0}' through remote server at '{1}'"\
.format(browser_name, webdriver_remote_url))
else:
print_debug("Opening browser '%s'" % (browser_name))
browser_name = browser_name
browser = self._make_browser(browser_name, desired_capabilities,
profile_dir, webdriver_remote_url,
binary=binary, gecko_path=gecko_path)
print_info("The Selenium Webdriver version is '{0}'".format(webdriver.__version__))
if browser:
browser_detail_dict = self.get_browser_details(browser)
for details, value in browser_detail_dict.items():
print_info("The Browser '{0}' {1} is '{2}'".format(browser_name, details, value))
return browser
def get_testsuite_list(project_filepath):
"""Takes the location of any Project.xml file as input
Returns a list of all the Testsuite elements present in the Project"""
testsuite_list_new = []
root = Utils.xml_Utils.getRoot(project_filepath)
testsuites = root.find('Testsuites')
if testsuites is None:
print_info('Testsuite is empty: tag <Testsuites> not "\
"found in the input file ')
else:
testsuite_list = testsuites.findall('Testsuite')
for ts in testsuite_list:
runmode, value = common_execution_utils.\
get_runmode_from_xmlfile(ts)
retry_type, _, _, retry_value, _ = common_execution_utils.\
get_retry_from_xmlfile(ts)
if runmode is not None and value > 0:
# more than one suite in suite list, insert new suite
go_next = len(testsuite_list_new) + value + 1
for i in range(0, value):
copy_ts = copy.deepcopy(ts)
copy_ts.find("runmode").set("value", go_next)
copy_ts.find("runmode").set("attempt", i + 1)
testsuite_list_new.append(copy_ts)
if retry_type is not None and retry_value > 0:
if len(testsuite_list) > 1:
go_next = len(testsuite_list_new) + retry_value + 1
if runmode is not None:
get_runmode = ts.find('runmode')
ts.remove(get_runmode)
for i in range(0, retry_value):
copy_ts = copy.deepcopy(ts)
copy_ts.find("retry").set("count", go_next)
copy_ts.find("retry").set("attempt", i + 1)
testsuite_list_new.append(copy_ts)
if retry_type is None and runmode is None:
testsuite_list_new.append(ts)
return testsuite_list_new
def wait_for_timeout(self, timeout, notify_count=4):
"""waits (sleeps) for the time provided
:Arguments:
1. timeout= time to wait in seconds
2. notify_count= number of times, the user needs to be notified
during wait time. Default value is 4.
Ex: If the notify_count=4 and timeout=400
the timeout is divided into 4 partitions
each as 100 and notified to user as
100(25%),200(50%),300(75%),400(100%)
:Returns:
1. status (bool)
"""
WDesc = "Waits for the timeout provided"
Utils.testcase_Utils.pSubStep(WDesc)
print_info("Command timeout for {0} seconds".format(timeout))
status = datetime_utils.wait_for_timeout(timeout, notify_count=notify_count)
pNote('********Below Testing occured after Timeout *********')
Utils.testcase_Utils.report_substep_status(status)
return status
def create_jira_issue(self, issue_summary, issue_description, issue_type='Bug'):
"""
Function to Create jira Ticket using JIRA rest API
:Arguments:
1. issue_summary(str) - Jira issue ID
2. issue_description(str) - warrior execution status
3. issue_type(str) - Jira issue type(Ex. Story/Bug/Task)
:Returns:
1. issue_id(str/boolean) - (a) issue_key if created
(b) False if not created
(c) issue_key if already exists and the append_log is True
(d) False if already exists and the append_log is not True
"""
issue_id = False
issue_summary = issue_summary.replace('"', " ")
issue_description = issue_description.replace('"', "-")
postdata_url = self.server + '/rest/api/2/issue/'
headers = {"Content-Type": "application/json"}
postdata = """
{
"fields": {
"project":
{
"key": \""""+self.project_key+"""\"
},
"summary": \""""+issue_summary+"""\",
"description": \""""+issue_description+"""\",
"issuetype": {
"name": \""""+issue_type+"""\"
}
}
}
"""
existed = self.check_jira_issue(issue_summary)
if not existed:
# POST request to create new Jira issue
response = requests.post(postdata_url, auth=self.auth,
headers=headers, data=postdata)
if response:
resp_dict = response.json()
issue_id = str(resp_dict['key'])
print_info("JIRA Issue Created. Issue-Id: {0}".format(issue_id))
else:
print_error("Problem creating JIRA issue")
print_error("JIRA Error code: ({0}), Error message: ({1})".
format(response.status_code, response.reason))
else:
if self.append:
print_info("Issue '{0}' already exists and the execution logs "
"will be uploaded since the 'append_log' option is "
"set to True in jira config file".format(str(existed)))
issue_id = existed
else:
print_info("Issue '{0}' already exists and the execution logs "
"will not be uploaded since the 'append_log' option is "
"not set to True in jira config file".format(str(existed)))
return issue_id
def go_to(self, url, browser_instance=None):
"""Navigates the active browser instance to the provided URL."""
status = True
try:
print_info("Opening url '%s'" % url)
if browser_instance is not None:
browser_instance.get(url)
else:
self.current_browser.get(url)
except WebDriverException as err:
print_error(err)
if "Reached error page" in str(err):
print_error("Unable to Navigate to URL:{}"\
"possibly because of the url is not valid".format(url))
else:
status = False
except Exception as err:
print_error(err)
status = False
print_error("Unable to Navigate to URL:'%s'" % url)
traceback.print_exc()
return status
def copy_file(self, remotepath, localpath, filename):
"""Get the file from remotepath
:Argument:
1. remotepath - File path in the remote server
2. localpath - Local path to save the file
3. filename - Filename of the file to be tranferred
:Returns:
1. status(bool)= True / False
"""
sftpobj = self.sshobj.open_sftp()
print_info("Copying {} from {} to {}".format(filename, remotepath,
localpath))
if filename:
remotepath = os.path.join(remotepath, filename)
localpath = os.path.join(localpath, filename)
sftpobj.get(remotepath, localpath)
if os.path.isfile(localpath):
return True
else:
return False
def upload_logfile_to_jira_issue(self,
issue_id,
logfile,
attachment_name=None):
"""Function to attach logs to Jira Ticket using JIRA rest API"""
fetchuri = self.server
postdata_url = fetchuri + '/rest/api/2/issue/' + issue_id + '/attachments'
credential_handler = self.username + ":" + self.password
password = base64.b64encode(credential_handler)
boundary = '----------%s' % ''.join(
random.sample('0123456789abcdef', 15))
post_data = []
post_data.append('--%s' % boundary)
post_data.append(
'Content-Disposition: form-data; name="file"; filename="%s"' %
str(logfile.split("/")[-1]))
post_data.append('Content-Type: %s' % 'text/plain')
post_data.append('')
post_data.append(open(logfile, 'r').read())
post_data.append('--%s--' % boundary)
post_data.append('')
body = '\r\n'.join(post_data)
req = urllib2.Request(str(postdata_url), body)
req.add_header("X-Atlassian-Token", "nocheck")
req.add_header("Authorization", "Basic " + password)
req.add_header("Content-Type",
"multipart/form-data; boundary=%s" % boundary)
try:
handler = urllib2.urlopen(req)
extension = json.loads(handler.read())
print_info("Log File {0} uploaded to Issue-Id: {1}".format(
logfile.split("/")[-1], issue_id))
except urllib2.HTTPError, e:
pNote("Problem attaching logs to JIRA issue {0}".format(issue_id),
"error")
pNote("JIRA Error code: ({0})".format(e.code), "error")
exit(1)
def diff_json_objects(self, json_object1, json_object2,case_conversion=False):
""" Takes two json objects as inputs and calculates the difference between them.
:Returns:
Returns a status and a comparison result(tuple or None)
1. No difference between two json objects.
- status = True
- comparison result = None.
2. Difference found between two json objects.
- status=False
- comparison result = a tuple of two lists
list1= items in json1 but not json2
list2= items in json2 but not json1
3. If any exception encountered during comparison:
- status=False
- comaprison result = None
"""
result = False
try:
if case_conversion == True:
json_object1 = self.case_conversion_json(json_object1)
json_object2 = self.case_conversion_json(json_object2)
json_object1 = self.nested_json_object(json_object1)
json_object2 = self.nested_json_object(json_object2)
list1 = list(json_object1.difference(json_object2))
list2 = list(json_object2.difference(json_object1))
if list1 or list2:
print_info("Items in json 1 but not json 2: {0}".format(str(list1)))
print_info("\nItems in json 2 but not json 1: {0} ".format(str(list2)))
result_list = (list1, list2)
else:
result, result_list = (True, None)
except Exception as exception:
print_exception(exception)
result_list = None
return result, result_list
def download_remote_file_sftp(self, remotepath, localpath, filename, \
remotehost, username, password, port=22):
"""Downloads a remote file from the remote server to
the localpath using SFTP
:Arguments:
1. remotepath (string) = the remote path to download the file from remotehost
2. localpath (string) = the local path on the local host
3. filename (string) = name of the remote file to download
4. remotehost (string) = remote host
5. username (string) = remote login username
6. password (string) = remote login password
:Returns:
1. status(bool)
"""
status = False
transport = self.param.Transport((remotehost, port))
transport.connect(username=username, password=password)
sftp = self.param.SFTPClient.from_transport(transport)
if filename:
try:
sftp.get(remotepath + filename, localpath + filename)
if os.path.isfile(localpath + filename):
print_info(
"Downloading file from remote server successful")
status = True
else:
print_info("Downloading file from remote server failed")
except Exception as exception:
print_exception(exception)
finally:
sftp.close()
transport.close()
return status
def get_element(self, browser, locator, **kwargs):
"""Get an element based on the locator and value
- By defaults gets a single element,
- To get the list of all elements matching the value
use findall='y' as argument.
:Arguments:
- browser = instance of selenium webdriver browser.
- locator = how to locate the element in the webpage.
supported format: "supported locator value = value for the locator"
1. to locate element by its id:
format = "id=id of the element"
eg: "id=j_username" will find the element whose\
id is j_username
2. "name=name of the element"
3. "xpath=xpath of the element"
4. "link=link to the element"
5. "partial_link=partial link to the element"
6. "tag=tag of the element"
7. "class=class of the element"
8. "css=css of the element"
- **kwargs:
1. findall = 'y' - finds all the elements with matching value
= None - finds the first elemtn with matching value.
:Returns:
- the selenium webdriver element if found.
- None if element was not found
(prints a NoSuchElementException message to the user)
"""
assert browser is not None
print_info("Finding element by {0}"\
.format(locator))
element = self._get_element(browser, locator, **kwargs)
if element is None:
print_error("Could not find element(s) with {0}"\
.format(locator))
return element
def testsuite_prerun(self, testsuite_filepath, root, check_files_dict=None):
"""Executes prerun of a testsuite file """
print('\n')
print_info('*'*40)
print_debug("Validating Test suite xml")
print_info('*'*40)
testsuite_xsd_fullpath = self.xsd_dir + os.sep + 'warrior_suite.xsd'
testsuite_status = self.xml_to_xsd_validation(testsuite_filepath, testsuite_xsd_fullpath)
if testsuite_status:
data_file_valid, check_files_dict = self.check_testsuite_input_datafile(\
testsuite_filepath, check_files_dict)
testsuite_status &= data_file_valid
for testcase in root.iter('Testcase'):
tc_path_rel = testsuite_utils.get_path_from_xmlfile(testcase)
tc_path = file_Utils.getAbsPath(tc_path_rel,
os.path.dirname(testsuite_filepath))
time.sleep(5)
if os.path.isfile(tc_path):
print('\n')
print_info('tc_path: {0}, Testcase file exists...'.format(tc_path))
tc_status = self.testcase_prerun(tc_path, check_files_dict)
else:
print('\n')
tc_status = False
print_error('tc_path: {0}, Testcase file does not exist'.format(tc_path))
print_info('TC STATUS: {0}'.format('FAILED'))
testsuite_status &= tc_status
else:
print_error("Incorrect xml format")
time.sleep(5)
print('\n')
status = testcase_Utils.convertLogic(testsuite_status)
print_info('SUITE STATUS: {0}ED'.format(status))
return testsuite_status
def _make_browser(self, browser_name, desired_capabilities=None,
profile_dir=None, webdriver_remote_url=None, **kwargs):
"""method to open a browser, calls other sepcific/generic
make browser methods to open a browser """
browser_methods = {'ff': self._make_ff, 'firefox': self._make_ff,
'chrome': self._make_chrome}
creation_method = browser_methods.get(browser_name, None)
if creation_method is None:
print_error("{} is not a supported browser. Please use firefox or chrome".\
format(browser_name))
browser = None
else:
kwargs["browser_name"] = browser_name
browser = creation_method(webdriver_remote_url, desired_capabilities,
profile_dir, **kwargs)
if browser is not None:
print_info("The {} browser version is {}".format(
browser_name, self.get_browser_version(browser)))
else:
print_error("Unable to create browser for: {}".format(browser_name))
return browser
def convert_string_to_datatype(self):
"""Converts an input string to a python datatype """
err_msg = ("\nUser input argument value {0} does not match python "
"syntax for '{1}'").format(self.arg_value, self.datatype)
info_msg = ("Warrior FW will handle user input argument value as "
"string (default)\n")
result = self.arg_value
try:
if self.datatype is not IOBase:
result = ast.literal_eval(self.arg_value)
except Exception:
print_error(err_msg)
print_info(info_msg)
print_error('unexpected error: {0}'.format(traceback.format_exc()))
result = self.arg_value
else:
if self.datatype is not IOBase and not isinstance(
result, self.datatype):
print_error(err_msg)
print_info(info_msg)
result = self.arg_value
return result
def create_partitions_in_topic(self, partitions, **kwargs):
"""
create partitions in topic
Arguments:
partitions(list) : list of ['topic_name','num_partitions'] lists
example : [['topic1',4], ['topic2',5]]
timeout(int): timeout in milliseconds
Returns:
result(bool) : False if exception occures, True otherwise
"""
timeout = kwargs.get("timeout", None)
validate = kwargs.get("validate", False)
topic_partitions = {tup[0]:NewPartitions(total_count=tup[1]) for tup in partitions}
print_info("creating partitions in topic")
try:
self.kafka_client.create_partitions(topic_partitions=topic_partitions,
timeout_ms=timeout,
validate_only=validate)
result = True
except KafkaError as exc:
print_error("Exception during creating partitions - {}".format(exc))
result = False
return result
