capybara 2.18.0 → 3.38.0

data/lib/capybara/rack_test/form.rb

@@ -1,87 +1,64 @@
 # frozen_string_literal: true
+
 class Capybara::RackTest::Form < Capybara::RackTest::Node
   # This only needs to inherit from Rack::Test::UploadedFile because Rack::Test checks for
   # the class specifically when determining whether to construct the request as multipart.
   # That check should be based solely on the form element's 'enctype' attribute value,
   # which should probably be provided to Rack::Test in its non-GET request methods.
   class NilUploadedFile < Rack::Test::UploadedFile
-    def initialize
-      @empty_file = Tempfile.new("nil_uploaded_file")
+    def initialize # rubocop:disable Lint/MissingSuper
+      @empty_file = Tempfile.new('nil_uploaded_file')
       @empty_file.close
     end
 
-    def original_filename; ""; end
-    def content_type; "application/octet-stream"; end
+    def original_filename; ''; end
+    def content_type; 'application/octet-stream'; end
     def path; @empty_file.path; end
     def size; 0; end
-    def read; ""; end
+    def read; ''; end
+    def append_to(_); end
+    def set_encoding(_); end # rubocop:disable Naming/AccessorMethodName
   end
 
   def params(button)
-    params = make_params
-
-    form_element_types=[:input, :select, :textarea]
-    form_elements_xpath=XPath.generate do |x|
-      xpath=x.descendant(*form_element_types).where(~x.attr(:form))
-      xpath=xpath.union(x.anywhere(*form_element_types).where(x.attr(:form) == native[:id])) if native[:id]
-      xpath.where(~x.attr(:disabled))
+    form_element_types = %i[input select textarea button]
+    form_elements_xpath = XPath.generate do |xp|
+      xpath = xp.descendant(*form_element_types).where(!xp.attr(:form))
+      xpath += xp.anywhere(*form_element_types).where(xp.attr(:form) == native[:id]) if native[:id]
+      xpath.where(!xp.attr(:disabled))
     end.to_s
 
-    native.xpath(form_elements_xpath).map do |field|
+    form_elements = native.xpath(form_elements_xpath).reject { |el| submitter?(el) && (el != button.native) }
+
+    form_params = form_elements.each_with_object({}.compare_by_identity) do |field, params|
       case field.name
-      when 'input'
-        if %w(radio checkbox).include? field['type']
-          if field['checked']
-            node=Capybara::RackTest::Node.new(self.driver, field)
-            merge_param!(params, field['name'].to_s, node.value.to_s)
-          end
-        elsif %w(submit image).include? field['type']
-          # TO DO identify the click button here (in document order, rather
-          # than leaving until the end of the params)
-        elsif field['type'] =='file'
-          if multipart?
-            file = \
-              if (value = field['value']).to_s.empty?
-                NilUploadedFile.new
-              else
-                mime_info = MiniMime.lookup_by_filename(value)
-                Rack::Test::UploadedFile.new(value, (mime_info && mime_info.content_type).to_s)
-              end
-            merge_param!(params, field['name'].to_s, file)
-          else
-            merge_param!(params, field['name'].to_s, File.basename(field['value'].to_s))
-          end
-        else
-          merge_param!(params, field['name'].to_s, field['value'].to_s)
-        end
-      when 'select'
-        if field['multiple'] == 'multiple'
-          options = field.xpath(".//option[@selected]")
-          options.each do |option|
-            merge_param!(params, field['name'].to_s, (option['value'] || option.text).to_s)
-          end
-        else
-          option = field.xpath(".//option[@selected]").first
-          option ||= field.xpath('.//option').first
-          merge_param!(params, field['name'].to_s, (option['value'] || option.text).to_s) if option
-        end
-      when 'textarea'
-        merge_param!(params, field['name'].to_s, field['_capybara_raw_value'].to_s.gsub(/\n/, "\r\n"))
+      when 'input', 'button' then add_input_param(field, params)
+      when 'select' then add_select_param(field, params)
+      when 'textarea' then add_textarea_param(field, params)
       end
     end
