capybara 3.0.0 → 3.40.0

data/lib/capybara/queries/sibling_query.rb

@@ -2,21 +2,23 @@
 
 module Capybara
   module Queries
-    class SiblingQuery < MatchQuery
+    class SiblingQuery < SelectorQuery
       # @api private
       def resolve_for(node, exact = nil)
         @sibling_node = node
         node.synchronize do
-          match_results = super(node.session.current_scope, exact)
-          node.all(:xpath, XPath.preceding_sibling + XPath.following_sibling) do |el|
-            match_results.include?(el)
-          end
+          scope = node.respond_to?(:session) ? node.session.current_scope : node.find(:xpath, '/*')
+          match_results = super(scope, exact)
+          siblings = node.find_xpath((XPath.preceding_sibling + XPath.following_sibling).to_s)
+                         .map(&method(:to_element))
+                         .select { |el| match_results.include?(el) }
+          Capybara::Result.new(ordered_results(siblings), self)
         end
       end
 
-      def description
+      def description(applied = false) # rubocop:disable Style/OptionalBooleanParameter
         desc = super
-        sibling_query = @sibling_node && @sibling_node.instance_variable_get(:@query)
+        sibling_query = @sibling_node&.instance_variable_get(:@query)
         desc += " that is a sibling of #{sibling_query.description}" if sibling_query
         desc
       end

data/lib/capybara/queries/style_query.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Capybara
+  # @api private
+  module Queries
+    class StyleQuery < BaseQuery
+      def initialize(expected_styles, session_options:, **options)
+        @expected_styles = stringify_keys(expected_styles)
+        @options = options
+        @actual_styles = {}
+        super(@options)
+        self.session_options = session_options
+
+        assert_valid_keys
+      end
+
+      def resolves_for?(node)
+        @node = node
+        @actual_styles = node.style(*@expected_styles.keys)
+        @expected_styles.all? do |style, value|
+          if value.is_a? Regexp
+            value.match? @actual_styles[style]
+          else
+            @actual_styles[style] == value
+          end
+        end
+      end
+
+      def failure_message
+        +"Expected node to have styles #{@expected_styles.inspect}. " \
+         "Actual styles were #{@actual_styles.inspect}"
+      end
+
+    private
+
+      def stringify_keys(hsh)
+        hsh.transform_keys(&:to_s)
+      end
+
+      def valid_keys
+        %i[wait]
+      end
+    end
+  end
+end

data/lib/capybara/queries/text_query.rb

@@ -5,17 +5,20 @@ module Capybara
   module Queries
     class TextQuery < BaseQuery
       def initialize(type = nil, expected_text, session_options:, **options) # rubocop:disable Style/OptionalArguments
-        @type = if type.nil?
-          Capybara.ignore_hidden_elements || Capybara.visible_text_only ? :visible : :all
-        else
-          type
-        end
+        @type = type.nil? ? default_type : type
+        raise ArgumentError, "#{@type} is not a valid type for a text query" unless valid_types.include?(@type)
 
-        @expected_text = expected_text.is_a?(Regexp) ? expected_text : expected_text.to_s
         @options = options
         super(@options)
         self.session_options = session_options
 
+        if expected_text.nil? && !exact?
+          warn 'Checking for expected text of nil is confusing and/or pointless since it will always match. ' \
+               "Please specify a string or regexp instead. #{Capybara::Helpers.filter_backtrace(caller)}"
+        end
+
+        @expected_text = expected_text.is_a?(Regexp) ? expected_text : expected_text.to_s
+
         @search_regexp = Capybara::Helpers.to_regexp(@expected_text, exact: exact?)
 
         assert_valid_keys
@@ -23,7 +26,7 @@ module Capybara
 
       def resolve_for(node)
         @node = node
-        @actual_text = text(node, @type)
+        @actual_text = text
         @count = @actual_text.scan(@search_regexp).size
       end
 
@@ -39,7 +42,7 @@ module Capybara
         if @expected_text.is_a?(Regexp)
           "text matching #{@expected_text.inspect}"
         else
-          "#{"exact " if exact?}text #{@expected_text.inspect}"
+          "#{'exact ' if exact?}text #{@expected_text.inspect}"
         end
       end
 
@@ -50,15 +53,15 @@ module Capybara
       end
 
       def build_message(report_on_invisible)
