capybara 2.7.0 → 3.35.3

data/lib/capybara/queries/sibling_query.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Queries
+    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)
+          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(applied = false) # rubocop:disable Style/OptionalBooleanParameter
+        desc = super
+        sibling_query = @sibling_node&.instance_variable_get(:@query)
+        desc += " that is a sibling of #{sibling_query.description}" if sibling_query
+        desc
+      end
+    end
+  end
+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

@@ -1,47 +1,115 @@
 # frozen_string_literal: true
+
 module Capybara
   # @api private
   module Queries
     class TextQuery < BaseQuery
-      def initialize(*args)
-        @type = (args.first.is_a?(Symbol) || args.first.nil?) ? args.shift : nil
-        @expected_text, @options = args
-        unless @expected_text.is_a?(Regexp)
-          @expected_text = Capybara::Helpers.normalize_whitespace(@expected_text)
+      def initialize(type = nil, expected_text, session_options:, **options) # rubocop:disable Style/OptionalArguments
+        @type = type.nil? ? default_type : type
+        raise ArgumentError, "#{@type} is not a valid type for a text query" unless valid_types.include?(@type)
+
+        @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
-        @search_regexp = Capybara::Helpers.to_regexp(@expected_text)
-        @options ||= {}
+
+        @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
       end
 
       def resolve_for(node)
-        @actual_text = Capybara::Helpers.normalize_whitespace(node.text(@type))
+        @node = node
+        @actual_text = text
         @count = @actual_text.scan(@search_regexp).size
       end
 
       def failure_message
-        description =
-          if @expected_text.is_a?(Regexp)
-            "text matching #{@expected_text.inspect}"
-          else
-            "text #{@expected_text.inspect}"
-          end
-
-        message = Capybara::Helpers.failure_message(description, @options)
+        super << build_message(true)
+      end
+
+      def negative_failure_message
+        super << build_message(false)
+      end
+
+      def description
+        if @expected_text.is_a?(Regexp)
+          "text matching #{@expected_text.inspect}"
+        else
+          "#{'exact ' if exact?}text #{@expected_text.inspect}"
+        end
+      end
+
+    private
+
+      def exact?
+        options.fetch(:exact, session_options.exact_text)
+      end
+
+      def build_message(report_on_invisible)
+        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 && 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?
+        message
       end
 
-      def negative_failure_message
-        failure_message.sub(/(to find)/, 'not \1')
+      def case_insensitive_message
+        insensitive_regexp = Capybara::Helpers.to_regexp(@expected_text, options: Regexp::IGNORECASE)
+        insensitive_count = @actual_text.scan(insensitive_regexp).size
+        return if insensitive_count == @count
+
+        "it was found #{occurrences insensitive_count} using a case insensitive search"
       end
 
-      private
+      def invisible_message
+        invisible_text = text(query_type: :all)
+        invisible_count = invisible_text.scan(@search_regexp).size
+        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 + [:wait]
+        COUNT_KEYS + %i[wait exact normalize_ws]
+      end
+
+      def valid_types
+        %i[all visible]
+      end
+
+      def check_visible_text?
+        @type == :visible
+      end
+
+      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

@@ -1,21 +1,19 @@
 # frozen_string_literal: true
+
 module Capybara
   # @api private
   module Queries
     class TitleQuery < BaseQuery
-      def initialize(expected_title, options = {})
-        @expected_title = expected_title
+      def initialize(expected_title, **options)
+        @expected_title = expected_title.is_a?(Regexp) ? expected_title : expected_title.to_s
         @options = options
-        unless @expected_title.is_a?(Regexp)
-          @expected_title = Capybara::Helpers.normalize_whitespace(@expected_title)
-        end
-        @search_regexp = Capybara::Helpers.to_regexp(@expected_title)
+        super(@options)
+        @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
-        @actual_title.match(@search_regexp)
+        (@actual_title = node.title).match?(@search_regexp)
       end
 
       def failure_message
@@ -26,15 +24,15 @@ module Capybara
         failure_message_helper(' not')
       end
 
-      private
+    private
 
       def failure_message_helper(negated = '')
-        verb = (@expected_title.is_a?(Regexp))? 'match' : 'include'
+        verb = @expected_title.is_a?(Regexp) ? 'match' : 'include'
         "expected #{@actual_title.inspect}#{negated} to #{verb} #{@expected_title.inspect}"
       end
 
       def valid_keys
-        [:wait]
+        %i[wait exact]
       end
     end
   end

data/lib/capybara/rack_test/browser.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 class Capybara::RackTest::Browser
   include ::Rack::Test::Methods
 
@@ -7,6 +8,7 @@ class Capybara::RackTest::Browser
 
   def initialize(driver)
     @driver = driver
+    @current_fragment = nil
   end
 
   def app
@@ -17,61 +19,82 @@ class Capybara::RackTest::Browser
     driver.options
   end
 
-  def visit(path, attributes = {})
+  def visit(path, **attributes)
     reset_host!
     process_and_follow_redirects(:get, path, attributes)
   end
 
+  def refresh
+    reset_cache!
+    request(last_request.fullpath, last_request.env)
+  end
+
   def submit(method, path, attributes)
-    path = request_path if not path or path.empty?
-    process_and_follow_redirects(method, path, attributes, {'HTTP_REFERER' => current_url})
+    path = request_path if path.nil? || path.empty?
+    uri = build_uri(path)
+    uri.query = '' if method.to_s.casecmp('get').zero?
+    process_and_follow_redirects(method, uri.to_s, attributes, 'HTTP_REFERER' => current_url)
   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})
