def drag_and_drop(self, destination):
Log.info("Drag and Drop on %s" % self.name)
element = self.get_element()
if not isinstance(destination, WebElement):
destination = destination.get_element()
ActionChains(element.parent).drag_and_drop(element,
destination).perform()
def exists(self, wait_time: int = 0) -> bool:
Log.info("Checking if '%s' element exists" % self.name)
try:
self.wait_for.presence_of_element_located(wait_time)
return True
except (NoSuchElementException, TimeoutException):
return False
def alert_is_present(self,
wait_time: int = page_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info('Expect an alert to be present.')
return self.condition(wait_time, alert_is_present(), poll_frequency,
ignored_exceptions)
def get_rows_by_attribute_value(self,
column_name: str,
attribute_name: str,
attribute_value: str,
wait_time: int = element_load_time) -> T:
Log.debug(
f"Getting rows by column {column_name} by attribute {attribute_name} and value {attribute_value} "
f"from the table: {self.name}")
out = list()
end_time = time.time() + wait_time
while True:
content = self.get_content()
for row in content:
column = getattr(row, column_name)
if column.exists():
act_attr_value = getattr(
row, column_name).get_attribute(attribute_name)
if act_attr_value == attribute_value:
out.append(row)
if self.next_page():
return self.get_rows_by_attribute_value(
column_name, attribute_name, attribute_value, wait_time)
elif out or time.time() > end_time:
break
return out
def get_row_by_index(self,
index: int,
wait_time: int = element_load_time) -> T:
Log.info("Getting row by index %s from the table: %s" %
(index, self.name))
rows = self.get_content(wait_time=wait_time)
return rows[index]
def inject_waiter(self):
Log.debug(
"Injecting JavaScrip HTTP requests waiter into '%s' element" %
self.element_name)
with open(js_waiter_file, 'r') as content:
js_waiter = content.read()
self.execute(js_waiter)
def execute_action(self,
action,
element_condition:
expected_conditions = presence_of_element_located,
*args):
try:
obj = getattr(self.get_element(element_condition), action)
if isinstance(obj, str):
self.__retry_count = 0
return obj
else:
if self.action_element:
self.inject_js_waiter()
if args:
value = obj(*args)
else:
value = obj()
if self.action_element:
self.wait_until_http_requests_are_finished()
return value
except (StaleElementReferenceException, WebDriverException,
InvalidElementStateException) as e:
if self.__retry_count <= 2:
self.__retry_count += 1
Log.error('Error on performing \'%s\' action. Retrying...' %
action)
Log.error(e.msg)
time.sleep(retry_delay)
if 'is not clickable at point' in e.msg:
self.scroll_to_element()
return self.execute_action(action, element_condition, *args)
else:
raise e
def wait_for_text_to_be_present_in_element(
self, wait_time: int = element_load_time, text: str = ""):
Log.info('Waiting for the text %s to be present' % self.name)
x = WebDriverWait(self.get_element().parent, wait_time).until(
expected_conditions.text_to_be_present_in_element(
self.locator, text))
return x
def url_changes(self,
url: str,
wait_time: int = page_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info('An expectation for checking the current url.')
return self.condition(wait_time, url_changes(url), poll_frequency,
ignored_exceptions)
def title_is(self,
title: str,
wait_time: int = page_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info('An expectation for checking the title of a page.')
return self.condition(wait_time, title_is(title), poll_frequency,
ignored_exceptions)
def element_to_be_clickable(self,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An Expectation for checking an element "%s" is visible and enabled such that you can click it.'
% self.name)
return self.condition(wait_time, element_to_be_clickable(self.locator),
poll_frequency, ignored_exceptions)
def number_of_windows_to_be(self,
num_windows: int,
wait_time: int = page_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation for the number of windows to be a certain value.')
return self.condition(wait_time, number_of_windows_to_be(num_windows),
poll_frequency, ignored_exceptions)
def invisibility_of_element_located(self,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An Expectation for checking that an element "%s" is either invisible or not present on the DOM.'
% self.name)
return self.condition(wait_time,
invisibility_of_element_located(self.locator),
poll_frequency, ignored_exceptions)
def url_contains(self,
url: str,
wait_time: int = page_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation for checking that the current url contains a case-sensitive substring.'
)
return self.condition(wait_time, url_contains(url), poll_frequency,
ignored_exceptions)
def visibility_of(self,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'Waiting for the existing "%s" element on the page to be visible.'
% self.name)
return self.condition(
wait_time, visibility_of(self.presence_of_element_located()),
poll_frequency, ignored_exceptions)
def staleness_of(self,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'Wait until an element is no longer attached to the DOM. "%s" is the element to wait for'
% self.name)
return self.condition(wait_time,
staleness_of(self.presence_of_element_located()),
poll_frequency, ignored_exceptions)
def element_located_to_be_selected(self,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation for the element "%s" to be located is selected.' %
self.name)
return self.condition(wait_time,
element_located_to_be_selected(self.locator),
poll_frequency, ignored_exceptions)
def presence_of_all_elements_located(self,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation for checking that there is at least one element "%s" present on a web page.'
% self.name)
return self.condition(wait_time,
presence_of_all_elements_located(self.locator),
poll_frequency, ignored_exceptions)
def presence_of_element_located(self,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation for checking that an element "%s" is present on the DOM of a page.'
% self.name)
return self.condition(wait_time,
presence_of_element_located(self.locator),
poll_frequency, ignored_exceptions)
def visibility_of_any_elements_located(self,
wait_time: int = element_load_time,
poll_frequency=0.5,
ignored_exceptions=None):
Log.info(
'An expectation for checking that there is at least one element "%s" visible on a web page.'
% self.name)
return self.condition(wait_time,
visibility_of_any_elements_located(self.locator),
poll_frequency, ignored_exceptions)
def new_window_is_opened(self,
current_handles: list,
wait_time: int = page_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation that a new window will be opened and have the number of windows handles increase'
)
return self.condition(wait_time, new_window_is_opened(current_handles),
poll_frequency, ignored_exceptions)
def visibility_of_all_elements_located(self,
wait_time: int = element_load_time,
poll_frequency=0.5,
ignored_exceptions=None):
Log.info(
'An expectation for checking that all elements "%s" are present on the DOM of a page and visible.'
% self.name)
return self.condition(wait_time,
visibility_of_all_elements_located(self.locator),
poll_frequency, ignored_exceptions)
def exists(
self,
wait_time: int = 0,
condition: expected_conditions = presence_of_element_located
) -> bool:
Log.info("Checking if '%s' element exists" % self.name)
try:
self.get_element(condition=condition, wait_time=wait_time)
return True
except (NoSuchElementException, TimeoutException):
return False
def element_to_be_selected(self,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation for checking the selection "%s" is selected.' %
self.name)
return self.condition(
wait_time,
element_to_be_selected(self.presence_of_element_located()),
poll_frequency, ignored_exceptions)
def exists(self, wait_time: int = 0):
Log.debug(
f"Window '{self.name}' existence verification. Wait time = {str(wait_time)}"
)
if self.get_driver():
try:
self.wait_for.visibility_of_element_located(self.load_time)
return True
except (NoSuchElementException, TimeoutException):
Log.debug("Window '%s' was not found" % self.name)
return False
def number_of_elements(self,
elements_count: int,
wait_time: int = element_load_time,
poll_frequency=0.5,
ignored_exceptions=None):
Log.info(
'An expectation for checking that number elements "%s" are present on the DOM of a page.'
% self.name)
return self.condition(
wait_time, lambda driver: len(driver.find_elements(*self.locator))
== elements_count, poll_frequency, ignored_exceptions)
def text_to_be_present_in_element_value(self,
text: str,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'Checking if the given text is present in the element\'s locator "%s", text.'
% self.name)
return self.condition(
wait_time, text_to_be_present_in_element_value(self.locator, text),
poll_frequency, ignored_exceptions)
def frame_to_be_available_and_switch_to_it(self,
locator: Locator,
wait_time: int = page_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation for checking whether the given frame "%s" is available to switch to.'
% str(locator))
return self.condition(wait_time,
frame_to_be_available_and_switch_to_it(locator),
poll_frequency, ignored_exceptions)
def wait_until_http_requests_are_finished(
self, wait_time: int = http_request_wait_time):
try:
end_time = time.time() + wait_time
while True:
if not self.execute(
"return window.openHTTPs") or time.time() > end_time:
break
except TimeoutException:
Log.error('HTTP request execution time is more than %s seconds' %
wait_time)
self.execute("window.openHTTPs=0")
def element_located_selection_state_to_be(
self,
is_selected: bool,
wait_time: int = element_load_time,
poll_frequency=POLL_FREQUENCY,
ignored_exceptions=None):
Log.info(
'An expectation to locate an element "%s" and check if the selection state specified is in that '
'state.' % self.name)
return self.condition(
wait_time, element_selection_state_to_be(self.locator,
is_selected),
poll_frequency, ignored_exceptions)