capybara 3.32.2

data/lib/capybara/selenium/driver_specializations/chrome_driver.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'capybara/selenium/nodes/chrome_node'
+require 'capybara/selenium/patches/logs'
+
+module Capybara::Selenium::Driver::ChromeDriver
+  def self.extended(base)
+    bridge = base.send(:bridge)
+    bridge.extend Capybara::Selenium::ChromeLogs unless bridge.respond_to?(:log)
+    bridge.extend Capybara::Selenium::IsDisplayed unless bridge.commands(:is_element_displayed)
+    base.options[:native_displayed] = false if base.options[:native_displayed].nil?
+  end
+
+  def fullscreen_window(handle)
+    within_given_window(handle) do
+      begin
+        super
+      rescue NoMethodError => e
+        raise unless e.message.match?(/full_screen_window/)
+
+        result = bridge.http.call(:post, "session/#{bridge.session_id}/window/fullscreen", {})
+        result['value']
+      end
+    end
+  end
+
+  def resize_window_to(handle, width, height)
+    super
+  rescue Selenium::WebDriver::Error::UnknownError => e
+    raise unless e.message.match?(/failed to change window state/)
+
+    # Chromedriver doesn't wait long enough for state to change when coming out of fullscreen
+    # and raises unnecessary error. Wait a bit and try again.
+    sleep 0.25
+    super
+  end
+
+  def reset!
+    # Use instance variable directly so we avoid starting the browser just to reset the session
+    return unless @browser
+
+    switch_to_window(window_handles.first)
+    window_handles.slice(1..-1).each { |win| close_window(win) }
+    return super if chromedriver_version < 73
+
+    timer = Capybara::Helpers.timer(expire_in: 10)
+    begin
+      clear_storage unless uniform_storage_clear?
+      @browser.navigate.to('about:blank')
+      wait_for_empty_page(timer)
+    rescue *unhandled_alert_errors
+      accept_unhandled_reset_alert
+      retry
+    end
+
+    execute_cdp('Storage.clearDataForOrigin', origin: '*', storageTypes: storage_types_to_clear)
+  end
+
+private
+
+  def storage_types_to_clear
+    types = ['cookies']
+    types << 'local_storage' if clear_all_storage?
+    types.join(',')
+  end
+
+  def clear_all_storage?
+    storage_clears.none? { |s| s == false }
+  end
+
+  def uniform_storage_clear?
+    storage_clears.uniq { |s| s == false }.length <= 1
+  end
+
+  def storage_clears
+    options.values_at(:clear_session_storage, :clear_local_storage)
+  end
+
+  def clear_storage
+    # Chrome errors if attempt to clear storage on about:blank
+    # In W3C mode it crashes chromedriver
+    url = current_url
+    super unless url.nil? || url.start_with?('about:')
+  end
+
+  def delete_all_cookies
+    execute_cdp('Network.clearBrowserCookies')
+  rescue *cdp_unsupported_errors
+    # If the CDP clear isn't supported do original limited clear
+    super
+  end
+
+  def cdp_unsupported_errors
+    @cdp_unsupported_errors ||= [Selenium::WebDriver::Error::WebDriverError]
+  end
+
+  def execute_cdp(cmd, params = {})
+    if browser.respond_to? :execute_cdp
+      browser.execute_cdp(cmd, **params)
+    else
+      args = { cmd: cmd, params: params }
+      result = bridge.http.call(:post, "session/#{bridge.session_id}/goog/cdp/execute", args)
+      result['value']
+    end
+  end
+
+  def build_node(native_node, initial_cache = {})
+    ::Capybara::Selenium::ChromeNode.new(self, native_node, initial_cache)
+  end
+
+  def chromedriver_version
+    @chromedriver_version ||= begin
+      caps = browser.capabilities
+      caps['chrome']&.fetch('chromedriverVersion', nil).to_f
+    end
+  end
+end
+
+Capybara::Selenium::Driver.register_specialization :chrome, Capybara::Selenium::Driver::ChromeDriver