-        message = "".dup
+        message = +''
         unless (COUNT_KEYS & @options.keys).empty?
           message << " but found #{@count} #{Capybara::Helpers.declension('time', 'times', @count)}"
         end
         message << " in #{@actual_text.inspect}"
 
         details_message = []
-        details_message << case_insensitive_message if @node and !@expected_text.is_a? Regexp
-        details_message << invisible_message if @node and check_visible_text? and report_on_invisible
+        details_message << case_insensitive_message if @node && check_case_insensitive?
+        details_message << invisible_message if @node && check_visible_text? && report_on_invisible
         details_message.compact!
 
         message << ". (However, #{details_message.join(' and ')}.)" unless details_message.empty?
@@ -68,30 +71,45 @@ module Capybara
       def case_insensitive_message
         insensitive_regexp = Capybara::Helpers.to_regexp(@expected_text, options: Regexp::IGNORECASE)
         insensitive_count = @actual_text.scan(insensitive_regexp).size
-        if insensitive_count != @count
-          "it was found #{insensitive_count} #{Capybara::Helpers.declension("time", "times", insensitive_count)} using a case insensitive search"
-        end
+        return if insensitive_count == @count
+
+        "it was found #{occurrences insensitive_count} using a case insensitive search"
       end
 
       def invisible_message
-        invisible_text = text(@node, :all)
+        invisible_text = text(query_type: :all)
         invisible_count = invisible_text.scan(@search_regexp).size
-        if invisible_count != @count
-          "it was found #{invisible_count} #{Capybara::Helpers.declension("time", "times", invisible_count)} including non-visible text"
-        end
-      rescue # An error getting the non-visible text (if element goes out of scope) should not affect the response
+        return if invisible_count == @count
+
+        "it was found #{occurrences invisible_count} including non-visible text"
+      rescue StandardError
+        # An error getting the non-visible text (if element goes out of scope) should not affect the response
+        nil
       end
 
       def valid_keys
-        COUNT_KEYS + %i[wait exact]
+        COUNT_KEYS + %i[wait exact normalize_ws]
+      end
+
+      def valid_types
+        %i[all visible]
       end
 
       def check_visible_text?
         @type == :visible
       end
 
-      def text(node, query_type)
-        node.text(query_type)
+      def check_case_insensitive?
+        !@expected_text.is_a?(Regexp)
+      end
+
+      def text(node: @node, query_type: @type)
+        normalize_ws = options.fetch(:normalize_ws, session_options.default_normalize_ws)
+        node.text(query_type, normalize_ws: normalize_ws)
+      end
+
+      def default_type
+        Capybara.ignore_hidden_elements || Capybara.visible_text_only ? :visible : :all
       end
     end
   end

data/lib/capybara/queries/title_query.rb

@@ -8,12 +8,12 @@ module Capybara
         @expected_title = expected_title.is_a?(Regexp) ? expected_title : expected_title.to_s
         @options = options
         super(@options)
-        @search_regexp = Capybara::Helpers.to_regexp(@expected_title, all_whitespace: true, exact: options.fetch(:exact, false))
+        @search_regexp = Helpers.to_regexp(@expected_title, all_whitespace: true, exact: options.fetch(:exact, false))
         assert_valid_keys
       end
 
       def resolves_for?(node)
-        (@actual_title = node.title).match(@search_regexp)
+        (@actual_title = node.title).match?(@search_regexp)
       end
 
       def failure_message

data/lib/capybara/rack_test/browser.rb

@@ -8,6 +8,7 @@ class Capybara::RackTest::Browser
 
   def initialize(driver)
     @driver = driver
+    @current_fragment = nil
   end
 
   def app
@@ -19,6 +20,8 @@ class Capybara::RackTest::Browser
   end
 
   def visit(path, **attributes)
+    @new_visit_request = true
+    reset_cache!
     reset_host!
     process_and_follow_redirects(:get, path, attributes)
   end
@@ -28,60 +31,83 @@ class Capybara::RackTest::Browser
     request(last_request.fullpath, last_request.env)
   end
 
-  def submit(method, path, attributes)
+  def submit(method, path, attributes, content_type: nil)
     path = request_path if path.nil? || path.empty?
-    process_and_follow_redirects(method, path, attributes, 'HTTP_REFERER' => current_url)
+    uri = build_uri(path)
+    uri.query = '' if method.to_s.casecmp('get').zero?
+    env = { 'HTTP_REFERER' => referer_url }
+    env['CONTENT_TYPE'] = content_type if content_type
+    process_and_follow_redirects(
+      method,
+      uri.to_s,
+      attributes,
+      env
+    )
   end
 
   def follow(method, path, **attributes)
