Warning
This document is for an old release of Galaxy. You can alternatively view this page in the latest release if it exists or view the top of the latest release's documentation.
Source code for galaxy.selenium.has_driver
"""A mixin to extend a class that has self.driver with higher-level constructs.
This should be mixed into classes with a self.driver and self.default_timeout
attribute.
"""
from selenium.common.exceptions import TimeoutException as SeleniumTimeoutException
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.remote.webdriver import WebDriver
from selenium.webdriver.support import expected_conditions as ec
from selenium.webdriver.support.ui import WebDriverWait
UNSPECIFIED_TIMEOUT = object()
[docs]class HasDriver:
driver: WebDriver
[docs] def re_get_with_query_params(self, params_str: str):
driver = self.driver
new_url = driver.current_url
if "?" not in new_url:
new_url += "?"
new_url += params_str
driver.get(new_url)
[docs] def assert_selector(self, selector):
assert self.driver.find_element_by_css_selector(selector)
[docs] def selector_is_displayed(self, selector):
element = self.driver.find_element_by_css_selector(selector)
return element.is_displayed()
[docs] def is_displayed(self, selector_template):
element = self.driver.find_element(*selector_template.element_locator)
return element.is_displayed()
[docs] def assert_selector_absent(self, selector):
assert len(self.driver.find_elements_by_css_selector(selector)) == 0
[docs] def find_elements(self, selector_template):
return self.driver.find_elements(*selector_template.element_locator)
[docs] def assert_absent(self, selector_template):
assert len(self.find_elements(selector_template)) == 0
[docs] def element_absent(self, selector_template):
return len(self.find_elements(selector_template)) == 0
[docs] def wait_for_xpath(self, xpath, **kwds):
element = self._wait_on(
ec.presence_of_element_located((By.XPATH, xpath)), f"XPATH selector [{xpath}] to become present", **kwds
)
return element
[docs] def wait_for_xpath_visible(self, xpath, **kwds):
element = self._wait_on(
ec.visibility_of_element_located((By.XPATH, xpath)), f"XPATH selector [{xpath}] to become visible", **kwds
)
return element
[docs] def wait_for_selector(self, selector, **kwds):
element = self._wait_on(
ec.presence_of_element_located((By.CSS_SELECTOR, selector)),
f"CSS selector [{selector}] to become present",
**kwds,
)
return element
[docs] def wait_for_present(self, selector_template, **kwds):
element = self._wait_on(
ec.presence_of_element_located(selector_template.element_locator),
f"{selector_template.description} to become present",
**kwds,
)
return element
[docs] def wait_for_visible(self, selector_template, **kwds):
element = self._wait_on(
ec.visibility_of_element_located(selector_template.element_locator),
f"{selector_template.description} to become visible",
**kwds,
)
return element
[docs] def wait_for_selector_visible(self, selector, **kwds):
element = self._wait_on(
ec.visibility_of_element_located((By.CSS_SELECTOR, selector)),
f"CSS selector [{selector}] to become visible",
**kwds,
)
return element
[docs] def wait_for_selector_clickable(self, selector, **kwds):
element = self._wait_on(
ec.element_to_be_clickable((By.CSS_SELECTOR, selector)),
f"CSS selector [{selector}] to become clickable",
**kwds,
)
return element
[docs] def wait_for_clickable(self, selector_template, **kwds):
element = self._wait_on(
ec.element_to_be_clickable(selector_template.element_locator),
f"{selector_template.description} to become clickable",
**kwds,
)
return element
[docs] def wait_for_selector_absent(self, selector, **kwds):
element = self._wait_on(
lambda driver: len(driver.find_elements_by_css_selector(selector)) == 0,
f"CSS selector [{selector}] to become absent",
**kwds,
)
return element
[docs] def wait_for_element_count_of_at_least(self, selector_template, n, **kwds):
element = self._wait_on(
lambda driver: len(driver.find_elements(*selector_template.element_locator)) >= n,
f"{selector_template.description} to become absent",
**kwds,
)
return element
[docs] def wait_for_absent(self, selector_template, **kwds):
element = self._wait_on(
lambda driver: len(driver.find_elements(*selector_template.element_locator)) == 0,
f"{selector_template.description} to become absent",
**kwds,
)
return element
[docs] def wait_for_id(self, id, **kwds):
return self._wait_on(ec.presence_of_element_located((By.ID, id)), f"presence of DOM ID [{id}]", **kwds)
[docs] def click(self, selector_template):
element = self.driver.find_element(*selector_template.element_locator)
element.click()
def _timeout_message(self, on_str):
return f"Timeout waiting on {on_str}."
def _wait_on(self, condition, on_str=None, **kwds):
if on_str is None:
on_str = str(condition)
wait = self.wait(**kwds)
return wait.until(condition, self._timeout_message(on_str))
[docs] def send_escape(self, element=None):
if element is None:
self.action_chains().send_keys(Keys.ESCAPE)
else:
element.send_keys(Keys.ESCAPE)
[docs] def wait(self, timeout=UNSPECIFIED_TIMEOUT, **kwds):
if timeout is UNSPECIFIED_TIMEOUT:
timeout = self.timeout_for(**kwds)
return WebDriverWait(self.driver, timeout)
[docs] def click_xpath(self, xpath):
element = self.driver.find_element_by_xpath(xpath)
element.click()
[docs] def click_label(self, text):
element = self.driver.find_element_by_link_text(text)
element.click()
[docs] def click_selector(self, selector):
element = self.driver.find_element_by_css_selector(selector)
element.click()
[docs] def fill(self, form, info):
for key, value in info.items():
input_element = form.find_element_by_name(key)
input_element.send_keys(value)
[docs] def click_submit(self, form):
submit_button = form.find_element_by_css_selector("input[type='submit']")
submit_button.click()
[docs] def prepend_timeout_message(self, timeout_exception, message):
msg = message
timeout_msg = timeout_exception.msg
if timeout_msg:
msg += f" {timeout_msg}"
return SeleniumTimeoutException(
msg=msg,
screen=timeout_exception.screen,
stacktrace=timeout_exception.stacktrace,
)
[docs] def accept_alert(self):
try:
alert = self.driver.switch_to.alert
alert.accept()
finally:
self.driver.switch_to.default_content()
[docs]def exception_indicates_click_intercepted(exception):
return "click intercepted" in str(exception)
__all__ = (
"exception_indicates_click_intercepted",
"exception_indicates_not_clickable",
"exception_indicates_stale_element",
"HasDriver",
"SeleniumTimeoutException",
)