capybara 3.0.0 → 3.36.0

data/lib/capybara/rack_test/node.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'capybara/rack_test/errors'
+
 class Capybara::RackTest::Node < Capybara::Driver::Node
   BLOCK_ELEMENTS = %w[p h1 h2 h3 h4 h5 h6 ol ul pre address blockquote dl div fieldset form hr noscript table].freeze
 
@@ -7,16 +9,16 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
     native.text
           .gsub(/[\u200b\u200e\u200f]/, '')
           .gsub(/[\ \n\f\t\v\u2028\u2029]+/, ' ')
-          .gsub(/\A[[:space:]&&[^\u00a0]]+/, "")
-          .gsub(/[[:space:]&&[^\u00a0]]+\z/, "")
+          .gsub(/\A[[:space:]&&[^\u00a0]]+/, '')
+          .gsub(/[[:space:]&&[^\u00a0]]+\z/, '')
           .tr("\u00a0", ' ')
   end
 
   def visible_text
-    displayed_text.gsub(/\ +/, ' ')
+    displayed_text.squeeze(' ')
                   .gsub(/[\ \n]*\n[\ \n]*/, "\n")
-                  .gsub(/\A[[:space:]&&[^\u00a0]]+/, "")
-                  .gsub(/[[:space:]&&[^\u00a0]]+\z/, "")
+                  .gsub(/\A[[:space:]&&[^\u00a0]]+/, '')
+                  .gsub(/[[:space:]&&[^\u00a0]]+\z/, '')
                   .tr("\u00a0", ' ')
   end
 
@@ -24,6 +26,10 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
     string_node[name]
   end
 
+  def style(_styles)
+    raise NotImplementedError, 'The rack_test driver does not process CSS'
+  end
+
   def value
     string_node.value
   end
@@ -39,6 +45,7 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
 
     if radio? then set_radio(value)
     elsif checkbox? then set_checkbox(value)
+    elsif range? then set_range(value)
     elsif input_field? then set_input(value)
     elsif textarea? then native['_capybara_raw_value'] = value.to_s
     end
@@ -46,17 +53,20 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
 
   def select_option
     return if disabled?
+
     deselect_options unless select_node.multiple?
-    native["selected"] = 'selected'
+    native['selected'] = 'selected'
   end
 
   def unselect_option
-    raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box." unless select_node.multiple?
+    raise Capybara::UnselectNotAllowed, 'Cannot unselect option from single select box.' unless select_node.multiple?
+
     native.remove_attribute('selected')
   end
 
-  def click(keys = [], offset = {})
-    raise ArgumentError, "The RackTest driver does not support click options" unless keys.empty? && offset.empty?
+  def click(keys = [], **options)
+    options.delete(:offset)
+    raise ArgumentError, 'The RackTest driver does not support click options' unless keys.empty? && options.empty?
 
     if link?
       follow_link
@@ -67,6 +77,8 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
       set(!checked?)
     elsif tag_name == 'label'
       click_label
+    elsif (details = native.xpath('.//ancestor-or-self::details').last)
+      toggle_details(details)
     end
   end
 
@@ -90,26 +102,48 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
     return true if string_node.disabled?
 
     if %w[option optgroup].include? tag_name
-      find_xpath("parent::*[self::optgroup or self::select]")[0].disabled?
+      find_xpath(OPTION_OWNER_XPATH)[0].disabled?
     else
-      !find_xpath("parent::fieldset[@disabled] | ancestor::*[not(self::legend) or preceding-sibling::legend][parent::fieldset[@disabled]]").empty?
+      !find_xpath(DISABLED_BY_FIELDSET_XPATH).empty?
     end
   end
 
+  def readonly?
+    # readonly attribute not valid on these input types
+    return false if input_field? && %w[hidden range color checkbox radio file submit image reset button].include?(type)
+
+    super
+  end
+
   def path
     native.path
   end
 
-  def find_xpath(locator)
-    native.xpath(locator).map { |n| self.class.new(driver, n) }
+  def find_xpath(locator, **_hints)
+    native.xpath(locator).map { |el| self.class.new(driver, el) }
   end
 
-  def find_css(locator)
-    native.css(locator, Capybara::RackTest::CSSHandlers.new).map { |n| self.class.new(driver, n) }
+  def find_css(locator, **_hints)
+    native.css(locator, Capybara::RackTest::CSSHandlers.new).map { |el| self.class.new(driver, el) }
   end
 
