capybara 3.16.1 → 3.33.0

data/lib/capybara/selenium/driver.rb

@@ -11,20 +11,35 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     clear_local_storage: nil,
     clear_session_storage: nil
   }.freeze
-  SPECIAL_OPTIONS = %i[browser clear_local_storage clear_session_storage timeout].freeze
+  SPECIAL_OPTIONS = %i[browser clear_local_storage clear_session_storage timeout native_displayed].freeze
   attr_reader :app, :options
 
-  def self.load_selenium
-    require 'selenium-webdriver'
-    warn "Warning: You're using an unsupported version of selenium-webdriver, please upgrade." if Gem.loaded_specs['selenium-webdriver'].version < Gem::Version.new('3.5.0')
-  rescue LoadError => err
-    raise err if err.message !~ /selenium-webdriver/
+  class << self
+    def load_selenium
+      require 'selenium-webdriver'
+      require 'capybara/selenium/logger_suppressor'
+      require 'capybara/selenium/patches/atoms'
+      require 'capybara/selenium/patches/is_displayed'
+      require 'capybara/selenium/patches/action_pauser'
+      if Gem.loaded_specs['selenium-webdriver'].version < Gem::Version.new('3.5.0')
+        warn "Warning: You're using an unsupported version of selenium-webdriver, please upgrade."
+      end
+    rescue LoadError => e
+      raise e unless e.message.match?(/selenium-webdriver/)
+
+      raise LoadError, "Capybara's selenium driver is unable to load `selenium-webdriver`, please install the gem and add `gem 'selenium-webdriver'` to your Gemfile if you are using bundler."
+    end
 
-    raise LoadError, "Capybara's selenium driver is unable to load `selenium-webdriver`, please install the gem and add `gem 'selenium-webdriver'` to your Gemfile if you are using bundler."
+    attr_reader :specializations
+
+    def register_specialization(browser_name, specialization)
+      @specializations ||= {}
+      @specializations[browser_name] = specialization
+    end
   end
 
   def browser
-    @browser ||= begin
+    unless @browser
       options[:http_client] ||= begin
         require 'capybara/selenium/patches/persistent_client'
         if options[:timeout]
@@ -34,10 +49,10 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
         end
       end
       processed_options = options.reject { |key, _val| SPECIAL_OPTIONS.include?(key) }
-      Selenium::WebDriver.for(options[:browser], processed_options).tap do |driver|
-        specialize_driver(driver)
-        setup_exit_handler
-      end
+      @browser = Selenium::WebDriver.for(options[:browser], processed_options)
+
+      specialize_driver
+      setup_exit_handler
     end
     @browser
   end
@@ -70,6 +85,8 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def html
     browser.page_source
+  rescue Selenium::WebDriver::Error::JavascriptError => e
+    raise unless e.message.match?(/documentElement is null/)
   end
 
   def title
@@ -115,7 +132,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
       navigated = true
       # Ensure the page is empty and trigger an UnhandledAlertError for any modals that appear during unload
       wait_for_empty_page(timer)
-    rescue Selenium::WebDriver::Error::UnhandledAlertError, Selenium::WebDriver::Error::UnexpectedAlertOpenError
+    rescue *unhandled_alert_errors
       # This error is thrown if an unhandled alert is on the page
       # Firefox appears to automatically dismiss this alert, chrome does not
       # We'll try to accept it
@@ -125,6 +142,18 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     end
   end
 
+  def frame_obscured_at?(x:, y:)
+    frame = @frame_handles[current_window_handle].last
+    return false unless frame
+
+    switch_to_frame(:parent)
+    begin
+      frame.base.obscured?(x: x, y: y)
+    ensure
+      switch_to_frame(frame)
+    end
+  end
+
   def switch_to_frame(frame)
     handles = @frame_handles[current_window_handle]
     case frame
@@ -135,7 +164,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
       handles.pop
       browser.switch_to.parent_frame
     else
-      handles << frame.native
+      handles << frame
       browser.switch_to.frame(frame.native)
     end
   end
@@ -195,7 +224,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def accept_modal(_type, **options)
     yield if block_given?
-    modal = find_modal(options)
+    modal = find_modal(**options)
 
     modal.send_keys options[:with] if options[:with]
 
@@ -206,7 +235,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def dismiss_modal(_type, **options)
     yield if block_given?
-    modal = find_modal(options)
+    modal = find_modal(**options)
     message = modal.text
     modal.dismiss
     message
@@ -214,31 +243,39 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def quit
     @browser&.quit
-  rescue Selenium::WebDriver::Error::SessionNotCreatedError, Errno::ECONNREFUSED # rubocop:disable Lint/HandleExceptions
+  rescue Selenium::WebDriver::Error::SessionNotCreatedError, Errno::ECONNREFUSED
     # Browser must have already gone
