def get_messages(self, get_all_messages=False, **kwargs):
"""
Get messages from consumer.
Arguments:
get_all_messages(bool): set this to True to get all the messages, seeks to the beginning.
Defaults to False.
timeout(int): timeout in milliseconds
max_records(int): maximum messages to fetch
Returns:
messages(list): messages from the consumer
"""
timeout_ms = kwargs.get("timeout", 0)
max_records = kwargs.get("max_records", None)
messages = []
msg_pack = {}
print_info("get messages published to subscribed topics")
try:
if get_all_messages:
self.kafka_consumer.seek_to_beginning()
msg_pack = self.kafka_consumer.poll(timeout_ms, max_records)
except KafkaError as exc:
print_error("Exception occured in get_messages - {}".format(exc))
for topic, message_list in msg_pack.items():
for message in message_list:
messages.append(message.value)
return messages
def decide_createsuite_actions(w_cli_obj, namespace):
"""Decide the actions for -createsuite tag """
filepath = namespace.filepath
# already check namespace.create here, no need to double check
if namespace.filepath is not None and len(namespace.filepath) == 0:
namespace.filepath = None
if all([namespace.suitename, namespace.filepath]):
filepath = w_cli_obj.examine_create_suite(namespace)
print_info("suite created in ", filepath[0])
exit(0)
if all([namespace.suitename, namespace.cat]):
filepath = w_cli_obj.examine_create_suite(namespace)
print_info("suite created in ", filepath[0])
exit(0)
elif not namespace.cat and not all(
[namespace.suitename, namespace.filepath]):
print_error("Invalid combination... Use -createsuite with -suitename, "
"filepath(s) (i.e. list of testcase xml files. "
"Use -h or --help for more command line options")
exit(1)
elif namespace.cat and not namespace.suitename:
print_error("Invalid combination... Use -creatsuite + -category "
"with -suitename")
exit(1)
return filepath
def check_tag(self, category_list, dirlist):
"""return list of valid testcase xml
files with the correct category tag"""
result = []
cur_dir = os.path.abspath(os.getcwd())
if dirlist is None:
dirlist = [cur_dir]
for folder in dirlist:
os.chdir(cur_dir)
folder = Utils.file_Utils.getAbsPath(folder, os.curdir)
if os.path.isdir(folder):
all_files = [
Utils.file_Utils.getAbsPath(f, folder)
for f in os.listdir(folder)
]
is_xml_files = self.check_xml(all_files)
for xmlfile in is_xml_files:
root = Utils.xml_Utils.getRoot(xmlfile)
detail = root.find('Details')
if detail is not None:
if detail.find('Category') is not None:
cat_text = detail.find('Category').text.strip()
cat_text = cat_text.split(",")
if len(set(category_list) & set(cat_text)) > 0:
result.append(xmlfile)
else:
print_error(str(folder) + "is not a directory")
print_info("Number of matching testcases: {0}".format(len(result)))
return result
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 save_screenshot(self,
browser_instance=None,
filename=None,
directory=None):
"""
Save screenshot of the specified/current browser
"""
status = True
if browser_instance is None:
browser_instance = self.current_browser
if filename is None:
current_datetime = str(get_current_timestamp())
current_datetime = current_datetime.replace(" ", "_")
current_datetime = current_datetime.replace(":", "-")
filename = "screenshot_" + current_datetime + ".png"
else:
filename += ".png"
print_info(
"Screenshot will be saved by the name {0} in directory {1}".format(
filename, directory))
directory = os.path.join(directory, filename)
try:
browser_instance.save_screenshot(directory)
sleep(10)
except Exception as e:
print_error("Could not save screenshot {0}".format(e))
status = False
return status
def verify_response(self, command, exp_string, fail_resp, timeout=None):
"""Execute a command using the paramiko SSH object and returns
the response string
:Arguments:
1. command - command to be executed
2. exp_string - String to be expected
3. fail_resp - Failure response to be expected
4. timeout - wait for response
:Returns:
1. status(bool)= True / False
2. out/err = response string
"""
out, stderr = self.ssh_exec(command, timeout)
err = stderr.read()
if out and ((exp_string in out) and (fail_resp not in out)):
print_info("Output:", out)
return True, out
elif out and ((exp_string not in out) or (fail_resp in out)):
print_info("Error:", out)
return False, out
else:
print_error("Error:", err)
return False, err
def get_testwrapper_file_details(testsuite_filepath, data_repository):
"""retuns testwrapperfile to use if specified, else returns False"""
if 'ow_testwrapperfile' in 'data_repository':
testwrapperfile = data_repository['ow_testwrapperfile']
else:
if Utils.xml_Utils.nodeExists(testsuite_filepath, "TestWrapperFile"):
testwrapperfile = Utils.xml_Utils.getChildTextbyParentTag\
(testsuite_filepath, 'Details', 'TestWrapperFile')
else:
return [False, False, False, 'abort']
abs_cur_dir = os.path.dirname(testsuite_filepath)
abs_testwrapperfile = Utils.file_Utils.getAbsPath(testwrapperfile,
abs_cur_dir)
Utils.xml_Utils.getRoot(abs_testwrapperfile)
if not data_repository.get('suite_data_file', False):
print_error(
"Input data file must be specified in test suite global details section"
)
exit(0)
j_data_type = common_execution_utils.check_get_datatype(
abs_testwrapperfile, data_repository['suite_data_file'])
j_runtype = common_execution_utils.check_get_runtype(abs_testwrapperfile)
setup_on_error_action = Utils.testcase_Utils.get_setup_on_error(
abs_testwrapperfile)
return [abs_testwrapperfile, j_data_type, j_runtype, setup_on_error_action]
def verify_data(self, expected, object_key, type='str', comparison='eq'):
"""Verify value in 'object_key' in the data repository matches
with expected
:Argument:
expected = the value to be compared with
object_key = the object in the data repository to be compared
type = the type of this expected (str/int/float)
comparison = actual comparison (eq/ne/gt/ge/lt/le)
eq - check if both are same(equal)
ne - check if both are not same(not equal)
gt - check if object_key is greater than expected
ge - check if object_key is greater than or equal to expected
lt - check if object_key is lesser than expected
le - check if object_key is lesser than or equal to expected
:Returns:
status (boolean)
"""
wDesc = "Verify if value of object_key in data_repository "
"matches with expected"
Utils.testcase_Utils.pNote(
"KEYWORD: verify_data | Description: {0}".format(wDesc))
result, value = Utils.data_Utils.verify_data(expected, object_key,
type, comparison)
if result not in ["FALSE", "TRUE"]:
return result
elif result == "FALSE":
print_error("Expected: {0} {1} {2} but found {0}={3}".format(
object_key, comparison, expected, value))
return False
elif result == "TRUE":
print_info("Expected: {0} {1} {2} found the same".format(
object_key, comparison, expected, value))
return True
def _execute_current_step(self):
"""
This function actually executes a given step and returns necessary details about that step.
"""
try:
result = step_driver.main(self.current_step,
self.current_step_number,
self.data_repository,
self.system_name,
skip_invoked=self.skip_invoked)
step_status = result[0]
kw_resultfile = result[1]
step_impact = result[2]
except Exception as e:
print_error('unexpected error %s' % str(e))
step_status = False
kw_resultfile = None
step_impact = Utils.testcase_Utils.get_impact_from_xmlfile(
self.current_step)
print_error('unexpected error {0}'.format(traceback.format_exc()))
self.go_to_step_number = False
self.step_status_list, self.step_impact_list = \
common_execution_utils.compute_status(self.current_step,
self.step_status_list,
self.step_impact_list,
step_status, step_impact)
self.kw_resultfile_list.append(kw_resultfile)
return step_status
def report_status(self, status, text="", level='Keyword'):
"""
Reports the status to the testcase xml result file base on the received status
On receiving a True reports keyword status as Passed
On receiving a False reports keyword status as Failed
On receiving a Skip reports keyword status as Skipped
On receiving a Exception reports keyword status as Exception
On receiving a Error reports Keyword status as Error
On receiving a RAN reports Keyword status as RAN
:Arguments:
1. status = (bool) True or False
2. text = (string) any useful description
3. level = (string) only supported value currently is Keyword
:Returns:
None
"""
status = {
'TRUE': self.p_pass,
'FALSE': self.p_fail,
'SKIP': self.p_skip,
'EXCEPTION': self.p_exception,
'ERROR': self.p_error,
'RAN': self.p_ran
}.get(str(status).upper())
if status is None:
print_error(
"unexpected or no value received, expecting TRUE/FALSE/SKIP")
self.p_error(level, text)
else:
status(level, text)
def report_warning(self, status, text="", level='subStep'):
"""
Reports the status to the testcase xml result file based on the received status
On receiving a True reports keyword status as Passed
On receiving a False reports keyword status as Warning
On receiving a Skip reports keyword status as Skipped
On receiving a Exception reports keyword status as Exception
On receiving a Error reports Keyword status as Error
:Arguments:
1. status = (bool) True or False
2. text = (string) any useful description
3. level = (string) only supported value currently is Keyword
:Returns:
None
"""
from warrior.WarriorCore.Classes.war_cli_class import WarriorCliClass
if WarriorCliClass.mock:
if str(status).upper() == 'TRUE' or str(status).upper() == 'FALSE':
status = 'RAN'
status = {
'TRUE': self.p_pass,
'FALSE': self.p_warn,
'SKIP': self.p_skip,
'EXCEPTION': self.p_exception,
'ERROR': self.p_error,
'RAN': self.p_ran
}.get(str(status).upper())
if status is None:
print_error(
"unexpected or no value received, expecting TRUE/FALSE/SKIP")
self.p_error(level, text)
else:
status(level, text)
def __get_list(self, string):
"""
Get the list of variable from the string (can have multiple ${list} )
:param string:
:return:
a dictionary
if nothing wrong with list range
return a dict with orignal list/range as key "1..4,5,6..7:0.5"
parsed list as value [1,2,3,4,5,6,6.5,7]
if invalid range found
return a dict {'Error':False}
if no list/range found
return a dict {'False':False}
"""
return_value = string
result = {}
check = self.end_pat
match = self.__find_match(return_value[:return_value.find(check) +
len(check)])
while match is not None:
try:
parsed_value = self.__parse_list(self.get_value(
match.group(2)))
except (ValueError, TypeError, AttributeError):
print_error("Invalid list range found")
return {'Error': False}
if parsed_value:
result[match.group(2)] = parsed_value
return_value = return_value.replace(
return_value[:return_value.find(check) + len(check)], '')
match = self.__find_match(return_value[:return_value.find(check) +
len(check)])
if result == {}:
return {'False': False}
return result
def main(step, skip_invoked=True):
"""
Entry function for execute nodes in a step
Handle checking and call the logical decision functions
combine the final result and return
:param:
step: the step Element
:return:
decision: Whether the step should be executed or not
trigger_action: When decision failed, what kind of action to perform
"""
exec_node = step.find("Execute")
if exec_node is None:
return True, None
trigger_action = None
exec_type = exec_node.get("ExecType", "")
if exec_type.upper() == 'IF' or exec_type.upper() == 'IF NOT':
decision, trigger_action = decision_maker(exec_node)
elif exec_type.upper() == 'NO':
decision = False
trigger_action = "SKIP"
elif exec_type.upper() == 'YES':
decision = True
elif exec_type.upper() == "INVOKED":
decision = not skip_invoked
trigger_action = "SKIP_INVOKED"
else:
decision = False
supported_values = ['no', 'yes', 'if', 'if not', "invoked"]
print_error(
"Unsupported value used for ExecType, supported values are:"
"{0} and case-insensitive".format(supported_values))
return decision, trigger_action
def open_tab(self,
browser_instance=None,
url=None,
browser_type="firefox"):
"""Opens a new tab in the browser"""
status = True
if browser_instance is None:
browser_instance = self.current_browser
# only when firefox version < 47, open new window
if browser_type == "firefox" and\
LooseVersion(self.get_browser_version(browser_instance)) < LooseVersion("47.0.0"):
element = browser_instance.find_element_by_tag_name("body")
element.send_keys(Keys.LEFT_CONTROL, 'n')
elif browser_type == "firefox" or (browser_type == "chrome" and\
LooseVersion(self.get_browser_version(browser_instance)) > LooseVersion("60.0.0")):
# If FF version > 47, this action is not supported
print_error("Firefox (47 or above) and Chrome with chromedriver (2.32 or above)"\
"doesn't support opening new tab. Open tab may not function correctly")
status = False
else:
# If it is chrome ver < 60, actually open a new tab
element = browser_instance.find_element_by_tag_name("body")
element.send_keys(Keys.LEFT_CONTROL, 't')
sleep(1)
browser_instance.switch_to.window(browser_instance.window_handles\
[len(browser_instance.window_handles) - 1])
if url is not None:
self.go_to(url, browser_instance)
sleep(1)
return status
def get_firefox_version(self, binary):
"""
Use firefox binary to find out firefox version
before launching firefox in selenium
"""
command = ""
# If the platform is Linux,
# If Binary - None: default binary is set as "firefox".
# else the binary path passed through datafile is considered.
# If the platform is Windows,
# If Binary - None: default binary is set to Program Files path.
# else the binary path passed through datafile is considered.
if platform.system() in "Linux":
if binary in [False, None]:
binary = "firefox"
command = [binary, "-v"]
elif platform.system() in "Windows":
if binary in [False, None]:
binary = self.ff_binary_object._default_windows_location()
command = "%s -v | more" % (binary)
print_info("Platform: {0} Firefox binary path: {1}".format(
platform.system(), binary))
version = False
try:
raw_version = check_output(command).decode("utf-8")
match = re.search(r"\d+\.\d+", raw_version)
if match is not None:
version = LooseVersion(match.group(0))
else:
print_info(
"Cannot parse Firefox version: {}".format(raw_version))
except CalledProcessError:
print_error("Cannot find firefox version, will not launch browser")
return version
def get_action_dirlist(driverpath):
""" Get the list of action directories """
actions_package_list = []
try:
if os.path.isfile(driverpath):
lines = []
with open(driverpath, 'r') as fobj:
lines = fobj.readlines()
lines_as_string = ''.join(lines)
search_string = re.compile(r'package_list.*=.*\]',
re.DOTALL | re.MULTILINE)
match = re.search(search_string, lines_as_string)
if match:
match_string = match.group()
actions_package_list = match_string.split('[')[1].split(
']')[0].split(',')
return actions_package_list
else:
print_error(("file {0} does not exist".format(driverpath)))
return actions_package_list
except Exception as exception:
print_exception(exception)
return actions_package_list
def testcase_prerun(self, tc_filepath, check_files_dict=None):
"""Executes prerun of a testcase file """
print_debug('\n')
print_debug('=' * 40)
print_debug("Validating Test case xml")
print_debug('=' * 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 check_jira_issue(self, issue_summary):
"""
check jira server for any existing issue with the same summary(title)
:Arguments,:
1. issue_summary(str) - issue title
:Returns:
1. issue_id(str/boolean) - existing issue key or False if not found
"""
issue_id = False
parsed_summary = issue_summary.replace("[", "\\\\[")
parsed_summary = parsed_summary.replace("]", "\\\\]")
postdata_url = (self.server + '/rest/api/2/search/?jql=summary~' +
'\"' + parsed_summary + '\"')
response = requests.get(postdata_url, auth=self.auth)
if response:
resp_dict = response.json()
for issue in resp_dict["issues"]:
if issue_summary[:-2].strip(
) == issue["fields"]["summary"].strip():
issue_id = issue["key"]
else:
# partially match title
pass
else:
print_error("Problem checking JIRA issues with same issue summary")
print_error("JIRA Error code: ({0}), Error message: ({1})".format(
response.status_code, response.reason))
return issue_id
def upload_logfile_to_jira_issue(self,
issue_id,
logfile,
attachment_name="Log file"):
"""
Function to attach logs to jira Ticket using JIRA rest API
:Arguments:
1. issue_id(str) - Jira issue ID
2. logfile(str) - File(path) to be attached
3. attachment_name(str) - Name of the file to be attached
"""
status = False
postdata_url = self.server + '/rest/api/2/issue/' + issue_id + '/attachments'
print_info("logfile is : {0}".format(logfile))
fileobj = open(logfile, 'rb').read()
logfile_name = os.path.basename(logfile)
headers = {"X-Atlassian-Token": "nocheck"}
files = {"file": (logfile_name, fileobj)}
response = requests.post(postdata_url,
auth=self.auth,
files=files,
headers=headers)
if response:
status = True
print_info("{0} - '{1}' uploaded to Jira issue '{2}'".format(
attachment_name, logfile_name, issue_id))
else:
print_error(
"Problem attaching logs to Jira issue '{0}'".format(issue_id))
print_error("JIRA Error code: ({0}), Error message: ({1})".format(
response.status_code, response.reason))
return status
def get_list_direct(self, string):
"""
entry function for __get_list
:param string:
:return:
a dictionary
if nothing wrong with list range
return a dict with orignal list/range as key "1..4,5,6..7:0.5"
parsed list as value [1,2,3,4,5,6,6.5,7]
if invalid range found
return a dict {'Error':False}
if no list/range found
return a dict {'False':False}
"""
return_value = string
result = {}
check = self.end_pat
match = self.__find_match(return_value[:return_value.find(check) +
len(check)])
while match is not None:
try:
parsed_value = self.__parse_list("{" + match.group(2) + "}")
except (ValueError, TypeError, AttributeError):
print_error("Invalid list range found")
return {'Error': False}
if parsed_value:
result[match.group(2)] = parsed_value
return_value = return_value.replace(
return_value[:return_value.find(check) + len(check)], '')
match = self.__find_match(return_value[:return_value.find(check) +
len(check)])
if result == {}:
return {'False': False}
return result
def _check_property(self, element, **kwargs):
"""
check property
"""
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 create_topics(self, topic_sets, **kwargs):
"""
create topics for the producer or consumer to use
Arguments:
topic_sets(list) : list of
['topic_name', 'num_partitions', 'replication_factor'] lists
example : ['topic1',1,1]
timeout(int): time in milliseconds
Returns:
result(bool) : False if exception occures, True otherwise
None.
"""
timeout = kwargs.get("timeout", None)
validate = kwargs.get("validate", False)
new_topics = [NewTopic(name=tup[0], num_partitions=tup[1],\
replication_factor=tup[2]) for tup in topic_sets]
print_info("creating topics")
try:
self.kafka_client.create_topics(new_topics=new_topics,
timeout_ms=timeout,
validate_only=validate)
result = True
except KafkaError as exc:
print_error("Exception during creating topics - {}".format(exc))
result = False
return result
def _perform_keypress(self, element, **kwargs):
"""
This function expects to receive a browser instance through the
"browser" argument and a key "keys" through the kwargs.
The value for "keys" would be a list of keys tha need to pressed.
"""
status = True
flag = False
keys = kwargs.get('keys')
actions = ActionChains(element)
for key in keys:
try:
selenium_key = KEYS[key.upper()]
except KeyError:
print_error("{0} is not supported by Selenium.".format(key))
status = False
else:
flag = True
actions.send_keys(selenium_key)
if flag:
actions.perform()
sleep(2)
return status
def send_messages(self, topic, value=None, **kwargs):
"""
Publish messages to the desired topic
Arguments:
topic(str): topic name to publish messages
partition(int): partition nubmer
key(str): key name
value(str): message to publish
Returns:
result(bool) : False if exception occures, True otherwise
"""
partition = kwargs.get("partition", None)
headers = kwargs.get("headers", None)
timestamp = kwargs.get("timestamp", None)
key = kwargs.get("key", None)
print_info("publishing messages to the topic")
try:
self.kafka_producer.send(topic=topic,
value=value,
partition=partition,
key=key,
headers=headers,
timestamp_ms=timestamp)
self.kafka_producer.flush()
result = True
except KafkaError as exc:
print_error("Exception during publishing messages - {}".format(exc))
result = False
return result
def __init__(self, **configs):
"""
create a kafka client
"""
print_info("Creating kafka client")
try:
self.kafka_client = KafkaAdminClient(**configs)
except KafkaError as exc:
print_error("kafka client - Exception during connecting to broker- {}".format(exc))
def __init__(self, *topics, **configs):
"""
Create Kafka Consumer object
"""
print_info("creating kafka consumer")
try:
self.kafka_consumer = KafkaConsumer(*topics, **configs)
except KafkaError as exc:
print_error("Kafka consumer - Exception during connecting to broker - {}".format(exc))
def wait_for_timeout(wait_time, unit="SECONDS", notify_count=4):
"""
Warrior, Wait till the time is a generic wait. The Wait is informed to the user as a countdown.
:Arguments:
1.wait_time: Time for Warrior wait.
2.unit: The unit of Time supported are
1. Second (default)
2. Minute
3. Hour
4. Day
5. Month (30 days is assumed for one Month)
6. Year (365 days is assumed for one Year)
3.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%)
:return:
Status = Bool
"""
try:
wait_time = float(wait_time)
if unit.upper() in ["SECOND", "SECONDS", "SEC", "SECS"]:
seconds = wait_time
elif unit.upper() in ["MINUTE", "MINUTES", "MIN", "MINS"]:
seconds = 60 * wait_time
elif unit.upper() in ["HOUR", "HOURS"]:
seconds = 60 * 60 * wait_time
elif unit.upper() in ["DAY", "DAYS"]:
seconds = 24 * 60 * 60 * wait_time
elif unit.upper() in ["MONTH", "MONTHS"]:
seconds = 30 * 24 * 60 * 60 * wait_time
elif unit.upper() in ["YEAR", "YEARS"]:
seconds = 365 * 24 * 60 * 60 * wait_time
else:
print_warning('The supported unit of seconds is Seconds/Minutes/Hours/Months/Years'
'The default unit of Seconds would be used')
# To notify user on the wait time, based on the notify value provided,
# Default notify value is 4
notify_count = int(notify_count)
notify_sec = seconds/notify_count
print_without_logging("Wait time of {0}s will be notified every {1}s"
.format(seconds, notify_sec))
for count in range(notify_count):
print_without_logging("Remaining wait time: {:.1f}s"
.format(seconds-(count*notify_sec)))
time.sleep(notify_sec)
print_without_logging("End of {0}s wait time".format(seconds))
return True
except TypeError:
print_warning('Unable to parse wait_time value, Please use int/float as wait_time value.')
return False
except Exception as e:
print_error('Encountered unexpected error {0} Unable to wait as requested'.format(e))
return False
def __init__(self, **configs):
"""
Create kafka producer object
"""
print_info("Creating kafka producer")
try:
self.kafka_producer = KafkaProducer(**configs)
except KafkaError as exc:
print_error("kafka producer - Exception during connecting to broker - {}".format(exc))
def file_execution(cli_args, abs_filepath, default_repo):
"""
Call the corresponded driver of each file type
"""
result = False
a_defects = cli_args.ad
jiraproj = cli_args.jiraproj
jiraid = cli_args.jiraid
if Utils.xml_Utils.getRoot(abs_filepath).tag == 'Testcase':
default_repo['war_file_type'] = "Case"
result, _, data_repository = testcase_driver.main(
abs_filepath,
data_repository=default_repo,
runtype='SEQUENTIAL_KEYWORDS',
auto_defects=a_defects,
jiraproj=jiraproj,
jiraid=jiraid)
if not Utils.data_Utils.get_object_from_datarepository(
'genericdatafile'):
update_jira_by_id(
jiraproj, jiraid,
os.path.dirname(data_repository['wt_resultsdir']), result)
email.compose_send_email("Test Case: ", abs_filepath,
data_repository['wt_logsdir'],
data_repository['wt_resultsdir'], result)
elif Utils.xml_Utils.getRoot(abs_filepath).tag == 'TestSuite':
default_repo['war_file_type'] = "Suite"
result, suite_repository = testsuite_driver.main(
abs_filepath,
auto_defects=a_defects,
jiraproj=jiraproj,
data_repository=default_repo)
update_jira_by_id(jiraproj, jiraid,
suite_repository['suite_execution_dir'], result)
email.compose_send_email("Test Suite: ", abs_filepath,
suite_repository['ws_logs_execdir'],
suite_repository['ws_results_execdir'],
result)
elif Utils.xml_Utils.getRoot(abs_filepath).tag == 'Project':
default_repo['war_file_type'] = "Project"
result, project_repository = project_driver.main(
abs_filepath,
auto_defects=a_defects,
jiraproj=jiraproj,
data_repository=default_repo)
update_jira_by_id(jiraproj, jiraid,
project_repository['project_execution_dir'], result)
email.compose_send_email("Project: ", abs_filepath,
project_repository['wp_logs_execdir'],
project_repository['wp_results_execdir'],
result)
else:
print_error("Unrecognized root tag in the input xml file ! exiting!!!")
return result
def main(step_list, data_repository, tc_status, system_name=None):
"""Executes the list of steps in parallel
Computes and returns the testcase status"""
try:
testcase_status = execute_custom_parallel(step_list, data_repository,
tc_status, system_name)
except Exception:
testcase_status = False
print_error('unexpected error {0}'.format(traceback.format_exc()))
return testcase_status
