capybara 3.15.0 → 3.17.0

data/lib/capybara/selector.rb

@@ -7,20 +7,28 @@ Capybara::Selector::FilterSet.add(:_field) do
   node_filter(:checked, :boolean) { |node, value| !(value ^ node.checked?) }
   node_filter(:unchecked, :boolean) { |node, value| (value ^ node.checked?) }
   node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
-  node_filter(:multiple, :boolean) { |node, value| !(value ^ node.multiple?) }
 
   expression_filter(:name) { |xpath, val| xpath[XPath.attr(:name) == val] }
   expression_filter(:placeholder) { |xpath, val| xpath[XPath.attr(:placeholder) == val] }
+  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
+  expression_filter(:multiple) { |xpath, val| xpath[val ? XPath.attr(:multiple) : ~XPath.attr(:multiple)] }
 
-  describe(:node_filters) do |checked: nil, unchecked: nil, disabled: nil, multiple: nil, **|
+  describe(:expression_filters) do |name: nil, placeholder: nil, disabled: nil, multiple: nil, **|
+    desc = +''
+    desc << ' that is not disabled' if disabled == false
+    desc << " with name #{name}" if name
+    desc << " with placeholder #{placeholder}" if placeholder
+    desc << ' with the multiple attribute' if multiple == true
+    desc << ' without the multiple attribute' if multiple == false
+    desc
+  end
+
+  describe(:node_filters) do |checked: nil, unchecked: nil, disabled: nil, **|
     desc, states = +'', []
     states << 'checked' if checked || (unchecked == false)
     states << 'not checked' if unchecked || (checked == false)
     states << 'disabled' if disabled == true
-    states << 'not disabled' if disabled == false
     desc << " that is #{states.join(' and ')}" unless states.empty?
-    desc << ' with the multiple attribute' if multiple == true
-    desc << ' without the multiple attribute' if multiple == false
     desc
   end
 end
@@ -37,7 +45,7 @@ end
 
 Capybara.add_selector(:id, locator_type: [String, Symbol, Regexp]) do
   xpath { |id| builder(XPath.descendant).add_attribute_conditions(id: id) }
-  locator_filter {  |node, id| id.is_a?(Regexp) ? node[:id] =~ id : true }
+  locator_filter {  |node, id| id.is_a?(Regexp) ? id.match?(node[:id]) : true }
 end
 
 Capybara.add_selector(:field, locator_type: [String, Symbol]) do
@@ -63,16 +71,13 @@ Capybara.add_selector(:field, locator_type: [String, Symbol]) do
   node_filter(:readonly, :boolean) { |node, value| !(value ^ node.readonly?) }
   node_filter(:with) do |node, with|
     val = node.value
-    (with.is_a?(Regexp) ? val =~ with : val == with.to_s).tap do |res|
+    (with.is_a?(Regexp) ? with.match?(val) : val == with.to_s).tap do |res|
       add_error("Expected value to be #{with.inspect} but was #{val.inspect}") unless res
     end
   end
 
-  describe_expression_filters do |type: nil, **options|
-    desc = +''
-    (expression_filters.keys & options.keys).each { |ef| desc << " with #{ef} #{options[ef]}" }
-    desc << " of type #{type.inspect}" if type
-    desc
+  describe_expression_filters do |type: nil, **|
+    " of type #{type.inspect}" if type
   end
 
   describe_node_filters do |**options|
@@ -90,6 +95,7 @@ Capybara.add_selector(:fieldset, locator_type: [String, Symbol]) do
   end
 
   node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
+  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
 end
 
 Capybara.add_selector(:link, locator_type: [String, Symbol]) do
@@ -123,26 +129,28 @@ Capybara.add_selector(:link, locator_type: [String, Symbol]) do
     builder(expr).add_attribute_conditions(download: download)
   end
 
-  describe_expression_filters do |**options|
+  describe_expression_filters do |download: nil, **options|
     desc = +''
     if (href = options[:href])
       desc << " with href #{'matching ' if href.is_a? Regexp}#{href.inspect}"
     elsif options.key?(:href) # is nil/false specified?
       desc << ' with no href attribute'
     end
+    desc << " with download attribute#{" #{download}" if download.is_a? String}" if download
+    desc << ' without download attribute' if download == false
     desc
   end
 end
 
 Capybara.add_selector(:button, locator_type: [String, Symbol]) do