-  rescue Selenium::WebDriver::Error::UnknownError => err
-    unless silenced_unknown_error_message?(err.message) # Most likely already gone
+  rescue Selenium::WebDriver::Error::UnknownError => e
+    unless silenced_unknown_error_message?(e.message) # Most likely already gone
       # probably already gone but not sure - so warn
-      warn "Ignoring Selenium UnknownError during driver quit: #{err.message}"
+      warn "Ignoring Selenium UnknownError during driver quit: #{e.message}"
     end
   ensure
     @browser = nil
   end
 
   def invalid_element_errors
-    [
-      ::Selenium::WebDriver::Error::StaleElementReferenceError,
-      ::Selenium::WebDriver::Error::UnhandledError,
-      ::Selenium::WebDriver::Error::ElementNotVisibleError,
-      ::Selenium::WebDriver::Error::InvalidSelectorError, # Work around a chromedriver go_back/go_forward race condition
-      ::Selenium::WebDriver::Error::ElementNotInteractableError,
-      ::Selenium::WebDriver::Error::ElementClickInterceptedError,
-      ::Selenium::WebDriver::Error::InvalidElementStateError,
-      ::Selenium::WebDriver::Error::ElementNotSelectableError,
-      ::Selenium::WebDriver::Error::ElementNotSelectableError,
-      ::Selenium::WebDriver::Error::NoSuchElementError, # IE
-      ::Selenium::WebDriver::Error::InvalidArgumentError # IE
-    ]
+    @invalid_element_errors ||= begin
+      [
+        ::Selenium::WebDriver::Error::StaleElementReferenceError,
+        ::Selenium::WebDriver::Error::ElementNotInteractableError,
+        ::Selenium::WebDriver::Error::InvalidSelectorError, # Work around chromedriver go_back/go_forward race condition
+        ::Selenium::WebDriver::Error::ElementClickInterceptedError,
+        ::Selenium::WebDriver::Error::NoSuchElementError, # IE
+        ::Selenium::WebDriver::Error::InvalidArgumentError # IE
+      ].tap do |errors|
+        unless selenium_4?
+          ::Selenium::WebDriver.logger.suppress_deprecations do
+            errors.concat [
+              ::Selenium::WebDriver::Error::UnhandledError,
+              ::Selenium::WebDriver::Error::ElementNotVisibleError,
+              ::Selenium::WebDriver::Error::InvalidElementStateError,
+              ::Selenium::WebDriver::Error::ElementNotSelectableError
+            ]
+          end
+        end
+      end
+    end
   end
 
   def no_such_window_error
@@ -247,6 +284,10 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
 private
 
+  def selenium_4?
+    defined?(Selenium::WebDriver::VERSION) && (Selenium::WebDriver::VERSION.to_f >= 4)
+  end
+
   def native_args(args)
     args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg }
   end
@@ -254,12 +295,23 @@ private
   def clear_browser_state
     delete_all_cookies
     clear_storage
-  rescue Selenium::WebDriver::Error::UnhandledError # rubocop:disable Lint/HandleExceptions
+  rescue *clear_browser_state_errors
     # delete_all_cookies fails when we've previously gone
     # to about:blank, so we rescue this error and do nothing
     # instead.
   end
 
+  def clear_browser_state_errors
+    @clear_browser_state_errors ||= [Selenium::WebDriver::Error::UnknownError]
+  end
+
+  def unhandled_alert_errors
+    @unhandled_alert_errors ||= with_legacy_error(
+      [Selenium::WebDriver::Error::UnexpectedAlertOpenError],
+      'UnhandledAlertError'
+    )
+  end
+
   def delete_all_cookies
     @browser.manage.delete_all_cookies
   end
@@ -267,7 +319,7 @@ private
   def clear_storage
     clear_session_storage unless options[:clear_session_storage] == false
     clear_local_storage unless options[:clear_local_storage] == false
-  rescue Selenium::WebDriver::Error::JavascriptError # rubocop:disable Lint/HandleExceptions
+  rescue Selenium::WebDriver::Error::JavascriptError
     # session/local storage may not be available if on non-http pages (e.g. about:blank)
   end
 
@@ -278,7 +330,9 @@ private
       begin
         @browser&.execute_script('window.sessionStorage.clear()')
       rescue # rubocop:disable Style/RescueStandardError
-        warn 'sessionStorage clear requested but is not supported by this driver' unless options[:clear_session_storage].nil?
+        unless options[:clear_session_storage].nil?
+          warn 'sessionStorage clear requested but is not supported by this driver'
+        end
       end
     end
   end
