capybara 3.0.0 → 3.36.0

data/lib/capybara/selenium/driver.rb

@@ -1,50 +1,103 @@
 # frozen_string_literal: true
 
-require "uri"
-require "English"
+require 'uri'
+require 'English'
 
 class Capybara::Selenium::Driver < Capybara::Driver::Base
+  include Capybara::Selenium::Find
+
   DEFAULT_OPTIONS = {
     browser: :firefox,
-    clear_local_storage: false,
-    clear_session_storage: false
+    clear_local_storage: nil,
+    clear_session_storage: nil
   }.freeze
-  SPECIAL_OPTIONS = %i[browser clear_local_storage clear_session_storage].freeze
+  SPECIAL_OPTIONS = %i[browser clear_local_storage clear_session_storage timeout native_displayed].freeze
+  CAPS_VERSION = Gem::Requirement.new('~> 4.0.0.alpha6')
 
   attr_reader :app, :options
 
-  def browser
-    unless @browser
-      if firefox?
-        options[:desired_capabilities] ||= {}
-        options[:desired_capabilities][:unexpectedAlertBehaviour] = "ignore"
+  class << self
+    attr_reader :selenium_webdriver_version
+
+    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'
+
+      # Look up the version of `selenium-webdriver` to
+      # see if it's a version we support.
+      #
+      # By default, we use Gem.loaded_specs to determine
+      # the version number. However, in some cases, such
+      # as when loading `selenium-webdriver` outside of
+      # Rubygems, we fall back to referencing
+      # Selenium::WebDriver::VERSION. Ideally we'd
+      # use the constant in all cases, but earlier versions
+      # of `selenium-webdriver` didn't provide the constant.
+      @selenium_webdriver_version =
+        if Gem.loaded_specs['selenium-webdriver']
+          Gem.loaded_specs['selenium-webdriver'].version
+        else
+          Gem::Version.new(Selenium::WebDriver::VERSION)
+        end
+
+      unless Gem::Requirement.new('>= 3.142.7').satisfied_by? @selenium_webdriver_version
+        warn "Warning: You're using an unsupported version of selenium-webdriver, please upgrade."
       end
 
-      @processed_options = options.reject { |key, _val| SPECIAL_OPTIONS.include?(key) }
-      @browser = Selenium::WebDriver.for(options[:browser], @processed_options)
+      @selenium_webdriver_version
+    rescue LoadError => e
+      raise e unless e.message.include?('selenium-webdriver')
 
-      @w3c = ((defined?(Selenium::WebDriver::Remote::W3CCapabilities) && @browser.capabilities.is_a?(Selenium::WebDriver::Remote::W3CCapabilities)) ||
-              (defined?(Selenium::WebDriver::Remote::W3C::Capabilities) && @browser.capabilities.is_a?(Selenium::WebDriver::Remote::W3C::Capabilities)))
-      main = Process.pid
+      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
 
-      at_exit do
-        # Store the exit status of the test run since it goes away after calling the at_exit proc...
-        @exit_status = $ERROR_INFO.status if $ERROR_INFO.is_a?(SystemExit)
-        quit if Process.pid == main
-        exit @exit_status if @exit_status # Force exit with stored status
+    attr_reader :specializations
+
+    def register_specialization(browser_name, specialization)
+      @specializations ||= {}
+      @specializations[browser_name] = specialization
+    end
+  end
+
+  def browser
+    unless @browser
+      options[:http_client] ||= begin
+        require 'capybara/selenium/patches/persistent_client'
+        if options[:timeout]
+          ::Capybara::Selenium::PersistentClient.new(read_timeout: options[:timeout])
+        else
+          ::Capybara::Selenium::PersistentClient.new
+        end
+      end
+      processed_options = options.reject { |key, _val| SPECIAL_OPTIONS.include?(key) }
+
+      @browser = if options[:browser] == :firefox &&
+                    RUBY_VERSION >= '3.0' &&
+                    Capybara::Selenium::Driver.selenium_webdriver_version <= Gem::Version.new('4.0.0.alpha1')
+        # selenium-webdriver 3.x doesn't correctly pass options through for Firefox with Ruby 3 so workaround that
+        Selenium::WebDriver::Firefox::Driver.new(**processed_options)
+      else
+        Selenium::WebDriver.for(options[:browser], processed_options)
       end