-  def ==(other)
-    native == other.native
+  public_instance_methods(false).each do |meth_name|
+    alias_method "unchecked_#{meth_name}", meth_name
+    private "unchecked_#{meth_name}" # rubocop:disable Style/AccessModifierDeclarations
+
+    if RUBY_VERSION >= '2.7'
+      class_eval <<~METHOD, __FILE__, __LINE__ + 1
+        def #{meth_name}(...)
+          stale_check
+          method(:"unchecked_#{meth_name}").call(...)
+        end
+      METHOD
+    else
+      define_method meth_name do |*args|
+        stale_check
+        send("unchecked_#{meth_name}", *args)
+      end
+    end
   end
 
 protected
@@ -128,15 +162,19 @@ protected
       end.join || ''
       text = "\n#{text}\n" if BLOCK_ELEMENTS.include?(tag_name)
       text
-    else
+    else # rubocop:disable Lint/DuplicateBranch
       ''
     end
   end
 
 private
 
+  def stale_check
+    raise Capybara::RackTest::Errors::StaleElementReferenceError unless native.document == driver.dom
+  end
+
   def deselect_options
-    select_node.find_xpath(".//option[@selected]").each { |node| node.native.remove_attribute("selected") }
+    select_node.find_xpath('.//option[@selected]').each { |node| node.native.remove_attribute('selected') }
   end
 
   def string_node
@@ -161,8 +199,8 @@ private
   end
 
   def set_radio(_value) # rubocop:disable Naming/AccessorMethodName
-    other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name) == self[:name]] }.to_s
-    driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute("checked") }
+    other_radios_xpath = XPath.generate { |xp| xp.anywhere(:input)[xp.attr(:name) == self[:name]] }.to_s
+    driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute('checked') }
     native['checked'] = 'checked'
   end
 
@@ -174,6 +212,14 @@ private
     end
   end
 
+  def set_range(value) # rubocop:disable Naming/AccessorMethodName
+    min, max, step = (native['min'] || 0).to_f, (native['max'] || 100).to_f, (native['step'] || 1).to_f
+    value = value.to_f
+    value = value.clamp(min, max)
+    value = (((value - min) / step).round * step) + min
+    native['value'] = value.clamp(min, max)
+  end
+
   def set_input(value) # rubocop:disable Naming/AccessorMethodName
     if text_or_password? && attribute_is_not_blank?(:maxlength)
       # Browser behavior for maxlength="0" is inconsistent, so we stick with
@@ -181,11 +227,11 @@ private
       value = value.to_s[0...self[:maxlength].to_i]
     end
     if value.is_a?(Array) # Assert multiple attribute is present
-      value.each do |v|
+      value.each do |val|
         new_native = native.clone
         new_native.remove_attribute('value')
         native.add_next_sibling(new_native)
-        new_native['value'] = v.to_s
+        new_native['value'] = val.to_s
       end
       native.remove
     else
@@ -198,7 +244,7 @@ private
   end
 
   def follow_link
-    method = self["data-method"] if driver.options[:respect_data_method]
+    method = self['data-method'] if driver.options[:respect_data_method]
     method ||= :get
     driver.follow(method, self[:href].to_s)
   end
@@ -207,11 +253,20 @@ private
     labelled_control = if native[:for]
       find_xpath("//input[@id='#{native[:for]}']")
     else
-      find_xpath(".//input")
+      find_xpath('.//input')
     end.first
 
-    if labelled_control && (labelled_control.checkbox? || labelled_control.radio?)
-      labelled_control.set(!labelled_control.checked?)
+    labelled_control.set(!labelled_control.checked?) if checkbox_or_radio?(labelled_control)
+  end
+
+  def toggle_details(details = nil)
+    details ||= native.xpath('.//ancestor-or-self::details').last
+    return unless details
+
+    if details.has_attribute?('open')
+      details.remove_attribute('open')
+    else
+      details.set_attribute('open', 'open')
     end
   end
 
@@ -220,32 +275,54 @@ private
   end
 
   def submits?
-    (tag_name == 'input' and %w[submit image].include?(type)) || (tag_name == 'button' and [nil, "submit"].include?(type))
+    (tag_name == 'input' && %w[submit image].include?(type)) || (tag_name == 'button' && [nil, 'submit'].include?(type))
   end
 
   def checkable?
-    tag_name == 'input' and %w[checkbox radio].include?(type)
+    tag_name == 'input' && %w[checkbox radio].include?(type)
   end
 
 protected
 
-  def checkbox?
-    input_field? && type == 'checkbox'
+  def checkbox_or_radio?(field = self)
+    field&.checkbox? || field&.radio?
   end
 
-  def input_field?
-    tag_name == 'input'
+  def checkbox?
+    input_field? && type == 'checkbox'
   end
 
   def radio?
     input_field? && type == 'radio'
   end
 
