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