data/lib/capybara/selenium/driver_specializations/edge_driver.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'capybara/selenium/nodes/edge_node'
+
+module Capybara::Selenium::Driver::EdgeDriver
+  def self.extended(base)
+    bridge = base.send(:bridge)
+    bridge.extend Capybara::Selenium::IsDisplayed unless bridge.commands(:is_element_displayed)
+    base.options[:native_displayed] = false if base.options[:native_displayed].nil?
+  end
+
+  def fullscreen_window(handle)
+    return super if edgedriver_version < 75
+
+    within_given_window(handle) do
+      begin
+        super
+      rescue NoMethodError => e
+        raise unless e.message.match?(/full_screen_window/)
+
+        result = bridge.http.call(:post, "session/#{bridge.session_id}/window/fullscreen", {})
+        result['value']
+      end
+    end
+  end
+
+  def resize_window_to(handle, width, height)
+    super
+  rescue Selenium::WebDriver::Error::UnknownError => e
+    raise unless e.message.match?(/failed to change window state/)
+
+    # Chromedriver doesn't wait long enough for state to change when coming out of fullscreen
+    # and raises unnecessary error. Wait a bit and try again.
+    sleep 0.25
+    super
+  end
+
+  def reset!
+    return super if edgedriver_version < 75
+    # Use instance variable directly so we avoid starting the browser just to reset the session
+    return unless @browser
+
+    switch_to_window(window_handles.first)
+    window_handles.slice(1..-1).each { |win| close_window(win) }
+
+    timer = Capybara::Helpers.timer(expire_in: 10)
+    begin
+      clear_storage unless uniform_storage_clear?
+      @browser.navigate.to('about:blank')
+      wait_for_empty_page(timer)
+    rescue *unhandled_alert_errors
+      accept_unhandled_reset_alert
+      retry
+    end
+
+    execute_cdp('Storage.clearDataForOrigin', origin: '*', storageTypes: storage_types_to_clear)
+  end
+
+  def download_path=(path)
+    if @browser.respond_to?(:download_path=)
+      @browser.download_path = path
+    else
+      # Not yet implemented in seleniun-webdriver for edge so do it ourselves
+      execute_cdp('Page.setDownloadBehavior', behavior: 'allow', downloadPath: path)
+    end
+  end
+
+private
+
+  def storage_types_to_clear
+    types = ['cookies']
+    types << 'local_storage' if clear_all_storage?
+    types.join(',')
+  end
+
+  def clear_all_storage?
+    storage_clears.none? { |s| s == false }
+  end
+
+  def uniform_storage_clear?
+    storage_clears.uniq { |s| s == false }.length <= 1
+  end
+
+  def storage_clears
+    options.values_at(:clear_session_storage, :clear_local_storage)
+  end
+
+  def clear_storage
+    # Edgedriver crashes if attempt to clear storage on about:blank
+    url = current_url
+    super unless url.nil? || url.start_with?('about:')
+  end
+
+  def delete_all_cookies
+    return super if edgedriver_version < 75
+
+    execute_cdp('Network.clearBrowserCookies')
+  rescue *cdp_unsupported_errors
+    # If the CDP clear isn't supported do original limited clear
+    super
+  end
+
+  def cdp_unsupported_errors
+    @cdp_unsupported_errors ||= [Selenium::WebDriver::Error::WebDriverError]
+  end
+
+  def execute_cdp(cmd, params = {})
+    args = { cmd: cmd, params: params }
+    result = bridge.http.call(:post, "session/#{bridge.session_id}/goog/cdp/execute", args)
+    result['value']
+  end
+
+  def build_node(native_node, initial_cache = {})
+    ::Capybara::Selenium::EdgeNode.new(self, native_node, initial_cache)
+  end
+
+  def edgedriver_version
+    @edgedriver_version ||= begin
+      caps = browser.capabilities
+      caps['chrome']&.fetch('chromedriverVersion', nil).to_f
+    end
+  end
+end
+
+Capybara::Selenium::Driver.register_specialization :edge, Capybara::Selenium::Driver::EdgeDriver
+Capybara::Selenium::Driver.register_specialization :edge_chrome, Capybara::Selenium::Driver::EdgeDriver