+
+      specialize_driver
+      setup_exit_handler
     end
     @browser
   end
 
   def initialize(app, **options)
-    load_selenium
-    @session = nil
+    super()
+    self.class.load_selenium
     @app = app
     @browser = nil
     @exit_status = nil
-    @frame_handles = {}
+    @frame_handles = Hash.new { |hash, handle| hash[handle] = [] }
     @options = DEFAULT_OPTIONS.merge(options)
+    @node_class = ::Capybara::Selenium::Node
   end
 
   def visit(path)
@@ -65,6 +118,8 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def html
     browser.page_source
+  rescue Selenium::WebDriver::Error::JavascriptError => e
+    raise unless e.message.include?('documentElement is null')
   end
 
   def title
@@ -75,19 +130,11 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser.current_url
   end
 
-  def find_xpath(selector)
-    browser.find_elements(:xpath, selector).map { |node| Capybara::Selenium::Node.new(self, node) }
-  end
-
-  def find_css(selector)
-    browser.find_elements(:css, selector).map { |node| Capybara::Selenium::Node.new(self, node) }
-  end
-
   def wait?; true; end
   def needs_server?; true; end
 
   def execute_script(script, *args)
-    browser.execute_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg })
+    browser.execute_script(script, *native_args(args))
   end
 
   def evaluate_script(script, *args)
@@ -97,10 +144,19 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   def evaluate_async_script(script, *args)
     browser.manage.timeouts.script_timeout = Capybara.default_max_wait_time
-    result = browser.execute_async_script(script, *args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg })
+    result = browser.execute_async_script(script, *native_args(args))
     unwrap_script_result(result)
   end
 
+  def active_element
+    build_node(native_active_element)
+  end
+
+  def send_keys(*args)
+    # Should this call the specialized nodes rather than native???
+    native_active_element.send_keys(*args)
+  end
+
   def save_screenshot(path, **_options)
     browser.save_screenshot(path)
   end
@@ -109,74 +165,48 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     # Use instance variable directly so we avoid starting the browser just to reset the session
     return unless @browser
 
-    if firefox? || chrome?
-      switch_to_window(window_handles.first)
-      window_handles.slice(1..-1).each { |win| close_window(win) }
-    end
-
     navigated = false
-    start_time = Capybara::Helpers.monotonic_time
+    timer = Capybara::Helpers.timer(expire_in: 10)
     begin
-      unless navigated
-        # Only trigger a navigation if we haven't done it already, otherwise it
-        # can trigger an endless series of unload modals
-        begin
-          @browser.manage.delete_all_cookies
-          clear_storage
-        rescue Selenium::WebDriver::Error::UnhandledError
-          # delete_all_cookies fails when we've previously gone
-          # to about:blank, so we rescue this error and do nothing
-          # instead.
-        end
-        @browser.navigate.to("about:blank")
-      end
+      # Only trigger a navigation if we haven't done it already, otherwise it
+      # can trigger an endless series of unload modals
+      reset_browser_state unless navigated
       navigated = true
-
       # Ensure the page is empty and trigger an UnhandledAlertError for any modals that appear during unload
-      until find_xpath("/html/body/*").empty?
-        raise Capybara::ExpectationNotMet, 'Timed out waiting for Selenium session reset' if (Capybara::Helpers.monotonic_time - start_time) >= 10
-        sleep 0.05
-      end
-    rescue Selenium::WebDriver::Error::UnhandledAlertError, Selenium::WebDriver::Error::UnexpectedAlertOpenError
+      wait_for_empty_page(timer)
+    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
-      begin
-        @browser.switch_to.alert.accept
-        sleep 0.25 # allow time for the modal to be handled
-      rescue modal_error
-        # The alert is now gone
-        if current_url != "about:blank"
-          begin
-            # If navigation has not occurred attempt again and accept alert
-            # since FF may have dismissed the alert at first attempt
-            @browser.navigate.to("about:blank")
-            sleep 0.1 # slight wait for alert
-            @browser.switch_to.alert.accept
-          rescue modal_error # rubocop:disable Metrics/BlockNesting
-            # alert now gone, should mean navigation happened
-          end
-        end
-      end
+      accept_unhandled_reset_alert
       # try cleaning up the browser again
       retry
     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
     when :top
