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)