data/lib/capybara/selenium/driver_specializations/firefox_driver.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'capybara/selenium/nodes/firefox_node'
+
+module Capybara::Selenium::Driver::FirefoxDriver
+  def self.extended(driver)
+    driver.extend Capybara::Selenium::Driver::W3CFirefoxDriver if w3c?(driver)
+    bridge = driver.send(:bridge)
+    bridge.extend Capybara::Selenium::IsDisplayed unless bridge.commands(:is_element_displayed)
+  end
+
+  def self.w3c?(driver)
+    (defined?(Selenium::WebDriver::VERSION) && (Selenium::WebDriver::VERSION.to_f >= 4)) ||
+      driver.browser.capabilities.is_a?(::Selenium::WebDriver::Remote::W3C::Capabilities)
+  end
+end
+
+module Capybara::Selenium::Driver::W3CFirefoxDriver
+  class << self
+    def extended(driver)
+      require 'capybara/selenium/patches/pause_duration_fix' if pause_broken?(driver.browser)
+      driver.options[:native_displayed] = false if driver.options[:native_displayed].nil?
+    end
+
+    def pause_broken?(sel_driver)
+      sel_driver.capabilities['moz:geckodriverVersion']&.start_with?('0.22.')
+    end
+  end
+
+  def resize_window_to(handle, width, height)
+    within_given_window(handle) do
+      # Don't set the size if already set - See https://github.com/mozilla/geckodriver/issues/643
+      if window_size(handle) == [width, height]
+        {}
+      else
+        super
+      end
+    end
+  end
+
+  def reset!
+    # Use instance variable directly so we avoid starting the browser just to reset the session
+    return unless @browser
+
+    if browser_version >= 68
+      begin
+        # Firefox 68 hangs if we try to switch windows while a modal is visible
+        browser.switch_to.alert&.dismiss
+      rescue Selenium::WebDriver::Error::NoSuchAlertError
+        # Swallow
+      end
+    end
+
+    switch_to_window(window_handles.first)
+    window_handles.slice(1..-1).each { |win| close_window(win) }
+    super
+  end
+
+  def refresh
+    # Accept any "will repost content" confirmation that occurs
+    accept_modal :confirm, wait: 0.1 do
+      super
+    end
+  rescue Capybara::ModalNotFound
+    # No modal was opened - page has refreshed - ignore
+  end
+
+  def switch_to_frame(frame)
+    return super unless frame == :parent
+
+    # geckodriver/firefox has an issue if the current frame is removed from within it
+    # so we have to move to the default_content and iterate back through the frames
+    handles = @frame_handles[current_window_handle]
+    browser.switch_to.default_content
+    handles.tap(&:pop).each { |fh| browser.switch_to.frame(fh.native) }
+  end
+
+private
+
+  def build_node(native_node, initial_cache = {})
+    ::Capybara::Selenium::FirefoxNode.new(self, native_node, initial_cache)
+  end
+
+  def browser_version
+    browser.capabilities[:browser_version].to_f
+  end
+end
+
+Capybara::Selenium::Driver.register_specialization :firefox, Capybara::Selenium::Driver::FirefoxDriver

data/lib/capybara/selenium/driver_specializations/internet_explorer_driver.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'capybara/selenium/nodes/ie_node'
+
+module Capybara::Selenium::Driver::InternetExplorerDriver
+  def switch_to_frame(frame)
+    return super unless frame == :parent
+
+    # iedriverserver has an issue if the current frame is removed from within it
+    # so we have to move to the default_content and iterate back through the frames
+    handles = @frame_handles[current_window_handle]
+    browser.switch_to.default_content
+    handles.tap(&:pop).each { |fh| browser.switch_to.frame(fh.native) }
+  end
+
+private
+
+  def build_node(native_node, initial_cache = {})
+    ::Capybara::Selenium::IENode.new(self, native_node, initial_cache)
+  end
+end
+
+module Capybara::Selenium
+  Driver.register_specialization :ie, Driver::InternetExplorerDriver
+  Driver.register_specialization :internet_explorer, Driver::InternetExplorerDriver
+end

data/lib/capybara/selenium/driver_specializations/safari_driver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'capybara/selenium/nodes/safari_node'
+
+module Capybara::Selenium::Driver::SafariDriver
+  def switch_to_frame(frame)
+    return super unless frame == :parent
+
+    # safaridriver/safari has an issue where switch_to_frame(:parent)
+    # behaves like switch_to_frame(:top)
+    handles = @frame_handles[current_window_handle]
+    browser.switch_to.default_content
+    handles.tap(&:pop).each { |fh| browser.switch_to.frame(fh.native) }
+  end
+
+private
+
+  def build_node(native_node, initial_cache = {})
+    ::Capybara::Selenium::SafariNode.new(self, native_node, initial_cache)
+  end
+end
+
+Capybara::Selenium::Driver.register_specialization(/^(safari|Safari_Technology_Preview)$/,
+                                                   Capybara::Selenium::Driver::SafariDriver)