-      @frame_handles[browser.window_handle] = []
+      handles.clear
       browser.switch_to.default_content
     when :parent
-      # would love to use browser.switch_to.parent_frame here
-      # but it has an issue if the current frame is removed from within it
-      @frame_handles[browser.window_handle].pop
-      browser.switch_to.default_content
-      @frame_handles[browser.window_handle].each { |fh| browser.switch_to.frame(fh) }
+      handles.pop
+      browser.switch_to.parent_frame
     else
-      @frame_handles[browser.window_handle] ||= []
-      @frame_handles[browser.window_handle] << frame.native
+      handles << frame
       browser.switch_to.frame(frame.native)
     end
   end
@@ -194,12 +224,7 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
 
   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 marionette? && (window_size(handle) == [width, height])
-        {}
-      else
-        browser.manage.window.resize_to(width, height)
-      end
+      browser.manage.window.resize_to(width, height)
     end
   end
 
@@ -210,8 +235,15 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     sleep 0.1 # work around for https://code.google.com/p/selenium/issues/detail?id=7405
   end
 
+  def fullscreen_window(handle)
+    within_given_window(handle) do
+      browser.manage.window.full_screen
+    end
+  end
+
   def close_window(handle)
-    raise ArgumentError, "Not allowed to close the primary window" if handle == window_handles.first
+    raise ArgumentError, 'Not allowed to close the primary window' if handle == window_handles.first
+
     within_given_window(handle) do
       browser.close
     end
@@ -221,7 +253,16 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser.window_handles
   end
 
-  def open_new_window
+  def open_new_window(kind = :tab)
+    if browser.switch_to.respond_to?(:new_window)
+      handle = current_window_handle
+      browser.switch_to.new_window(kind)
+      switch_to_window(handle)
+    else
+      browser.manage.new_window(kind)
+    end
+  rescue NoMethodError, Selenium::WebDriver::Error::WebDriverError
+    # If not supported by the driver or browser default to using JS
     browser.execute_script('window.open();')
   end
 
@@ -231,7 +272,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]
 
@@ -242,15 +283,16 @@ 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
   end
 
   def quit
-    @browser.quit if @browser
-  rescue Selenium::WebDriver::Error::SessionNotCreatedError, Errno::ECONNREFUSED
+    @browser&.quit
+  rescue Selenium::WebDriver::Error::SessionNotCreatedError, Errno::ECONNREFUSED,
+         Selenium::WebDriver::Error::InvalidSessionIdError
     # Browser must have already gone
   rescue Selenium::WebDriver::Error::UnknownError => e
     unless silenced_unknown_error_message?(e.message) # Most likely already gone
@@ -262,133 +304,115 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   end
 
   def invalid_element_errors
