def create_namespace_loader(cls, config, ns_file_path): from arjuna.tpi.constant import ArjunaOption multi_context_enabled = config.value(ArjunaOption.GUIAUTO_DEF_MULTICONTEXT) context = multi_context_enabled and None or config.guiauto_context _, file_extension = os.path.splitext(ns_file_path) ext = file_extension.upper()[1:] considered_path = ns_file_path try: file_format = FileFormat[ext] except: raise Exception("Unsupported format for namespace: {}".format(file_extension)) else: full_file_path = ns_file_path if os.path.isdir(full_file_path): raise Exception("Namespace file path is a directory and not a file: {}".format(considered_path)) elif not os.path.isfile(full_file_path): from arjuna import Arjuna Arjuna.get_logger().warning("Namespace file path does not exist: {}".format(considered_path)) return DummyGnsLoader(considered_path) # raise Exception() # if file_format == FileFormat.GNS: # if multi_context_enabled: # return MGNSFileLoader(full_file_path) # else: # return GNSFileLoader(full_file_path, context) if file_format == FileFormat.YAML: return YamlGnsLoader(full_file_path, context) else: raise Exception("Unsupported format for namespace: {}".format(file_extension))
def __init__(self): self.files = [] self.found_class_names = set() self.temp_map = {} from arjuna import Arjuna self.logger = Arjuna.get_logger() self.console = Arjuna.get_console()
def select_tests(cls, pytest_items, pytest_config): ''' Select tests from items collected by pytest, based on Arjuna rules. Arguments: pytest_items: List of pytest `Item` objects. Each item represents a collected test function node. pytest_config: pytest Config object ''' from arjuna import Arjuna from arjuna.core.error import ExclusionRuleMet, NoInclusionRuleMet selector = Arjuna.get_test_selector() final_selection = [] deselected = [] for item in pytest_items: qual_name = item.nodeid.split('::')[0].replace("/", ".").replace( '\\', "").replace(".py", "") + "." + item.name.split("[")[0] try: selector.validate(Arjuna.get_test_meta_data(qual_name)) except (ExclusionRuleMet, NoInclusionRuleMet) as e: deselected.append(item) else: final_selection.append(item) if deselected: pytest_config.hook.pytest_deselected(items=deselected) pytest_items[:] = final_selection
def __log(invoker, level, msg, contexts=None): from arjuna import Arjuna if type(contexts) is str: contexts = (contexts, ) elif contexts is None: contexts = ("default", ) contexts = set(contexts) try: getattr(Arjuna.get_logger(), level)( msg.replace('\n', ' ').replace('\r', ''), extra={ 'invoker': invoker, 'contexts': contexts, 'config': Arjuna.get_config("data_env") } ) # data_env conf is ref config with log settings. available in non-thred map. except AttributeError: # In case the logging is called before the logger is set. # In future versions, see if there can be a fallabck logger. pass except OSError: ## On Windows 10, random handle related bugs happen. if level.lower() in {"info", "debug"}: sys.stdout.write(msg + "\n") else: sys.stderr.write(msg + "\n")
def pytest_configure(config): if config.getoption("help"): return arg_dict, rule_dict = _load_argdict_rule_dict(config) _init_arjuna(config, arg_dict) gname = config.getoption("group").lower() if gname == "mgroup": group = TestGroup.from_pickers(rconf_name=config.getoption("ref.conf"), rules=rule_dict) else: filtered_rule_dict = {k: v for k, v in rule_dict.items() if v} if filtered_rule_dict: raise Exception( "When you provide a group name, you can not provide test selectors/rules in Command line. You have provided group name as >>{}<< and also provided selectors/rules: {}." .format(gname, {k: v for k, v in filtered_rule_dict.items() if v})) else: group = TestGroup.from_def(gname, rconf_name=config.getoption("ref.conf")) _configure_pytest_reports(config) from arjuna import Arjuna Arjuna._set_command(" ".join(RAW_ARGS)) Arjuna.register_pytest_command_for_group(" ".join(CONVERTED_ARGS)) PytestHooks.add_env_data(config)
def call_func(func, my, request, *args, **kwargs): from arjuna import Arjuna my.set_req_obj(request) qual_name = my.info.qual_name_with_data Arjuna.get_logger().info("Begin test function: {}".format(qual_name)) func(my, request, *args, **kwargs) Arjuna.get_logger().info("End test function: {}".format(qual_name))
def main(args=None): try: import signal import sys def signal_handler(sig, frame): print('Exiting...') sys.exit(0) signal.signal(signal.SIGINT, signal_handler) from arjuna import Arjuna Arjuna.launch(args and args or sys.argv) except Exception as e: # The following sleep is to accommodate a common IDE issue of # interspersing main exception with console output. time.sleep(0.5) msg = ''' {0} Sorry. Looks like this is an error Arjuna couldn't handle. Create a bug report on GitHub: https://github.com/rahul-verma/arjuna {0} Message: {1} '''.format("-" * 70, str(e)) print(msg) import traceback print(traceback.format_exc())
def __register_network_info(self, request, response): from arjuna import Arjuna from arjuna.tpi.helper.arjtype import NetworkPacketInfo # Should be configurable sub_network_packets = [] for redir_resp in response.redir_history: redir_req = redir_resp.request sub_network_packets.append( NetworkPacketInfo(label="Sub-Request: {} {}".format( redir_req.method, redir_req.url), request=str(redir_req), response=str(redir_resp), sub_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 sub_network_packets.append( NetworkPacketInfo(label="Sub-Request: {} {}".format( last_req.method, last_req.url), request=str(last_req), response=str(response), sub_network_packets=tuple())) Arjuna.get_report_metadata().add_network_packet_info( NetworkPacketInfo(label=request.label, request=str(request), response=str(response), sub_network_packets=tuple(sub_network_packets)))
def execute(self, arg_dict): for parent in self.parents: parent.process(arg_dict) from arjuna import Arjuna project_root_dir = arg_dict.pop("project.root.dir") runid = arg_dict.pop("run.id") static_rid = arg_dict.pop("static.rid") self.dry_run = arg_dict.pop("dry_run") if self.dry_run: self.dry_run = DryRunType[self.dry_run] if "ref_conf" in arg_dict: self.ref_conf_name = arg_dict.pop("ref_conf") self.pop_command_args(arg_dict) Arjuna.init(project_root_dir, CliArgsConfig(arg_dict), runid, static_rid=static_rid) import sys proj_dir = Arjuna.get_config().value(ArjunaOption.PROJECT_ROOT_DIR) sys.path.append(proj_dir + "/..") py_3rdparty_dir = Arjuna.get_config().value( ArjunaOption.ARJUNA_EXTERNAL_IMPORTS_DIR) sys.path.append(py_3rdparty_dir)
def __init__(self, *, name="mgroup", rconf_name="ref"): from arjuna import Arjuna from arjuna.tpi.constant import ArjunaOption Arjuna.register_group_params( name=name, config=Arjuna.get_config(rconf_name), thread_name=threading.currentThread().name)
def main(args=None): try: import signal import sys def signal_handler(sig, frame): print('Exiting...') sys.exit(0) signal.signal(signal.SIGINT, signal_handler) from arjuna import Arjuna Arjuna.launch(args and args or sys.argv) except Exception as e: # The following sleep is to accommodate a common IDE issue of # interspersing main exception with console output. time.sleep(0.5) msg = ''' {0} Sorry. Looks like this is an error Arjuna couldn't handle. If Arjuna should handle this error, write to us: [email protected] {0} Message: {1} '''.format("-" * 70, str(e)) print(msg) import traceback print(traceback.format_exc())
def find(self, dispatcher_call, wmd, context="ELEMENT"): from arjuna import Arjuna Arjuna.get_logger().debug("Finding with wmd: {}".format(str(wmd))) from arjuna import Arjuna found = False js_call_name = context == "ELEMENT" and "_find_element_with_js" or "_find_multielement_with_js" js_call = getattr(self.container, js_call_name) locators = wmd.locators if context != "ELEMENT": if "POINT" in {l.ltype.name for l in locators}: raise ConditionException("With.POINT can be used only with GuiElement.") we = None for locator in locators: try: if locator.ltype.name == "POINT": # Assumption here is that this container is automator. size, dispatcher = js_call(locator.lvalue) elif locator.ltype.name == "JS": size, dispatcher = js_call(locator.lvalue) else: lvalue = locator.lvalue if locator.ltype.name == "XPATH": if not lvalue.startswith("."): lvalue = "." + lvalue size, dispatcher = dispatcher_call(locator.ltype.name, lvalue) return locator.ltype.name, locator.lvalue, size, dispatcher except WaitableError as e: we = e except Exception as f: raise f else: we = None if not found: raise GuiWidgetNotFoundError(*wmd.locators, container=self.__container)
def L(in_str, *, locale=None, bucket=None, strict=None): from arjuna import Arjuna, ArjunaOption bucket = bucket query = in_str if bucket is None: if in_str.find('.') != -1: bucket, query = in_str.split('.', 1) bucket = bucket.lower() if bucket not in Arjuna.get_localizer().bucket_names: bucket = None query = in_str else: query = in_str lang = locale and locale.name.lower() or Arjuna.get_config().l10n_locale.name.lower() try: if not bucket: val = Arjuna.get_localizer().globals.lang(lang)[query] else: val = Arjuna.get_localizer().buckets[bucket].lang(lang)[query] if not val: raise Exception("No localized string found for: {} for Locale.{}".format(in_str, lang.upper())) else: return val except Exception as e: if strict is None: strict_mode = Arjuna.get_config().value(ArjunaOption.L10N_STRICT) else: strict_mode = strict if strict_mode: import traceback raise Exception("Error in retrieving localized string for: {}. {}. {}".format(in_str, str(e), traceback.format_exc())) else: return in_str
def call_func(request, *args, **kwargs): from arjuna import Arjuna request_wrapper = My() request_wrapper.set_req_obj(request) qual_name = request_wrapper.info.qual_name_with_data Arjuna.get_logger().info("Begin fixture function: {}".format(qual_name)) yield from func(request_wrapper, *args, **kwargs) Arjuna.get_logger().info("End fixture function: {}".format(qual_name))
def add_element_meta_data(self, name, context, raw_locators, meta): wmd = GuiWidgetMetaData.create_wmd(*raw_locators, meta=meta) name = name.lower() if not self.has(name): self.__ns[name] = {} self.__ns[name][context] = wmd from arjuna import Arjuna Arjuna.get_logger().debug("Loaded {} label. EMD: {}".format(name, str(wmd)))
def add_env_data(cls, config): from arjuna import C, Arjuna import pkg_resources config._metadata['Arjuna Version'] = pkg_resources.require("arjuna")[0].version config._metadata['Arjuna Test Project Directory'] = C("project.root.dir") config._metadata['Arjuna Test Project Name'] = C("project.name") config._metadata['Reference Configuration'] = Arjuna.get_config().name config._metadata['Pytest Command (Converted)'] = Arjuna.get_pytest_command_for_group() config._metadata['Pytest Command (Provided)'] = Arjuna._get_command()
def __init__(self, gns_format="sgns"): Arjuna.init( "/Users/rahulverma/Documents/github_tm/arjuna/arjuna-samples/workspace/arjex" ) config = Arjuna.get_ref_config() super().__init__( config=config, base_url=config.get_user_option_value("wp.login.url").as_str(), ns_dir="{}_wordpress".format(gns_format.lower()))
def _register(self): from arjuna import Arjuna, ArjunaOption har = Har.from_har(self.har) filter_resources = self.__automator.config.value( ArjunaOption.REPORT_NETWORK_FILTER) for packet in har.get_pagewise_network_packet_info( filter_resources=filter_resources): Arjuna.get_report_metadata().add_network_packet_info(packet) self.__new_har() # This is done to clear har. self._proxy.new_page(title="Ignore")
def __init__(self): from arjuna import Arjuna from arjuna.core.enums import ArjunaOption self.__project_dir = Arjuna.get_ref_config().get_arjuna_option_value(ArjunaOption.PROJECT_ROOT_DIR).as_str() self.__tests_dir = Arjuna.get_ref_config().get_arjuna_option_value(ArjunaOption.PROJECT_TESTS_DIR).as_str() self.__xml_path = os.path.join(Arjuna.get_ref_config().get_arjuna_option_value(ArjunaOption.PROJECT_RUN_REPORT_XML_DIR).as_str(), "report.xml") self.__html_path = os.path.join(Arjuna.get_ref_config().get_arjuna_option_value(ArjunaOption.PROJECT_RUN_REPORT_HTML_DIR).as_str(), "report.html") self.__report_formats = Arjuna.get_ref_config().get_arjuna_option_value(ArjunaOption.PROJECT_REPORT_FORMATS).as_enum_list(ReportFormat) # -s is to print to console. self.__pytest_args = ["--rootdir", self.__project_dir, "--no-print-logs", "-s"] self.__test_args = []
def __load_tests(self, *, rules): from arjuna import Arjuna from arjuna.engine.selection.selector import Selector selector = Selector() if rules: for rule in rules['ir']: selector.include(rule) for rule in rules['er']: selector.exclude(rule) Arjuna.register_test_selector_for_group(selector)
def run(self): from arjuna import Arjuna from arjuna.tpi.constant import ArjunaOption Arjuna.register_group_params(name=self.__name, config=self.__config, thread_name=self.thread_name) self.__load_command_line() os.chdir(self.__project_dir) print("Executing pytest with args: {}".format(" ".join(self.__pytest_args))) Arjuna.register_pytest_command_for_group(" ".join(self.__pytest_args)) pytest_retcode = pytest.main(self.__pytest_args) return pytest_retcode
def _externalize(self): try: self.__guidef = GuiDef(self.__guimgr.name_store, self._automator, self.label, self.def_file_path) except Exception as e: import traceback raise GuiNamespaceLoadingError(self, str(e) + traceback.format_exc()) from arjuna import Arjuna Arjuna.get_logger().debug( "Gui Namespace loading completed for {}.".format(self.label))
def __getitem__(self, name): scopes = _LOOKUP_ORDER[self._request.scope] from arjuna import Arjuna for scope in scopes: Arjuna.get_logger().debug("Space: Getting value for {} from {} scope".format(name, scope)) try: container = getattr(self._request, _SCOPE_MAP[scope]) return getattr(container, name) except Exception as e: Arjuna.get_logger().debug("Space: No value for {} in {} scope".format(name, scope)) continue raise Exception("Attribute with name >>{}<< does not exist in request scope for {}".format(name, scopes))
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 _load_anchor_element(self): label = self._gui_def.anchor_element_name from arjuna import Arjuna Arjuna.get_logger().debug( "Loading Anchor Element for {} Gui. anchor label in GNS: {}.". format( self.label, self._gui_def.anchor_element_name, )) if label is not None: getattr(self.gns, label)
def __init__(self, name, ref_config_name, dry_run=False): self.__yaml = None self.load_session_defs() self.__yaml = self.get_session_yaml(name) from arjuna import Arjuna self.__config = None if ref_config_name is None: self.__config = Arjuna.get_config() else: self.__config = Arjuna.get_config(ref_config_name) self.__load_metadata() super().__init__(name, self.__config, dry_run=dry_run) self.__load_stages()
def __create_excel_file_data_ref(cls, file_path, context=DataRefContextType.COLUMN): ext = file_path.lower() if not ext.endswith("xls"): raise Exception("Unsupported file extension for Excel data reference: {}".format(file_path)) from arjuna import Arjuna, ArjunaOption if context == DataRefContextType.COLUMN: data_dir = Arjuna.get_config().value(ArjunaOption.DATA_REF_COLUMN_DIR) file_path = get_data_file_path(data_dir, file_path) return ExcelColumnDataReference(file_path) elif context == DataRefContextType.ROW: data_dir = Arjuna.get_config().value(ArjunaOption.DATA_REF_ROW_DIR) file_path = get_data_file_path(data_dir, file_path) return ExcelRowDataReference(file_path)
def _simple_dec(func, test_meta_data): __process_test_meta_data(func, test_meta_data) from arjuna import Arjuna Arjuna.register_test_meta_data(test_meta_data['info']['qual_name'], CIStringDict(test_meta_data)) func.__name__ = "check_" + func.__name__ @functools.wraps(func) def wrapper(request, *args, **kwargs): request_wrapper = My(test_meta_data) request_wrapper.set_req_obj(request) _call_func(func, request_wrapper, *args, **kwargs) return wrapper
def __init__(self, test_session, name, parent_config=None): self.__test_session = test_session self.__name = name self.__parent_config = parent_config and parent_config or None from arjuna import Arjuna self.__configs = {"default_config": Arjuna.get_ref_config()} self.__conf_trace = dict()
def _load_tests(self, rule_dict): i_e_rules = self.__create_rule_strs(rule_dict) rules = {'ir': [], 'er': []} rules['ir'].extend(i_e_rules['ir']) rules['er'].extend(i_e_rules['er']) from arjuna.engine.selection.selector import Selector selector = Selector() if rules: for rule in rules['ir']: selector.include(rule) for rule in rules['er']: selector.exclude(rule) from arjuna import Arjuna Arjuna.register_test_selector_for_group(selector)