r"""-----------------------------------------------------------------> | ______ __ _ ____ | | / ____/__ / /__ ____ (_)_ ______ ___ / _ \____ ________ | | \__ \/ _ \/ / _ \/ __ \/ / / / / __ `__ \ / /_) / __ \/ ___/ _ \ | | ___/ / __/ / __/ / / / / /_/ / / / / / // /_) / (_/ /__ / __/ | | /____/\___/_/\___/_/ /_/_/\__,_/_/ /_/ /_//_____/\__,_/____/\___/ | | | ---------------------------------------------------------------------> The BaseCase class is the main gateway for using The SeleniumBase Framework. It inherits Python's unittest.TestCase class and runs with pytest or pynose. All tests using BaseCase automatically launch WebDriver browsers for tests. Example Test: # -------------------------------------------------------------- from seleniumbase import BaseCase BaseCase.main(__name__, __file__) class MyTestClass(BaseCase): def test_anything(self): # Write your code here. Example: self.open("https://github.com/") self.click('span[data-target*="inputButtonText"]') self.type("input#query-builder-test", "SeleniumBase\n") self.click('a[href="/seleniumbase/SeleniumBase"]') self.assert_element("div.repository-content") self.assert_text("SeleniumBase", "strong a") # -------------------------------------------------------------- SeleniumBase methods expand and improve on existing WebDriver commands. Improvements include making WebDriver more robust, reliable, and flexible. Page elements are given enough time to load before WebDriver acts on them. Code becomes greatly simplified and easier to maintain.""" import colorama import fasteners import json import logging import math import os import re import shutil import sys import textwrap import time import unittest import urllib3 from contextlib import contextmanager, suppress from selenium.common.exceptions import ( ElementClickInterceptedException as ECI_Exception, ElementNotInteractableException as ENI_Exception, InvalidArgumentException, MoveTargetOutOfBoundsException, NoSuchElementException, NoSuchWindowException, StaleElementReferenceException as Stale_Exception, TimeoutException, WebDriverException, ) 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.remote_connection import LOGGER from selenium.webdriver.remote.webelement import WebElement from seleniumbase import config as sb_config from seleniumbase.__version__ import __version__ from seleniumbase.common import decorators from seleniumbase.common.exceptions import ( NotConnectedException, NotUsingChromeException, NotUsingChromiumException, ProxyConnectionException, OutOfScopeException, VisualException, ) from seleniumbase.config import settings from seleniumbase.core import browser_launcher from seleniumbase.core import download_helper from seleniumbase.core import log_helper from seleniumbase.core import session_helper from seleniumbase.core import visual_helper from seleniumbase.fixtures import constants from seleniumbase.fixtures import css_to_xpath from seleniumbase.fixtures import js_utils from seleniumbase.fixtures import page_actions from seleniumbase.fixtures import page_utils from seleniumbase.fixtures import shared_utils from seleniumbase.fixtures import unittest_helper from seleniumbase.fixtures import xpath_to_css __all__ = ["BaseCase"] logging.getLogger("requests").setLevel(logging.ERROR) logging.getLogger("urllib3").setLevel(logging.ERROR) logging.getLogger("websocket").setLevel(logging.CRITICAL) urllib3.disable_warnings() LOGGER.setLevel(logging.WARNING) is_linux = shared_utils.is_linux() is_windows = shared_utils.is_windows() python3_11_or_newer = False if sys.version_info >= (3, 11): python3_11_or_newer = True py311_patch2 = constants.PatchPy311.PATCH class BaseCase(unittest.TestCase): """""" def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.__initialize_variables() def __initialize_variables(self): self.driver = None self.environment = None self.env = None # Add a shortened version of self.environment self.version_list = shared_utils.make_version_list(__version__) self.version_tuple = tuple(self.version_list) self.version_info = self.version_tuple self.time = time.time self.__page_sources = [] self.__extra_actions = [] self.__js_start_time = 0 self.__set_c_from_switch = False self.__frame_switch_layer = 0 # Used by Recorder-Mode self.__frame_switch_multi = False # Used by Recorder-Mode self.__last_saved_url = None # Used by Recorder-Mode self.__uc_frame_layer = 0 self.__called_setup = False self.__called_teardown = False self.__start_time_ms = int(time.time() * 1000.0) self.__requests_timeout = None self.__page_source_count = 0 self.__screenshot_count = 0 self.__saved_pdf_count = 0 self.__logs_data_count = 0 self.__last_data_file = None self.__level_0_visual_f = False self.__will_be_skipped = False self.__passed_then_skipped = False self.__visual_baseline_copies = [] self.__last_url_of_deferred_assert = "about:blank" self.__last_page_load_url = "about:blank" self.__last_page_screenshot = None self.__last_page_screenshot_png = None self.__last_page_url = None self.__last_page_source = None self.__skip_reason = None self.__origins_to_save = [] self.__actions_to_save = [] self.__dont_record_open = False self.__dont_record_js_click = False self.__new_window_on_rec_open = True self.__overrided_default_timeouts = False self.__added_pytest_html_extra = None self.__deferred_assert_count = 0 self.__deferred_assert_failures = [] self.__device_width = None self.__device_height = None self.__device_pixel_ratio = None self.__changed_jqc_theme = False self.__jqc_default_theme = None self.__jqc_default_color = None self.__jqc_default_width = None self.__saved_id = None # Requires self._* instead of self.__* for external class use self._language = "English" self._presentation_slides = {} self._presentation_transition = {} self._output_file_saves = True # For Presenter / ChartMaker self._rec_overrides_switch = True # Recorder-Mode uses set_c vs switch self._sb_test_identifier = None self._html_report_extra = [] # (Used by pytest_plugin.py) self._last_page_screenshot = None self._last_page_url = None self._final_debug = None self._default_driver = None self._drivers_list = [] self._drivers_browser_map = {} self._was_skipped = False self._chart_data = {} self._chart_count = 0 self._chart_label = {} self._chart_xcount = 0 self._chart_first_series = {} self._chart_series_count = {} self._tour_steps = {} self._xvfb_display = None self._xvfb_width = None self._xvfb_height = None @classmethod def main(self, name, file, *args): """Run pytest if file was called with "python". Usage example: from seleniumbase import BaseCase BaseCase.main(__name__, __file__) class MyTestClass(BaseCase): def test_example(self): pass The run command: python my_test.py # (Instead of "pytest my_test.py") This is useful when sharing code with people who may not be aware that SeleniumBase tests are run with "pytest" instead of "python". Now, if they accidentally type "python", the tests will still run. Eg. "python my_test.py" instead of "pytest my_test.py".""" if name == "__main__": # Test called with "python" import subprocess all_args = [] for arg in args: all_args.append(arg) for arg in sys.argv[1:]: all_args.append(arg) # See: https://stackoverflow.com/a/54666289/7058266 # from pytest import main as pytest_main # pytest_main([file, "-s", *all_args]) subprocess.call( [sys.executable, "-m", "pytest", file, "-s", *all_args] ) def open(self, url, **kwargs): """Navigates the current browser window to the specified page.""" self.__check_scope() if self.__is_cdp_swap_needed(): self.cdp.open(url, **kwargs) return elif ( getattr(self.driver, "_is_using_uc", None) # and getattr(self.driver, "_is_using_auth", None) and not getattr(self.driver, "_is_using_cdp", None) ): # Auth in UC Mode requires CDP Mode # (and now we're always forcing it) logging.info("open() in UC Mode now always activates CDP Mode.") self.activate_cdp_mode(url, **kwargs) return elif ( getattr(self.driver, "_is_using_uc", None) and getattr(self.driver, "_is_using_cdp", None) ): self.disconnect() self.cdp.open(url, **kwargs) return self._check_browser() if self.__needs_minimum_wait(): time.sleep(0.04) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url url = str(url).strip() # Remove leading and trailing whitespace if not self.__looks_like_a_page_url(url): # url should start with one of the following: # "http:", "https:", "://", "data:", "file:", # "about:", "chrome:", or "edge:". if page_utils.is_valid_url("https://" + url): url = "https://" + url else: raise Exception('Invalid URL: "%s"!' % url) self.__last_page_load_url = None js_utils.clear_out_console_logs(self.driver) if url.startswith("://"): # Convert URLs such as "://google.com" into "https://google.com" url = "https" + url if self.recorder_mode and not self.__dont_record_open: time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() action = ["o_url", origin, url, str(int(time_stamp) - 1)] self.__extra_actions.append(action) action = ["_url_", origin, url, time_stamp] self.__extra_actions.append(action) if self.recorder_mode and self.__new_window_on_rec_open: c_url = self.driver.current_url if ("http:") in c_url or ("https:") in c_url or ("file:") in c_url: if self.get_domain_url(url) != self.get_domain_url(c_url): self.open_new_window(switch_to=True) try: self.driver.get(url) except Exception as e: if not hasattr(e, "msg") and hasattr(self.driver, "default_get"): try: self._check_browser() time.sleep(0.4) except Exception: logging.debug("Browser crashed! Will open new browser!") self.driver = self.get_new_driver() self.driver.default_get(url) elif ( "ERR_CONNECTION_TIMED_OUT" in e.msg or "ERR_CONNECTION_CLOSED" in e.msg or "ERR_CONNECTION_RESET" in e.msg or "ERR_NAME_NOT_RESOLVED" in e.msg ): shared_utils.check_if_time_limit_exceeded() self._check_browser() time.sleep(0.8) self.driver.get(url) elif ( "ERR_INTERNET_DISCONNECTED" in e.msg or "neterror?e=dnsNotFound" in e.msg or "ERR_PROXY_CONNECTION_FAILED" in e.msg ): shared_utils.check_if_time_limit_exceeded() self._check_browser() time.sleep(1.05) try: self.driver.get(url) except Exception as e2: if ( "ERR_INTERNET_DISCONNECTED" in e2.msg or "neterror?e=dnsNotFound" in e2.msg ): message = "ERR_INTERNET_DISCONNECTED: " message += "Internet unreachable!" raise NotConnectedException(message) elif "ERR_PROXY_CONNECTION_FAILED" in e2.msg: message = "ERR_PROXY_CONNECTION_FAILED: " message += "Internet unreachable and/or invalid proxy!" raise ProxyConnectionException(message) else: raise elif "Timed out receiving message from renderer" in e.msg: page_load_timeout = self.driver.timeouts.page_load logging.info( "The page load timed out after %s seconds! Will retry..." % page_load_timeout ) try: self.driver.get(url) except Exception as e: if "Timed out receiving message from renderer" in e.msg: raise Exception( "Retry of page load timed out after %s seconds!" % page_load_timeout ) else: raise elif ( "cannot determine loading status" in e.msg or "unexpected command response" in e.msg ): if self.__needs_minimum_wait(): time.sleep(0.2) self.driver.get(url) else: pass # Odd issue where the open did happen. Continue. elif "invalid session id" in e.msg: logging.debug("Invalid session id. Will open new browser.") self.driver = self.get_new_driver() self.driver.get(url) else: raise try: if ( self.driver.current_url == pre_action_url and pre_action_url != url ): time.sleep(0.1) # Make sure load happens except Exception: time.sleep(0.1) # First see if waiting helps try: self._check_browser() if not self.driver.current_url: raise Exception("No current URL!") except Exception: # Spin up a new driver with the URL self.driver = self.get_new_driver() self.driver.get(url) self._check_browser() if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: if not self.undetectable: self.wait_for_ready_state_complete() if self.__needs_minimum_wait(): time.sleep(0.08) # Force a minimum wait, even if skipping waits. if self.undetectable: self.__uc_frame_layer = 0 if self.demo_mode: if self.driver.current_url.startswith(("http", "file", "data")): if not js_utils.is_jquery_activated(self.driver): with suppress(Exception): js_utils.add_js_link( self.driver, constants.JQuery.MIN_JS ) self.__demo_mode_pause_if_active() def get(self, url): """If "url" looks like a page URL, open the URL in the web browser. Otherwise, return self.get_element(URL_AS_A_SELECTOR) Examples: self.get("https://seleniumbase.io") # Navigates to the URL self.get("input.class") # Finds and returns the WebElement """ self.__check_scope() if self.__looks_like_a_page_url(url): self.open(url) else: return self.get_element(url) # url is treated like a selector def click( self, selector, by="css selector", timeout=None, delay=0, scroll=True ): self.__check_scope() self.__skip_if_esc() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) original_selector = selector original_by = by selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.click(selector, timeout=timeout, scroll=scroll) return if delay and (type(delay) in [int, float]) and delay > 0: time.sleep(delay) if page_utils.is_link_text_selector(selector) or by == By.LINK_TEXT: if not self.is_link_text_visible(selector): # Handle a special case of links hidden in dropdowns self.click_link_text(selector, timeout=timeout) return if ( page_utils.is_partial_link_text_selector(selector) or by == By.PARTIAL_LINK_TEXT ): if not self.is_partial_link_text_visible(selector): # Handle a special case of partial links hidden in dropdowns self.click_partial_link_text(selector, timeout=timeout) return if self.__is_shadow_selector(selector): self.__shadow_click(selector, timeout) return if self.__needs_minimum_wait() or self.browser == "safari": time.sleep(0.05) element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) self.__demo_mode_highlight_if_active(original_selector, original_by) if scroll and not self.demo_mode and not self.slow_mode: self.__scroll_to_element(element, selector, by) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url pre_window_count = len(self.driver.window_handles) try: if ( by == By.LINK_TEXT and (self.browser == "ie" or self.browser == "safari") ): self.__jquery_click(selector, by=by) elif self.browser == "safari": self.execute_script("arguments[0].click();", element) else: href = None new_tab = False onclick = None with suppress(Exception): if self.headless and element.tag_name.lower() == "a": # Handle a special case of opening a new tab (headless) href = element.get_attribute("href").strip() onclick = element.get_attribute("onclick") target = element.get_attribute("target") if target == "_blank": new_tab = True if new_tab and self.__looks_like_a_page_url(href): if onclick: with suppress(Exception): self.execute_script(onclick) current_window = self.driver.current_window_handle self.open_new_window() with suppress(Exception): self.open(href) self.switch_to_window(current_window) return # Normal click self.__element_click(element) except Stale_Exception: self.wait_for_ready_state_complete() time.sleep(0.16) element = page_actions.wait_for_element_clickable( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) with suppress(Exception): self.__scroll_to_element(element, selector, by) if self.browser == "safari" and by == By.LINK_TEXT: self.__jquery_click(selector, by=by) elif self.browser == "safari": self.execute_script("arguments[0].click();", element) else: self.__element_click(element) except ENI_Exception as e: with suppress(Exception): if ( "element has zero size" in e.msg and element.tag_name.lower() == "a" ): if "contains(" not in selector: self.js_click(selector, by=by) else: self.jquery_click(selector, by=by) if self.__needs_minimum_wait(): time.sleep(0.04) return self.wait_for_ready_state_complete() time.sleep(0.1) element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) if not page_actions.is_element_clickable( self.driver, selector, by ): with suppress(Exception): self.wait_for_element_clickable( selector, by, timeout=1.8 ) element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) href = None new_tab = False onclick = None with suppress(Exception): if element.tag_name.lower() == "a": # Handle a special case of opening a new tab (non-headless) href = element.get_attribute("href").strip() onclick = element.get_attribute("onclick") target = element.get_attribute("target") if target == "_blank": new_tab = True if new_tab and self.__looks_like_a_page_url(href): if onclick: with suppress(Exception): self.execute_script(onclick) current_window = self.driver.current_window_handle self.open_new_window() with suppress(Exception): self.open(href) self.switch_to_window(current_window) return if scroll and not self.demo_mode and not self.slow_mode: self.__scroll_to_element(element, selector, by) if self.browser == "firefox" or self.browser == "safari": if by == By.LINK_TEXT or "contains(" in selector: self.__jquery_click(selector, by=by) else: self.__js_click(selector, by=by) else: try: self.__element_click(element) except Exception: self.wait_for_ready_state_complete() element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) self.__element_click(element) except MoveTargetOutOfBoundsException: self.wait_for_ready_state_complete() try: self.__js_click(selector, by=by) except Exception: try: self.__jquery_click(selector, by=by) except Exception: # One more attempt to click on the element element = page_actions.wait_for_element_clickable( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) self.__element_click(element) except WebDriverException as e: if ( "cannot determine loading status" in e.msg or "unexpected command response" in e.msg ): pass # Odd issue where the click did happen. Continue. else: self.wait_for_ready_state_complete() try: self.__js_click(selector, by=by) except Exception: try: self.__jquery_click(selector, by=by) except Exception: # One more attempt to click on the element element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) self.__element_click(element) latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() elif ( latest_window_count == pre_window_count - 1 and latest_window_count > 0 ): # If a click closes the active window, # switch to the last one if it exists. self.switch_to_window(-1) if settings.WAIT_FOR_RSC_ON_CLICKS: if not self.undetectable: with suppress(Exception): self.wait_for_ready_state_complete() if self.__needs_minimum_wait() or self.browser == "safari": time.sleep(0.05) else: time.sleep(0.08) else: if not self.undetectable: # A smaller subset of self.wait_for_ready_state_complete() with suppress(Exception): self.wait_for_angularjs(timeout=settings.MINI_TIMEOUT) if self.__needs_minimum_wait() or self.browser == "safari": time.sleep(0.045) try: if self.driver.current_url != pre_action_url: self.__ad_block_as_needed() self.__disable_beforeunload_as_needed() if self.__needs_minimum_wait(): time.sleep(0.075) except Exception: with suppress(Exception): self.wait_for_ready_state_complete() if self.__needs_minimum_wait(): time.sleep(0.05) else: time.sleep(0.085) if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() self.__set_esc_skip() def slow_click(self, selector, by="css selector", timeout=None): """Similar to click(), but pauses for a brief moment before clicking. When used in combination with setting the user-agent, you can often bypass bot-detection by tricking websites into thinking that you're not a bot. (Useful on websites that block web automation tools.) To set the user-agent, use: ``--agent=AGENT``. Here's an example message from GitHub's bot-blocker: ``You have triggered an abuse detection mechanism...`` """ self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) if not self.demo_mode and not self.slow_mode: self.click(selector, by=by, timeout=timeout, delay=1.05) elif self.slow_mode: self.click(selector, by=by, timeout=timeout, delay=0.65) else: # Demo Mode already includes a small delay self.click(selector, by=by, timeout=timeout, delay=0.25) def double_click(self, selector, by="css selector", timeout=None): self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) original_selector = selector original_by = by selector, by = self.__recalculate_selector(selector, by) element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) self.__demo_mode_highlight_if_active(original_selector, original_by) if not self.demo_mode and not self.slow_mode: self.__scroll_to_element(element, selector, by) self.wait_for_ready_state_complete() if self.__needs_minimum_wait(): time.sleep(0.02) # Find the element one more time in case scrolling hid it element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url try: if self.browser == "safari": # Jump to the "except" block where the other script should work raise Exception("This Exception will be caught.") actions = ActionChains(self.driver) actions.double_click(element).perform() except Exception: css_selector = self.convert_to_css_selector(selector, by=by) css_selector = re.escape(css_selector) # Add "\\" to special chars css_selector = self.__escape_quotes_if_needed(css_selector) double_click_script = ( """var targetElement1 = document.querySelector('%s'); var clickEvent1 = document.createEvent('MouseEvents'); clickEvent1.initEvent('dblclick', true, true); targetElement1.dispatchEvent(clickEvent1);""" % css_selector ) if ":contains\\(" not in css_selector: self.execute_script(double_click_script) else: double_click_script = ( """var targetElement1 = arguments[0]; var clickEvent1 = document.createEvent('MouseEvents'); clickEvent1.initEvent('dblclick', true, true); targetElement1.dispatchEvent(clickEvent1);""" ) self.execute_script(double_click_script, element) if settings.WAIT_FOR_RSC_ON_CLICKS: self.wait_for_ready_state_complete() else: # A smaller subset of self.wait_for_ready_state_complete() self.wait_for_angularjs(timeout=settings.MINI_TIMEOUT) if self.driver.current_url != pre_action_url: self.__ad_block_as_needed() self.__disable_beforeunload_as_needed() if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() elif self.__needs_minimum_wait(): time.sleep(0.02) def context_click(self, selector, by="css selector", timeout=None): """(A context click is a right-click that opens a context menu.)""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) original_selector = selector original_by = by selector, by = self.__recalculate_selector(selector, by) element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) self.__demo_mode_highlight_if_active(original_selector, original_by) if not self.demo_mode and not self.slow_mode: self.__scroll_to_element(element, selector, by) self.wait_for_ready_state_complete() if self.__needs_minimum_wait(): time.sleep(0.02) # Find the element one more time in case scrolling hid it element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout=timeout, original_selector=original_selector, ) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url try: if self.browser == "safari": # Jump to the "except" block where the other script should work raise Exception("This Exception will be caught.") actions = ActionChains(self.driver) actions.context_click(element).perform() except Exception: css_selector = self.convert_to_css_selector(selector, by=by) css_selector = re.escape(css_selector) # Add "\\" to special chars css_selector = self.__escape_quotes_if_needed(css_selector) right_click_script = ( """var targetElement1 = document.querySelector('%s'); var clickEvent1 = document.createEvent('MouseEvents'); clickEvent1.initEvent('contextmenu', true, true); targetElement1.dispatchEvent(clickEvent1);""" % css_selector ) if ":contains\\(" not in css_selector: self.execute_script(right_click_script) else: right_click_script = ( """var targetElement1 = arguments[0]; var clickEvent1 = document.createEvent('MouseEvents'); clickEvent1.initEvent('contextmenu', true, true); targetElement1.dispatchEvent(clickEvent1);""" ) self.execute_script(right_click_script, element) if settings.WAIT_FOR_RSC_ON_CLICKS: self.wait_for_ready_state_complete() else: # A smaller subset of self.wait_for_ready_state_complete() self.wait_for_angularjs(timeout=settings.MINI_TIMEOUT) if self.driver.current_url != pre_action_url: self.__ad_block_as_needed() self.__disable_beforeunload_as_needed() if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() elif self.__needs_minimum_wait(): time.sleep(0.02) if self.recorder_mode and self.__current_url_is_recordable(): if self.get_session_storage_item("pause_recorder") == "no": if by == By.XPATH: selector = original_selector time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() action = ["r_clk", selector, origin, time_stamp] self.__extra_actions.append(action) def click_chain( self, selectors_list, by="css selector", timeout=None, spacing=0 ): """This method clicks on a list of elements in succession. @Params selectors_list - The list of selectors to click on. by - The type of selector to search by (Default: "css selector"). timeout - How long to wait for the selector to be visible. spacing - The amount of time to wait between clicks (in seconds).""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) for selector in selectors_list: self.click(selector, by=by, timeout=timeout) if spacing > 0: time.sleep(spacing) def update_text( self, selector, text, by="css selector", timeout=None, retry=False ): """This method updates an element's text field with new text. Has multiple parts: * Waits for the element to be visible. * Waits for the element to be interactive. * Clears the text field. * Types in the new text. * Hits Enter/Submit (if the text ends in "\n"). @Params selector - The selector of the text field. text - The new text to type into the text field. by - The type of selector to search by. (Default: "css selector") timeout - How long to wait for the selector to be visible. retry - If True, use JS if the Selenium text update fails.""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.type(selector, text, timeout=timeout) return if self.__is_shadow_selector(selector): self.__shadow_type(selector, text, timeout) return element = self.wait_for_element_clickable( selector, by=by, timeout=timeout ) self.__demo_mode_highlight_if_active(selector, by) if not self.demo_mode and not self.slow_mode: self.__scroll_to_element(element, selector, by) if self.__needs_minimum_wait(): time.sleep(0.04) try: element.clear() # May need https://stackoverflow.com/a/50691625 backspaces = Keys.BACK_SPACE * 42 # Is the answer to everything element.send_keys(backspaces) # In case autocomplete keeps text except (Stale_Exception, ENI_Exception): self.wait_for_ready_state_complete() time.sleep(0.16) element = self.wait_for_element_clickable( selector, by=by, timeout=timeout ) with suppress(Exception): element.clear() except Exception: pass # Clearing the text field first might not be necessary self.__demo_mode_pause_if_active(tiny=True) pre_action_url = None if self.demo_mode: with suppress(Exception): pre_action_url = self.driver.current_url text = self.__get_type_checked_text(text) try: if not text.endswith("\n"): element.send_keys(text) if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: self.wait_for_ready_state_complete() else: element.send_keys(text[:-1]) if self.slow_mode or self.demo_mode: self.__demo_mode_pause_if_active(tiny=True) else: time.sleep(0.0135) try: element.send_keys(Keys.RETURN) except WebDriverException as e: if ( "cannot determine loading status" in e.msg or "unexpected command response" in e.msg ): pass # Odd issue where the click did happen. Continue. else: raise if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: self.wait_for_ready_state_complete() if self.__needs_minimum_wait(): time.sleep(0.04) except Exception: self.wait_for_ready_state_complete() time.sleep(0.14) element = self.wait_for_element_visible( selector, by=by, timeout=timeout ) time.sleep(0.04) if not text.endswith("\n"): element.send_keys(text) else: element.send_keys(text[:-1]) if self.slow_mode or self.demo_mode: self.__demo_mode_pause_if_active(tiny=True) else: time.sleep(0.0135) try: element.send_keys(Keys.RETURN) except WebDriverException as e: if ( "cannot determine loading status" in e.msg or "unexpected command response" in e.msg ): pass # Odd issue where the click did happen. Continue. else: raise if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: self.wait_for_ready_state_complete() if self.__needs_minimum_wait(): time.sleep(0.03) if self.undetectable: time.sleep(0.025) if ( retry and element.get_attribute("value") != text and not text.endswith("\n") ): logging.debug("update_text() is falling back to JavaScript!") self.set_value(selector, text, by=by) if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() def add_text(self, selector, text, by="css selector", timeout=None): """The more-reliable version of driver.send_keys() Similar to update_text(), but won't clear the text field first.""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.send_keys(selector, text) return if self.__is_shadow_selector(selector): self.__shadow_type(selector, text, timeout, clear_first=False) return if selector == "html" and text in ["\n", Keys.ENTER, Keys.RETURN]: # This is a shortcut for calling self.click_active_element(). # Use after "\t" or Keys.TAB to cycle through elements first. self.click_active_element() return element = self.wait_for_element_present( selector, by=by, timeout=timeout ) if ( selector == "html" and text.count("\t") >= 1 and text.count("\n") == 1 and text.endswith("\n") and text.replace("\t", "").replace("\n", "").replace(" ", "") == "" ): # Shortcut to send multiple tabs followed by click_active_element() self.wait_for_ready_state_complete() element.send_keys(Keys.TAB * text.count("\t")) self.click_active_element() return self.__demo_mode_highlight_if_active(selector, by) if not self.demo_mode and not self.slow_mode: self.__scroll_to_element(element, selector, by) pre_action_url = None if self.demo_mode: with suppress(Exception): pre_action_url = self.driver.current_url text = self.__get_type_checked_text(text) try: if not text.endswith("\n"): element.send_keys(text) else: element.send_keys(text[:-1]) if self.slow_mode or self.demo_mode: self.__demo_mode_pause_if_active(tiny=True) else: time.sleep(0.0135) element.send_keys(Keys.RETURN) if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: self.wait_for_ready_state_complete() except (Stale_Exception, ENI_Exception): self.wait_for_ready_state_complete() time.sleep(0.16) element = self.wait_for_element_visible( selector, by=by, timeout=timeout ) if not text.endswith("\n"): element.send_keys(text) else: element.send_keys(text[:-1]) if self.slow_mode or self.demo_mode: self.__demo_mode_pause_if_active(tiny=True) else: time.sleep(0.0135) element.send_keys(Keys.RETURN) if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: self.wait_for_ready_state_complete() if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() def type( self, selector, text, by="css selector", timeout=None, retry=False ): """Same as self.update_text() This method updates an element's text field with new text. Has multiple parts: * Waits for the element to be visible. * Waits for the element to be interactive. * Clears the text field. * Types in the new text. * Hits Enter/Submit (if the text ends in "\n"). @Params selector - The selector of the text field. text - The new text to type into the text field. by - The type of selector to search by. (Default: "css selector") timeout - How long to wait for the selector to be visible. retry - If True, use JS if the Selenium text update fails. DO NOT confuse self.type() with Python type()! They are different! """ self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) self.update_text(selector, text, by=by, timeout=timeout, retry=retry) def send_keys(self, selector, text, by="css selector", timeout=None): """Same as self.add_text() Similar to update_text(), but won't clear the text field first.""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) self.add_text(selector, text, by=by, timeout=timeout) def press_keys(self, selector, text, by="css selector", timeout=None): """Use send_keys() to press one key at a time.""" if self.__is_cdp_swap_needed(): self.cdp.press_keys(selector, text, timeout=timeout) return self.wait_for_ready_state_complete() element = self.wait_for_element_present( selector, by=by, timeout=timeout ) if self.demo_mode: selector, by = self.__recalculate_selector(selector, by) css_selector = self.convert_to_css_selector(selector, by=by) self.__demo_mode_highlight_if_active(css_selector, By.CSS_SELECTOR) if self.recorder_mode and self.__current_url_is_recordable(): if self.get_session_storage_item("pause_recorder") == "no": css_selector = self.convert_to_css_selector(selector, by=by) time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() sel_tex = [css_selector, text] action = ["pkeys", sel_tex, origin, time_stamp] self.__extra_actions.append(action) press_enter = False if text.endswith("\n"): text = text[:-1] press_enter = True for key in text: element.send_keys(key) if press_enter: if self.slow_mode or self.demo_mode: self.__demo_mode_pause_if_active(tiny=True) else: time.sleep(0.0135) element.send_keys(Keys.RETURN) if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: if not self.undetectable: self.wait_for_ready_state_complete() else: time.sleep(0.15) if self.demo_mode: if press_enter: self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() elif self.__needs_minimum_wait(): time.sleep(0.05) if self.undetectable: time.sleep(0.02) def submit(self, selector, by="css selector"): """Alternative to self.driver.find_element_by_*(SELECTOR).submit()""" self.__check_scope() selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.submit(selector) return element = self.wait_for_element_clickable( selector, by=by, timeout=settings.SMALL_TIMEOUT ) element.submit() self.__demo_mode_pause_if_active() def clear(self, selector, by="css selector", timeout=None): """This method clears an element's text field. A clear() is already included with most methods that type text, such as self.type(), self.update_text(), etc. Does not use Demo Mode highlights, mainly because we expect that some users will be calling an unnecessary clear() before calling a method that already includes clear() as part of it. In case websites trigger an autofill after clearing a field, add backspaces to make sure autofill doesn't undo the clear. @Params selector - The selector of the text field. by - The type of selector to search by. (Default: "css selector") timeout - How long to wait for the selector to be visible.""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.clear_input(selector) return if self.__is_shadow_selector(selector): self.__shadow_clear(selector, timeout) return element = self.wait_for_element_visible( selector, by=by, timeout=timeout ) self.scroll_to(selector, by=by, timeout=timeout) try: element.clear() backspaces = Keys.BACK_SPACE * 42 # Autofill Defense element.send_keys(backspaces) except (Stale_Exception, ENI_Exception): self.wait_for_ready_state_complete() time.sleep(0.16) element = self.wait_for_element_visible( selector, by=by, timeout=timeout ) element.clear() with suppress(Exception): backspaces = Keys.BACK_SPACE * 42 # Autofill Defense element.send_keys(backspaces) except Exception: element.clear() def focus(self, selector, by="css selector", timeout=None): """Make the current page focus on an interactable element. If the element is not interactable, only scrolls to it. The "tab" key is another way of setting the page focus.""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.focus(selector) return element = self.wait_for_element_present( selector, by=by, timeout=timeout ) if not element.is_displayed(): css_selector = self.convert_to_css_selector(selector, by=by) css_selector = re.escape(css_selector) # Add "\\" to special chars css_selector = self.__escape_quotes_if_needed(css_selector) script = """document.querySelector('%s').focus();""" % css_selector self.execute_script(script) self.__demo_mode_pause_if_active() return self.scroll_to(selector, by=by, timeout=timeout) try: element.send_keys(Keys.NULL) except (Stale_Exception, ENI_Exception): self.wait_for_ready_state_complete() time.sleep(0.12) element = self.wait_for_element_visible( selector, by=by, timeout=timeout ) try: element.send_keys(Keys.NULL) except ENI_Exception: # Non-interactable element. Skip focus and continue. pass self.__demo_mode_pause_if_active() def refresh_page(self): self.__check_scope() self.__last_page_load_url = None if self.__is_cdp_swap_needed(): self.cdp.reload() return js_utils.clear_out_console_logs(self.driver) self.driver.refresh() self.wait_for_ready_state_complete() def refresh(self): """The shorter version of self.refresh_page()""" self.refresh_page() def get_current_url(self): self.__check_scope() current_url = None if self.__is_cdp_swap_needed(): current_url = self.cdp.get_current_url() else: current_url = self.driver.current_url if "%" in current_url: try: from urllib.parse import unquote current_url = unquote(current_url, errors="strict") except Exception: pass return current_url def get_origin(self): self.__check_scope() return self.execute_script("return window.location.origin;") def get_html(self, *args, **kwargs): return self.get_page_source(*args, **kwargs) def get_page_source(self, *args, **kwargs): if self.__is_cdp_swap_needed(*args, **kwargs): return self.cdp.get_page_source() self.wait_for_ready_state_complete() if self.__needs_minimum_wait: time.sleep(0.025) return self.driver.page_source def get_page_title(self): if self.__is_cdp_swap_needed(): return self.cdp.get_title() self.wait_for_ready_state_complete() with suppress(Exception): self.wait_for_element_present( "title", by="css selector", timeout=settings.MINI_TIMEOUT ) time.sleep(0.025) return self.driver.title def get_title(self): """The shorter version of self.get_page_title()""" return self.get_page_title() def get_user_agent(self): if self.__is_cdp_swap_needed(): return self.cdp.get_user_agent() return self.execute_script("return navigator.userAgent;") def get_locale_code(self): if self.__is_cdp_swap_needed(): return self.cdp.get_locale_code() return self.execute_script( "return navigator.language || navigator.languages[0];" ) def go_back(self): self.__check_scope() if self.__is_cdp_swap_needed(): self.cdp.go_back() return if getattr(self, "recorder_mode", None): self.save_recorded_actions() pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url self.__last_page_load_url = None self.driver.back() with suppress(Exception): if pre_action_url == self.driver.current_url: self.driver.back() # Again because the page was redirected if self.recorder_mode: time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() action = ["go_bk", "", origin, time_stamp] self.__extra_actions.append(action) if self.browser == "safari": self.wait_for_ready_state_complete() time.sleep(0.02) self.driver.refresh() time.sleep(0.02) self.wait_for_ready_state_complete() self.__demo_mode_pause_if_active() def go_forward(self): self.__check_scope() if self.__is_cdp_swap_needed(): self.cdp.go_forward() return if getattr(self, "recorder_mode", None): self.save_recorded_actions() self.__last_page_load_url = None self.driver.forward() if self.recorder_mode: time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() action = ["go_fw", "", origin, time_stamp] self.__extra_actions.append(action) self.wait_for_ready_state_complete() self.__demo_mode_pause_if_active() def open_start_page(self): """Navigates the current browser window to the start_page. You can set the start_page on the command-line in three ways: '--start_page=URL', '--start-page=URL', or '--url=URL'. If the start_page is not set, then "about:blank" will be used.""" self.__check_scope() start_page = self.start_page if isinstance(start_page, str): start_page = start_page.strip() # Remove extra whitespace if start_page and len(start_page) >= 4: if page_utils.is_valid_url(start_page): self.open(start_page) else: new_start_page = "https://" + start_page if page_utils.is_valid_url(new_start_page): self.__dont_record_open = True self.open(new_start_page) self.__dont_record_open = False else: logging.info('Invalid URL: "%s"!' % start_page) if self.get_current_url() != "about:blank": self.open("about:blank") else: if self.get_current_url() != "about:blank": self.open("about:blank") def open_if_not_url(self, url): """Opens the url in the browser if it's not the current url (*). Parameters tagged on by search engines are ignored for this method. Eg. If the current url is: * https://www.bing.com/search?q=SeleniumBase&source=hp And the url privided by this method call is: * https://www.bing.com/search?q=SeleniumBase Then the urls will be considered the same, and no open() action will be performed. This method is primarily used by Recorder Mode script generation, where both clicks and opens are recorded. So if a click() action leads to an open() action, then the script generator will attempt to convert the open() action into open_if_not_url() so that the same page isn't opened again if the user is already on the page.""" self.__check_scope() current_url = self.get_current_url() if current_url != url: if ( "?q=" not in current_url or "&" not in current_url or current_url.find("?q=") >= current_url.find("&") or current_url.split("&")[0] != url ): self.open(url) def is_element_present(self, selector, by="css selector"): """Returns whether the element exists in the HTML.""" if self.__is_cdp_swap_needed(): return self.cdp.is_element_present(selector) self.wait_for_ready_state_complete() selector, by = self.__recalculate_selector(selector, by) if self.__is_shadow_selector(selector): return self.__is_shadow_element_present(selector) return page_actions.is_element_present(self.driver, selector, by) def is_element_visible(self, selector, by="css selector"): """Returns whether the element is visible on the page.""" if self.__is_cdp_swap_needed(): return self.cdp.is_element_visible(selector) self.wait_for_ready_state_complete() selector, by = self.__recalculate_selector(selector, by) if self.__is_shadow_selector(selector): return self.__is_shadow_element_visible(selector) return page_actions.is_element_visible(self.driver, selector, by) def is_element_clickable(self, selector, by="css selector"): self.wait_for_ready_state_complete() selector, by = self.__recalculate_selector(selector, by) if self.__is_shadow_selector(selector): return self.__is_shadow_element_clickable(selector) return page_actions.is_element_clickable(self.driver, selector, by) def is_element_enabled(self, selector, by="css selector"): self.wait_for_ready_state_complete() selector, by = self.__recalculate_selector(selector, by) if self.__is_shadow_selector(selector): return self.__is_shadow_element_enabled(selector) return page_actions.is_element_enabled(self.driver, selector, by) def is_text_visible(self, text, selector="body", by="css selector"): """Returns whether the text substring is visible in the element.""" if self.__is_cdp_swap_needed(): return self.cdp.is_text_visible(text, selector) self.wait_for_ready_state_complete() time.sleep(0.01) selector, by = self.__recalculate_selector(selector, by) if self.__is_shadow_selector(selector): return self.__is_shadow_text_visible(text, selector) return page_actions.is_text_visible(self.driver, text, selector, by) def is_exact_text_visible(self, text, selector="body", by="css selector"): """Returns whether the text is exactly equal to the element text. (Leading and trailing whitespace is ignored in the verification.)""" if self.__is_cdp_swap_needed(): return self.cdp.is_exact_text_visible(text, selector) self.wait_for_ready_state_complete() time.sleep(0.01) selector, by = self.__recalculate_selector(selector, by) if self.__is_shadow_selector(selector): return self.__is_shadow_exact_text_visible(text, selector) return page_actions.is_exact_text_visible( self.driver, text, selector, by ) def is_non_empty_text_visible(self, selector="body", by="css selector"): """Returns whether the element has any non-empty text visible. Whitespace-only text is considered empty text.""" self.wait_for_ready_state_complete() time.sleep(0.01) selector, by = self.__recalculate_selector(selector, by) if self.__is_shadow_selector(selector): return self.__is_shadow_non_empty_text_visible(selector) return page_actions.is_non_empty_text_visible( self.driver, selector, by=by ) def is_attribute_present( self, selector, attribute, value=None, by="css selector" ): """Returns True if the element attribute/value is found. If the value is not specified, the attribute only needs to exist.""" if self.__is_cdp_swap_needed(): return self.cdp.is_attribute_present( selector, attribute, value=value ) self.wait_for_ready_state_complete() time.sleep(0.01) selector, by = self.__recalculate_selector(selector, by) if self.__is_shadow_selector(selector): return self.__is_shadow_attribute_present( selector, attribute, value ) return page_actions.is_attribute_present( self.driver, selector, attribute, value, by ) def is_link_text_visible(self, link_text): """Returns whether there's an exact match for the link text.""" self.wait_for_ready_state_complete() time.sleep(0.01) return page_actions.is_element_visible( self.driver, link_text, by="link text" ) def is_partial_link_text_visible(self, partial_link_text): """Returns whether there's a substring match for the link text.""" self.wait_for_ready_state_complete() time.sleep(0.01) return page_actions.is_element_visible( self.driver, partial_link_text, by="partial link text" ) def is_link_text_present(self, link_text): """Returns True if the link text appears in the HTML of the page. The element doesn't need to be visible, such as elements hidden inside a dropdown selection.""" self.wait_for_ready_state_complete() soup = self.get_beautiful_soup() html_links = soup.find_all("a") for html_link in html_links: if html_link.text.strip() == link_text.strip(): return True return False def is_partial_link_text_present(self, link_text): """Returns True if the partial link appears in the HTML of the page. The element doesn't need to be visible, such as elements hidden inside a dropdown selection.""" self.wait_for_ready_state_complete() soup = self.get_beautiful_soup() html_links = soup.find_all("a") for html_link in html_links: if link_text.strip() in html_link.text.strip(): return True return False def get_link_attribute(self, link_text, attribute, hard_fail=True): """Finds a link by link text and then returns the attribute's value. If the link text or attribute cannot be found, an exception will get raised if hard_fail is True (otherwise None is returned).""" self.wait_for_ready_state_complete() soup = self.get_beautiful_soup() html_links = soup.find_all("a") for html_link in html_links: if html_link.text.strip() == link_text.strip(): if html_link.has_attr(attribute): attribute_value = html_link.get(attribute) return attribute_value if hard_fail: raise Exception( "Unable to find attribute {%s} from link text {%s}!" % (attribute, link_text) ) else: return None if hard_fail: raise Exception("Link text {%s} was not found!" % link_text) else: return None def get_link_text_attribute(self, link_text, attribute, hard_fail=True): """Same as self.get_link_attribute() Finds a link by link text and then returns the attribute's value. If the link text or attribute cannot be found, an exception will get raised if hard_fail is True (otherwise None is returned).""" return self.get_link_attribute(link_text, attribute, hard_fail) def get_partial_link_text_attribute( self, link_text, attribute, hard_fail=True ): """Finds a link by partial link text and then returns the attribute's value. If the partial link text or attribute cannot be found, an exception will get raised if hard_fail is True (otherwise None is returned).""" self.wait_for_ready_state_complete() soup = self.get_beautiful_soup() html_links = soup.find_all("a") for html_link in html_links: if link_text.strip() in html_link.text.strip(): if html_link.has_attr(attribute): attribute_value = html_link.get(attribute) return attribute_value if hard_fail: raise Exception( "Unable to find attribute {%s} from " "partial link text {%s}!" % (attribute, link_text) ) else: return None if hard_fail: msg = "Partial Link text {%s} was not found!" % link_text page_actions.timeout_exception("LinkTextNotFoundException", msg) else: return None def click_link_text(self, link_text, timeout=None): """This method clicks link text on a page.""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) if self.__is_cdp_swap_needed(): self.cdp.find_element(link_text, timeout=timeout).click() return self.__skip_if_esc() link_text = self.__get_type_checked_text(link_text) if self.__is_cdp_swap_needed(): self.cdp.click_link(link_text) return if self.browser == "safari": if self.demo_mode: self.wait_for_link_text_present(link_text, timeout=timeout) try: self.__jquery_slow_scroll_to(link_text, by="link text") except Exception: element = self.wait_for_link_text_visible( link_text, timeout=timeout ) self.__slow_scroll_to_element(element) o_bs = "" # original_box_shadow loops = settings.HIGHLIGHTS selector = self.convert_to_css_selector( link_text, by="link text" ) selector = self.__make_css_match_first_element_only(selector) try: selector = re.escape(selector) selector = self.__escape_quotes_if_needed(selector) self.__highlight_with_jquery(selector, loops, o_bs) except Exception: pass # JQuery probably couldn't load. Skip highlighting. self.__jquery_click(link_text, by="link text") return if not self.is_link_text_present(link_text): self.wait_for_link_text_present(link_text, timeout=timeout) if not self.demo_mode and not self.slow_mode: if self.__needs_minimum_wait(): time.sleep(0.04) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url pre_window_count = len(self.driver.window_handles) try: element = self.wait_for_link_text_visible(link_text, timeout=0.2) self.__demo_mode_highlight_if_active(link_text, by="link text") try: self.__element_click(element) except (Stale_Exception, ENI_Exception, ECI_Exception): self.wait_for_ready_state_complete() time.sleep(0.16) element = self.wait_for_link_text_visible( link_text, timeout=timeout ) self.__element_click(element) except Exception: found_css = False text_id = self.get_link_attribute(link_text, "id", False) if text_id: link_css = '[id="%s"]' % link_text found_css = True if not found_css: href = self.__get_href_from_link_text(link_text, False) if href: if href.startswith("/") or page_utils.is_valid_url(href): link_css = '[href="%s"]' % href found_css = True if not found_css: ngclick = self.get_link_attribute(link_text, "ng-click", False) if ngclick: link_css = '[ng-click="%s"]' % ngclick found_css = True if not found_css: onclick = self.get_link_attribute(link_text, "onclick", False) if onclick: link_css = '[onclick="%s"]' % onclick found_css = True success = False if found_css: if self.is_element_visible(link_css): self.click(link_css) success = True else: # The link text might be hidden under a dropdown menu success = self.__click_dropdown_link_text( link_text, link_css ) if not success: element = self.wait_for_link_text_visible( link_text, timeout=settings.MINI_TIMEOUT ) self.__element_click(element) latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() elif ( latest_window_count == pre_window_count - 1 and latest_window_count > 0 ): # If a click closes the active window, # switch to the last one if it exists. self.switch_to_window(-1) if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: with suppress(Exception): self.wait_for_ready_state_complete() if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() elif self.__needs_minimum_wait(): time.sleep(0.04) def click_partial_link_text(self, partial_link_text, timeout=None): """This method clicks the partial link text on a page.""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) partial_link_text = self.__get_type_checked_text(partial_link_text) if self.__is_cdp_swap_needed(): self.cdp.find_element(partial_link_text, timeout=timeout).click() return if not self.is_partial_link_text_present(partial_link_text): self.wait_for_partial_link_text_present( partial_link_text, timeout=timeout ) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url pre_window_count = len(self.driver.window_handles) try: element = self.wait_for_partial_link_text( partial_link_text, timeout=0.2 ) self.__demo_mode_highlight_if_active( partial_link_text, by="link text" ) try: self.__element_click(element) except (Stale_Exception, ENI_Exception, ECI_Exception): self.wait_for_ready_state_complete() time.sleep(0.16) element = self.wait_for_partial_link_text( partial_link_text, timeout=timeout ) self.__element_click(element) except Exception: found_css = False text_id = self.get_partial_link_text_attribute( partial_link_text, "id", False ) if text_id: link_css = '[id="%s"]' % partial_link_text found_css = True if not found_css: href = self.__get_href_from_partial_link_text( partial_link_text, False ) if href: if href.startswith("/") or page_utils.is_valid_url(href): link_css = '[href="%s"]' % href found_css = True if not found_css: ngclick = self.get_partial_link_text_attribute( partial_link_text, "ng-click", False ) if ngclick: link_css = '[ng-click="%s"]' % ngclick found_css = True if not found_css: onclick = self.get_partial_link_text_attribute( partial_link_text, "onclick", False ) if onclick: link_css = '[onclick="%s"]' % onclick found_css = True success = False if found_css: if self.is_element_visible(link_css): self.click(link_css) success = True else: # The link text might be hidden under a dropdown menu success = self.__click_dropdown_partial_link_text( partial_link_text, link_css ) if not success: element = self.wait_for_partial_link_text( partial_link_text, timeout=settings.MINI_TIMEOUT ) self.__element_click(element) latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() elif ( latest_window_count == pre_window_count - 1 and latest_window_count > 0 ): # If a click closes the active window, # switch to the last one if it exists. self.switch_to_window(-1) if settings.WAIT_FOR_RSC_ON_PAGE_LOADS: with suppress(Exception): self.wait_for_ready_state_complete() if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() def get_text(self, selector="body", by="css selector", timeout=None): self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): return self.cdp.get_text(selector) if self.__is_shadow_selector(selector): return self.__get_shadow_text(selector, timeout) self.wait_for_ready_state_complete() time.sleep(0.01) element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout ) try: element_text = element.text if self.browser == "safari": if element.tag_name.lower() in ["input", "textarea"]: element_text = element.get_attribute("value") else: element_text = element.get_attribute("innerText") elif element.tag_name.lower() in ["input", "textarea"]: element_text = element.get_property("value") except (Stale_Exception, ENI_Exception, TimeoutException): self.wait_for_ready_state_complete() time.sleep(0.14) element = page_actions.wait_for_element_visible( self.driver, selector, by, timeout ) element_text = element.text if self.browser == "safari": if element.tag_name.lower() in ["input", "textarea"]: element_text = element.get_attribute("value") else: element_text = element.get_attribute("innerText") elif element.tag_name.lower() in ["input", "textarea"]: element_text = element.get_property("value") return element_text def get_attribute( self, selector, attribute, by="css selector", timeout=None, hard_fail=True, ): """This method uses JavaScript to get the value of an attribute. If the attribute doesn't exist or isn't found, an exception will get raised if hard_fail is True (otherwise None is returned).""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): if hard_fail: return self.cdp.get_element_attribute(selector, attribute) else: return self.cdp.get_attribute(selector, attribute) self.wait_for_ready_state_complete() time.sleep(0.01) if self.__is_shadow_selector(selector): return self.__get_shadow_attribute( selector, attribute, timeout=timeout ) element = page_actions.wait_for_element_present( self.driver, selector, by, timeout ) try: attribute_value = element.get_attribute(attribute) except (Stale_Exception, ENI_Exception, TimeoutException): self.wait_for_ready_state_complete() time.sleep(0.14) element = page_actions.wait_for_element_present( self.driver, selector, by, timeout ) attribute_value = element.get_attribute(attribute) if attribute_value is not None: return attribute_value else: if hard_fail: raise Exception( "Element {%s} has no attribute {%s}!" % (selector, attribute) ) else: return None def set_attribute( self, selector, attribute, value, by="css selector", timeout=None, scroll=False, ): """This method uses JavaScript to set/update an attribute. Only the first matching selector from querySelector() is used.""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) original_attribute = attribute original_value = value if scroll and self.is_element_visible(selector, by=by): with suppress(Exception): self.scroll_to(selector, by=by, timeout=timeout) attribute = re.escape(attribute) attribute = self.__escape_quotes_if_needed(attribute) value = re.escape(value) value = self.__escape_quotes_if_needed(value) css_selector = self.convert_to_css_selector(selector, by=by) css_selector = re.escape(css_selector) # Add "\\" to special chars css_selector = self.__escape_quotes_if_needed(css_selector) script = ( """document.querySelector('%s').setAttribute('%s','%s');""" % (css_selector, attribute, value) ) self.execute_script(script) if self.recorder_mode and self.__current_url_is_recordable(): if self.get_session_storage_item("pause_recorder") == "no": time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() sele_attr_val = [selector, original_attribute, original_value] action = ["s_at_", sele_attr_val, origin, time_stamp] self.__extra_actions.append(action) def set_attributes(self, selector, attribute, value, by="css selector"): """This method uses JavaScript to set/update a common attribute. All matching selectors from querySelectorAll() are used. Example => (Make all links on a website redirect to Google): self.set_attributes("a", "href", "https://google.com")""" self.__check_scope() selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.set_attributes(selector, attribute, value) return original_attribute = attribute original_value = value attribute = re.escape(attribute) attribute = self.__escape_quotes_if_needed(attribute) value = re.escape(value) value = self.__escape_quotes_if_needed(value) css_selector = self.convert_to_css_selector(selector, by=by) css_selector = re.escape(css_selector) # Add "\\" to special chars css_selector = self.__escape_quotes_if_needed(css_selector) script = """var $elements = document.querySelectorAll('%s'); var index = 0, length = $elements.length; for(; index < length; index++){ $elements[index].setAttribute('%s','%s');}""" % ( css_selector, attribute, value, ) with suppress(Exception): self.execute_script(script) if self.recorder_mode and self.__current_url_is_recordable(): if self.get_session_storage_item("pause_recorder") == "no": time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() sele_attr_val = [selector, original_attribute, original_value] action = ["s_ats", sele_attr_val, origin, time_stamp] self.__extra_actions.append(action) def set_attribute_all(self, selector, attribute, value, by="css selector"): """Same as set_attributes(), but using querySelectorAll naming scheme. This method uses JavaScript to set/update a common attribute. All matching selectors from querySelectorAll() are used. Example => (Make all links on a website redirect to Google): self.set_attribute_all("a", "href", "https://google.com")""" self.set_attributes(selector, attribute, value, by=by) def remove_attribute( self, selector, attribute, by="css selector", timeout=None ): """This method uses JavaScript to remove an attribute. Only the first matching selector from querySelector() is used.""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.is_element_visible(selector, by=by): with suppress(Exception): self.scroll_to(selector, by=by, timeout=timeout) attribute = re.escape(attribute) attribute = self.__escape_quotes_if_needed(attribute) css_selector = self.convert_to_css_selector(selector, by=by) css_selector = re.escape(css_selector) # Add "\\" to special chars css_selector = self.__escape_quotes_if_needed(css_selector) script = """document.querySelector('%s').removeAttribute('%s');""" % ( css_selector, attribute, ) self.execute_script(script) def remove_attributes(self, selector, attribute, by="css selector"): """This method uses JavaScript to remove a common attribute. All matching selectors from querySelectorAll() are used.""" self.__check_scope() selector, by = self.__recalculate_selector(selector, by) attribute = re.escape(attribute) attribute = self.__escape_quotes_if_needed(attribute) css_selector = self.convert_to_css_selector(selector, by=by) css_selector = re.escape(css_selector) # Add "\\" to special chars css_selector = self.__escape_quotes_if_needed(css_selector) script = """var $elements = document.querySelectorAll('%s'); var index = 0, length = $elements.length; for(; index < length; index++){ $elements[index].removeAttribute('%s');}""" % ( css_selector, attribute, ) with suppress(Exception): self.execute_script(script) def internalize_links(self): """All `target="_blank"` links become `target="_self"`. This prevents those links from opening in a new tab.""" if self.__is_cdp_swap_needed(): self.cdp.internalize_links() return self.set_attributes('[target="_blank"]', "target", "_self") def get_parent(self, element, by="css selector", timeout=None): """Returns the parent element. If element is a string, then finds element first via selector.""" if self.__is_cdp_swap_needed(): return self.cdp.get_parent(element) if isinstance(element, str): if not timeout: timeout = settings.LARGE_TIMEOUT element = self.wait_for_element_present( element, by=by, timeout=timeout ) return element.find_element(by="xpath", value="..") def get_property( self, selector, property, by="css selector", timeout=None ): """Returns the property value of an element. This is not the same as self.get_property_value(), which returns the value of an element's computed style using a different algorithm. If no result is found, an empty string (instead of None) is returned. Example: html_text = self.get_property(SELECTOR, "textContent") """ self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) self.wait_for_ready_state_complete() time.sleep(0.01) element = page_actions.wait_for_element_present( self.driver, selector, by, timeout ) try: property_value = element.get_property(property) except (Stale_Exception, ENI_Exception, TimeoutException): self.wait_for_ready_state_complete() time.sleep(0.14) element = page_actions.wait_for_element_present( self.driver, selector, by, timeout ) property_value = element.get_property(property) if not property_value: return "" return property_value def get_text_content( self, selector="body", by="css selector", timeout=None ): """Returns the text that appears in the HTML for an element. This is different from "self.get_text(selector, by="css selector")" because that only returns the visible text on a page for an element, rather than the HTML text that's being returned from this method.""" self.__check_scope() return self.get_property( selector, property="textContent", by=by, timeout=timeout ) def get_property_value( self, selector, property, by="css selector", timeout=None ): """Returns the property value of a page element's computed style. Example: opacity = self.get_property_value("html body a", "opacity") self.assertTrue(float(opacity) > 0, "Element not visible!") """ self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) self.wait_for_ready_state_complete() element = page_actions.wait_for_element_present( self.driver, selector, by, timeout ) try: selector = self.convert_to_css_selector(selector, by=by) except Exception: # If can't convert to CSS_Selector for JS, use element directly script = ( """var $elm = arguments[0]; $val = window.getComputedStyle($elm).getPropertyValue('%s'); return $val;""" % property ) value = self.execute_script(script, element) if value is not None: return value else: return "" selector = re.escape(selector) selector = self.__escape_quotes_if_needed(selector) script = """var $elm = document.querySelector('%s'); $val = window.getComputedStyle($elm).getPropertyValue('%s'); return $val;""" % (selector, property) value = self.execute_script(script) if value is not None: return value else: return "" # Return an empty string if the property doesn't exist def get_image_url(self, selector, by="css selector", timeout=None): """Extracts the URL from an image element on the page.""" self.__check_scope() if not timeout: timeout = settings.LARGE_TIMEOUT if self.timeout_multiplier and timeout == settings.LARGE_TIMEOUT: timeout = self.__get_new_timeout(timeout) return self.get_attribute( selector, attribute="src", by=by, timeout=timeout ) def find_elements(self, selector, by="css selector", limit=0): """Returns a list of matching WebElements. Elements could be either hidden or visible on the page. If "limit" is set and > 0, will only return that many elements.""" selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): elements = self.cdp.select_all(selector) if limit and limit > 0 and len(elements) > limit: elements = elements[:limit] return elements self.wait_for_ready_state_complete() time.sleep(0.05) elements = self.driver.find_elements(by=by, value=selector) if limit and limit > 0 and len(elements) > limit: elements = elements[:limit] return elements def find_visible_elements(self, selector, by="css selector", limit=0): """Returns a list of matching WebElements that are visible. If "limit" is set and > 0, will only return that many elements.""" selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): elements = self.cdp.find_visible_elements(selector) if limit and limit > 0 and len(elements) > limit: elements = elements[:limit] return elements self.wait_for_ready_state_complete() time.sleep(0.05) return page_actions.find_visible_elements( self.driver, selector, by, limit ) def click_visible_elements( self, selector, by="css selector", limit=0, timeout=None, scroll=True ): """Finds all matching page elements and clicks visible ones in order. If a click reloads or opens a new page, the clicking will stop. If no matching elements appear, an Exception will be raised. If "limit" is set and > 0, will only click that many elements. Also clicks elements that become visible from previous clicks. Works best for actions such as clicking all checkboxes on a page. Example: self.click_visible_elements('input[type="checkbox"]')""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.click_visible_elements(selector, limit, scroll=scroll) return self.wait_for_ready_state_complete() if self.__needs_minimum_wait(): time.sleep(0.12) if self.undetectable: time.sleep(0.06) element = self.wait_for_element_present( selector, by=by, timeout=timeout ) with suppress(Exception): # If the first element isn't visible, wait a little. if not element.is_displayed(): time.sleep(0.16) if self.undetectable: time.sleep(0.06) elements = self.find_elements(selector, by=by) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url pre_window_count = len(self.driver.window_handles) click_count = 0 for element in elements: if limit and limit > 0 and click_count >= limit: return try: if element.is_displayed(): if scroll: self.__scroll_to_element(element) if self.browser == "safari": self.execute_script("arguments[0].click();", element) else: element.click() click_count += 1 self.wait_for_ready_state_complete() except ECI_Exception: continue # (Overlay likely) except (Stale_Exception, ENI_Exception): self.wait_for_ready_state_complete() time.sleep(0.12) try: if element.is_displayed(): if scroll: self.__scroll_to_element(element) if self.browser == "safari": self.execute_script( "arguments[0].click();", element ) else: element.click() click_count += 1 self.wait_for_ready_state_complete() except (Stale_Exception, ENI_Exception): latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() return # Probably on new page / Elements are all stale latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() def click_nth_visible_element( self, selector, number, by="css selector", timeout=None, scroll=True ): """Finds all matching page elements and clicks the nth visible one. Example: self.click_nth_visible_element('[type="checkbox"]', 5) (Clicks the 5th visible checkbox on the page.)""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.click_nth_visible_element(selector, number, scroll=scroll) return self.wait_for_ready_state_complete() self.wait_for_element_present(selector, by=by, timeout=timeout) elements = self.find_visible_elements(selector, by=by) if len(elements) < number: raise Exception( "Not enough matching {%s} elements of type {%s} to " "click number %s!" % (selector, by, number) ) number = number - 1 if number < 0: number = 0 element = elements[number] pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url pre_window_count = len(self.driver.window_handles) try: if scroll: self.__scroll_to_element(element) self.__element_click(element) except (Stale_Exception, ENI_Exception, ECI_Exception): time.sleep(0.12) self.wait_for_ready_state_complete() self.wait_for_element_present(selector, by=by, timeout=timeout) elements = self.find_visible_elements(selector, by=by) if len(elements) < number: raise Exception( "Not enough matching {%s} elements of type {%s} to " "click number %s!" % (selector, by, number) ) number = number - 1 if number < 0: number = 0 element = elements[number] self.__element_click(element) latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() def click_if_visible( self, selector, by="css selector", timeout=0, scroll=True ): """If the page selector exists and is visible, clicks on the element. This method only clicks on the first matching element found. Use click_visible_elements() to click all matching elements. If a "timeout" is provided, waits that long for the element to appear before giving up and returning without a click().""" if self.__is_cdp_swap_needed(): self.cdp.click_if_visible(selector, timeout=timeout, scroll=scroll) return self.wait_for_ready_state_complete() if self.is_element_visible(selector, by=by): self.click(selector, by=by, scroll=scroll) elif timeout > 0: with suppress(Exception): self.wait_for_element_visible( selector, by=by, timeout=timeout ) self.sleep(0.2) if self.is_element_visible(selector, by=by): self.click(selector, by=by, scroll=scroll) def click_active_element(self): if self.__is_cdp_swap_needed(): self.cdp.click_active_element() return self.wait_for_ready_state_complete() pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url pre_window_count = len(self.driver.window_handles) if self.recorder_mode: selector = js_utils.get_active_element_css(self.driver) self.click(selector) return else: self.execute_script("document.activeElement.click();") latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() if settings.WAIT_FOR_RSC_ON_CLICKS: self.wait_for_ready_state_complete() else: # A smaller subset of self.wait_for_ready_state_complete() self.wait_for_angularjs(timeout=settings.MINI_TIMEOUT) if self.driver.current_url != pre_action_url: self.__ad_block_as_needed() self.__disable_beforeunload_as_needed() if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() def click_with_offset( self, selector, x, y, by="css selector", mark=None, timeout=None, center=None, scroll=True, ): """Click an element at an {X,Y}-offset location. {0,0} is the top-left corner of the element. If center==True, {0,0} becomes the center of the element. If mark==True, will draw a dot at location. (Useful for debugging) In Demo Mode, mark becomes True unless set to False. (Default: None)""" self.__check_scope() self.__click_with_offset( selector, x, y, by=by, double=False, mark=mark, timeout=timeout, center=center, scroll=scroll, ) def double_click_with_offset( self, selector, x, y, by="css selector", mark=None, timeout=None, center=None, scroll=True, ): """Double click an element at an {X,Y}-offset location. {0,0} is the top-left corner of the element. If center==True, {0,0} becomes the center of the element. If mark==True, will draw a dot at location. (Useful for debugging) In Demo Mode, mark becomes True unless set to False. (Default: None)""" self.__check_scope() self.__click_with_offset( selector, x, y, by=by, double=True, mark=mark, timeout=timeout, center=center, scroll=scroll, ) def is_checked(self, selector, by="css selector", timeout=None): """Determines if a checkbox or a radio button element is checked. Returns True if the element is checked. Returns False if the element is not checked. If the element is not present on the page, raises an exception. If the element is not a checkbox or radio, raises an exception.""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): return self.cdp.is_checked(selector) kind = self.get_attribute(selector, "type", by=by, timeout=timeout) if kind != "checkbox" and kind != "radio": raise Exception("Expecting a checkbox or a radio button element!") return bool( self.get_attribute( selector, "checked", by=by, timeout=timeout, hard_fail=False ) ) def is_selected(self, selector, by="css selector", timeout=None): """Same as is_checked()""" return self.is_checked(selector, by=by, timeout=timeout) def check_if_unchecked(self, selector, by="css selector"): """If a checkbox or radio button is not checked, will check it.""" self.__check_scope() selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.check_if_unchecked(selector) return if not self.is_checked(selector, by=by): if self.is_element_visible(selector, by=by): self.click(selector, by=by) else: element = self.wait_for_element_present(selector, by=by) opacity = self.execute_script( 'return arguments[0].style.opacity;', element ) # Handle switches that sit on checkboxes with zero opacity: # Change the opacity a bit to allow the click to succeed. with suppress(Exception): self.execute_script( 'arguments[0].style.opacity="0.001";', element ) if self.is_element_visible(selector, by=by): self.click(selector, by=by) else: selector = self.convert_to_css_selector(selector, by=by) self.__dont_record_js_click = True self.js_click(selector, by="css selector") self.__dont_record_js_click = False with suppress(Exception): self.execute_script( 'arguments[0].style.opacity="arguments[1]";', element, opacity, ) def select_if_unselected(self, selector, by="css selector"): """Same as check_if_unchecked()""" self.check_if_unchecked(selector, by=by) def uncheck_if_checked(self, selector, by="css selector"): """If a checkbox is checked, will uncheck it.""" self.__check_scope() selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.uncheck_if_checked(selector) return if self.is_checked(selector, by=by): if self.is_element_visible(selector, by=by): self.click(selector, by=by) else: element = self.wait_for_element_present(selector, by=by) opacity = self.execute_script( 'return arguments[0].style.opacity;', element ) # Handle switches that sit on checkboxes with zero opacity: # Change the opacity a bit to allow the click to succeed. with suppress(Exception): self.execute_script( 'arguments[0].style.opacity="0.001";', element ) if self.is_element_visible(selector, by=by): self.click(selector, by=by) else: selector = self.convert_to_css_selector(selector, by=by) self.__dont_record_js_click = True self.js_click(selector, by="css selector") self.__dont_record_js_click = False with suppress(Exception): self.execute_script( 'arguments[0].style.opacity="arguments[1]";', element, opacity, ) def unselect_if_selected(self, selector, by="css selector"): """Same as uncheck_if_checked()""" self.uncheck_if_checked(selector, by=by) def is_element_in_an_iframe(self, selector, by="css selector"): """Returns True if the selector's element is located in an iframe. Otherwise returns False.""" self.__check_scope() selector, by = self.__recalculate_selector(selector, by) if self.is_element_present(selector, by=by): return False soup = self.get_beautiful_soup() iframe_list = soup.select("iframe") for iframe in iframe_list: iframe_identifier = None if iframe.has_attr("name") and len(iframe["name"]) > 0: iframe_identifier = iframe["name"] elif iframe.has_attr("id") and len(iframe["id"]) > 0: iframe_identifier = iframe["id"] elif iframe.has_attr("class") and len(iframe["class"]) > 0: iframe_class = " ".join(iframe["class"]) iframe_identifier = '[class="%s"]' % iframe_class else: continue self.switch_to_frame(iframe_identifier) if self.is_element_present(selector, by=by): self.switch_to_default_content() return True self.switch_to_default_content() return False def switch_to_frame_of_element(self, selector, by="css selector"): """Set driver control to the iframe containing element (assuming the element is in a single-nested iframe) and returns the iframe name. If element is not in an iframe, returns None, and nothing happens. May not work if multiple iframes are nested within each other.""" self.wait_for_ready_state_complete() if self.__needs_minimum_wait(): time.sleep(0.04) if self.undetectable: time.sleep(0.04) selector, by = self.__recalculate_selector(selector, by) if self.is_element_present(selector, by=by): return None soup = self.get_beautiful_soup() iframe_list = soup.select("iframe") for iframe in iframe_list: iframe_identifier = None if iframe.has_attr("name") and len(iframe["name"]) > 0: iframe_identifier = iframe["name"] elif iframe.has_attr("id") and len(iframe["id"]) > 0: iframe_identifier = iframe["id"] elif iframe.has_attr("class") and len(iframe["class"]) > 0: iframe_class = " ".join(iframe["class"]) iframe_identifier = '[class="%s"]' % iframe_class else: continue with suppress(Exception): self.switch_to_frame(iframe_identifier, timeout=1) if self.__needs_minimum_wait(): time.sleep(0.02) if self.is_element_present(selector, by=by): return iframe_identifier self.switch_to_default_content() if self.__needs_minimum_wait(): time.sleep(0.02) try: self.switch_to_frame(selector, timeout=1) if self.undetectable: self.__uc_frame_layer += 1 return selector except Exception: if self.is_element_present(selector, by=by): return "" raise Exception( "Could not switch to iframe containing " "element {%s}!" % selector ) def hover(self, selector, by="css selector", timeout=None): self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) original_selector = selector original_by = by selector, by = self.__recalculate_selector(selector, by) if self.__is_cdp_swap_needed(): self.cdp.hover_element(selector) return self.wait_for_element_visible( original_selector, by=original_by, timeout=timeout ) self.__demo_mode_highlight_if_active(original_selector, original_by) self.scroll_to(selector, by=by) time.sleep(0.05) # Settle down from scrolling before hovering element = page_actions.hover_on_element(self.driver, selector, by) if self.recorder_mode and self.__current_url_is_recordable(): if self.get_session_storage_item("pause_recorder") == "no": if by == By.XPATH: selector = original_selector time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() action = ["hover", selector, origin, time_stamp] self.__extra_actions.append(action) return element def hover_and_click( self, hover_selector, click_selector, hover_by="css selector", click_by="css selector", timeout=None, js_click=False, ): """When you want to hover over an element or dropdown menu, and then click an element that appears after that.""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) original_selector = hover_selector original_by = hover_by hover_selector, hover_by = self.__recalculate_selector( hover_selector, hover_by ) original_click_selector = click_selector click_selector, click_by = self.__recalculate_selector( click_selector, click_by ) if self.__is_cdp_swap_needed(): self.cdp.hover_and_click(hover_selector, click_selector) return dropdown_element = self.wait_for_element_visible( original_selector, by=original_by, timeout=timeout ) self.__demo_mode_highlight_if_active(original_selector, original_by) self.scroll_to(hover_selector, by=hover_by) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url pre_window_count = len(self.driver.window_handles) if self.recorder_mode and self.__current_url_is_recordable(): if self.get_session_storage_item("pause_recorder") == "no": if hover_by == By.XPATH: hover_selector = original_selector if click_by == By.XPATH: click_selector = original_click_selector time_stamp = self.execute_script("return Date.now();") origin = self.get_origin() the_selectors = [hover_selector, click_selector] action = ["ho_cl", the_selectors, origin, time_stamp] self.__extra_actions.append(action) outdated_driver = False element = None try: if self.mobile_emulator: # On mobile, click to hover the element dropdown_element.click() else: page_actions.hover_element(self.driver, dropdown_element) except Exception: outdated_driver = True element = self.wait_for_element_present( click_selector, click_by, timeout ) if click_by == By.LINK_TEXT: self.open(self.__get_href_from_link_text(click_selector)) elif click_by == By.PARTIAL_LINK_TEXT: self.open( self.__get_href_from_partial_link_text(click_selector) ) else: self.__dont_record_js_click = True self.js_click(click_selector, by=click_by) self.__dont_record_js_click = False if outdated_driver: pass # Already did the click workaround elif self.mobile_emulator: self.click(click_selector, by=click_by) elif not outdated_driver: element = page_actions.hover_and_click( self.driver, hover_selector, click_selector, hover_by, click_by, timeout, js_click, ) latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() elif self.browser == "safari": # Release the hover by hovering elsewhere with suppress(Exception): page_actions.hover_on_element(self.driver, "body") if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() return element def hover_and_js_click( self, hover_selector, click_selector, hover_by="css selector", click_by="css selector", timeout=None, ): self.hover_and_click( hover_selector=hover_selector, click_selector=click_selector, hover_by=hover_by, click_by=click_by, timeout=timeout, js_click=True, ) def hover_and_double_click( self, hover_selector, click_selector, hover_by="css selector", click_by="css selector", timeout=None, ): """When you want to hover over an element or dropdown menu, and then double-click an element that appears after that.""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) original_selector = hover_selector original_by = hover_by hover_selector, hover_by = self.__recalculate_selector( hover_selector, hover_by ) hover_selector = self.convert_to_css_selector(hover_selector, hover_by) hover_by = By.CSS_SELECTOR click_selector, click_by = self.__recalculate_selector( click_selector, click_by ) dropdown_element = self.wait_for_element_visible( original_selector, by=original_by, timeout=timeout ) self.__demo_mode_highlight_if_active(original_selector, original_by) self.scroll_to(hover_selector, by=hover_by) pre_action_url = None with suppress(Exception): pre_action_url = self.driver.current_url pre_window_count = len(self.driver.window_handles) outdated_driver = False element = None try: page_actions.hover_element(self.driver, dropdown_element) except Exception: outdated_driver = True element = self.wait_for_element_present( click_selector, click_by, timeout ) if click_by == By.LINK_TEXT: self.open(self.__get_href_from_link_text(click_selector)) elif click_by == By.PARTIAL_LINK_TEXT: self.open( self.__get_href_from_partial_link_text(click_selector) ) else: self.__dont_record_js_click = True self.js_click(click_selector, click_by) self.__dont_record_js_click = False if not outdated_driver: element = page_actions.hover_element_and_double_click( self.driver, dropdown_element, click_selector, click_by="css selector", timeout=timeout, ) latest_window_count = len(self.driver.window_handles) if ( latest_window_count > pre_window_count and ( self.recorder_mode or ( settings.SWITCH_TO_NEW_TABS_ON_CLICK and self.driver.current_url == pre_action_url ) ) ): self.__switch_to_newest_window_if_not_blank() if self.demo_mode: if self.driver.current_url != pre_action_url: if not js_utils.is_jquery_activated(self.driver): js_utils.add_js_link(self.driver, constants.JQuery.MIN_JS) self.__demo_mode_pause_if_active() else: self.__demo_mode_pause_if_active(tiny=True) elif self.slow_mode: self.__slow_mode_pause_if_active() return element def drag_and_drop( self, drag_selector, drop_selector, drag_by="css selector", drop_by="css selector", timeout=None, jquery=False, ): """Drag-and-drop an element from one selector to another.""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) drag_selector, drag_by = self.__recalculate_selector( drag_selector, drag_by ) drop_selector, drop_by = self.__recalculate_selector( drop_selector, drop_by ) if self.__is_cdp_swap_needed(): self.cdp.gui_drag_and_drop(drag_selector, drop_selector) return drag_element = self.wait_for_element_clickable( drag_selector, by=drag_by, timeout=timeout ) self.__demo_mode_highlight_if_active(drag_selector, drag_by) drop_element = self.wait_for_element_visible( drop_selector, by=drop_by, timeout=timeout ) self.__demo_mode_highlight_if_active(drop_selector, drop_by) self.scroll_to(drop_selector, by=drop_by) drag_selector = self.convert_to_css_selector(drag_selector, drag_by) drop_selector = self.convert_to_css_selector(drop_selector, drop_by) if not jquery: drag_and_drop_script = js_utils.get_js_drag_and_drop_script() self.execute_script( drag_and_drop_script, drag_element, drop_element, 0, 0, 1, None ) else: drag_and_drop_script = js_utils.get_drag_and_drop_script() self.safe_execute_script( drag_and_drop_script + ( "$('%s').simulateDragDrop(" "{dropTarget: " "'%s'});" % (drag_selector, drop_selector) ) ) if self.demo_mode: self.__demo_mode_pause_if_active() elif self.slow_mode: self.__slow_mode_pause_if_active() return drag_element def drag_and_drop_with_offset( self, selector, x, y, by="css selector", timeout=None ): """Drag-and-drop an element to an {X,Y}-offset location.""" self.__check_scope() if not timeout: timeout = settings.SMALL_TIMEOUT if self.timeout_multiplier and timeout == settings.SMALL_TIMEOUT: timeout = self.__get_new_timeout(timeout) selector, by = self.__recalculate_selector(selector, by) css_selector = self.convert_to_css_selector(selector, by=by) element = self.wait_for_element_visible(css_selector, timeout=timeout) self.__demo_mode_highlight_if_active(css_selector, By.CSS_SELECTOR) css_selector = re.escape(css_selector) # Add "\\" to special chars css_selector = self.__escape_quotes_if_needed(css_selector) script = js_utils.get_drag_and_drop_with_offset_script( css_selector, x, y ) self.execute_script(script) if self.demo_mode: self.__demo_mode_pause_if_active() elif self.slow_mode: self.__slow_mode_pause_if_active() return element def __element_click(self, element): self.__check_scope() if ( not self.undetectable or self.uc_cdp_events or self.__uc_frame_layer > 0 or not hasattr(element, "uc_click") or element.tag_name.lower() != "a" ): element.click() else: try: href = element.get_attribute("href") target = element.get_attribute("target") if len(href) > 0 and target != "_blank": element.uc_click() else: element.click() time.sleep(0.012) except Exception: element.click() def __select_option( self, dropdown_selector, option, dropdown_by="css selector", option_by="text", timeout=None, ): """Selects an HTML option by option text. @Params dropdown_selector - the option by option index. @Params dropdown_selector - the option by option value. @Params dropdown_selector - the