-  xpath(:value, :title, :type) do |locator, **options|
+  xpath(:value, :title, :type, :name) do |locator, **options|
     input_btn_xpath = XPath.descendant(:input)[XPath.attr(:type).one_of('submit', 'reset', 'image', 'button')]
     btn_xpath = XPath.descendant(:button)
     image_btn_xpath = XPath.descendant(:input)[XPath.attr(:type) == 'image']
 
     unless locator.nil?
       locator = locator.to_s
-      locator_matchers = XPath.attr(:id).equals(locator) | XPath.attr(:value).is(locator) | XPath.attr(:title).is(locator)
+      locator_matchers = XPath.attr(:id).equals(locator) | XPath.attr(:name).equals(locator) | XPath.attr(:value).is(locator) | XPath.attr(:title).is(locator)
       locator_matchers |= XPath.attr(:'aria-label').is(locator) if enable_aria_label
       locator_matchers |= XPath.attr(test_id) == locator if test_id
 
@@ -155,14 +163,20 @@ Capybara.add_selector(:button, locator_type: [String, Symbol]) do
       image_btn_xpath = image_btn_xpath[alt_matches]
     end
 
-    %i[value title type].inject(input_btn_xpath.union(btn_xpath).union(image_btn_xpath)) do |memo, ef|
+    %i[value title type name].inject(input_btn_xpath.union(btn_xpath).union(image_btn_xpath)) do |memo, ef|
       memo[find_by_attr(ef, options[ef])]
     end
   end
 
   node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
+  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
+
+  describe_expression_filters do |disabled: nil, **options|
+    desc = +''
+    desc << ' that is not disabled' if disabled == false
+    desc << describe_all_expression_filters(options)
+  end
 
-  describe_expression_filters
   describe_node_filters do |disabled: nil, **|
     ' that is disabled' if disabled == true
   end
@@ -176,7 +190,7 @@ Capybara.add_selector(:link_or_button, locator_type: [String, Symbol]) do
     end.reduce(:union)
   end
 
-  node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| node.tag_name == 'a' || !(value ^ node.disabled?) }
+  node_filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| !(value ^ node.disabled?) }
 
   describe_node_filters do |disabled: nil, **|
     ' that is disabled' if disabled == true
@@ -205,12 +219,11 @@ Capybara.add_selector(:fillable_field, locator_type: [String, Symbol]) do
 
   node_filter(:with) do |node, with|
     val = node.value
-    (with.is_a?(Regexp) ? val =~ with : val == with.to_s).tap do |res|
+    (with.is_a?(Regexp) ? with.match?(val) : val == with.to_s).tap do |res|
       add_error("Expected value to be #{with.inspect} but was #{val.inspect}") unless res
     end
   end
 
-  describe_expression_filters
   describe_node_filters do |**options|
     " with value #{options[:with].to_s.inspect}" if options.key?(:with)
   end
@@ -234,7 +247,6 @@ Capybara.add_selector(:radio_button, locator_type: [String, Symbol]) do
     end
   end
 
-  describe_expression_filters
   describe_node_filters do |option: nil, **|
     " with value #{option.inspect}" if option
   end
@@ -257,7 +269,6 @@ Capybara.add_selector(:checkbox, locator_type: [String, Symbol]) do
     end
   end
 
-  describe_expression_filters
   describe_node_filters do |option: nil, **|
     " with value #{option.inspect}" if option
   end
@@ -304,18 +315,18 @@ Capybara.add_selector(:select, locator_type: [String, Symbol]) do
     end
   end
 
-  describe_expression_filters do |with_options: nil, **opts|
+  describe_expression_filters do |with_options: nil, **|
     desc = +''
     desc << " with at least options #{with_options.inspect}" if with_options
-    desc << describe_all_expression_filters(opts)
     desc
   end
 
-  describe_node_filters do |options: nil, selected: nil, with_selected: nil, **|
+  describe_node_filters do |options: nil, selected: nil, with_selected: nil, disabled: nil, **|
     desc = +''
     desc << " with options #{options.inspect}" if options
     desc << " with #{selected.inspect} selected" if selected
     desc << " with at least #{with_selected.inspect} selected" if with_selected
+    desc << ' which is disabled' if disabled
     desc
   end
 end
@@ -343,10 +354,9 @@ Capybara.add_selector(:datalist_input, locator_type: [String, Symbol]) do
     end
   end
 
-  describe_expression_filters do |with_options: nil, **opts|
+  describe_expression_filters do |with_options: nil, **|
     desc = +''
     desc << " with at least options #{with_options.inspect}" if with_options
-    desc << describe_all_expression_filters(opts)
     desc
   end
 