data/lib/capybara/selenium/extensions/file_input_click_emulation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Capybara::Selenium::Node
+  module FileInputClickEmulation
+    def click(keys = [], **options)
+      super
+    rescue Selenium::WebDriver::Error::InvalidArgumentError
+      return emulate_click if attaching_file? && visible_file_field?
+
+      raise
+    end
+
+  private
+
+    def visible_file_field?
+      (attrs(:tagName, :type).map { |val| val&.downcase } == %w[input file]) && visible?
+    end
+
+    def attaching_file?
+      caller_locations.any? { |cl| cl.base_label == 'attach_file' }
+    end
+
+    def emulate_click
+      driver.execute_script(<<~JS, self)
+        arguments[0].dispatchEvent(
+          new MouseEvent('click', {
+            view: window,
+            bubbles: true,
+            cancelable: true
+          }));
+      JS
+    end
+  end
+end

data/lib/capybara/selenium/extensions/find.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Selenium
+    module Find
+      def find_xpath(selector, uses_visibility: false, styles: nil, position: false, **_options)
+        find_by(:xpath, selector, uses_visibility: uses_visibility, texts: [], styles: styles, position: position)
+      end
+
+      def find_css(selector, uses_visibility: false, texts: [], styles: nil, position: false, **_options)
+        find_by(:css, selector, uses_visibility: uses_visibility, texts: texts, styles: styles, position: position)
+      end
+
+    private
+
+      def find_by(format, selector, uses_visibility:, texts:, styles:, position:)
+        els = find_context.find_elements(format, selector)
+        hints = []
+
+        if (els.size > 2) && !ENV['DISABLE_CAPYBARA_SELENIUM_OPTIMIZATIONS']
+          els = filter_by_text(els, texts) unless texts.empty?
+          hints = gather_hints(els, uses_visibility: uses_visibility, styles: styles, position: position)
+        end
+        els.map.with_index { |el, idx| build_node(el, hints[idx] || {}) }
+      end
+
+      def gather_hints(elements, uses_visibility:, styles:, position:)
+        hints_js, functions = build_hints_js(uses_visibility, styles, position)
+        return [] unless functions.any?
+
+        es_context.execute_script(hints_js, elements).map! do |results|
+          hint = {}
+          hint[:style] = results.pop if functions.include?(:style_func)
+          hint[:position] = results.pop if functions.include?(:position_func)
+          hint[:visible] = results.pop if functions.include?(:vis_func)
+          hint
+        end
+      rescue ::Selenium::WebDriver::Error::StaleElementReferenceError,
+             ::Capybara::NotSupportedByDriverError
+        # warn 'Unexpected Stale Element Error - skipping optimization'
+        []
+      end
+
+      def filter_by_text(elements, texts)
+        es_context.execute_script <<~JS, elements, texts
+          var texts = arguments[1];
+          return arguments[0].filter(function(el){
+            var content = el.textContent.toLowerCase();
+            return texts.every(function(txt){ return content.indexOf(txt.toLowerCase()) != -1 });
+          })
+        JS
+      end
+
+      def build_hints_js(uses_visibility, styles, position)
+        functions = []
+        hints_js = +''
+
+        if uses_visibility && !is_displayed_atom.empty?
+          hints_js << <<~VISIBILITY_JS
+            var vis_func = #{is_displayed_atom};
+          VISIBILITY_JS
+          functions << :vis_func
+        end
+
+        if position
+          hints_js << <<~POSITION_JS
+            var position_func = function(el){
+              return el.getBoundingClientRect();
+            };
+          POSITION_JS
+          functions << :position_func
+        end
+
+        if styles.is_a? Hash
+          hints_js << <<~STYLE_JS
+            var style_func = function(el){
+              var el_styles = window.getComputedStyle(el);
+              return #{styles.keys.map(&:to_s)}.reduce(function(res, style){
+                res[style] = el_styles[style];
+                return res;
+              }, {});
+            };
+          STYLE_JS
+          functions << :style_func
+        end
+
+        hints_js << <<~EACH_JS
+          return arguments[0].map(function(el){
+            return [#{functions.join(',')}].map(function(fn){ return fn.call(null, el) });
+          });
+        EACH_JS
+
+        [hints_js, functions]
+      end
+
+      def es_context
+        respond_to?(:execute_script) ? self : driver
+      end
+
+      def is_displayed_atom # rubocop:disable Naming/PredicateName
+        @@is_displayed_atom ||= begin # rubocop:disable Style/ClassVars
+          browser.send(:bridge).send(:read_atom, 'isDisplayed')
+                                rescue StandardError
+                                  # If the atom doesn't exist or other error
+                                  ''
+        end
+      end
+    end
+  end
+end