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)