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 _get_row_by_locator_text(rows, locator, anchor):
matches = []
input_elements = []
row_index = []
anchor_text = None
try:
anchor = int(anchor) - 1
except ValueError:
anchor_text = anchor
for index, row in enumerate(rows):
row_content = row.text
if locator == 'EMPTY' and row_content.strip() == '':
return row, index
input_elements = javascript.execute_javascript(
'return arguments[0].querySelectorAll("input, textarea")', row)
for elem in input_elements:
row_content += str(
javascript.execute_javascript('return arguments[0].value',
elem))
if locator in row_content:
if anchor_text and anchor_text in row_content:
return row, index
row_index.append(index)
matches.append(row)
if matches and not anchor_text:
return matches[anchor], row_index[anchor]
raise QWebElementNotFoundError(
'Row that includes texts {} and {} not found'.format(
locator, anchor_text))
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_dd_elements_from_all_documents(locator, anchor, index, **kwargs):
if int(index) > 0:
index = int(index) - 1
css_selector = CONFIG["CssSelectors"]
if not css_selector or locator.startswith('xpath=') or locator.startswith(
'//'):
select = get_dropdown_element_by_locator(locator, anchor)
elif Table.is_table_coordinates(locator):
table = Table.ACTIVE_TABLE.update_table()
if table is None:
raise QWebInstanceDoesNotExistError(
'Table has not been defined with UseTable keyword')
locator = table.get_table_cell(locator, anchor)
select = element.get_element_from_childnodes(
locator, 'select', dom_traversing=False)[index]
else:
select = get_dropdown_element_by_css_selector(locator, anchor, index,
**kwargs)
if not select:
select = get_dropdown_element_by_locator(locator, anchor)
if select:
if CONFIG['SearchMode']:
element.draw_borders(select)
return Select(select)
raise QWebElementNotFoundError('No matching elements found')
def click_icon(image, template_res_w=1920, browser_res_w=1920, timeout=0): # pylint: disable=unused-argument
"""Click the icon on the screen.
In case you want to click icons you always have to have reference images.
If reference picture are not in default folders (images, files, downloads) then
BASE_IMAGE_PATH should be defined in a robot file before using this keyword
Examples
--------
.. code-block:: robotframework
*** Variables ***
${BASE_IMAGE_PATH} ${CURDIR}${/}..${/}resources${/}images
BASE_IMAGE_PATH should lead to the folder where all your reference icons are
.. code-block:: robotframework
ClickIcon plane
"""
template_res_w, browser_res_w = int(template_res_w), int(browser_res_w)
image_path = icon.get_full_image_path(image)
x, y = icon.image_recognition(image_path,
template_res_w,
browser_res_w,
pyautog=True)
if x == -1:
raise QWebElementNotFoundError(
"Couldn't find the icon from the screen")
pyautogui.moveTo(x, y)
pyautogui.click()
def get_unique_element_by_xpath(xpath, **kwargs):
"""Get element if it is needed to be unique.
One use case is that when xpath is written in the test script with
the prefix xpath=.
Parameters
----------
xpath : str
XPath string. If 'xpath=' -prefix is used, it will be omitted.
"""
if xpath.startswith("xpath="):
xpath = xpath.split("=", 1)[1]
elements = get_webelements_in_active_area(xpath, **kwargs)
# pylint: disable=no-else-return
if elements and len(elements) == 1:
if CONFIG['SearchMode']:
draw_borders(elements[0])
return elements[0]
elif not elements:
raise QWebElementNotFoundError(
'XPath {} did not find any elements'.format(xpath))
raise QWebValueError(
'XPath {} matched {} elements. Needs to be unique'.format(
xpath, len(elements)))
def get_element_count(locator, timeout=0, **kwargs): # pylint: disable=unused-argument
r"""Get count of appearances for certain web element.
Keyword waits until timeout has passed. If timeout is not specified, it
uses default timeout that can be adjusted with DefaultTimeout keyword.
GetTextCount does not require for the text to be unique.
Examples
--------
.. code-block:: robotframework
${COUNT} GetElementCount //*[@id\="Foo"]
${COUNT} GetElementCount Foo tag=div
Parameters
----------
locator : str
Xpath or some attribute value of element. When using XPaths, the equal sign "=" must be
escaped with a "\".
timeout : str | int
How long we try to find text before failing. Default 10 (seconds)
Accepted kwargs:
tag=tagname: Needed when attribute value is used as a locator
"""
kwargs['element_kw'] = True
if 'tag' in kwargs:
web_elements = element.get_elements_by_attributes(
kwargs.get('tag'), locator, **kwargs)
else:
web_elements = element.get_webelements(locator, **kwargs)
if web_elements:
return len(web_elements)
raise QWebElementNotFoundError('Webelements not found')
def find_text(text):
try:
if javascript.execute_javascript(
"return window.find('{}')".format(text.replace("\'", "\\'"))):
return True
except WebDriverException as e:
logger.debug('Got webdriver exception from find text func: {}'.format(e))
raise QWebElementNotFoundError('Text not found')
def get_parent_list_element(locator_element, css):
try:
web_element = javascript.get_parent_list(locator_element, css)
except (WebDriverException, JavascriptException) as e:
web_element = None
logger.debug('Got Exception from get_parent_list: {}'.format(e))
if web_element:
return web_element
raise QWebElementNotFoundError('Parent with tag {} not found.'.format(css))
def get_table_by_locator_table(locator, parent, child, level, index):
if parent:
script = ".parentElement.closest('table')" * int(level)
parent_table = javascript.execute_javascript(
"return arguments[0]{}".format(script), locator)
if parent_table:
if not child:
return parent_table
locator = parent_table
else:
raise QWebElementNotFoundError('No parent table found')
if child:
script = ".querySelectorAll('table')[{}]".format(int(index) - 1)
child_table = javascript.execute_javascript(
"return arguments[0]{}".format(script), locator)
if child_table:
return child_table
raise QWebElementNotFoundError('No child table found')
raise QWebElementNotFoundError('Sub/parent table not found')
def get_checkbox_elements_from_all_documents(locator, anchor, index, **kwargs):
"""Function for finding checkbox elements.
Parameters
----------
locator : str
Label text or attribute that points to the checkbox.
anchor : str
in case there is duplicates.
index : int
If multiple matches. Use index to pick correct one.
Returns
-------
WebElement
"""
index = int(index) - 1
css_selector = CONFIG["CssSelectors"]
css = '[type="checkbox"], [role="checkbox"]'
if Table.is_table_coordinates(locator):
table = Table.ACTIVE_TABLE.update_table()
if table is None:
raise QWebInstanceDoesNotExistError(
'Table has not been defined with UseTable keyword')
locator_element = table.get_table_cell(locator, anchor)
checkbox_element = element.get_element_from_childnodes(
locator_element, css, dom_traversing=False, **kwargs)
if checkbox_element:
return checkbox_element[index], locator_element
raise QWebElementNotFoundError('No matching checkbox found')
if not css_selector or locator.startswith('xpath=') or locator.startswith(
'//'):
checkbox_element, locator_element = get_checkbox_by_locator(
locator, anchor=anchor)
else:
checkbox_element, locator_element = get_checkbox_by_css_selector(
locator, anchor=anchor, index=index, **kwargs)
if not checkbox_element:
checkbox_element, locator_element = get_checkbox_by_locator(
locator, anchor)
if checkbox_element:
return checkbox_element, locator_element
raise QWebElementNotFoundError('No matching element found')
def verify_element(xpath, timeout=0, **kwargs): # pylint: disable=unused-argument
r"""Verify that element can be found on the page and it is visible.
Examples
--------
.. code-block:: robotframework
VerifyElement //*[@id\="wait_me"]
This keyword has timeout functionality. If the element is not visible after
given timeout, error is raised.
For example.
.. code-block:: robotframework
VerifyElement //*[@id\="wait_me"] 20 #waits 20 seconds
Parameters
----------
xpath : str
Xpath expression without xpath= prefix. The equal sign "=" must be escaped with a "\\".
timeout : str | int
Timeout for finding the element. If the element is not visible after
given timeout, error is raised. The str is converted to integer
using robot.utils.timestr_to_secs. (default 10 seconds)
kwargs :
| Accepted kwargs:
| tag : html tag of preferred elemenr -
| If tag is used then element is found
| by some of it's attribute (xpath is not needed)
| partial_match: True. If element is found by it's attribute set partial_match
| to True to allow partial match
Raises
------
QWebElementNotFoundError
Page did not contain element
Related keywords
----------------
\`ClickElement\`, \`GetAttribute\`, \`GetWebElement\`, \`GetElementCount\`,
\`VerifyItem\`, \`VerifyText\`
"""
kwargs['element_kw'] = True
if 'tag' in kwargs:
web_elements = element.get_visible_elements_from_elements(
element.get_elements_by_attributes(kwargs.get('tag'), xpath,
**kwargs))
else:
web_elements = element.get_webelements(xpath, **kwargs)
if web_elements:
return
raise QWebElementNotFoundError('No matching element found')
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 _equal_sign_handler(args, kwargs, function_name):
if 'go_to' in str(function_name):
if kwargs:
new_args = []
for k, v in kwargs.items():
new_args.append(k)
new_args.append(v)
args = tuple(["=".join(map(str, new_args))])
kwargs.clear()
try:
locator = args[0]
except IndexError:
raise QWebElementNotFoundError("Use \\= instead of = in xpaths")
return args, kwargs, locator
def click_icon(image, template_res_w=None, browser_res_w=None, timeout=0): # pylint: disable=unused-argument
r"""Click the icon on the screen.
In case you want to click icons you always have to have reference images.
If reference picture are not in default folders (images, files, downloads) then
BASE_IMAGE_PATH should be defined in a robot file before using this keyword
Examples
--------
.. code-block:: robotframework
*** Variables ***
${BASE_IMAGE_PATH} ${CURDIR}${/}..${/}resources${/}images
BASE_IMAGE_PATH should lead to the folder where all your reference icons are
.. code-block:: robotframework
ClickIcon plane
Related keywords
----------------
\`ClickCell\`, \`ClickCheckbox\`, \`ClickElement\`,
\`ClickItem\`, \`ClickList\`, \`ClickText\`,
\`ClickUntil\`, \`ClickWhile\`, \`VerifyIcon\`
"""
if not browser_res_w:
browser_res_w = util.get_monitor_width(
) # pyautogui works on whole screen
# use current resolution by default
if not template_res_w:
template_res_w = browser_res_w
template_res_w, browser_res_w = int(template_res_w), int(browser_res_w)
image_path = icon.get_full_image_path(image)
x, y = icon.image_recognition(image_path,
template_res_w,
browser_res_w,
pyautog=True)
if x == -1:
raise QWebElementNotFoundError(
"Couldn't find the icon from the screen")
if CONFIG.get_value("RetinaDisplay"):
x = x * 0.5
y = y * 0.5
pyautogui.moveTo(x, y)
pyautogui.click(x, y)
def get_draggable_element(text, index, anchor):
attribute_match = '[title^="{0}"][draggable="true"],[alt^="{0}"][draggable="true"],' \
'[tooltip^="{0}"][draggable="true"],' \
'[data-tooltip^="{0}"][draggable="true"],' \
'[data-icon^="{0}"][draggable="true"],' \
'[aria-label^="{0}"][draggable="true"],' \
'[title^="{0}"][class*="draggableCell"]'.format(text)
web_elements = []
matches = []
if text.startswith('xpath=') or text.startswith('//'):
web_element = element.get_unique_element_by_xpath(text)
if web_element:
return web_element
raise QWebElementNotFoundError('Draggable element not found by locator {}'.format(text))
try:
index = int(index) - 1
except ValueError as e:
raise QWebValueError('Index needs to be number') from e
web_elements = javascript.execute_javascript(
'return document.querySelectorAll(\'{}\')'.format(attribute_match))
if web_elements:
return web_elements[index]
web_elements = javascript.execute_javascript(
'return document.querySelectorAll(\'[draggable="true"]\')')
if web_elements:
matches = _find_matches(web_elements, text)
if matches:
return matches[index]
if text == 'index':
logger.warn('Text is not matching to any draggable element. Found {} '
'draggable elements. Using index..'.format(len(web_elements)))
return web_elements[index]
web_elements = get_text_using_anchor(text, anchor)
if web_elements:
return web_elements
raise QWebElementNotFoundError('Draggable element not found by locator {}'.format(text))
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 create_list(self, locator, anchor, **kwargs):
if locator.startswith('//') or locator.startswith('xpath='):
if locator.startswith('xpath='):
locator = locator.split("=", 1)[1]
web_elements = self.get_elements_by_locator_xpath_and_tag_name(
locator, anchor, **kwargs)
else:
web_elements = self.get_elements_by_locator_text_and_tag_name(
locator, anchor, **kwargs)
logger.debug('webelems: {}'.format(web_elements))
if web_elements:
if CONFIG['SearchMode']:
element.draw_borders(web_elements)
web_list = self.get_texts(web_elements)
return web_list, web_elements
raise QWebElementNotFoundError('Suitable elements not found')
def _execute_block(steps, timeout=0, **kwargs): # pylint: disable=unused-argument
logger.trace('Timeout for block: {}'.format(timeout))
logger.trace(steps)
for step in steps:
fn = step.get('paceword')
var_name = step.get('variable', None)
args = blocks.set_robot_args(*step.get('args'), **step.get('kwargs'))
status, res = BuiltIn().run_keyword_and_ignore_error(fn, *args)
logger.trace('status: {}, res: {}'.format(status, res))
if status == 'FAIL':
teardown = kwargs.get('exp_handler', None)
if teardown:
BuiltIn().run_keyword_and_ignore_error(teardown)
raise QWebElementNotFoundError('Err from block {}'.format(res))
if var_name:
BuiltIn().set_suite_variable('{}'.format(var_name), res)
def get_text_using_anchor(text, anchor, **kwargs):
"""Get WebElement that contains text using anchor if necessary.
First locates the elements that has the exact text. If no elements were
found then searching as a substring using XPath's contains function. If
we come up empty then NoSuchElementException is raised.
If text corresponded to multiple elements then anchor is taken in to
play.
Parameters
----------
text : str
Text on web page that is wanted to locate.
anchor : str
Unique text on web page which is close to the first argument.
Accepted kwargs:
css=False/off: Use this to bypass css search when finding elements
by visible text
Returns
-------
WebElement
"""
web_elements = get_all_text_elements(text, **kwargs)
modal_xpath = CONFIG['IsModalXpath']
driver = browser.get_current_browser()
if modal_xpath != "//body":
# filter elements by modal (dialog etc)
logger.debug("IsModalXpath filtering on, filtering...")
modal_exists = driver.find_elements(By.XPATH, modal_xpath)
if modal_exists:
web_elements = _filter_by_modal_ancestor(web_elements)
logger.debug(
f"after filtering there are: {len(web_elements)} matching elements"
)
if not web_elements:
raise QWebElementNotFoundError(
'Webpage did not contain text "{}"'.format(text))
if len(web_elements) == 1:
return web_elements[0]
# Found many elements, use anchors to determine correct element
correct_element = get_element_using_anchor(web_elements, anchor, **kwargs)
return correct_element
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 get_closest_element(locator_element, candidate_elements):
"""Get the closest element in a list of elements to a wanted element.
Parameters
----------
locator_element : WebElement
candidate_elements : :obj:`list` of :obj:`WebElement`
Returns
-------
WebElement
"""
if not candidate_elements:
raise QWebElementNotFoundError('No elements visible')
closest_element_list = []
closest_distance = 1000000 # Just some large number
for candidate_element in candidate_elements:
element_info = _list_info(candidate_element)
logger.debug("Measuring distance for: {}".format(element_info))
if _overlap(locator_element, candidate_element):
logger.debug(
'Elements overlap, returning this: {}'.format(element_info))
return candidate_element
distance = _calculate_closest_distance(locator_element,
candidate_element)
logger.debug("Candidate {}: distance: {}".format(
candidate_element, distance))
if abs(distance - closest_distance) < 2:
closest_element_list.append(candidate_element)
closest_distance = distance
elif distance < closest_distance:
closest_distance = distance
closest_element_list = [candidate_element]
closest_element = _get_closest_ortho_element(locator_element,
closest_element_list)
logger.debug("Closest distance found is {}".format(closest_distance))
logger.debug("Closest element is: {}".format(_list_info(closest_element)))
return closest_element
def get_table_element(self, locator, anchor):
if util.xpath_validator(locator):
table_element = element.get_unique_element_by_xpath(locator)
else: # Search using text
table_xpath = "//*[text()= '{0}']/ancestor::table".format(locator)
table_elements = element.get_webelements_in_active_area(
table_xpath)
if table_elements and len(table_elements) == 1:
table_element = table_elements[0]
elif not table_elements: # Find table element using locator
locator_element = text.get_text_using_anchor(locator, anchor)
table_elements = self._get_all_table_elements()
table_element = element.get_closest_element(
locator_element, table_elements)
else: # Found many
table_element = text.get_element_using_anchor(
table_elements, anchor)
if table_element:
return table_element
raise QWebElementNotFoundError(
'Table element not found by locator {}'.format(locator))
def get_table_cell(self, coordinates, anchor, **kwargs): # pylint: disable=unused-argument
cell = None
try:
if '/' in coordinates:
cell = self.get_using_text_in_coordinates(coordinates, anchor)
else:
row, column = self._convert_coordinates(coordinates)
try:
cell = self.table.find_element(
By.XPATH, './/tr[{0}]//td[{1}]'.format(row, column))
except AttributeError as e:
logger.debug('exception {}'.format(e))
self.update_table()
if cell:
if CONFIG['SearchMode']:
element.draw_borders(cell)
return cell
except (StaleElementReferenceException, NoSuchElementException) as e:
logger.debug('exception {}'.format(e))
self.update_table()
raise QWebElementNotFoundError(
'Cell for coords {} not found after'.format(coordinates))
def get_elements_from_dom_content(*args, **kwargs):
try:
args, kwargs, locator = _equal_sign_handler(args, kwargs, fn)
msg = None
params = signature(fn).parameters
args, kwargs = _args_to_kwargs(params, args, kwargs)
timeout = get_timeout(**kwargs)
logger.debug('Timeout is {} sec'.format(timeout))
try:
if 'go_to' not in str(fn) and 'switch_window' not in str(fn):
frame.wait_page_loaded()
except UnexpectedAlertPresentException as e:
if not CONFIG["HandleAlerts"]:
raise QWebUnexpectedAlert(str(e))
logger.debug('Got {}. Trying to retry..'.format(e))
time.sleep(SHORT_DELAY)
start = time.time()
while time.time() < timeout + start:
try:
kwargs['timeout'] = float(timeout + start - time.time())
config.set_config('FrameTimeout',
float(timeout + start - time.time()))
return fn(*args, **kwargs)
except (QWebUnexpectedConditionError, QWebTimeoutError) as e:
logger.warn('Got {}'.format(e))
except (InvalidSelectorException, NoSuchElementException,
QWebElementNotFoundError,
UnexpectedAlertPresentException,
QWebStalingElementError,
StaleElementReferenceException,
QWebIconNotFoundError) as e:
time.sleep(SHORT_DELAY)
logger.debug(
'Got exception: {}. Trying to retry..'.format(e))
except InvalidSessionIdException:
CONFIG.set_value("OSScreenshots", True)
raise QWebBrowserError(
"Browser session lost. Did browser crash?")
except (WebDriverException, QWebDriverError) as e:
if any(s in str(e) for s in FATAL_MESSAGES):
CONFIG.set_value("OSScreenshots", True)
raise QWebBrowserError(e)
logger.info(
'From timeout decorator: Webdriver exception. Retrying..'
)
logger.info(e)
time.sleep(SHORT_DELAY)
err = QWebDriverError
msg = e
except QWebValueError as ve:
logger.debug(
'Got QWebValueError: {}. Trying to retry..'.format(ve))
err = QWebValueError
msg = ve
time.sleep(SHORT_DELAY)
if msg:
raise err(msg)
if 'count' in str(fn):
return 0
if 'is_text' in str(fn) or 'is_no_text' in str(fn):
return False
raise QWebElementNotFoundError(
'Unable to find element for locator {} in {} sec'.format(
locator, timeout))
except QWebSearchingMode:
pass
def get_attribute(locator,
attribute,
anchor='1',
element_type=None,
timeout=0,
**kwargs):
r"""Get attribute value of an element.
Examples
--------
Using attributes or xpaths like with ClickElement etc. kw:s without specified
element_type. If element_type is not specified end result is a type of list:
.. code-block:: robotframework
${attribute_value} GetAttribute click_me id tag=button
${attribute_value} GetAttribute //*[@id\="click_me"] id
${attribute_value} GetAttribute xpath\=//*[@id\="click_me"] name
GetAttribute using element_type attribute to locate element.
Text elements works as ClickText, VerifyText, GetText etc.:
.. code-block:: robotframework
${attribute_value} GetAttribute Log In type element_type=text
${attribute_value} GetAttribute Contact id element_type=text anchor=Qentinel
${attribute_value} GetAttribute Contact class parent=div
Item, Input, Dropdown, Checkbox elements:
.. code-block:: robotframework
${attribute_value} GetAttribute Log In id element_type=item
${attribute_value} GetAttribute Username placeholder element_type=input
${attribute_value} GetAttribute Country value element_type=dropdown
${attribute_value} GetAttribute Gender checked element_type=checkbox
All flags are available for using (timeout, anchor, index, visibility, parent, child etc.).
in same way as you are using those with Pacewords like ClickText/Item, TypeText, Dropdown etc.
Parameters
----------
locator : str
Visible text, attribute value or Xpath expression with or without xpath= prefix.
The equal sign "=" must be escaped with a "\\".
attribute: str
Attribute which value we want to get.
anchor : int
Used when element_type is defined. Default=1 (first match)
element_type : string
Define element type/preferred searching method
(available types: text, input, checkbox, item, dropdown).
timeout : int
How long we wait element to appear. Default=10 sec
kwargs :
| Accepted kwargs:
| Any available for picked searching method.
| See interacting with text, item, input etc. elements from
| documentation
Returns
-------
value : Value of attribute (true if attribute exist but does not have value)
Related keywords
----------------
\`VerifyAttribute\`, \`VerifyElement\`
"""
webelement = get_webelement(locator, anchor, element_type, timeout,
**kwargs)
if not webelement:
raise QWebElementNotFoundError(
'Could not find element {} with attribute {}'.format(
locator, attribute))
if not isinstance(webelement, list):
return webelement.get_attribute(attribute)
if len(webelement) == 1:
return webelement[0].get_attribute(attribute)
raise QWebValueError(
'Found {} occurences of locator {}. '
'Use index etc. to uniquely identify the element'.format(
len(webelement), locator))
def get_parent_element(web_element, tag):
web_element = javascript.execute_javascript(
'return arguments[0].closest(\'{}\')'.format(tag), web_element)
if web_element:
return web_element
raise QWebElementNotFoundError('Parent with tag {} not found.'.format(tag))
def get_webelement(locator,
anchor='1',
element_type=None,
timeout=0,
**kwargs):
r"""Get Webelement using any Paceword -stylish locator.
Examples
--------
Using attributes or xpaths like with ClickElement etc. kw:s without specified
element_type. If element_type is not specified end result is a type of list:
.. code-block:: robotframework
${list of elems} GetWebelement click_me tag=button
${list of elems} GetWebelement //*[@id\="click_me"]
${list of elems} GetWebelement xpath\=//*[@id\="click_me"]
Get element using element_type attribute to locate element.
Text elements works as ClickText, VerifyText, GetText etc.:
.. code-block:: robotframework
${elem} GetWebelement Log In element_type=text
${elem} GetWebelement Contact element_type=text anchor=Qentinel
${elem} GetWebelement Contact parent=div
Item, Input, Dropdown, Checkbox elements:
.. code-block:: robotframework
${elem} GetWebelement Log In element_type=item
${elem} GetWebelement Username element_type=input
${elem} GetWebelement Country element_type=dropdown
${elem} GetWebelement Gender element_type=checkbox
All flags are available for using (timeout, anchor, index, visibility, parent, child etc.).
in same way as you are using those with Pacewords like ClickText/Item, TypeText, Dropdown etc.
Parameters
----------
locator : str
Visible text, attribute value or Xpath expression with or without xpath= prefix.
The equal sign "=" must be escaped with a "\\".
anchor : int
Used when element_type is defined. Default=1 (first match)
element_type : string
Define element type/preferred searching method
(available types: text, input, checkbox, item, dropdown).
timeout : int
How long we wait element to appear. Default=10 sec
kwargs :
| Accepted kwargs:
| Any available for picked searching method.
| See interacting with text, item, input etc. elements from
| documentation
Related keywords
----------------
\`ClickElement\`, \`HoverElement\`, \`TypeText\`
"""
kwargs['index'] = kwargs.get('index', 1)
kwargs['timeout'] = timeout
if element_type:
if element_type.lower() == 'text':
return text.get_element_by_locator_text(locator, anchor, **kwargs)
if element_type.lower() == 'item':
return text.get_item_using_anchor(locator, anchor, **kwargs)
if element_type.lower() == "dropdown":
return dropdown.get_dd_elements_from_all_documents(
locator, anchor, **kwargs)
if element_type.lower() == "input":
return input_.get_input_elements_from_all_documents(
locator, anchor, **kwargs)
if element_type.lower() == "checkbox":
return checkbox.get_checkbox_elements_from_all_documents(
locator, anchor, **kwargs)
kwargs['element_kw'] = True
if 'tag' in kwargs:
web_elements = element.get_visible_elements_from_elements(
element.get_elements_by_attributes(kwargs.get('tag'), locator,
**kwargs))
else:
web_elements = element.get_webelements(locator)
if web_elements:
return web_elements
raise QWebElementNotFoundError('No matching element found')
def get_input_elements_from_all_documents(locator,
anchor,
timeout,
index=1,
enable_check=False,
**kwargs): # pylint: disable=unused-argument
"""Function for finding input elements.
Parameters
----------
locator : str
Label text or attribute that points to the checkbox.
anchor : str
in case there is duplicates.
timeout : str
How long we are finding before fail.
Default = Search Strategy global default = 10 sec)
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)
enable_check : bool
When CSS Selectors are used, we are not return disabled input element
always by default. Element is needed with verify input status kw
so if enable_check= True, disabled input_element is returned
kwargs:
limit_traverse : bool
If set to false. We are heading up to fifth parent element if needed when
finding relative input element for some label text.
Returns
-------
WebElement
"""
index = int(index) - 1
css = 'input:not([type="hidden"]):not([type="submit"]):not([type="button"])' \
':not([type="reset"]):not([type="checkbox"]):not([type="radio"])' \
':not([aria-hidden="true"]),' \
'textarea:not([type="hidden"]),[contenteditable="true"]'
kwargs['css'] = kwargs.get('css', css)
if Table.is_table_coordinates(locator):
table = Table.ACTIVE_TABLE.update_table()
if table is None:
raise QWebInstanceDoesNotExistError(
'Table has not been defined with UseTable keyword')
locator_element = table.get_table_cell(locator, anchor)
input_element = element.get_element_from_childnodes(
locator_element, kwargs['css'], dom_traversing=False)
if input_element:
return input_element[index]
raise QWebElementNotFoundError('No matching table input found')
css_selector = CONFIG["CssSelectors"]
if not css_selector or locator.startswith('xpath=') or locator.startswith(
'//'):
input_element = get_input_element_by_locator(locator, anchor, **kwargs)
else:
logger.debug('Uses CSS-selectors to locate element')
input_element = get_input_element_by_css_selector(
locator, anchor, index, enable_check, **kwargs)
if not input_element:
input_element = get_input_element_by_locator(
locator, anchor, **kwargs)
if input_element:
if CONFIG['SearchMode']:
element.draw_borders(input_element)
return input_element
raise QWebElementNotFoundError('No matching input elements found')