-  def textarea?
-    tag_name == "textarea"
-  end
-
   def text_or_password?
     input_field? && (type == 'text' || type == 'password')
   end
+
+  def input_field?
+    tag_name == 'input'
+  end
+
+  def textarea?
+    tag_name == 'textarea'
+  end
+
+  def range?
+    input_field? && type == 'range'
+  end
+
+  OPTION_OWNER_XPATH = XPath.parent(:optgroup, :select, :datalist).to_s.freeze
+  DISABLED_BY_FIELDSET_XPATH = XPath.generate do |x|
+    x.parent(:fieldset)[
+      XPath.attr(:disabled)
+    ] + x.ancestor[
+      ~x.self(:legend) |
+      x.preceding_sibling(:legend)
+    ][
+      x.parent(:fieldset)[
+        x.attr(:disabled)
+      ]
+    ]
+  end.to_s.freeze
 end

data/lib/capybara/rails.rb

@@ -3,7 +3,7 @@
 require 'capybara/dsl'
 
 Capybara.app = Rack::Builder.new do
-  map "/" do
+  map '/' do
     run Rails.application
   end
 end.to_app

data/lib/capybara/registration_container.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Capybara
+  # @api private
+  class RegistrationContainer
+    def names
+      @registered.keys
+    end
+
+    def [](name)
+      @registered[name]
+    end
+
+    def []=(name, value)
+      Capybara::Helpers.warn 'DEPRECATED: Directly setting drivers/servers is deprecated, please use Capybara.register_driver/register_server instead'
+      @registered[name] = value
+    end
+
+    def method_missing(method_name, *args, **options, &block)
+      if @registered.respond_to?(method_name)
+        Capybara::Helpers.warn "DEPRECATED: Calling '#{method_name}' on the drivers/servers container is deprecated without replacement"
+        # RUBY 2.6 will send an empty hash rather than nothing with **options so fix that
+        return @registered.public_send(method_name, *args, &block) if options.empty?
+
+        return @registered.public_send(method_name, *args, **options, &block)
+      end
+      super
+    end
+
+    def respond_to_missing?(method_name, include_all)
+      @registered.respond_to?(method_name) || super
+    end
+
+  private
+
+    def initialize
+      @registered = {}
+    end
+
+    def register(name, block)
+      @registered[name] = block
+    end
+  end
+end

data/lib/capybara/registrations/drivers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+Capybara.register_driver :rack_test do |app|
+  Capybara::RackTest::Driver.new(app)
+end
+
+Capybara.register_driver :selenium do |app|
+  Capybara::Selenium::Driver.new(app)
+end
+
+Capybara.register_driver :selenium_headless do |app|
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  browser_options = ::Selenium::WebDriver::Firefox::Options.new.tap do |opts|
+    opts.add_argument '-headless'
+  end
+  Capybara::Selenium::Driver.new(app, **{ :browser => :firefox, options_key => browser_options })
+end
+
+Capybara.register_driver :selenium_chrome do |app|
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  browser_options = ::Selenium::WebDriver::Chrome::Options.new.tap do |opts|
+    # Workaround https://bugs.chromium.org/p/chromedriver/issues/detail?id=2650&q=load&sort=-id&colspec=ID%20Status%20Pri%20Owner%20Summary
+    opts.add_argument('--disable-site-isolation-trials')
+  end
+
+  Capybara::Selenium::Driver.new(app, **{ :browser => :chrome, options_key => browser_options })
+end
+
+Capybara.register_driver :selenium_chrome_headless do |app|
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  browser_options = ::Selenium::WebDriver::Chrome::Options.new.tap do |opts|
+    opts.add_argument('--headless')
+    opts.add_argument('--disable-gpu') if Gem.win_platform?
+    # Workaround https://bugs.chromium.org/p/chromedriver/issues/detail?id=2650&q=load&sort=-id&colspec=ID%20Status%20Pri%20Owner%20Summary
+    opts.add_argument('--disable-site-isolation-trials')
+  end
+
+  Capybara::Selenium::Driver.new(app, **{ :browser => :chrome, options_key => browser_options })
+end

