def connect(self, reconnect=False):
'''
Connect to the server and login using the provided account details.
Keyword Arguments:
reconnect: If already connected, force a reconnect. Default is False.
'''
if self.__ready:
if not reconnect:
return
else:
self.quit()
from arjuna import log_info
log_info(
"Connecting to IMAP server >{}< at port >{}< (Using SSL: {}) for user: >{}<."
.format(self.host, self.port, self.uses_ssl, self.user))
if not self.__connected:
if self.uses_ssl:
self.__imap = imaplib.IMAP4_SSL(self.host, self.port)
else:
self.__imap = imaplib.IMAP4(self.host, self.port)
self.__connected = True
if not self.__loggedin:
self._imap.login(self.user, self.password)
self.__loggedin = True
# By default connects to Inbox.
self.__ready = True
log_info("Connected to IMAP Server >{}<.".format(self.host))
def run(self):
from arjuna import log_info
for stage in self.__stages:
log_info("Executing stage: {} ...".format(stage.name))
stage.run()
log_info("Finished Executing stage: {} ...".format(stage.name))
import time
time.sleep(2)
def call_func(request, *args, **kwargs):
from arjuna import log_info
request_wrapper = My()
request_wrapper.set_req_obj(request)
request_wrapper.data = hasattr(request, "param") and request.param or None
qual_name = request_wrapper.info.get_qual_name_with_data()
if func.__name__ != 'group':
log_info("(Setup) Begin fixture function: {}".format(qual_name))
yield from func(request_wrapper, *args, **kwargs)
if func.__name__ != 'group':
log_info("(Teardown) End fixture function: {}".format(qual_name))
def _send(self, request) -> HttpResponse:
'''
Send the provided HttpRequest to server.
In case of ConnectionError, retries the connection 5 times at a gap of 1 second. Currently, not configurable.
Returns
`HttpResponse` object. In case of redirections, this is the last HttpResponse object, which encapsulates all redirections which can be retrieved from it.
'''
from arjuna import Arjuna, log_info
from arjuna.tpi.helper.arjtype import NetworkPacketInfo
log_info(request.label)
max_connection_retries = 5
try:
counter = 0
exc_flag = False
exc_desc = None
while counter < max_connection_retries:
counter += 1
try:
if self._session.proxies:
response = HttpResponse(self, self._session.send(request._request, allow_redirects=request.allow_redirects, timeout=request.timeout, proxies=self._session.proxies, verify=False))
else:
response = HttpResponse(self, self._session.send(request._request, allow_redirects=request.allow_redirects, timeout=request.timeout))
except (ProxyError, InvalidProxyURL) as e:
raise HttpConnectError(request, "There is an error in connecting to the configured proxy. Proxy settings: {}. Error: {}".format(self.__session.proxies, str(e)))
except ConnectionError as f:
exc_flag = True
exc_desc = str(f)
time.sleep(1)
continue
else:
break
if exc_flag:
raise HttpConnectError(request, "Connection error despite trying 5 times. Error: {}".format(exc_desc))
except TooManyRedirects as e:
response = HttpResponse(self._session, e.response)
self.__register_network_info(request, response)
raise HttpSendError(self, response, str(e) + ". Error redir URL: " + e.response.url)
except Exception as e:
import traceback
response = "Error in sending the request\n"
response += e.__class__.__name__ + ":" + str(e) + "\n"
response += traceback.format_exc()
Arjuna.get_report_metadata().add_network_packet_info(
NetworkPacketInfo(label=request.label, request=str(request), response=str(response), sub_network_packets=tuple())
)
raise e
else:
self.__register_network_info(request, response)
if request.xcodes is not None:
self._validate_status_code(response, request.xcodes)
return response
def perform(self, **fargs):
from arjuna import log_info
log_info(f"Performing", self)
check_data_arg_type(fargs)
responses = list()
meta, fargs, steps = self._load(**fargs)
for index, step in enumerate(steps):
response = step.perform(**fargs)
new_data = {k:v for k,v in response.store.items() if k != "default_content" and not isinstance(v, NotFound)}
self.store.update(new_data)
fargs.update(new_data)
responses.append(HttpMessageResponse(step=index+1, msg=step._message, response=response))
return responses
def send(self, **fargs):
from arjuna import log_info
log_info("Sending", self)
check_data_arg_type(fargs)
label, req_repr, resp_proc = self._load(**fargs)
method = req_repr.method
try:
call = getattr(self._action._endpoint.service._session, method)
except AttributeError:
raise Exception(f"Unsupported HTTP method: {method}")
else:
response = call(req_repr.route, label=label, **req_repr.attrs)
resp_proc.validate(response)
return response
def __process_func_for_xfail(func, test_meta_data, xfail_obj):
from arjuna import log_info
log_info(test_meta_data["info"]["qual_name"])
log_info(xfail_obj)
if type(xfail_obj) is bool:
if xfail_obj:
return pytest.mark.xfail(True, reason="Expected Failure")(func)
else:
return func
elif isinstance(xfail_obj, _XFail):
return pytest.mark.xfail(xfail_obj.condition,
reason=xfail_obj.reason,
raises=xfail_obj.raises,
run=xfail_obj.run,
strict=xfail_obj.strict)(func)
else:
raise TestDecoratorError(
func_qual_name=test_meta_data["info"]["qual_name"],
msg="xfail argument should be of type XFail or bool.")
def run(self):
from arjuna import log_info
pref = ""
if self.session.name != "msession":
pref += self.session.name + "-"
if self.name != "mstage":
pref += self.name + "-"
if self.session.dry_run:
self.__num_threads = 1
self.__groups.freeze()
for i in range(self.num_threads):
self.__workers.append(TestGroupRunner(pref, i + 1, self.__groups))
for w in self.__workers:
w.start()
for w in self.__workers:
w.join()
log_info("All group runners in stage finished.")
def _call_func(func, request_wrapper, data=None, *args, **kwargs):
from arjuna import log_info
qual_name = request_wrapper.info.get_qual_name_with_data()
log_info("Begin test function: {}".format(qual_name))
try:
if data:
func(request=request_wrapper, data=data, *args, **kwargs)
else:
func(request=request_wrapper, *args, **kwargs)
except Exception as e:
log_info(
"End test function (with failure/error): {}. Exception Message: {}"
.format(qual_name, str(e)))
raise e
log_info("End test function: {}".format(qual_name))
def quit(self):
'''
Disconnect from the server and logout.
'''
from arjuna import log_info
log_info("Disconnecting from IMAP Server >{}<.".format(self.host))
if self.__ready:
# Select should be done atleast once before closing. So this line takes care of that.
self.__imap.select("INBOX")
self._imap.close()
self.__msg_count = None
if self.__loggedin:
self._imap.logout()
self.__loggedin = False
log_info("Disconnected from IMAP Server >{}<.".format(self.host))
self.__connected = False
return
log_info(
"Quit called without active connection to IMAP Server >{}<. Ignored."
.format(self.host))
def run(self):
from arjuna import log_info
log_info("Group runner started")
while True:
try:
child = self.__commands.next()
except TestGroupsFinished as e:
log_info("Groups finished")
return
except Exception as e:
log_info(
"An exception occured in thread pooling. Would continue executing."
)
log_info(e)
import traceback
traceback.print_exc()
return
try:
log_info("Running child")
child.thread_name = self.name
child.run()
except Exception as e:
import traceback
log_info(str(e) + traceback.format_exc())
continue
log_info("Group runner started")
def send(self):
from arjuna import Arjuna, log_info
from arjuna.tpi.helper.arjtype import NetworkPacketInfo
log_info(self.__printable_label)
max_connection_retries = 5
try:
counter = 0
exc_flag = False
while counter < max_connection_retries:
counter += 1
try:
response = HttpResponse(self.__session,
self.__session.send(self.__req))
except ConnectionError:
exc_flag = True
time.sleep(1)
continue
else:
break
if exc_flag:
raise Exception("Connection error despite trying 5 times.")
except Exception as e:
import traceback
response = "Error in sending the request\n"
response += e.__class__.__name__ + ":" + str(e) + "\n"
response += traceback.format_exc()
Arjuna.get_report_metadata().add_network_packet_info(
NetworkPacketInfo(label=self.label,
request=str(self),
response=str(response)))
raise e
else:
# Should be configurable
redir_network_packets = []
for redir_resp in response.redir_history:
redir_req = redir_resp.request
redir_network_packets.append(
NetworkPacketInfo(label="Sub-Request: {} {}".format(
redir_req.method, redir_req.url),
request=str(redir_req),
response=str(redir_resp),
redir_network_packets=tuple()))
# The request for last response object was the last request and hence the last redirection.
if response.redir_history:
last_req = response.last_request
if not last_req:
last_req = response.request
redir_network_packets.append(
NetworkPacketInfo(label="Sub-Request: {} {}".format(
last_req.method, last_req.url),
request=str(last_req),
response=str(response),
redir_network_packets=tuple()))
Arjuna.get_report_metadata().add_network_packet_info(
NetworkPacketInfo(
label=self.label,
request=str(self),
response=str(response),
redir_network_packets=tuple(redir_network_packets)))
if self.__xcodes is not None and response.status_code not in self.__xcodes:
raise HttpUnexpectedStatusCode(self.__req, response)
return response