@@ -363,11 +373,19 @@ Capybara.add_selector(:option, locator_type: [String, Symbol]) do
   end
 
   node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
+  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
+
   node_filter(:selected, :boolean) { |node, value| !(value ^ node.selected?) }
 
+  describe_expression_filters do |disabled: nil, **options|
+    desc = +''
+    desc << ' that is not disabled' if disabled == false
+    (expression_filters.keys & options.keys).inject(desc) { |memo, ef| memo << " with #{ef} #{options[ef]}" }
+  end
+
   describe_node_filters do |**options|
     desc = +''
-    desc << " that is#{' not' unless options[:disabled]} disabled" if options.key?(:disabled)
+    desc << ' that is disabled' if options[:disabled]
     desc << " that is#{' not' unless options[:selected]} selected" if options.key?(:selected)
     desc
   end
@@ -384,9 +402,16 @@ Capybara.add_selector(:datalist_option, locator_type: [String, Symbol]) do
   end
 
   node_filter(:disabled, :boolean) { |node, value| !(value ^ node.disabled?) }
+  expression_filter(:disabled) { |xpath, val| val ? xpath : xpath[~XPath.attr(:disabled)] }
+
+  describe_expression_filters do |disabled: nil, **options|
+    desc = +''
+    desc << ' that is not disabled' if disabled == false
+    desc << describe_all_expression_filters(options)
+  end
 
   describe_node_filters do |**options|
-    " that is#{' not' unless options[:disabled]} disabled" if options.key?(:disabled)
+    ' that is disabled' if options[:disabled]
   end
 end
 
@@ -400,8 +425,6 @@ Capybara.add_selector(:file_field, locator_type: [String, Symbol]) do
   end
 
   filter_set(:_field, %i[disabled multiple name])
-
-  describe_expression_filters
 end
 
 Capybara.add_selector(:label, locator_type: [String, Symbol]) do
@@ -459,100 +482,92 @@ Capybara.add_selector(:table, locator_type: [String, Symbol]) do
   expression_filter(:with_cols, valid_values: [Array]) do |xpath, cols|
     col_conditions = cols.map do |col|
       if col.is_a? Hash
-        col.reduce(nil) do |xp, (header, cell)|
-          header_xp = XPath.descendant(:th)[XPath.string.n.is(header)]
-          cell_xp = XPath.descendant(:tr)[header_xp].descendant(:td)
-          next cell_xp[XPath.string.n.is(cell)] unless xp
-
-          table_ancestor = XPath.ancestor(:table)[1]
-          xp = XPath::Expression.new(:join, table_ancestor, xp)
-          cell_xp[XPath.string.n.is(cell) & XPath.position.equals(xp.preceding_sibling(:td).count.plus(1))]
+        col.reduce(nil) do |xp, (header, cell_str)|
+          header = XPath.descendant(:th)[XPath.string.n.is(header)]
+          td = XPath.descendant(:tr)[header].descendant(:td)
+          cell_condition = XPath.string.n.is(cell_str)
+          cell_condition &= prev_col_position?(XPath.ancestor(:table)[1].join(xp)) if xp
+          td[cell_condition]
         end
       else
-        cells_xp = col.reduce(nil) do |xp, cell|
-          cell_conditions = [XPath.string.n.is(cell)]
-          if xp
-            prev_row_xp = XPath::Expression.new(:join, XPath.ancestor(:tr)[1].preceding_sibling(:tr), xp)
-            cell_conditions << XPath.position.equals(prev_row_xp.preceding_sibling(:td).count.plus(1))
+        cells_xp = col.reduce(nil) do |prev_cell, cell_str|
+          cell_condition = XPath.string.n.is(cell_str)
+
+          if prev_cell
+            prev_cell = XPath.ancestor(:tr)[1].preceding_sibling(:tr).join(prev_cell)
+            cell_condition &= prev_col_position?(prev_cell)
           end
-          XPath.descendant(:td)[cell_conditions.reduce :&]
+
+          XPath.descendant(:td)[cell_condition]
         end
-        XPath::Expression.new(:join, XPath.descendant(:tr), cells_xp)
+        XPath.descendant(:tr).join(cells_xp)
       end
     end.reduce(:&)
     xpath[col_conditions]
   end
 
   expression_filter(:cols, valid_values: [Array]) do |xpath, cols|
-    raise ArgumentError, ":cols must be an Array of Arrays" unless cols.all? { |col| col.is_a? Array }
+    raise ArgumentError, ':cols must be an Array of Arrays' unless cols.all? { |col| col.is_a? Array }
 
     rows = cols.transpose