+  def follow(method, path, **attributes)
+    return if fragment_or_script?(path)
+
+    process_and_follow_redirects(method, path, attributes, 'HTTP_REFERER' => current_url)
   end
 
   def process_and_follow_redirects(method, path, attributes = {}, env = {})
+    @current_fragment = build_uri(path).fragment
     process(method, path, attributes, env)
-    if driver.follow_redirects?
-      driver.redirect_limit.times do
-        process(:get, last_response["Location"], {}, env) if last_response.redirect?
+
+    return unless driver.follow_redirects?
+
+    driver.redirect_limit.times do
+      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
-      raise Capybara::InfiniteRedirectError, "redirected more than #{driver.redirect_limit} times, check for infinite redirects." if last_response.redirect?
+    end
+
+    if last_response.redirect? # rubocop:disable Style/GuardClause
+      raise Capybara::InfiniteRedirectError, "redirected more than #{driver.redirect_limit} times, check for infinite redirects."
     end
   end
 
   def process(method, path, attributes = {}, env = {})
-    new_uri = URI.parse(path)
-    method.downcase! unless method.is_a? Symbol
-
-    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?('/')
-    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
-
+    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!
     send(method, new_uri.to_s, attributes, env.merge(options[:headers] || {}))
   end
 
+  def build_uri(path)
+    URI.parse(path).tap do |uri|
+      uri.path = request_path if path.empty? || path.start_with?('?')
+      uri.path = '/' if uri.path.empty?
+      uri.path = request_path.sub(%r{/[^/]*$}, '/') + uri.path unless uri.path.start_with?('/')
+
+      uri.scheme ||= @current_scheme
+      uri.host ||= @current_host
+      uri.port ||= @current_port unless uri.default_port == @current_port
+    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(Capybara.app_host || Capybara.default_host)
-    @current_scheme = uri.scheme
-    @current_host = uri.host
-    @current_port = uri.port
+    uri = URI.parse(driver.session_options.app_host || driver.session_options.default_host)
+    @current_scheme, @current_host, @current_port = uri.select(:scheme, :host, :port)
   end
 
   def reset_cache!
@@ -83,7 +106,7 @@ class Capybara::RackTest::Browser
   end
 
   def find(format, selector)
-    if format==:css
+    if format == :css
       dom.css(selector, Capybara::RackTest::CSSHandlers.new)
     else
       dom.xpath(selector)
@@ -93,16 +116,11 @@ class Capybara::RackTest::Browser
   def html
     last_response.body
   rescue Rack::Test::Error
-    ""
+    ''
   end
 
   def title
-    if dom.respond_to? :title
-      dom.title
-    else
-      #old versions of nokogiri don't have #title - remove in 3.0
-      dom.xpath('/html/head/title | /html/title').first.text
-    end
+    dom.title
   end
 
 protected
@@ -115,6 +133,12 @@ protected
   def request_path
     last_request.path
   rescue Rack::Test::Error
-    "/"
+    '/'
+  end
+
+private
+
+  def fragment_or_script?(path)
+    path.gsub(/^#{Regexp.escape(request_path)}/, '').start_with?('#') || path.downcase.start_with?('javascript:')
   end
 end

data/lib/capybara/rack_test/css_handlers.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
+
 class Capybara::RackTest::CSSHandlers < BasicObject
   include ::Kernel
-  
-  def disabled list
+
+  def disabled(list)
     list.find_all { |node| node.has_attribute? 'disabled' }
-  end        
-  def enabled list
+  end
+
+  def enabled(list)
     list.find_all { |node| !node.has_attribute? 'disabled' }
   end
 end

data/lib/capybara/rack_test/driver.rb

@@ -1,20 +1,23 @@
 # frozen_string_literal: true
+
 require 'rack/test'
 require 'rack/utils'
-require 'mime/types'
+require 'mini_mime'
 require 'nokogiri'
 require 'cgi'
 
 class Capybara::RackTest::Driver < Capybara::Driver::Base
   DEFAULT_OPTIONS = {
-    :respect_data_method => false,
-    :follow_redirects => true,
-    :redirect_limit => 5
-  }
+    respect_data_method: false,
+    follow_redirects: true,
+    redirect_limit: 5
+  }.freeze
   attr_reader :app, :options
 
-  def initialize(app, options={})
-    raise ArgumentError, "rack-test requires a rack application, but none was given" unless app
+  def initialize(app, **options)
+    raise ArgumentError, 'rack-test requires a rack application, but none was given' unless app
+
+    super()
     @app = app
     @options = DEFAULT_OPTIONS.merge(options)
   end
@@ -39,15 +42,19 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
     browser.last_request
   end
 
-  def visit(path, attributes = {})
-    browser.visit(path, attributes)
+  def visit(path, **attributes)
+    browser.visit(path, **attributes)
+  end
+
+  def refresh
+    browser.refresh
   end
 
   def submit(method, path, attributes)
     browser.submit(method, path, attributes)
   end
 
-  def follow(method, path, attributes = {})
+  def follow(method, path, **attributes)
     browser.follow(method, path, attributes)
   end
 
@@ -68,7 +75,11 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
   end
 
   def find_css(selector)
-    browser.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
@@ -87,14 +98,13 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
     @browser = nil
   end
 
-  # @deprecated This method is being removed
-  def browser_initialized?
-    super && !@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 header(key, value); browser.header(key, value); end
+
+  def invalid_element_errors
+    [Capybara::RackTest::Errors::StaleElementReferenceError]
+  end
 end