@@ -290,7 +344,9 @@ private
       begin
         @browser&.execute_script('window.localStorage.clear()')
       rescue # rubocop:disable Style/RescueStandardError
-        warn 'localStorage clear requested but is not supported by this driver' unless options[:clear_local_storage].nil?
+        unless options[:clear_local_storage].nil?
+          warn 'localStorage clear requested but is not supported by this driver'
+        end
       end
     end
   end
@@ -299,7 +355,7 @@ private
     @browser.navigate.to(url)
     sleep 0.1 # slight wait for alert
     @browser.switch_to.alert.accept
-  rescue modal_error # rubocop:disable Lint/HandleExceptions
+  rescue modal_error
     # alert now gone, should mean navigation happened
   end
 
@@ -329,16 +385,35 @@ private
     begin
       wait.until do
         alert = @browser.switch_to.alert
-        regexp = text.is_a?(Regexp) ? text : Regexp.escape(text.to_s)
-        alert.text.match?(regexp) ? alert : nil
+        regexp = text.is_a?(Regexp) ? text : Regexp.new(Regexp.escape(text.to_s))
+        matched = alert.text.match?(regexp)
+        unless matched
+          raise Capybara::ModalNotFound, "Unable to find modal dialog with #{text} - found '#{alert.text}' instead."
+        end
+
+        alert
       end
-    rescue Selenium::WebDriver::Error::TimeOutError
+    rescue *find_modal_errors
       raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{text}" if text}"
     end
   end
 
+  def find_modal_errors
+    @find_modal_errors ||= with_legacy_error([Selenium::WebDriver::Error::TimeoutError], 'TimeOutError')
+  end
+
+  def with_legacy_error(errors, legacy_error)
+    errors.tap do |errs|
+      unless selenium_4?
+        ::Selenium::WebDriver.logger.suppress_deprecations do
+          errs << Selenium::WebDriver::Error.const_get(legacy_error)
+        end
+      end
+    end
+  end
+
   def silenced_unknown_error_message?(msg)
-    silenced_unknown_error_messages.any? { |regex| msg =~ regex }
+    silenced_unknown_error_messages.any? { |regex| msg.match? regex }
   end
 
   def silenced_unknown_error_messages
@@ -366,22 +441,15 @@ private
     ::Capybara::Selenium::Node.new(self, native_node, initial_cache)
   end
 
-  def specialize_driver(sel_driver)
-    case sel_driver.browser
-    when :chrome
-      extend ChromeDriver
-    when :firefox
-      require 'capybara/selenium/patches/pause_duration_fix' if pause_broken?(sel_driver)
-      extend FirefoxDriver if sel_driver.capabilities.is_a?(::Selenium::WebDriver::Remote::W3C::Capabilities)
-    when :ie, :internet_explorer
-      extend InternetExplorerDriver
-    when :safari, :Safari_Technology_Preview
-      extend SafariDriver
-    end
+  def bridge
+    browser.send(:bridge)
   end
 
-  def pause_broken?(driver)
-    driver.capabilities['moz:geckodriverVersion']&.start_with?('0.22.')
+  def specialize_driver
+    browser_type = browser.browser
+    Capybara::Selenium::Driver.specializations.select { |k, _v| k === browser_type }.each_value do |specialization| # rubocop:disable Style/CaseEquality
+      extend specialization
+    end
   end
 
   def setup_exit_handler
@@ -427,3 +495,4 @@ require 'capybara/selenium/driver_specializations/chrome_driver'
 require 'capybara/selenium/driver_specializations/firefox_driver'
 require 'capybara/selenium/driver_specializations/internet_explorer_driver'
 require 'capybara/selenium/driver_specializations/safari_driver'
+require 'capybara/selenium/driver_specializations/edge_driver'

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

@@ -1,25 +1,31 @@
 # 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 => err
-        raise unless err.message =~ /full_screen_window/
-
-        result = bridge.http.call(:post, "session/#{bridge.session_id}/window/fullscreen", {})
-        result['value']
-      end
+      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
 
   def resize_window_to(handle, width, height)
     super
-  rescue Selenium::WebDriver::Error::UnknownError => err
-    raise unless err.message =~ /failed to change window state/
+  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.
@@ -33,29 +39,79 @@ module Capybara::Selenium::Driver::ChromeDriver
 
     switch_to_window(window_handles.first)
     window_handles.slice(1..-1).each { |win| close_window(win) }
-    super
+    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? 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 Selenium::WebDriver::Error::UnhandledError, Selenium::WebDriver::Error::WebDriverError
+  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']
+    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 bridge
-    browser.send(:bridge)
+  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,124 @@
+# 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
+      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
+
+  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? 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