def open_context_menu(self, locator: Union[WebElement, str]):
"""Opens the context menu on the element identified by ``locator``."""
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action = ActionChains(self.driver)
action.context_click(element).perform()
def _click_with_action_chain(self, locator: Union[WebElement, str]):
self.info(f"Clicking '{locator}' using an action chain.")
action = ActionChains(self.driver)
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action.move_to_element(element)
action.click()
action.perform()
def drag_and_drop(self, locator: str, target: str):
"""Drags the element identified by ``locator`` into the ``target`` element.
The ``locator`` argument is the locator of the dragged element
and the ``target`` is the locator of the target. See the
`Locating elements` section for details about the locator syntax.
Example:
| `Drag And Drop` | css:div#element | css:div.target |
"""
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
target = self.find_element(target)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
target = _unwrap_eventfiring_element(target)
action = ActionChains(self.driver)
action.drag_and_drop(element, target).perform()
def mouse_up(self, locator: Union[WebElement, str]):
"""Simulates releasing the left mouse button on the element ``locator``.
See the `Locating elements` section for details about the locator
syntax.
"""
self.info(f"Simulating Mouse Up on element '{locator}'.")
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
ActionChains(self.driver).release(element).perform()
def mouse_down_on_link(self, locator: Union[WebElement, str]):
"""Simulates a mouse down event on a link identified by ``locator``.
See the `Locating elements` section for details about the locator
syntax. When using the default locator strategy, links are searched
using ``id``, ``name``, ``href`` and the link text.
"""
element = self.find_element(locator, tag="link")
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action = ActionChains(self.driver)
action.click_and_hold(element).perform()
def mouse_over(self, locator: Union[WebElement, str]):
"""Simulates hovering the mouse over the element ``locator``.
See the `Locating elements` section for details about the locator
syntax.
"""
self.info(f"Simulating Mouse Over on element '{locator}'.")
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action = ActionChains(self.driver)
action.move_to_element(element).perform()
def scroll_element_into_view(self, locator: Union[WebElement, str]):
"""Scrolls the element identified by ``locator`` into view.
See the `Locating elements` section for details about the locator
syntax.
New in SeleniumLibrary 3.2.0
"""
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
ActionChains(self.driver).move_to_element(element).perform()
def double_click_element(self, locator: Union[WebElement, str]):
"""Double clicks the element identified by ``locator``.
See the `Locating elements` section for details about the locator
syntax.
"""
self.info(f"Double clicking element '{locator}'.")
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action = ActionChains(self.driver)
action.double_click(element).perform()
def mouse_down_on_image(self, locator: str):
"""Simulates a mouse down event on an image identified by ``locator``.
See the `Locating elements` section for details about the locator
syntax. When using the default locator strategy, images are searched
using ``id``, ``name``, ``src`` and ``alt``.
"""
element = self.find_element(locator, tag="image")
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action = ActionChains(self.driver)
action.click_and_hold(element).perform()
def mouse_out(self, locator: Union[WebElement, str]):
"""Simulates moving the mouse away from the element ``locator``.
See the `Locating elements` section for details about the locator
syntax.
"""
self.info(f"Simulating Mouse Out on element '{locator}'.")
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
size = element.size
offsetx = (size["width"] / 2) + 1
offsety = (size["height"] / 2) + 1
action = ActionChains(self.driver)
action.move_to_element(element)
action.move_by_offset(offsetx, offsety)
action.perform()
def mouse_down(self, locator: Union[WebElement, str]):
"""Simulates pressing the left mouse button on the element ``locator``.
See the `Locating elements` section for details about the locator
syntax.
The element is pressed without releasing the mouse button.
See also the more specific keywords `Mouse Down On Image` and
`Mouse Down On Link`.
"""
self.info(f"Simulating Mouse Down on element '{locator}'.")
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action = ActionChains(self.driver)
action.click_and_hold(element).perform()
def _click_with_modifier(self, locator, tag, modifier):
self.info(
f"Clicking {tag if tag[0] else 'element'} '{locator}' with {modifier}."
)
modifier = self.parse_modifier(modifier)
action = ActionChains(self.driver)
for item in modifier:
action.key_down(item)
element = self.find_element(locator, tag=tag[0], required=False)
if not element:
element = self.find_element(locator, tag=tag[1])
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action.click(element)
for item in modifier:
action.key_up(item)
action.perform()
def drag_and_drop_by_offset(self, locator: str, xoffset: int, yoffset: int):
"""Drags the element identified with ``locator`` by ``xoffset/yoffset``.
See the `Locating elements` section for details about the locator
syntax.
The element will be moved by ``xoffset`` and ``yoffset``, each of which
is a negative or positive number specifying the offset.
Example:
| `Drag And Drop By Offset` | myElem | 50 | -35 | # Move myElem 50px right and 35px down |
"""
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action = ActionChains(self.driver)
action.drag_and_drop_by_offset(element, xoffset, yoffset)
action.perform()
def click_element_at_coordinates(self, locator, xoffset, yoffset):
"""Click the element ``locator`` at ``xoffset/yoffset``.
The Cursor is moved and the center of the element and x/y coordinates are
calculated from that point.
See the `Locating elements` section for details about the locator
syntax.
"""
self.info(
f"Clicking element '{locator}' at coordinates x={xoffset}, y={yoffset}."
)
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
action = ActionChains(self.driver)
action.move_to_element(element)
action.move_by_offset(xoffset, yoffset)
action.click()
action.perform()
def press_keys(self,
locator: Union[WebElement, None, str] = None,
*keys: str):
"""Simulates the user pressing key(s) to an element or on the active browser.
If ``locator`` evaluates as false, see `Boolean arguments` for more
details, then the ``keys`` are sent to the currently active browser.
Otherwise element is searched and ``keys`` are send to the element
identified by the ``locator``. In later case, keyword fails if element
is not found. See the `Locating elements` section for details about
the locator syntax.
``keys`` arguments can contain one or many strings, but it can not
be empty. ``keys`` can also be a combination of
[https://seleniumhq.github.io/selenium/docs/api/py/webdriver/selenium.webdriver.common.keys.html|Selenium Keys]
and strings or a single Selenium Key. If Selenium Key is combined
with strings, Selenium key and strings must be separated by the
`+` character, like in `CONTROL+c`. Selenium Keys
are space and case sensitive and Selenium Keys are not parsed
inside of the string. Example AALTO, would send string `AALTO`
and `ALT` not parsed inside of the string. But `A+ALT+O` would
found Selenium ALT key from the ``keys`` argument. It also possible
to press many Selenium Keys down at the same time, example
'ALT+ARROW_DOWN`.
If Selenium Keys are detected in the ``keys`` argument, keyword
will press the Selenium Key down, send the strings and
then release the Selenium Key. If keyword needs to send a Selenium
Key as a string, then each character must be separated with
`+` character, example `E+N+D`.
`CTRL` is alias for
[https://seleniumhq.github.io/selenium/docs/api/py/webdriver/selenium.webdriver.common.keys.html#selenium.webdriver.common.keys.Keys.CONTROL|Selenium CONTROL]
and ESC is alias for
[https://seleniumhq.github.io/selenium/docs/api/py/webdriver/selenium.webdriver.common.keys.html#selenium.webdriver.common.keys.Keys.ESCAPE|Selenium ESCAPE]
New in SeleniumLibrary 3.3
Examples:
| `Press Keys` | text_field | AAAAA | | # Sends string "AAAAA" to element. |
| `Press Keys` | None | BBBBB | | # Sends string "BBBBB" to currently active browser. |
| `Press Keys` | text_field | E+N+D | | # Sends string "END" to element. |
| `Press Keys` | text_field | XXX | YY | # Sends strings "XXX" and "YY" to element. |
| `Press Keys` | text_field | XXX+YY | | # Same as above. |
| `Press Keys` | text_field | ALT+ARROW_DOWN | | # Pressing "ALT" key down, then pressing ARROW_DOWN and then releasing both keys. |
| `Press Keys` | text_field | ALT | ARROW_DOWN | # Pressing "ALT" key and then pressing ARROW_DOWN. |
| `Press Keys` | text_field | CTRL+c | | # Pressing CTRL key down, sends string "c" and then releases CTRL key. |
| `Press Keys` | button | RETURN | | # Pressing "ENTER" key to element. |
"""
parsed_keys = self._parse_keys(*keys)
if not is_noney(locator):
self.info(f"Sending key(s) {keys} to {locator} element.")
element = self.find_element(locator)
# _unwrap_eventfiring_element can be removed when minimum required Selenium is 4.0 or greater.
element = _unwrap_eventfiring_element(element)
ActionChains(self.driver).click(element).perform()
else:
self.info(f"Sending key(s) {keys} to page.")
element = None
for parsed_key in parsed_keys:
actions = ActionChains(self.driver)
for key in parsed_key:
if key.special:
self._press_keys_special_keys(actions, element, parsed_key,
key)
else:
self._press_keys_normal_keys(actions, key)
self._special_key_up(actions, parsed_key)
actions.perform()