-    merge_param!(params, button[:name], button[:value] || "") if button[:name]
 
-    params.to_params_hash
+    form_params.each_with_object(make_params) do |(name, value), params|
+      merge_param!(params, name, value)
+    end.to_params_hash
+
+    # form_elements.each_with_object(make_params) do |field, params|
+    #   case field.name
+    #   when 'input', 'button' then add_input_param(field, params)
+    #   when 'select' then add_select_param(field, params)
+    #   when 'textarea' then add_textarea_param(field, params)
+    #   end
+    # end.to_params_hash
   end
 
   def submit(button)
-    action = (button && button['formaction']) || native['action']
-    method = (button && button['formmethod']) || request_method
-    driver.submit(method, action.to_s, params(button))
+    action = button&.[]('formaction') || native['action']
+    method = button&.[]('formmethod') || request_method
+    driver.submit(method, action.to_s, params(button), content_type: native['enctype'])
   end
 
   def multipart?
-    self[:enctype] == "multipart/form-data"
+    self[:enctype] == 'multipart/form-data'
   end
 
 private
@@ -93,10 +70,11 @@ private
   end
 
   def request_method
-    self[:method] =~ /post/i ? :post : :get
+    /post/i.match?(self[:method] || '') ? :post : :get
   end
 
   def merge_param!(params, key, value)
+    key = key.to_s
     if Rack::Utils.respond_to?(:default_query_parser)
       Rack::Utils.default_query_parser.normalize_params(params, key, value, Rack::Utils.param_depth_limit)
     else
@@ -111,4 +89,61 @@ private
       ParamsHash.new
     end
   end
+
+  def add_input_param(field, params)
+    name, value = field['name'].to_s, field['value'].to_s
+    return if name.empty?
+
+    value = case field['type']
+    when 'radio', 'checkbox'
+      return unless field['checked']
+
+      Capybara::RackTest::Node.new(driver, field).value.to_s
+    when 'file'
+      return if value.empty? && params.keys.include?(name) && Rack::Test::VERSION.to_f >= 2.0 # rubocop:disable Performance/InefficientHashSearch
+
+      if multipart?
+        file_to_upload(value)
+      else
+        File.basename(value)
+      end
+    else
+      value
+    end
+    # merge_param!(params, name, value)
+    params[name] = value
+  end
+
+  def file_to_upload(filename)
+    if filename.empty?
+      NilUploadedFile.new
+    else
+      mime_info = MiniMime.lookup_by_filename(filename)
+      Rack::Test::UploadedFile.new(filename, mime_info&.content_type&.to_s)
+    end
+  end
+
+  def add_select_param(field, params)
+    name = field['name']
+    if field.has_attribute?('multiple')
+      value = field.xpath('.//option[@selected]').map do |option|
+        # merge_param!(params, field['name'], (option['value'] || option.text).to_s)
+        (option['value'] || option.text).to_s
+      end
+      params[name] = value unless value.empty?
+    else
+      option = field.xpath('.//option[@selected]').first || field.xpath('.//option').first
+      # merge_param!(params, field['name'], (option['value'] || option.text).to_s) if option
+      params[name] = (option['value'] || option.text).to_s if option
+    end
+  end
+
+  def add_textarea_param(field, params)
+    # merge_param!(params, field['name'], field['_capybara_raw_value'].to_s.gsub(/\r?\n/, "\r\n"))
+    params[field['name']] = field['_capybara_raw_value'].to_s.gsub(/\r?\n/, "\r\n")
+  end
+
+  def submitter?(el)
+    (%w[submit image].include? el['type']) || (el.name == 'button')
+  end
 end

data/lib/capybara/rack_test/node.rb

@@ -1,79 +1,84 @@
 # 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
+
   def all_text
-    Capybara::Helpers.normalize_whitespace(native.text)
+    native.text
+          .gsub(/[\u200b\u200e\u200f]/, '')
+          .gsub(/[\ \n\f\t\v\u2028\u2029]+/, ' ')
+          .gsub(/\A[[:space:]&&[^\u00a0]]+/, '')
+          .gsub(/[[:space:]&&[^\u00a0]]+\z/, '')
+          .tr("\u00a0", ' ')
   end
 
   def visible_text