data/lib/capybara/registrations/patches/puma_ssl.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Puma
+  module MiniSSL
+    class Socket
+      def read_nonblock(size, *_)
+        wait_states = %i[wait_readable wait_writable]
+
+        loop do
+          output = engine_read_all
+          return output if output
+
+          data = @socket.read_nonblock(size, exception: false)
+          raise IO::EAGAINWaitReadable if wait_states.include? data
+          return nil if data.nil?
+
+          @engine.inject(data)
+          output = engine_read_all
+
+          return output if output
+
+          while (neg_data = @engine.extract)
+            @socket.write neg_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/registrations/servers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+Capybara.register_server :default do |app, port, _host|
+  Capybara.run_default_server(app, port)
+end
+
+Capybara.register_server :webrick do |app, port, host, **options|
+  require 'rack/handler/webrick'
+  options = { Host: host, Port: port, AccessLog: [], Logger: WEBrick::Log.new(nil, 0) }.merge(options)
+  Rack::Handler::WEBrick.run(app, **options)
+end
+
+Capybara.register_server :puma do |app, port, host, **options|
+  begin
+    require 'rack/handler/puma'
+  rescue LoadError
+    raise LoadError, 'Capybara is unable to load `puma` for its server, please add `puma` to your project or specify a different server via something like `Capybara.server = :webrick`.'
+  else
+    unless Rack::Handler::Puma.respond_to?(:config)
+      raise LoadError, 'Capybara requires `puma` version 3.8.0 or higher, please upgrade `puma` or register and specify your own server block'
+    end
+  end
+
+  # If we just run the Puma Rack handler it installs signal handlers which prevent us from being able to interrupt tests.
+  # Therefore construct and run the Server instance ourselves.
+  # Rack::Handler::Puma.run(app, { Host: host, Port: port, Threads: "0:4", workers: 0, daemon: false }.merge(options))
+  default_options = { Host: host, Port: port, Threads: '0:4', workers: 0, daemon: false }
+  options = default_options.merge(options)
+
+  conf = Rack::Handler::Puma.config(app, options)
+  conf.clamp
+  events = conf.options[:Silent] ? ::Puma::Events.strings : ::Puma::Events.stdio
+
+  puma_ver = Gem::Version.new(Puma::Const::PUMA_VERSION)
+  require_relative 'patches/puma_ssl' if Gem::Requirement.new('>=4.0.0', '< 4.1.0').satisfied_by?(puma_ver)
+
+  events.log 'Capybara starting Puma...'
+  events.log "* Version #{Puma::Const::PUMA_VERSION} , codename: #{Puma::Const::CODE_NAME}"
+  events.log "* Min threads: #{conf.options[:min_threads]}, max threads: #{conf.options[:max_threads]}"
+
+  Puma::Server.new(conf.app, events, conf.options).tap do |s|
+    s.binder.parse conf.options[:binds], s.events
+    s.min_threads, s.max_threads = conf.options[:min_threads], conf.options[:max_threads]
+  end.run.join
+end

data/lib/capybara/result.rb

@@ -7,7 +7,7 @@ module Capybara
   # A {Capybara::Result} represents a collection of {Capybara::Node::Element} on the page. It is possible to interact with this
   # collection similar to an Array because it implements Enumerable and offers the following Array methods through delegation:
   #
-  # * []
+  # * \[\]
   # * each()
   # * at()
   # * size()
@@ -16,6 +16,8 @@ module Capybara
   # * first()
   # * last()
   # * empty?()
+  # * values_at()
+  # * sample()
   #
   # @see Capybara::Node::Element
   #
@@ -26,35 +28,52 @@ module Capybara
     def initialize(elements, query)
       @elements = elements
       @result_cache = []
-      @results_enum = lazy_select_elements { |node| query.matches_filters?(node) }
+      @filter_errors = []
+      @results_enum = lazy_select_elements { |node| query.matches_filters?(node, @filter_errors) }
       @query = query
+      @allow_reload = false
     end
 
     def_delegators :full_results, :size, :length, :last, :values_at, :inspect, :sample
 
-    alias :index :find_index
+    alias index find_index
 
     def each(&block)
-      return enum_for(:each) unless block_given?
+      return enum_for(:each) unless block
 
       @result_cache.each(&block)
       loop do
         next_result = @results_enum.next
-        @result_cache << next_result
+        add_to_cache(next_result)
         yield next_result
       end
       self
     end
 
     def [](*args)
-      if (args.size == 1) && ((idx = args[0]).is_a? Integer) && (idx >= 0)
-        @result_cache << @results_enum.next while @result_cache.size <= idx
-        @result_cache[idx]
-      else
+      idx, length = args
+      max_idx = case idx
+      when Integer
+        if idx.negative?
+          nil
+        else
+          length.nil? ? idx : idx + length - 1
+        end
+      when Range
+        # idx.max is broken with beginless ranges
+        # idx.end && idx.max # endless range will have end == nil
+        max = idx.end
+        max = nil if max&.negative?
+        max -= 1 if max && idx.exclude_end?
+        max
+      end
+
+      if max_idx.nil?
         full_results[*args]
