def assert_element_active(self, should_active=True):
"""
assert that element class contain active attribute
"""
actual = self.is_element_active()
assert_should_be_equal(actual_value=actual, expected_value=should_active,
message=f"Verify is element {self.element.name} active")
def assert_element_attribute(self, attribute, expected_value):
"""
assert that element attribute is equal to expected
"""
attribute_value = self.element.get_attribute(attribute)
assert_should_be_equal(actual_value=attribute_value,
expected_value=expected_value,
silent=True)
def assert_element_text(self, expected):
"""
assert that element text is equal to expected
"""
element_text = self.element.text
assert_should_be_equal(actual_value=element_text,
expected_value=expected,
silent=True)
def assert_visible(self, is_visible=True):
"""
assert element visible, test fails if expected state isn't equal to actual
:param is_visible: if true - should be visible, if false - should be hidden
"""
actual_state = self.element.is_displayed()
assert_should_be_equal(actual_value=actual_state,
expected_value=is_visible,
message="Verify is element '{}' "
"visible".format(self.name))
def assert_enabled(self, is_enabled=True):
"""
assert element enabled, test fails if expected state isn't equal to actual
:param is_enabled: if true - should be enabled, if false - should be disabled
"""
actual_state = self.element.is_enabled()
assert_should_be_equal(actual_value=actual_state,
expected_value=is_enabled,
message="Verify is element '{}' "
"enabled {}".format(self.name, is_enabled))
def assert_focused(self, is_focused=True):
"""
assert element focused, test fails if expected state isn't equal to actual
:param is_focused: if true - should be focused, if false - not focused
"""
expected_state = "true" if is_focused else "false"
actual_state = self.element.get_attribute("focused")
assert_should_be_equal(actual_value=actual_state,
expected_value=expected_state,
message="Verify is element '{}' focused".format(
self.name))
def assert_present(self, is_present=True, with_waiting=True):
"""
assert element present, test fails if expected state isn't equal to actual
:param is_present: if true - should be present, if false - should be absent
:param with_waiting: if true - find element using is_present() method (with implicitly wait timeout),
if false - find element using is_present_without_waiting() method (without timeout)
"""
actual_state = self.is_present(
) if with_waiting else self.is_present_without_waiting()
assert_should_be_equal(
actual_value=actual_state,
expected_value=is_present,
message=f"Verify is element '{self.name}' present on the page")
def wait_element_invisible(self, silent=False, second=WAIT_SECONDS):
"""
wait for element invisible
:param silent: true - log message isn't displayed, false - log message is displayed
:param second: number of seconds after which test will wail if element is visible.
"""
if not silent:
logger.info("Wait for '{0}' is invisible".format(self.name))
assert_should_be_equal(
actual_value=self.element.is_displayed,
expected_value=False,
message="Verify is element '{}' invisible".format(self.name),
timeout=second,
silent=silent)
def assert_page_not_present(self, second=20):
"""
assert page not present, test fails if page is present
"""
logger.info(f"Verify is page '{self.name}' absent in {second} seconds")
end_time = time.time() + second
present_status = True
while time.time() < end_time and present_status:
time.sleep(0.2)
present_status = BaseElement(
self.locator_type, self.locator,
self.driver).is_present_without_waiting()
assert_should_be_equal(actual_value=present_status,
expected_value=False,
silent=True)
def assert_page_present(self, second=20, silent=False):
"""
assert page present, test fails if page is absent
"""
if not silent:
logger.info(
f"Verify is page '{self.name}' opens in {second} seconds")
page_element = BaseElement(self.locator_type, self.locator,
self.driver)
assert_should_be_equal(
actual_value=page_element.is_present_without_waiting,
expected_value=True,
silent=silent,
timeout=second)
if not silent:
logger.info(f"Page '{self.name}' is opened")
def assert_element_placeholder(self, expected):
"""
assert that element placeholder is equal to expected
"""
element_placeholder = self.element.get_attribute("placeholder")
assert_should_be_equal(actual_value=element_placeholder, expected_value=expected, silent=True)