-    Capybara::Helpers.normalize_whitespace(unnormalized_text)
+    displayed_text.squeeze(' ')
+                  .gsub(/[\ \n]*\n[\ \n]*/, "\n")
+                  .gsub(/\A[[:space:]&&[^\u00a0]]+/, '')
+                  .gsub(/[[:space:]&&[^\u00a0]]+\z/, '')
+                  .tr("\u00a0", ' ')
   end
 
   def [](name)
     string_node[name]
   end
 
+  def style(_styles)
+    raise NotImplementedError, 'The rack_test driver does not process CSS'
+  end
+
   def value
     string_node.value
   end
 
-  def set(value)
-    return if disabled?
-    if readonly?
-      warn "Attempt to set readonly element with value: #{value} \n * This will raise an exception in a future version of Capybara"
-      return
-    end
+  def set(value, **options)
+    return if disabled? || readonly?
 
-    if (Array === value) && !multiple?
-      raise TypeError.new "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
+    warn "Options passed to Node#set but the RackTest driver doesn't support any - ignoring" unless options.empty?
+
+    if value.is_a?(Array) && !multiple?
+      raise TypeError, "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
     end
 
-    if radio?
-      set_radio(value)
-    elsif checkbox?
-      set_checkbox(value)
-    elsif input_field?
-      set_input(value)
-    elsif textarea?
-      native['_capybara_raw_value'] = value.to_s
+    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
   end
 
   def select_option
     return if disabled?
-    if select_node['multiple'] != 'multiple'
-      select_node.find_xpath(".//option[@selected]").each { |node| node.native.remove_attribute("selected") }
-    end
-    native["selected"] = 'selected'
+
+    deselect_options unless select_node.multiple?
+    native['selected'] = 'selected'
   end
 
   def unselect_option
-    if select_node['multiple'] != 'multiple'
-      raise Capybara::UnselectNotAllowed, "Cannot unselect option from single select box."
-    end
+    raise Capybara::UnselectNotAllowed, 'Cannot unselect option from single select box.' unless select_node.multiple?
+
     native.remove_attribute('selected')
   end
 
-  def click
-    if tag_name == 'a' && !self[:href].nil?
-      method = self["data-method"] if driver.options[:respect_data_method]
-      method ||= :get
-      driver.follow(method, self[:href].to_s)
-    elsif (tag_name == 'input' and %w(submit image).include?(type)) or
-        ((tag_name == 'button') and type.nil? or type == "submit")
+  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
+    elsif submits?
       associated_form = form
       Capybara::RackTest::Form.new(driver, associated_form).submit(self) if associated_form
-    elsif (tag_name == 'input' and %w(checkbox radio).include?(type))
+    elsif checkable?
       set(!checked?)
-    elsif (tag_name == 'label')
-      labelled_control = if native[:for]
-        find_xpath("//input[@id='#{native[:for]}']").first
-      else
-        find_xpath(".//input").first
-      end
-
-      if labelled_control && (labelled_control.checkbox? || labelled_control.radio?)
-        labelled_control.set(!labelled_control.checked?)
-      end
+    elsif tag_name == 'label'
+      click_label
+    elsif (details = native.xpath('.//ancestor-or-self::details').last)
+      toggle_details(details)
     end
   end
 
@@ -94,47 +99,84 @@ class Capybara::RackTest::Node < Capybara::Driver::Node
   end
 
   def disabled?
-    if %w(option optgroup).include? tag_name
-      string_node.disabled? || find_xpath("parent::*[self::optgroup or self::select]")[0].disabled?
+    return true if string_node.disabled?
+
+    if %w[option optgroup].include? tag_name
+      find_xpath(OPTION_OWNER_XPATH)[0].disabled?
     else
-      string_node.disabled? || !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
 