-    xpath = xpath[XPath.descendant(:tbody).descendant(:tr).count.equals(rows.size) | (XPath.descendant(:tr).count.equals(rows.size) & ~XPath.descendant(:tbody))]
-
-    col_conditions = rows.map do |row|
-      row_conditions = row.map do |cell|
-        XPath.self(:td)[XPath.string.n.is(cell)]
-      end
-      row_conditions = row_conditions.reverse.reduce do |cond, cell|
-        cell[XPath.following_sibling[cond]]
-      end
-      row_xpath = XPath.descendant(:tr)[XPath.descendant(:td)[row_conditions]]
-      row_xpath[XPath.descendant(:td).count.equals(row.size)]
-    end.reduce(:&)
-
-    xpath[col_conditions]
+    col_conditions = rows.map { |row| match_row(row, match_size: true) }.reduce(:&)
+    xpath[match_row_count(rows.size)][col_conditions]
   end
 
   expression_filter(:with_rows, valid_values: [Array]) do |xpath, rows|
-    rows_conditions = rows.map do |row|
-      if row.is_a? Hash
-        row_conditions = row.map do |header, cell|
-          header_xp = XPath.ancestor(:table)[1].descendant(:tr)[1].descendant(:th)[XPath.string.n.is(header)]
-          XPath.descendant(:td)[
-            XPath.string.n.is(cell) & XPath.position.equals(header_xp.preceding_sibling.count.plus(1))
-          ]
-        end.reduce(:&)
-        XPath.descendant(:tr)[row_conditions]
-      else
-        row_conditions = row.map do |cell|
-          XPath.self(:td)[XPath.string.n.is(cell)]
-        end
-        row_conditions = row_conditions.reverse.reduce do |cond, cell|
-          cell[XPath.following_sibling[cond]]
-        end
-        XPath.descendant(:tr)[XPath.descendant(:td)[row_conditions]]
-      end
-    end.reduce(:&)
+    rows_conditions = rows.map { |row| match_row(row) }.reduce(:&)
     xpath[rows_conditions]
   end
 
   expression_filter(:rows, valid_values: [Array]) do |xpath, rows|
-    xpath = xpath[XPath.descendant(:tbody).descendant(:tr).count.equals(rows.size) | (XPath.descendant(:tr).count.equals(rows.size) & ~XPath.descendant(:tbody))]
-    rows_conditions = rows.map do |row|
-      row_xpath = if row.is_a? Hash
-        row_conditions = row.map do |header, cell|
-          header_xp = XPath.ancestor(:table)[1].descendant(:tr)[1].descendant(:th)[XPath.string.n.is(header)]
-          XPath.descendant(:td)[
-            XPath.string.n.is(cell) & XPath.position.equals(header_xp.preceding_sibling.count.plus(1))
-          ]
-        end.reduce(:&)
-        XPath.descendant(:tr)[row_conditions]
+    rows_conditions = rows.map { |row| match_row(row, match_size: true) }.reduce(:&)
+    xpath[match_row_count(rows.size)][rows_conditions]
+  end
+
+  describe_expression_filters do |caption: nil, **|
+    " with caption \"#{caption}\"" if caption
+  end
+
+  def prev_col_position?(cell)
+    XPath.position.equals(cell_position(cell))
+  end
+
+  def cell_position(cell)
+    cell.preceding_sibling(:td).count.plus(1)
+  end
+
+  def match_row(row, match_size: false)
+    xp = XPath.descendant(:tr)[
+      if row.is_a? Hash
+        row_match_cells_to_headers(row)
       else
-        row_conditions = row.map do |cell|
-          XPath.self(:td)[XPath.string.n.is(cell)]
-        end
-        row_conditions = row_conditions.reverse.reduce do |cond, cell|
-          cell[XPath.following_sibling[cond]]
-        end
-        XPath.descendant(:tr)[XPath.descendant(:td)[row_conditions]]
+        XPath.descendant(:td)[row_match_ordered_cells(row)]
       end
-      row_xpath[XPath.descendant(:td).count.equals(row.size)]
+    ]
+    xp = xp[XPath.descendant(:td).count.equals(row.size)] if match_size
+    xp
+  end
+
+  def match_row_count(size)
+    XPath.descendant(:tbody).descendant(:tr).count.equals(size) | (XPath.descendant(:tr).count.equals(size) & ~XPath.descendant(:tbody))
+  end
+
+  def row_match_cells_to_headers(row)
+    row.map do |header, cell|
+      header_xp = XPath.ancestor(:table)[1].descendant(:tr)[1].descendant(:th)[XPath.string.n.is(header)]
+      XPath.descendant(:td)[
+        XPath.string.n.is(cell) & XPath.position.equals(header_xp.preceding_sibling.count.plus(1))
+      ]
     end.reduce(:&)