-    [
-      ::Selenium::WebDriver::Error::StaleElementReferenceError,
-      ::Selenium::WebDriver::Error::UnhandledError,
-      ::Selenium::WebDriver::Error::ElementNotVisibleError,
-      ::Selenium::WebDriver::Error::InvalidSelectorError, # Work around a race condition that can occur with chromedriver and #go_back/#go_forward
-      ::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 ||=
+      [
+        ::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
 
   def no_such_window_error
     Selenium::WebDriver::Error::NoSuchWindowError
   end
 
-  # @api private
-  def marionette?
-    firefox? && browser && @w3c
+private
+
+  def selenium_4?
+    defined?(Selenium::WebDriver::VERSION) && (Selenium::WebDriver::VERSION.to_f >= 4)
   end
 
-  # @api private
-  def firefox?
-    browser_name == "firefox"
+  def native_args(args)
+    args.map { |arg| arg.is_a?(Capybara::Selenium::Node) ? arg.native : arg }
   end
 
-  # @api private
-  def chrome?
-    browser_name == "chrome"
+  def native_active_element
+    browser.switch_to.active_element
   end
 
-  # @api private
-  def edge?
-    browser_name == "edge"
+  def clear_browser_state
+    delete_all_cookies
+    clear_storage
+  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
 
-  # @api private
-  def ie?
-    browser_name == "ie"
+  def clear_browser_state_errors
+    @clear_browser_state_errors ||= [Selenium::WebDriver::Error::UnknownError]
   end
 
-private
+  def unhandled_alert_errors
+    @unhandled_alert_errors ||= with_legacy_error(
+      [Selenium::WebDriver::Error::UnexpectedAlertOpenError],
+      'UnhandledAlertError'
+    )
+  end
 
-  def browser_name
-    options[:browser].to_s
+  def delete_all_cookies
+    @browser.manage.delete_all_cookies
   end
 
   def clear_storage
-    if options[:clear_session_storage]
-      if @browser.respond_to? :session_storage
-        @browser.session_storage.clear
-      else
-        warn "sessionStorage clear requested but is not available for this driver"
-      end
-    end
-    if options[:clear_local_storage]
-      if @browser.respond_to? :local_storage
-        @browser.local_storage.clear
-      else
-        warn "localStorage clear requested but is not available for this driver"
-      end
-    end
+    clear_session_storage unless options[:clear_session_storage] == false
+    clear_local_storage unless options[:clear_local_storage] == false
+  rescue Selenium::WebDriver::Error::JavascriptError
+    # session/local storage may not be available if on non-http pages (e.g. about:blank)
   end
 
-  def modal_error
-    if defined?(Selenium::WebDriver::Error::NoSuchAlertError)
-      Selenium::WebDriver::Error::NoSuchAlertError
+  def clear_session_storage
+    if @browser.respond_to? :session_storage
+      @browser.session_storage.clear
     else
-      Selenium::WebDriver::Error::NoAlertPresentError
+      begin
+        @browser&.execute_script('window.sessionStorage.clear()')
+      rescue # rubocop:disable Style/RescueStandardError
+        unless options[:clear_session_storage].nil?
+          warn 'sessionStorage clear requested but is not supported by this driver'
+        end
+      end
     end
   end
 
-  def insert_modal_handlers(accept, response_text)
-    prompt_response = if accept
-      if response_text.nil?
-        "default_text"
-      else
-        "'#{response_text.gsub("\\", "\\\\\\").gsub("'", "\\\\'")}'"
-      end
+  def clear_local_storage
+    if @browser.respond_to? :local_storage
+      @browser.local_storage.clear
     else
-      'null'
+      begin
+        @browser&.execute_script('window.localStorage.clear()')
+      rescue # rubocop:disable Style/RescueStandardError
+        unless options[:clear_local_storage].nil?
+          warn 'localStorage clear requested but is not supported by this driver'
+        end
+      end
     end
+  end
+
+  def navigate_with_accept(url)
+    @browser.navigate.to(url)
+    sleep 0.1 # slight wait for alert
+    @browser.switch_to.alert.accept
+  rescue modal_error
+    # alert now gone, should mean navigation happened
+  end
 
-    script = <<-JS
-      if (typeof window.capybara  === 'undefined') {
-        window.capybara = {
-          modal_handlers: [],
-          current_modal_status: function() {
-            return [this.modal_handlers[0].called, this.modal_handlers[0].modal_text];
-          },
-          add_handler: function(handler) {
-            this.modal_handlers.unshift(handler);
-          },
-          remove_handler: function(handler) {
-            window.alert = handler.alert;
-            window.confirm = handler.confirm;
-            window.prompt = handler.prompt;
-          },
-          handler_called: function(handler, str) {
-            handler.called = true;
-            handler.modal_text = str;
-            this.remove_handler(handler);
-          }
-        };
-      };
-
-      var modal_handler = {
-        prompt: window.prompt,
-        confirm: window.confirm,
-        alert: window.alert,
-        called: false
-      }
-      window.capybara.add_handler(modal_handler);
-
-      window.alert = window.confirm = function(str = "") {
-        window.capybara.handler_called(modal_handler, str.toString());
-        return #{accept ? 'true' : 'false'};
-      }
-      window.prompt = function(str = "", default_text = "") {
-        window.capybara.handler_called(modal_handler, str.toString());
-        return #{prompt_response};
-      }
-    JS
-    execute_script script
+  def modal_error
+    Selenium::WebDriver::Error::NoSuchAlertError
   end
 
   def within_given_window(handle)
@@ -413,47 +437,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_headless_modal(text: nil, **options)
-    # Selenium has its own built in wait (2 seconds)for a modal to show up, so this wait is really the minimum time
-    # Actual wait time may be longer than specified
-    wait = Selenium::WebDriver::Wait.new(
-      timeout: options.fetch(:wait, session_options.default_max_wait_time) || 0,
-      ignore: modal_error
-    )
-    begin
-      wait.until do
-        called, alert_text = evaluate_script('window.capybara && window.capybara.current_modal_status()')
-        if called
-          execute_script('window.capybara && window.capybara.modal_handlers.shift()')
-          regexp = text.is_a?(Regexp) ? text : Regexp.escape(text.to_s)
-          if alert_text.match(regexp)
-            alert_text
-          else
-            raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{text}" if text}"
-          end
-        elsif called.nil?
-          # page changed so modal_handler data has gone away
-          warn "Can't verify modal text when page change occurs - ignoring" if options[:text]
-          ""
-        else
-          nil
+  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
-    rescue Selenium::WebDriver::Error::TimeOutError
-      raise Capybara::ModalNotFound, "Unable to find modal dialog#{" with #{options[:text]}" if options[:text]}"
     end
   end
 
   def silenced_unknown_error_message?(msg)
-    silenced_unknown_error_messages.any? { |r| msg =~ r }
+    silenced_unknown_error_messages.any? { |regex| msg.match? regex }
   end
 
   def silenced_unknown_error_messages
@@ -463,30 +475,76 @@ private
   def unwrap_script_result(arg)
     case arg
     when Array
-      arg.map { |e| unwrap_script_result(e) }
+      arg.map { |arr| unwrap_script_result(arr) }
     when Hash
-      arg.each { |k, v| arg[k] = unwrap_script_result(v) }
+      arg.transform_values! { |value| unwrap_script_result(value) }
     when Selenium::WebDriver::Element
-      Capybara::Selenium::Node.new(self, arg)
+      build_node(arg)
     else
       arg
     end
   end
 
-  def load_selenium
-    require 'selenium-webdriver'
-    # Fix for selenium-webdriver 3.4.0 which misnamed these
-    unless defined?(::Selenium::WebDriver::Error::ElementNotInteractableError)
-      ::Selenium::WebDriver::Error.const_set('ElementNotInteractableError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
+  def find_context
+    browser
+  end
+
+  def build_node(native_node, initial_cache = {})
+    ::Capybara::Selenium::Node.new(self, native_node, initial_cache)
+  end
+
+  def bridge
+    browser.send(:bridge)
+  end
+
+  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
-    unless defined?(::Selenium::WebDriver::Error::ElementClickInterceptedError)
-      ::Selenium::WebDriver::Error.const_set('ElementClickInterceptedError', Class.new(::Selenium::WebDriver::Error::WebDriverError))
+  end
+
+  def setup_exit_handler
+    main = Process.pid
+    at_exit do
+      # Store the exit status of the test run since it goes away after calling the at_exit proc...
+      @exit_status = $ERROR_INFO.status if $ERROR_INFO.is_a?(SystemExit)
+      quit if Process.pid == main
+      exit @exit_status if @exit_status # Force exit with stored status
     end
-  rescue LoadError => e
-    if e.message =~ /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."
-    else
-      raise e
+  end
+
+  def reset_browser_state
+    clear_browser_state
+    @browser.navigate.to('about:blank')
+  end
+
+  def wait_for_empty_page(timer)
+    until find_xpath('/html/body/*').empty?
+      raise Capybara::ExpectationNotMet, 'Timed out waiting for Selenium session reset' if timer.expired?
+
+      sleep 0.01
+
+      # It has been observed that it is possible that asynchronous JS code in
+      # the application under test can navigate the browser away from about:blank
+      # if the timing is just right. Ensure we are still at about:blank...
+      @browser.navigate.to('about:blank') unless current_url == 'about:blank'
     end
   end
+
+  def accept_unhandled_reset_alert
+    @browser.switch_to.alert.accept
+    sleep 0.25 # allow time for the modal to be handled
+  rescue modal_error
+    # The alert is now gone.
+    # If navigation has not occurred attempt again and accept alert
+    # since FF may have dismissed the alert at first attempt.
+    navigate_with_accept('about:blank') if current_url != 'about:blank'
+  end
 end
+
+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'