+      else
+        load_up_to(max_idx + 1)
+        @result_cache[*args]
       end
-    rescue StopIteration
-      return nil
     end
     alias :at :[]
 
@@ -63,46 +82,28 @@ module Capybara
     end
 
     def compare_count
+      return 0 unless @query
+
+      count, min, max, between = @query.options.values_at(:count, :minimum, :maximum, :between)
+
       # Only check filters for as many elements as necessary to determine result
-      if @query.options[:count]
-        count_opt = Integer(@query.options[:count])
-        loop do
-          break if @result_cache.size > count_opt
-          @result_cache << @results_enum.next
-        end
-        return @result_cache.size <=> count_opt
+      if count && (count = Integer(count))
+        return load_up_to(count + 1) <=> count
       end
 
-      if @query.options[:minimum]
-        min_opt = Integer(@query.options[:minimum])
-        begin
-          @result_cache << @results_enum.next while @result_cache.size < min_opt
-        rescue StopIteration
-          return -1
-        end
-      end
+      return -1 if min && (min = Integer(min)) && (load_up_to(min) < min)
 
-      if @query.options[:maximum]
-        max_opt = Integer(@query.options[:maximum])
-        begin
-          @result_cache << @results_enum.next while @result_cache.size <= max_opt
-          return 1
-        rescue StopIteration
-        end
-      end
+      return 1 if max && (max = Integer(max)) && (load_up_to(max + 1) > max)
 
-      if @query.options[:between]
-        min, max = @query.options[:between].minmax
-        loop do
-          break if @result_cache.size > max
-          @result_cache << @results_enum.next
-        end
-        return 0 if @query.options[:between].include?(@result_cache.size)
-        return -1 if @result_cache.size < min
-        return 1
+      if between
+        min, max = (between.begin && between.min) || 1, between.end
+        max -= 1 if max && between.exclude_end?
+
+        size = load_up_to(max ? max + 1 : min)
+        return size <=> min unless between.include?(size)
       end
 
-      return 0
+      0
     end
 
     def matches_count?
@@ -112,13 +113,15 @@ module Capybara
     def failure_message
       message = @query.failure_message
       if count.zero?
-        message << " but there were no matches"
+        message << ' but there were no matches'
       else
-        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << full_results.map(&:text).map(&:inspect).join(", ")
+        message << ", found #{count} #{Capybara::Helpers.declension('match', 'matches', count)}: " \
+                << full_results.map(&:text).map(&:inspect).join(', ')
       end
       unless rest.empty?
-        elements = rest.map { |el| el.text rescue "<<ERROR>>" }.map(&:inspect).join(", ")
-        message << ". Also found " << elements << ", which matched the selector but not all filters."
+        elements = rest.map { |el| el.text rescue '<<ERROR>>' }.map(&:inspect).join(', ') # rubocop:disable Style/RescueModifier
+        message << '. Also found ' << elements << ', which matched the selector but not all filters. '
+        message << @filter_errors.join('. ') if (rest.size == 1) && count.zero?
       end
       message
     end
@@ -127,8 +130,34 @@ module Capybara
       failure_message.sub(/(to find)/, 'not \1')
     end
 
+    def unfiltered_size
+      @elements.length
+    end
+
+    ##
+    # @api private
+    #
+    def allow_reload!
+      @allow_reload = true
+      self
+    end
+
   private
 
+    def add_to_cache(elem)
+      elem.allow_reload!(@result_cache.size) if @allow_reload
+      @result_cache << elem
+    end
+
+    def load_up_to(num)
+      loop do
+        break if @result_cache.size >= num
+
+        add_to_cache(@results_enum.next)
+      end
+      @result_cache.size
+    end
+
     def full_results
       loop { @result_cache << @results_enum.next }
       @result_cache
@@ -138,13 +167,18 @@ module Capybara
       @rest ||= @elements - full_results
     end
 
-    def lazy_select_elements(&block)
-      # JRuby has an issue with lazy enumerators which
+    if RUBY_PLATFORM == 'java'
+      # JRuby < 9.2.8.0 has an issue with lazy enumerators which
       # causes a concurrency issue with network requests here
       # https://github.com/jruby/jruby/issues/4212
-      if RUBY_PLATFORM == 'java'
+      # while JRuby >= 9.2.8.0 leaks threads when using lazy enumerators
+      # https://github.com/teamcapybara/capybara/issues/2349
+      # so disable the use and JRuby users will need to pay a performance penalty
+      def lazy_select_elements(&block)
         @elements.select(&block).to_enum # non-lazy evaluation
-      else
+      end
+    else
+      def lazy_select_elements(&block)
         @elements.lazy.select(&block)
       end
     end