-    xpath[rows_conditions]
   end
 
-  describe_expression_filters do |caption: nil, **|
-    " with caption \"#{caption}\"" if caption
+  def row_match_ordered_cells(row)
+    row_conditions = row.map do |cell|
+      XPath.self(:td)[XPath.string.n.is(cell)]
+    end
+    row_conditions.reverse.reduce do |cond, cell|
+      cell[XPath.following_sibling[cond]]
+    end
   end
 end
 
@@ -603,7 +618,7 @@ Capybara.add_selector(:element, locator_type: [String, Symbol]) do
   node_filter(:attributes, matcher: /.+/) do |node, name, val|
     next true unless val.is_a?(Regexp)
 
-    (node[name] =~ val).tap do |res|
+    (val.match? node[name]).tap do |res|
       add_error("Expected #{name} to match #{val.inspect} but it was #{node[name]}") unless res
     end
   end

data/lib/capybara/selenium/driver.rb

@@ -14,25 +14,40 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
   SPECIAL_OPTIONS = %i[browser clear_local_storage clear_session_storage timeout].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'
+      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 => 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
+
+    attr_reader :specializations
 
-    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."
+    def register_specialization(browser_name, specialization)
+      @specializations ||= {}
+      @specializations[browser_name] = specialization
+    end
   end
 
   def browser
-    @browser ||= begin
-      if options[:timeout]
-        options[:http_client] ||= Selenium::WebDriver::Remote::Http::Default.new(read_timeout: options[:timeout])
+    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) }
-      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
@@ -110,7 +125,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
@@ -177,7 +192,10 @@ class Capybara::Selenium::Driver < Capybara::Driver::Base
     browser.window_handles
   end
 
-  def open_new_window
+  def open_new_window(kind = :tab)
+    browser.manage.new_window(kind)
+  rescue NoMethodError, Selenium::WebDriver::Error::WebDriverError
+    # If not supported by the driver or browser default to using JS
     browser.execute_script('window.open();')
   end
 
@@ -218,19 +236,27 @@ 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 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
@@ -239,6 +265,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
@@ -246,12 +276,32 @@ private
   def clear_browser_state
     delete_all_cookies
     clear_storage
-  rescue Selenium::WebDriver::Error::UnhandledError # rubocop:disable Lint/HandleExceptions
+  rescue *clear_browser_state_errors # rubocop:disable Lint/HandleExceptions
     # 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].tap do |errors|
+      unless selenium_4?
+        ::Selenium::WebDriver.logger.suppress_deprecations do
+          errors << Selenium::WebDriver::Error::UnhandledError
+        end
+      end
+    end
+  end
+
+  def unhandled_alert_errors
+    @unhandled_alert_errors ||= [Selenium::WebDriver::Error::UnexpectedAlertOpenError].tap do |errors|
+      unless selenium_4?
+        ::Selenium::WebDriver.logger.suppress_deprecations do
+          errors << Selenium::WebDriver::Error::UnhandledAlertError
+        end
+      end
+    end
+  end
+
   def delete_all_cookies
     @browser.manage.delete_all_cookies
   end
@@ -322,15 +372,25 @@ private
       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
+        alert.text.match?(regexp) ? alert : nil
       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 ||= [Selenium::WebDriver::Error::TimeoutError].tap do |errors|
+      unless selenium_4?
+        ::Selenium::WebDriver.logger.suppress_deprecations do
+          errors << Selenium::WebDriver::Error::TimeOutError
+        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
@@ -342,7 +402,7 @@ private
     when Array
       arg.map { |arr| unwrap_script_result(arr) }
     when Hash
-      arg.each { |key, value| arg[key] = unwrap_script_result(value) }
+      arg.transform_values! { |value| unwrap_script_result(value) }
     when Selenium::WebDriver::Element
       build_node(arg)
     else
@@ -358,24 +418,13 @@ 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
+  def specialize_driver
+    browser_type = browser.browser
+    self.class.specializations.select { |k, _v| k === browser_type }.each_value do |specialization| # rubocop:disable Style/CaseEquality
+      extend specialization
     end
   end
 
-  def pause_broken?(driver)
-    driver.capabilities['moz:geckodriverVersion']&.start_with?('0.22.')
-  end
-
   def setup_exit_handler
     main = Process.pid
     at_exit do