-  def unnormalized_text(check_ancestor_visibility = true)
-    if !string_node.visible?(check_ancestor_visibility)
+  # @api private
+  def displayed_text(check_ancestor: true)
+    if !string_node.visible?(check_ancestor)
       ''
     elsif native.text?
       native.text
+            .gsub(/[\u200b\u200e\u200f]/, '')
+            .gsub(/[\ \n\f\t\v\u2028\u2029]+/, ' ')
     elsif native.element?
-      native.children.map do |child|
-        Capybara::RackTest::Node.new(driver, child).unnormalized_text(false)
-      end.join
-    else
+      text = native.children.map do |child|
+        Capybara::RackTest::Node.new(driver, child).displayed_text(check_ancestor: false)
+      end.join || ''
+      text = "\n#{text}\n" if BLOCK_ELEMENTS.include?(tag_name)
+      text
+    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') }
+  end
+
   def string_node
     @string_node ||= Capybara::Node::Simple.new(native)
   end
@@ -150,19 +192,19 @@ private
 
   def form
     if native[:form]
-      native.xpath("//form[@id='#{native[:form]}']").first
+      native.xpath("//form[@id='#{native[:form]}']")
     else
-      native.ancestors('form').first
-    end
+      native.ancestors('form')
+    end.first
   end
 
-  def set_radio(_value)
-    other_radios_xpath = XPath.generate { |x| x.anywhere(:input)[x.attr(:name).equals(self[:name])] }.to_s
-    driver.dom.xpath(other_radios_xpath).each { |node| node.remove_attribute("checked") }
+  def set_radio(_value) # rubocop:disable Naming/AccessorMethodName
+    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
 
-  def set_checkbox(value)
+  def set_checkbox(value) # rubocop:disable Naming/AccessorMethodName
     if value && !native['checked']
       native['checked'] = 'checked'
     elsif !value && native['checked']
@@ -170,26 +212,30 @@ private
     end
   end
 
-  def set_input(value)
+  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
       # Firefox, allowing no input
       value = value.to_s[0...self[:maxlength].to_i]
     end
-    if Array === value #Assert multiple attribute is present
-      value.each do |v|
+    if value.is_a?(Array) # Assert multiple attribute is present
+      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
-      if readonly?
-        warn "Attempt to set readonly element with value: #{value} \n *This will raise an exception in a future version of Capybara"
-      else
-        native['value'] = value.to_s
-      end
+      native['value'] = value.to_s
     end
   end
 
@@ -197,25 +243,86 @@ private
     self[attribute] && !self[attribute].empty?
   end
 
+  def follow_link
+    method = self['data-method'] || self['data-turbo-method'] if driver.options[:respect_data_method]
+    method ||= :get
+    driver.follow(method, self[:href].to_s)
+  end
+
+  def click_label
+    labelled_control = if native[:for]
+      find_xpath("//input[@id='#{native[:for]}']")
+    else
+      find_xpath('.//input')
+    end.first
+
+    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
+
+  def link?
+    tag_name == 'a' && !self[:href].nil?
+  end
+
+  def submits?
+    (tag_name == 'input' && %w[submit image].include?(type)) || (tag_name == 'button' && [nil, 'submit'].include?(type))
+  end
+
+  def checkable?
+    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 text_or_password?
+    input_field? && (type == 'text' || type == 'password')
+  end
+
+  def input_field?
+    tag_name == 'input'
+  end
+
   def textarea?
-    tag_name == "textarea"
+    tag_name == 'textarea'
   end
 
-  def text_or_password?
-    input_field? && (type == 'text' || type == 'password')
+  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

@@ -1,14 +1,10 @@
 # frozen_string_literal: true
+
 require 'capybara/dsl'
 
 Capybara.app = Rack::Builder.new do
-  map "/" do
-    if Gem::Version.new(Rails.version) >= Gem::Version.new("3.0")
-      run Rails.application
-    else # Rails 2
-      use Rails::Rack::Static
-      run ActionController::Dispatcher.new
-    end
+  map '/' do
+    run Rails.application
   end
 end.to_app
 

data/lib/capybara/registration_container.rb

@@ -0,0 +1,41 @@
+# 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"
+        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