def inner(*args, **kwargs):
kwargs = {k.lower(): v
for k, v in kwargs.items()} # Kwargs keys to lowercase
if 'type_secret' not in str(keyword_method):
logger.debug('args: {}, kwargs: {}'.format(args, kwargs))
try:
time.sleep(
timestr_to_secs(kwargs.get('delay', CONFIG['Delay'])))
run_before_kw = CONFIG['RunBefore']
valid_pw = ['click', 'get_text', 'drop_down']
if run_before_kw and any(pw in str(keyword_method)
for pw in valid_pw):
logger.info(
'executing run before kw {}'.format(run_before_kw))
eval(run_before_kw) # pylint: disable=W0123
logger.trace(keyword_method)
logger.trace(args, kwargs)
return keyword_method(*args, **kwargs)
except Exception as e: # pylint: disable=W0703
logger.debug(traceback.format_exc())
if not self._is_run_on_failure_keyword(keyword_method):
if not util.par2bool(kwargs.get('skip_screenshot', False)):
BuiltIn().run_keyword(self._run_on_failure_keyword)
devmode = util.par2bool(BuiltIn().get_variable_value(
'${DEV_MODE}', False))
if devmode and not config.get_config('Debug_Run'):
Dialogs.pause_execution(
'Keyword {} {} {} failed. \n'
'Got {}'.format(
str(keyword_method).split(' ')[1].upper(),
str(args), str(kwargs), e))
debug.debug_on()
else:
raise
def execute_click_and_verify_condition(web_element, text_appear=True, **kwargs):
"""Click and optionally verify condition after click.
Accepted kwargs:
text(str) = In case we want to verify that some text appears/disappears after click
interval = How long we wait between the clicks
timeout = How long we are trying if element is not enabled or some other error exists
js = if js parameter exists, try javascript click instead of selenium
"""
js = util.par2bool(kwargs.get('js', False))
dbl_click = util.par2bool(kwargs.get('doubleclick', CONFIG["DoubleClick"]))
if web_element.is_enabled():
try:
if js:
js_click(web_element)
elif dbl_click:
double_click(web_element)
else:
wd_click(web_element, **kwargs)
logger.debug('element clicked')
except WebDriverException as e:
logger.info('Got {} when tried to click.'.format(e))
if 'text' not in kwargs:
raise e
if 'text' in kwargs:
logger.debug('button clicked. Verifying expected condition..')
try:
if text_appearance(kwargs['text'], text_appear=text_appear,
timeout=kwargs.get('interval')):
return True
except QWebTimeoutError as e:
logger.debug('timeout err')
raise QWebUnexpectedConditionError('Unexpected condition') from e
return True
raise QWebInvalidElementStateError('Element is not enabled')
def get_elements_by_attributes(css, locator=None, **kwargs):
any_element = util.par2bool(kwargs.get('any_element', None))
partial = util.par2bool(kwargs.get('partial_match',
CONFIG['PartialMatch']))
if 'tag' in kwargs:
css = kwargs.get('tag')
try:
elements = javascript.get_all_elements(css)
if any_element:
return elements
matches = javascript.get_by_attributes(elements,
locator.replace("\'", "\\'"),
partial)
logger.debug(
'attrfunc found full matches: {}, partial matches: {}'.format(
matches.get('full'), matches.get('partial')))
full, partial = matches.get('full'), matches.get('partial')
except (WebDriverException, JavascriptException, AttributeError) as e:
logger.debug(
'Got exception from get elements by attributes: {}'.format(e))
full, partial = [], []
if 'element_kw' not in kwargs:
return full, partial
web_elements = full + partial
if web_elements:
if CONFIG['SearchMode']:
draw_borders(web_elements)
return web_elements
raise QWebElementNotFoundError(
'Element with {} attribute not found'.format(locator))
def get_element_by_label_for(locator, css, **kwargs): # pylint: disable=unused-argument
partial = util.par2bool(kwargs.get('partial_match', CONFIG['PartialMatch']))
limit = util.par2bool(kwargs.get('limit_traverse', CONFIG['LimitTraverse']))
level = 3 if limit is True else 6
try:
matches = javascript.get_by_label(locator.replace("\'", "\\'"), css, level, partial)
logger.debug('labelfunc found full matches: {}, partial matches: {}'
.format(matches.get('full'), matches.get('partial')))
return matches.get('full'), matches.get('partial')
except (WebDriverException, JavascriptException) as e:
logger.warn('Exception from label func: {}'.format(e))
return [], []
def get_element_by_locator_text(locator, anchor="1", index=1, **kwargs):
"""Find element by it's visible text.
Accepted kwargs:
parent(tagName):Can be used when target element is some of the locators parent.
child(tagName): Find clickable target from locator's child elements.
allow_non_existent = True: Function returns immediately if element is not found
css=False: Use this to bypass css search when finding elements by visible text
"""
index = int(index) - 1
try:
web_element = get_text_using_anchor(locator, anchor, **kwargs)
except (QWebElementNotFoundError, InvalidSelectorException,
JavascriptException, WebDriverException):
try:
web_element = element.get_unique_element_by_xpath(locator)
except (QWebElementNotFoundError, InvalidSelectorException,
NoSuchFrameException) as e:
no_raise = util.par2bool(kwargs.get('allow_non_existent', False))
if no_raise:
return None
raise QWebElementNotFoundError(e) # pylint: disable=W0707
if web_element:
if 'parent' in kwargs and kwargs['parent']:
tag_name = kwargs['parent']
web_element = element.get_parent_element(web_element, tag_name)
elif 'child' in kwargs and kwargs['child']:
tag_name = kwargs['child']
web_element = element.get_element_from_childnodes(
web_element, tag_name, dom_traversing=False)[index]
if CONFIG['SearchMode']:
element.draw_borders(web_element)
return web_element
raise QWebElementNotFoundError('Element not found')
def write(input_element, input_text, timeout, **kwargs): # pylint: disable=unused-argument
click = util.par2bool(kwargs.get('click', CONFIG['ClickToFocus']))
if click:
wd_click(input_element)
if _ends_with_line_break(input_text):
input_text, key = _remove_ending_line_break(input_text)
kwargs['key'] = key
check = util.par2bool(kwargs.get('check', CONFIG['CheckInputValue']))
if check is True:
kwargs['check'] = True
input_handler.write(input_element, input_text, **kwargs)
time.sleep(1)
compare_input_values(input_element, kwargs.get('expected', input_text), timeout=2)
input_element.send_keys(kwargs.get('key', input_handler.line_break_key))
else:
input_handler.write(input_element, input_text, **kwargs)
logger.debug('Preferred text: "{}"'.format(input_text))
def wd_click(web_element, **kwargs):
try:
web_element.click()
except WebDriverException as e:
logger.debug(e)
js_click_on_failure = util.par2bool(kwargs.get('js_click', True))
if js_click_on_failure:
js_click(web_element)
def get_index_of(self, text, condition):
index = self.content.find(text)
if index > -1:
if util.par2bool(condition) is False:
index += len(text)
return index
raise QWebValueMismatchError(
'File did not contain the text "{}"'.format(text))
def upload_file(locator, filename, anchor='1', timeout=0, index=1, **kwargs):
r"""Upload file.
Examples
--------
.. code-block:: robotframework
UploadFile Upload text.txt
UploadFile Foo C:/path/to/file/test.pdf
UploadFile 1 text.txt #Using index as locator
With table(Pick table with use table keyword first):
.. code-block:: robotframework
UploadFile r1c1 text.txt
Parameters
----------
locator : str
Text or index that locates the upload element.
filename : file to upload
Default folders = users/downloads and project_dir/files
anchor : str
Index number or text near the input field's locator element.
If the page contains many places where the locator is then anchor is used
to select the wanted element. Index number selects the item from the list
of matching entries starting with 1. Text selects the entry with the closest
distance.
timeout : str | int
How long we find element before failing. Default 10 (seconds)
index : int
If table cell contains more than one input elements or if there is some kind of
nested structure inside of given input index may needed. Default = 1 (first)
kwargs :
| Accepted kwargs:
| limit_traverse : False. If limit traverse is set to false we are heading up to
| fifth parent element if needed when finding relative input element for some label.
Raises
------
ValueError: File not found
Related keywords
----------------
\`SaveFile\`
"""
kwargs['css'] = kwargs.get('css', '[type="file"]')
kwargs['upload'] = util.par2bool(kwargs.get('upload', True))
filepath = download.get_path(filename)
if filepath:
input_element = input_.get_input_elements_from_all_documents(
locator, anchor, timeout=timeout, index=index, **kwargs)
input_element.send_keys(str(filepath.resolve()))
return
raise QWebFileNotFoundError(
'Unable to find file {}. Tried from project/files and users/downloads'.
format(filename))
def _set_case_insensitivity(val):
check = util.par2bool(val)
if check:
CONFIG.set_value(
"ContainingTextMatch",
SearchStrategies.CONTAINING_TEXT_MATCH_CASE_INSENSITIVE)
else:
CONFIG.set_value("ContainingTextMatch",
SearchStrategies.CONTAINING_TEXT_MATCH_CASE_SENSITIVE)
def get_visible_elements_from_elements(web_elements, **kwargs):
visible_elements = []
hiding_elements = []
vis_check = util.par2bool(kwargs.get('visibility', CONFIG['Visibility']))
if not vis_check:
logger.debug('allow invisible elements')
return web_elements
viewport_check = util.par2bool(kwargs.get('viewport',
CONFIG['InViewport']))
try:
elem_objects = javascript.get_visibility(web_elements)
logger.debug('Checking visibility from all found elements: {}'.format(
len(elem_objects)))
except (JavascriptException, StaleElementReferenceException,
TypeError) as e:
raise QWebStalingElementError(
"Exception from visibility check: {}".format(e)) from e
for el in elem_objects:
onscreen = el.get('viewport')
logger.debug('Is element in viewport: {}'.format(onscreen))
css_visibility = el.get('css')
logger.debug('CSS visibility is not hidden and '
'display is not none: {}'.format(css_visibility))
offset = el.get('offset')
logger.debug('Element offsetWidth is > 0: {}'.format(offset))
if css_visibility and onscreen:
if util.par2bool(kwargs.get('offset', CONFIG['OffsetCheck'])):
if offset and onscreen:
visible_elements.append(el.get('elem'))
elif offset:
hiding_elements.append(el.get('elem'))
elif onscreen:
visible_elements.append(el.get('elem'))
else:
hiding_elements.append(el.get('elem'))
elif css_visibility:
hiding_elements.append(el.get('elem'))
logger.debug('found {} visible elements and {} hiding ones'.format(
len(visible_elements), len(hiding_elements)))
if viewport_check:
return visible_elements
return visible_elements + hiding_elements
def input_value(input_element, timeout, **kwargs):
blind = util.par2bool(kwargs.get('blind', CONFIG['BlindReturn']))
if input_handler.is_editable_text_element(input_element):
value = input_element.get_attribute('innerText')
else:
value = input_element.get_attribute('value')
if value:
return value.strip()
if blind:
return ''
raise QWebValueError('No Value found after {} sec'.format(timeout))
def get_text_elements(text, **kwargs):
web_elements = None
try:
web_elements = _get_exact_text_element(text, **kwargs)
except NoSuchFrameException:
logger.debug('Got no such frame from get exact text')
if util.par2bool(kwargs.get('partial_match', CONFIG['PartialMatch'])):
try:
web_elements = _get_contains_text_element(text, **kwargs)
except NoSuchFrameException:
logger.debug('Got no such frame from contains text')
return web_elements
def get_element_from_childnodes(locator_element, css, dom_traversing=True, **kwargs):
limit = util.par2bool(kwargs.get('limit_traverse', CONFIG['LimitTraverse']))
level = 3 if limit is True else 6
try:
web_elements = get_visible_elements_from_elements(
javascript.get_childnodes(locator_element, css, level, dom_traversing))
except (WebDriverException, JavascriptException) as e:
web_elements = None
logger.debug('Got Exception from get_element_from_childnodes: {}'.format(e))
if web_elements:
return web_elements
raise QWebElementNotFoundError('Child with tag {} not found.'.format(css))
def check_browser_reuse(**kwargs):
try:
browser_reuse = util.par2bool(
BuiltIn().get_variable_value('${BROWSER_REUSE}')) or False
session_id = kwargs.get('session_id', None) or \
BuiltIn().get_variable_value('${BROWSER_SESSION_ID}')
executor_url = kwargs.get('executor_url', None) or \
BuiltIn().get_variable_value('${BROWSER_EXECUTOR_URL}')
return browser_reuse, session_id, executor_url
except RobotNotRunningError:
pass
return False, None, None
def get_item_using_anchor(text, anchor, **kwargs):
xpath = '//*[@title="{0}" or @alt="{0}" or @data-tooltip="{0}" or ' \
'@tooltip="{0}" or @aria-label="{0}" or @data-icon="{0}"]'.format(text)
if CONFIG["CssSelectors"]:
web_elements = _get_item_by_css(text, **kwargs)
else:
web_elements = element.get_webelements(xpath, **kwargs)
if web_elements:
if CONFIG['SearchMode']:
element.draw_borders(_get_correct_element(web_elements, str(anchor)))
return _get_correct_element(web_elements, str(anchor))
no_raise = util.par2bool(kwargs.get('allow_non_existent', False))
if no_raise:
return None
raise QWebElementNotFoundError('Cannot find item for locator {}'.format(text))
def is_readonly(element):
"""Is the element interactable?
Uses the readonly attribute to determine if form element is enabled or
not.
Parameters
----------
element : WebElement
Returns
-------
bool
"""
return util.par2bool(javascript.execute_javascript(
'return arguments[0].hasAttribute("readonly")', element))
def get_row(self, locator, anchor, row_index=False, **kwargs):
skip_header = util.par2bool(kwargs.get('skip_header', False))
rows = self.get_all_rows()
if locator.startswith('//last'):
if skip_header:
return len(rows) - 1
return len(rows)
matches, index = self._get_row_by_locator_text(rows, locator, anchor)
if row_index:
if skip_header:
return index
return index + 1
if matches:
return matches
raise QWebValueError(
'Matching table row not found for locator {}.'.format(locator))
def get_all_text_elements(text, **kwargs):
"""Get all webelements found by text"""
web_elements = []
all_text_nodes = util.par2bool(kwargs.get('all_text_nodes', CONFIG['AllTextNodes']))
kwargs['partial_match'] = kwargs.get('partial_match', CONFIG['PartialMatch'])
if all_text_nodes:
web_elements = check_all_nodes(text, **kwargs)
if web_elements:
return web_elements
if 'css' not in kwargs:
try:
web_elements = get_clickable_element_by_js(text, **kwargs)
except (JavascriptException, WebDriverException, NoSuchFrameException,
QWebStalingElementError) as e:
logger.debug('got {}. Syntax might be invalid'.format(e))
if not web_elements:
web_elements = get_text_elements(text, **kwargs)
if not web_elements:
raise QWebElementNotFoundError('Webpage did not contain text "{}"'.format(text))
return web_elements
def is_checked(checkbox_element):
"""Is checkbox checked.
Parameters
----------
checkbox_element : WebElement
Returns
-------
bool
"""
js = """
var checked = function(el) {
if (el.hasAttribute("aria-checked")) {
return el.attributes["aria-checked"].value;
console.log(el.attributes["aria-checked"].value);
}
return el.checked;
}
return checked(arguments[0]);
"""
checked = util.par2bool(javascript.execute_javascript(
js, checkbox_element))
return bool(checked)
def test_par2bool():
should_return_true = ["TRue", "1", "ON", True, 1]
for x in should_return_true:
assert par2bool(x) is True
assert par2bool('False') is False
def open_browser(executable_path="chromedriver",
chrome_args=None,
desired_capabilities=None,
**kwargs):
"""Open Chrome browser instance and cache the driver.
Parameters
----------
executable_path : str (Default "chromedriver")
path to the executable. If the default is used it assumes the
executable is in the $PATH.
port : int (Default 0)
port you would like the service to run, if left as 0, a free port will
be found.
desired_capabilities : dict (Default None)
Dictionary object with non-browser specific capabilities only, such as
"proxy" or "loggingPref".
chrome_args : Optional arguments to modify browser settings
"""
options = Options()
logger.debug('opt: {}'.format(options))
# If user wants to re-use existing browser session then
# he/she has to set variable BROWSER_REUSE_ENABLED to True.
# If enabled, then web driver connection details are written
# to an argument file. This file enables re-use of the current
# chrome session.
#
# When variables BROWSER_SESSION_ID and BROWSER_EXECUTOR_URL are
# set from argument file, then OpenBrowser will use those
# parameters instead of opening new chrome session.
# New Remote Web Driver is created in headless mode.
chrome_path = kwargs.get(
'chrome_path', None) or BuiltIn().get_variable_value('${CHROME_PATH}')
if chrome_path:
options.binary_location = chrome_path
browser_reuse, session_id, executor_url = check_browser_reuse(**kwargs)
logger.debug('browser_reuse: {}, session_id: {}, executor_url: {}'.format(
browser_reuse, session_id, executor_url))
if browser_reuse and session_id and executor_url:
options.add_argument("headless")
# Gets rid of Devtools listening .... printing
options.add_experimental_option('excludeSwitches', ['enable-logging'])
driver = Remote(command_executor=executor_url,
desired_capabilities=options.to_capabilities())
BuiltIn().set_global_variable('${BROWSER_REMOTE_SESSION_ID}',
driver.session_id)
driver.session_id = session_id
else:
if user.is_root():
options.add_argument("no-sandbox")
if chrome_args:
if any('headless' in _.lower() for _ in chrome_args):
CONFIG.set_value('Headless', True)
for item in chrome_args:
options.add_argument(item.lstrip())
# options.add_argument("start-maximized")
options.add_argument("--disable-notifications")
if 'headless' in kwargs:
CONFIG.set_value('Headless', True)
options.add_argument("headless")
if 'prefs' in kwargs:
if isinstance(kwargs.get('prefs'), dict):
prefs = kwargs.get('prefs')
else:
prefs = util.prefs_to_dict(kwargs.get('prefs').strip())
options.add_experimental_option('prefs', prefs)
driver = Chrome(BuiltIn().get_variable_value('${CHROMEDRIVER_PATH}')
or executable_path,
options=options,
desired_capabilities=desired_capabilities)
browser_reuse_enabled = util.par2bool(
BuiltIn().get_variable_value('${BROWSER_REUSE_ENABLED}')) or False
if browser_reuse_enabled:
# Write WebDriver session info to RF arguments file for re-use
write_browser_session_argsfile(driver.session_id,
driver.command_executor._url) # pylint: disable=protected-access
# Clear possible existing global values
BuiltIn().set_global_variable('${BROWSER_SESSION_ID}', None)
BuiltIn().set_global_variable('${BROWSER_EXECUTOR_URL}', None)
browser.cache_browser(driver)
return driver
def open_browser(url, browser_alias, options=None, **kwargs):
r"""Open new browser to given url.
Uses the Selenium2Library open_browser method if the browser is not Chrome.
For Chrome, recognizes if we are inside docker container and sets chrome
capabilities accordingly.
Browser options can also be given in the robot command, for example:
robot -v browser_options:"--kiosk, --disable-gpu" testytest.robot
Examples
--------
.. code-block:: robotframework
OpenBrowser http://google.com chrome
#Use Chromium instead of Chrome:
OpenBrowser http://google.com chrome chrome_path=/path/to/chromium/chrome.exe
OpenBrowser http://google.com chrome executable_path=/path/to/my/chromedriver.exe
OpenBrowser file://resources/window.html firefox
OpenBrowser http://google.com chrome --allow-running-insecure-content, --xyz
OpenBrowser http://google.com chrome prefs="opt1":"True", "opt2":"False"
OpenBrowser http://google.com firefox -headless, -private, -xyz
OpenBrowser http://google.com firefox prefs="option1":"value1", "option2":"value2"
OpenBrowser http://google.com firefox -profile /path/to/profile
OpenBrowser http://google.com firefox -private prefs="option1":"value1"
#Supply preferences from a dictionary
${prefs_d}= Create Dictionary option1 value1 option2 value2
OpenBrowser http://google.com firefox prefs=${prefs_d}
Experimental feature for test debugging (for Chrome only):
----------------------------------------------------------
To re-use existing Chrome browser session, you need to set variable BROWSER_REUSE_SESSION
to True. Next you need to run the first test suite normally including `OpenBrowser` AND
excluding `CloseBrowser` (e.g. in Tear Down section). The first run will result to
arguments file in defined output directory. The file name is by default `browser_session.arg`.
For the next runs, which re-use the existing browser session, you need to specify the argument
file in robot command-line using `--argumentfile` parameter. Additionally, test
suites (or debugger) has to run `OpenBrowser` normally. QWeb will automatically override
normal parameters and use argument file's values instead, thus re-using the existing browser.
In the first test suite open Chrome browser normally without closing it at the tear down:
.. code-block:: robotframework
Set Global Variable ${BROWSER_REUSE_ENABLED} True
OpenBrowser http://google.com chrome
By running above, an argument file `browser_session.arg` is created to the output
directory or current working directory. To re-use the existing browser session, use
following command line examples:
.. code-block:: text
robot --argumentfile <path>/browser_session.arg ... example.robot
rfdebug --argumentfile <path>/browser_session.arg
Parameters
----------
url : str
URL of the website that will be opened.
browser_alias : str
Browser name. For example chrome, firefox or ie.
options
Arguments for initialization of WebDriver objects(chrome).
Some available opts: https://peter.sh/experiments/chromium-command-line-switches/
kwargs
prefs=args: Experimental options for chrome browser.
Raises
------
ValueError
Unknown browser type
Related keywords
----------------
\`Back\`, \`CloseAllBrowsers\`, \`CloseBrowser\`, \`GetTitle\`,
\`GetUrl\`, \`GoTo\`, \`RefreshPage\`, \`ReturnBrowser\`,
\`SwitchWindow\`, \`VerifyTitle\`, \`VerifyUrl\`
"""
try:
logger.info('\nQWeb version number: {}'.format(
pkg_resources.get_distribution('QWeb').version),
also_console=True)
except pkg_resources.DistributionNotFound:
logger.info('Could not find QWeb version number.')
number_of_open_sessions = _sessions_open()
if number_of_open_sessions > 0:
logger.warn('You have {} browser sessions already open'.format(
number_of_open_sessions))
options = util.option_handler(options)
b_lower = browser_alias.lower()
bs_project_name = BuiltIn().get_variable_value('${PROJECTNAME}') or ""
bs_run_id = BuiltIn().get_variable_value('${RUNID}') or ""
if os.getenv('QWEB_HEADLESS'):
kwargs = dict(headless=True)
if os.getenv('CHROME_ARGS') is not None:
if options is None:
options = os.getenv('CHROME_ARGS').split(',')
else:
options = options + os.getenv('CHROME_ARGS').split(',')
logger.debug('Options: {}'.format(options))
provider = BuiltIn().get_variable_value('${PROVIDER}')
if provider in ('bs', 'browserstack'):
bs_device = BuiltIn().get_variable_value('${DEVICE}')
if not bs_device and b_lower in bs_desktop.NAMES:
driver = bs_desktop.open_browser(b_lower, bs_project_name,
bs_run_id)
elif bs_device:
driver = bs_mobile.open_browser(bs_device, bs_project_name,
bs_run_id)
else:
raise exceptions.QWebException(
'Unknown browserstack browser {}'.format(browser_alias))
else:
driver = _browser_checker(b_lower, options, **kwargs)
util.initial_logging(driver.capabilities)
# If user wants to re-use Chrome browser then he/she has to give
# variable BROWSER_REUSE=True. In that case no URL loaded needed as
# user wants to continue with the existing browser session
is_browser_reused = util.par2bool(
BuiltIn().get_variable_value('${BROWSER_REUSE}')) or False
if not (is_browser_reused and b_lower == 'chrome'):
driver.get(url)
xhr.setup_xhr_monitor()