-    return if path.gsub(/^#{Regexp.escape(request_path)}/, '').start_with?('#') || path.downcase.start_with?('javascript:')
-    process_and_follow_redirects(method, path, attributes, 'HTTP_REFERER' => current_url)
+    return if fragment_or_script?(path)
+
+    process_and_follow_redirects(method, path, attributes, 'HTTP_REFERER' => referer_url)
   end
 
   def process_and_follow_redirects(method, path, attributes = {}, env = {})
+    @current_fragment = build_uri(path).fragment
     process(method, path, attributes, env)
-
     return unless driver.follow_redirects?
 
     driver.redirect_limit.times do
-      process(:get, last_response["Location"], {}, env) if last_response.redirect?
+      if last_response.redirect?
+        if [307, 308].include? last_response.status
+          process(last_request.request_method, last_response['Location'], last_request.params, env)
+        else
+          process(:get, last_response['Location'], {}, env)
+        end
+      end
     end
-    raise Capybara::InfiniteRedirectError, "redirected more than #{driver.redirect_limit} times, check for infinite redirects." if last_response.redirect?
-  end
 
-  def process(method, path, attributes = {}, env = {})
-    new_uri = URI.parse(path)
-    method.downcase! unless method.is_a? Symbol
-    if path.empty?
-      new_uri.path = request_path
-    else
-      new_uri.path = request_path if path.start_with?("?")
-      new_uri.path = "/" if new_uri.path.empty?
-      new_uri.path = request_path.sub(%r{/[^/]*$}, '/') + new_uri.path unless new_uri.path.start_with?('/')
+    if last_response.redirect? # rubocop:disable Style/GuardClause
+      raise Capybara::InfiniteRedirectError, "redirected more than #{driver.redirect_limit} times, check for infinite redirects."
     end
-    new_uri.scheme ||= @current_scheme
-    new_uri.host ||= @current_host
-    new_uri.port ||= @current_port unless new_uri.default_port == @current_port
-
-    @current_scheme = new_uri.scheme
-    @current_host = new_uri.host
-    @current_port = new_uri.port
+  end
 
+  def process(method, path, attributes = {}, env = {})
+    method = method.downcase
+    new_uri = build_uri(path)
+    @current_scheme, @current_host, @current_port = new_uri.select(:scheme, :host, :port)
+    @current_fragment = new_uri.fragment || @current_fragment
     reset_cache!
+    @new_visit_request = false
     send(method, new_uri.to_s, attributes, env.merge(options[:headers] || {}))
   end
 
+  def build_uri(path)
+    uri = URI.parse(path)
+    base_uri = base_relative_uri_for(uri)
+
+    uri.path = base_uri.path + uri.path unless uri.absolute? || uri.path.start_with?('/')
+
+    if base_uri.absolute?
+      base_uri.merge(uri)
+    else
+      uri.scheme ||= @current_scheme
+      uri.host ||= @current_host
+      uri.port ||= @current_port unless uri.default_port == @current_port
+      uri
+    end
+  end
+
   def current_url
-    last_request.url
+    uri = build_uri(last_request.url)
+    uri.fragment = @current_fragment if @current_fragment
+    uri.to_s
   rescue Rack::Test::Error
-    ""
+    ''
   end
 
   def reset_host!
     uri = URI.parse(driver.session_options.app_host || driver.session_options.default_host)
-    @current_scheme = uri.scheme
-    @current_host = uri.host
-    @current_port = uri.port
+    @current_scheme, @current_host, @current_port = uri.select(:scheme, :host, :port)
   end
 
   def reset_cache!
@@ -103,15 +129,46 @@ class Capybara::RackTest::Browser
   def html
     last_response.body
   rescue Rack::Test::Error
-    ""
+    ''
   end
 
   def title
     dom.title
   end
 
+  def last_request
+    raise Rack::Test::Error if @new_visit_request
+
+    super
+  end
+
+  def last_response
+    raise Rack::Test::Error if @new_visit_request
+
+    super
+  end
+
 protected
 
+  def base_href
+    find(:css, 'head > base').first&.[](:href).to_s
+  end
+
+  def base_relative_uri_for(uri)
+    base_uri = URI.parse(base_href)
+    current_uri = URI.parse(safe_last_request&.url.to_s).tap do |c|
+      c.path.sub!(%r{/[^/]*$}, '/') unless uri.path.empty?
+      c.path = '/' if c.path.empty?
+    end
+
+    if [current_uri, base_uri].any?(&:absolute?)
+      current_uri.merge(base_uri)
+    else
+      base_uri.path = current_uri.path if base_uri.path.empty?
+      base_uri
+    end
+  end
+
   def build_rack_mock_session
     reset_host! unless current_host
     Rack::MockSession.new(app, current_host)
@@ -120,6 +177,24 @@ protected
   def request_path
     last_request.path
   rescue Rack::Test::Error
-    "/"
+    '/'
+  end
+
+  def safe_last_request
+    last_request
+  rescue Rack::Test::Error
+    nil
+  end
+
+private
+
+  def fragment_or_script?(path)
+    path.gsub(/^#{Regexp.escape(request_path)}/, '').start_with?('#') || path.downcase.start_with?('javascript:')
+  end
+
+  def referer_url
+    build_uri(last_request.url).to_s
+  rescue Rack::Test::Error
+    ''
   end
 end

data/lib/capybara/rack_test/driver.rb

@@ -15,8 +15,9 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
   attr_reader :app, :options
 
   def initialize(app, **options)
-    raise ArgumentError, "rack-test requires a rack application, but none was given" unless app
-    @session = nil
+    raise ArgumentError, 'rack-test requires a rack application, but none was given' unless app
+
+    super()
     @app = app
     @options = DEFAULT_OPTIONS.merge(options)
   end
@@ -42,7 +43,7 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
   end
 
   def visit(path, **attributes)
-    browser.visit(path, attributes)
+    browser.visit(path, **attributes)
   end
 
   def refresh
@@ -75,6 +76,10 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
 
   def find_css(selector)
     browser.find(:css, selector)
+  rescue Nokogiri::CSS::SyntaxError
+    raise unless selector.include?(' i]')
+
+    raise ArgumentError, "This driver doesn't support case insensitive attribute matching when using CSS base selectors"
   end
 
   def html
@@ -93,9 +98,13 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
     @browser = nil
   end
 
-  def get(*args, &block); browser.get(*args, &block); end
-  def post(*args, &block); browser.post(*args, &block); end
-  def put(*args, &block); browser.put(*args, &block); end
-  def delete(*args, &block); browser.delete(*args, &block); end
+  def get(...); browser.get(...); end
+  def post(...); browser.post(...); end
+  def put(...); browser.put(...); end
+  def delete(...); browser.delete(...); end
   def header(key, value); browser.header(key, value); end
+
+  def invalid_element_errors
+    [Capybara::RackTest::Errors::StaleElementReferenceError]
+  end
 end

data/lib/capybara/rack_test/errors.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Capybara::RackTest::Errors
+  class StaleElementReferenceError < StandardError
+  end
+end

data/lib/capybara/rack_test/form.rb

@@ -6,51 +6,59 @@ class Capybara::RackTest::Form < Capybara::RackTest::Node
   # 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 = %i[input select textarea]
-    form_elements_xpath = XPath.generate do |x|
-      xpath = x.descendant(*form_element_types).where(!x.attr(:form))
-      xpath += 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'
-        add_input_param(field, params)
-      when 'select'
-        add_select_param(field, params)
-      when 'textarea'
-        add_textarea_param(field, params)
+      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
@@ -62,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
@@ -82,43 +91,59 @@ private
   end
 
   def add_input_param(field, params)
-    if %w[radio checkbox].include? field['type']
-      if field['checked']
-        node = Capybara::RackTest::Node.new(driver, field)
-        merge_param!(params, field['name'].to_s, node.value.to_s)
-      end
-    elsif %w[submit image].include? field['type']
-      # TODO: identify the click button here (in document order, rather
-      # than leaving until the end of the params)
-    elsif field['type'] == 'file'
+    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 = 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)
+        file_to_upload(value)
       else
-        merge_param!(params, field['name'].to_s, File.basename(field['value'].to_s))
+        File.basename(value)
       end
     else
-      merge_param!(params, field['name'].to_s, field['value'].to_s)
+      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)
-    if field['multiple'] == 'multiple'
-      field.xpath(".//option[@selected]").each do |option|
-        merge_param!(params, field['name'].to_s, (option['value'] || option.text).to_s)
+    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'].to_s, (option['value'] || option.text).to_s) if option
+      # 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'].to_s, field['_capybara_raw_value'].to_s.gsub(/\n/, "\r\n"))
+    # 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