capybara 3.9.0 → 3.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 42a9311d8f3e7670a90f5851cc9927db169022d550e1c9b2a086900145b7ad18
-  data.tar.gz: 8159deadf9826514634c55f9744d2b8f18a910434d71f66870eb299f6c5980ff
+  metadata.gz: 58e17a63edc194f43995b9c63196fe91311450999a03da4ee7c2f1aa1e1e34e4
+  data.tar.gz: f0a20f11e8a454f62a9abd62dc4d1f18f8419460c43a0e37f250d8c603cffc60
 SHA512:
-  metadata.gz: 8d8256a0c4bc0ca9586d65aec40d4814c060226a7902f5122271d4c9e22b63eec1568c81315d327e02873d732062beef6a0c01d0a50df9d49e14fcd0189084c0
-  data.tar.gz: a86ce539c90c9fbaea0ac8165bbf6f1b66ee8fa4589c129c366d88730cb1881616a3260c3a710b546c0e833aa708de8791326cbaa9c5ffe5f8875ce249c779cd
+  metadata.gz: ee9b34f496afec3a99be65c5fcdcfebef38640eccb146a4e43ec811a55c99edf8393695e9a9d228db07d738d753feaa7f8c8090bc7cf37189ff3b192e5b15482
+  data.tar.gz: 002ae33fdef7b207d2cba11b8ce125c1d4ef972b10226d9f766dc41605791b8167c11c69ae1295ff229049bbd668a4b49021747eefee4861b152489ddbbe4f5d

data/History.md

@@ -1,3 +1,18 @@
+# Version 3.10.0
+Release date: 2018-10-23
+
+### Added
+
+* :class filter can now check for class names starting with !
+* Selector `xpath`/`css` expression definitions will get filter names from block parameters if not explicitly provided
+* `any_of_selectors` assertions and matchers to complement `all_of_selectors` and `none_of_selectors`
+
+### Fixed
+
+* Selector `css` expression definiton declared filters now work again
+* Cleaned up warnings [Yuji Yaginuma]
+* Workaround installation of rspec matcher proxies under jruby by reverting to the old solution not using prepend, so jruby bugs are not hit - Issue #2115
+
 # Version 3.9.0
 Release date: 2018-10-03
 

data/License.txt

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2009-2016 Jonas Nicklas
+Copyright (c) 2009-2018 Thomas Walpole, Jonas Nicklas
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -7,7 +7,7 @@
 [![SemVer](https://api.dependabot.com/badges/compatibility_score?dependency-name=capybara&package-manager=bundler&version-scheme=semver)](https://dependabot.com/compatibility-score.html?dependency-name=capybara&package-manager=bundler&version-scheme=semver)
 
 **Note** You are viewing the README for the development version of Capybara.  If you are using the current release version
-you can find the README at https://github.com/teamcapybara/capybara/blob/3.8_stable/README.md
+you can find the README at https://github.com/teamcapybara/capybara/blob/3.9_stable/README.md
 
 
 Capybara helps you test web applications by simulating how a real user would

data/lib/capybara.rb

@@ -393,7 +393,7 @@ module Capybara
       if threadsafe
         Thread.current['capybara_specified_session']
       else
-        @specified_session
+        @specified_session ||= nil
       end
     end
 
@@ -414,7 +414,6 @@ module Capybara
   module RackTest; end
   module Selenium; end
 
-  require 'capybara/xpath_patches'
   require 'capybara/helpers'
   require 'capybara/session'
   require 'capybara/window'

data/lib/capybara/helpers.rb

@@ -49,8 +49,9 @@ module Capybara
     #
     def inject_asset_host(html, host: Capybara.asset_host)
       if host && Nokogiri::HTML(html).css('base').empty?
-        match = html.match(/<head[^<]*?>/)
-        return html.clone.insert match.end(0), "<base href='#{host}' />" if match
+        html.match(/<head[^<]*?>/) do |m|
+          return html.clone.insert m.end(0), "<base href='#{host}' />"
+        end
       end
       html
     end

data/lib/capybara/minitest.rb

@@ -87,7 +87,7 @@ module Capybara
       #   see {Capybara::Node::Matchers#assert_style}
 
       %w[assert_selector assert_no_selector
-         assert_all_of_selectors assert_none_of_selectors
+         assert_all_of_selectors assert_none_of_selectors assert_any_of_selectors
          assert_matches_selector assert_not_matches_selector
          assert_style].each do |assertion_name|
         class_eval <<-ASSERTION, __FILE__, __LINE__ + 1

data/lib/capybara/minitest/spec.rb

@@ -16,6 +16,7 @@ module Capybara
          %W[refute_#{assertion} wont_have_#{assertion}]]
       end + [%w[assert_all_of_selectors must_have_all_of_selectors],
              %w[assert_none_of_selectors must_have_none_of_selectors],
+             %w[assert_any_of_selectors must_have_any_of_selectors],
              %w[assert_style must_have_style]] +
       %w[selector xpath css].flat_map do |assertion|
         [%W[assert_matches_#{assertion} must_match_#{assertion}],

data/lib/capybara/node/finders.rb

@@ -15,15 +15,30 @@ module Capybara
       #   and defaults to 2 seconds.
       #   @option options [false, Numeric] wait (Capybara.default_max_wait_time) Maximum time to wait for matching element to appear.
       #
-      # +find+ takes the same options as +all+.
-      #
       #     page.find('#foo').find('.bar')
       #     page.find(:xpath, './/div[contains(., "bar")]')
       #     page.find('li', text: 'Quox').click_link('Delete')
       #
       # @param (see Capybara::Node::Finders#all)
       #
-      # @option options [Boolean] match        The matching strategy to use.
+      # @!macro system_filters
+      #   @option options [String, Regexp] text      Only find elements which contain this text or match this regexp
+      #   @option options [String, Boolean] exact_text (Capybara.exact_text) When String the elements contained text must match exactly, when Boolean controls whether the :text option must match exactly
+      #   @option options [Boolean] normalize_ws (Capybara.default_normalize_ws)  Whether the `text`/`exact_text` options are compared against elment text with whitespace normalized or as returned by the driver
+      #   @option options [Boolean, Symbol] visible  Only find elements with the specified visibility:
+      #                                              * true - only finds visible elements.
+      #                                              * false - finds invisible _and_ visible elements.
+      #                                              * :all - same as false; finds visible and invisible elements.
+      #                                              * :hidden - only finds invisible elements.
+      #                                              * :visible - same as true; only finds visible elements.
+      #   @option options [String, Regexp]  id           Only find elements with an id that matches the value passed
+      #   @option options [String, Array<String>, Regexp] class  Only find elements with matching class/classes.
+      #                                            + Absence of a class can be checked by prefixing the class name with !
+      #                                            + If you need to check for existence of a class name that starts with ! then prefix with !!
+      #                                            + ```class:['a', '!b', '!!!c'] # limit to elements with class 'a' and '!c' but not class 'b'```
+      #   @option options [Boolean] exact            Control whether `is` expressions in the given XPath match exactly or partially
+      #   @option options [Integer, false] wait (Capybara.default_max_wait_time)  The time to wait for matching elements to become available
+      # @option options [Symbol] match        The matching strategy to use.
       #
       # @return [Capybara::Node::Element]      The found element
       # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
@@ -46,7 +61,7 @@ module Capybara
       #
       # @param (see Capybara::Node::Finders#find)
       #
-      # @!macro waiting_behavior
+      # @macro waiting_behavior
       #
       # @option options [Boolean] match        The matching strategy to use.
       #
@@ -221,21 +236,11 @@ module Capybara
       #
       # @param [Symbol] kind                       Optional selector type (:css, :xpath, :field, etc.) - Defaults to Capybara.default_selector
       # @param [String] locator                    The locator for the specified selector
-      # @option options [String, Regexp] text      Only find elements which contain this text or match this regexp
-      # @option options [String, Boolean] exact_text (Capybara.exact_text) When String the elements contained text must match exactly, when Boolean controls whether the :text option must match exactly
-      # @option options [Boolean] normalize_ws (Capybara.default_normalize_ws)  Whether the `text`/`exact_text` options are compared against elment text with whitespace normalized or as returned by the driver
-      # @option options [Boolean, Symbol] visible  Only find elements with the specified visibility:
-      #                                              * true - only finds visible elements.
-      #                                              * false - finds invisible _and_ visible elements.
-      #                                              * :all - same as false; finds visible and invisible elements.
-      #                                              * :hidden - only finds invisible elements.
-      #                                              * :visible - same as true; only finds visible elements.
+      # @macro system_filters
       # @option options [Integer] count            Exact number of matches that are expected to be found
       # @option options [Integer] maximum          Maximum number of matches that are expected to be found
       # @option options [Integer] minimum          Minimum number of matches that are expected to be found
       # @option options [Range]   between          Number of matches found must be within the given range
-      # @option options [Boolean] exact            Control whether `is` expressions in the given XPath match exactly or partially
-      # @option options [Integer, false] wait (Capybara.default_max_wait_time)  The time to wait for matching elements to become available
       # @overload all([kind = Capybara.default_selector], locator = nil, **options)
       # @overload all([kind = Capybara.default_selector], locator = nil, **options, &filter_block)
       #   @yieldparam element [Capybara::Node::Element]  The element being considered for inclusion in the results

data/lib/capybara/node/matchers.rb

@@ -139,13 +139,9 @@ module Capybara
       #
       # @overload assert_all_of_selectors([kind = Capybara.default_selector], *locators, **options)
       #
-      def assert_all_of_selectors(*args, wait: nil, **options, &optional_filter_block)
-        wait = session_options.default_max_wait_time if wait.nil?
-        selector = extract_selector(args)
-        synchronize(wait) do
-          args.each do |locator|
-            assert_selector(selector, locator, options, &optional_filter_block)
-          end
+      def assert_all_of_selectors(*args, **options, &optional_filter_block)
+        _verify_multiple(*args, options) do |selector, locator, opts|
+          assert_selector(selector, locator, opts, &optional_filter_block)
         end
       end
 
@@ -164,13 +160,42 @@ module Capybara
       #
       # @overload assert_none_of_selectors([kind = Capybara.default_selector], *locators, **options)
       #
-      def assert_none_of_selectors(*args, wait: nil, **options, &optional_filter_block)
+      def assert_none_of_selectors(*args, **options, &optional_filter_block)
+        _verify_multiple(*args, options) do |selector, locator, opts|
+          assert_no_selector(selector, locator, opts, &optional_filter_block)
+        end
+      end
+
+      # Asserts that any of the provided selectors are present on the given page
+      # or descendants of the current node.  If options are provided, the assertion
+      # will check that each locator is present with those options as well (other than :wait).
+      #
+      #   page.assert_any_of_selectors(:custom, 'Tom', 'Joe', visible: all)
+      #   page.assert_any_of_selectors(:css, '#my_div', 'a.not_clicked')
+      #
+      # It accepts all options that {Capybara::Node::Finders#all} accepts,
+      # such as :text and :visible.
+      #
+      # The :wait option applies to all of the selectors as a group, so any of the locators must be present
+      # within :wait (Defaults to Capybara.default_max_wait_time) seconds.
+      #
+      # @overload assert_any_of_selectors([kind = Capybara.default_selector], *locators, **options)
+      #
+      def assert_any_of_selectors(*args, wait: nil, **options, &optional_filter_block)
         wait = session_options.default_max_wait_time if wait.nil?
         selector = extract_selector(args)
         synchronize(wait) do
-          args.each do |locator|
-            assert_no_selector(selector, locator, options, &optional_filter_block)
+          res = args.map do |locator|
+            begin
+              assert_selector(selector, locator, options, &optional_filter_block)
+              break nil
+            rescue Capybara::ExpectationNotMet => e
+              e.message
+            end
           end
+          raise Capybara::ExpectationNotMet, res.join(' or ') if res
+
+          true
         end
       end
 
@@ -700,6 +725,14 @@ module Capybara
         args.first.is_a?(Symbol) ? args.shift : session_options.default_selector
       end
 
+      def _verify_multiple(*args, wait: nil, **options)
+        wait = session_options.default_max_wait_time if wait.nil?
+        selector = extract_selector(args)
+        synchronize(wait) do
+          args.each { |locator| yield(selector, locator, options) }
+        end
+      end
+
       def _verify_selector_result(query_args, optional_filter_block)
         query_args = _set_query_session_options(*query_args)
         query = Capybara::Queries::SelectorQuery.new(*query_args, &optional_filter_block)

data/lib/capybara/queries/current_path_query.rb

@@ -18,8 +18,8 @@ module Capybara
 
       def resolves_for?(session)
         uri = ::Addressable::URI.parse(session.current_url)
-        uri.query = nil if uri && options[:ignore_query]
-        @actual_path = options[:url] ? uri.to_s : uri&.request_uri
+        uri&.query = nil if options[:ignore_query]
+        @actual_path = options[:url] ? uri&.to_s : uri&.request_uri
 
         if @expected_path.is_a? Regexp
           @actual_path.to_s.match(@expected_path)

data/lib/capybara/queries/selector_query.rb

@@ -61,8 +61,7 @@ module Capybara
         return true if (@resolved_node&.== node) && options[:allow_self]
 
         @applied_filters ||= :system
-        return false unless matches_id_filter?(node) && matches_class_filter?(node)
-        return false unless matches_text_filter?(node) && matches_exact_text_filter?(node) && matches_visible_filter?(node)
+        return false unless matches_system_filters?(node)
 
         @applied_filters = :node
         matches_node_filters?(node) && matches_filter_block?(node)
@@ -292,6 +291,14 @@ module Capybara
         node.is_a?(::Capybara::Node::Simple) && node.path == '/'
       end
 
+      def matches_system_filters?(node)
+        matches_id_filter?(node) &&
+          matches_class_filter?(node) &&
+          matches_text_filter?(node) &&
+          matches_exact_text_filter?(node) &&
+          matches_visible_filter?(node)
+      end
+
       def matches_id_filter?(node)
         return true unless use_default_id_filter? && options[:id].is_a?(Regexp)
 

data/lib/capybara/rack_test/browser.rb

@@ -57,25 +57,26 @@ class Capybara::RackTest::Browser
   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?('/')
-    end
-    new_uri.scheme ||= @current_scheme
-    new_uri.host ||= @current_host
-    new_uri.port ||= @current_port unless new_uri.default_port == @current_port
-
+    method = method.downcase
+    new_uri = build_uri(path)
     @current_scheme, @current_host, @current_port = new_uri.select(:scheme, :host, :port)
 
     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
   rescue Rack::Test::Error

data/lib/capybara/rack_test/form.rb

@@ -19,25 +19,22 @@ class Capybara::RackTest::Form < Capybara::RackTest::Node
   end
 
   def params(button)
-    params = make_params
-
-    form_element_types = %i[input select textarea]
+    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_elements.each_with_object(make_params) do |field, params|
       case field.name
-      when 'input' then add_input_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
+    end.to_params_hash
   end
 
   def submit(button)
@@ -80,28 +77,32 @@ 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'], 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'
       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&.content_type&.to_s)
-        end
-        merge_param!(params, field['name'], file)
+        file_to_upload(value)
       else
-        merge_param!(params, field['name'], File.basename(field['value'].to_s))
+        File.basename(value)
       end
     else
-      merge_param!(params, field['name'], field['value'].to_s)
+      value
+    end
+    merge_param!(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
 
@@ -119,4 +120,8 @@ private
   def add_textarea_param(field, params)
     merge_param!(params, field['name'], field['_capybara_raw_value'].to_s.gsub(/\n/, "\r\n"))
   end
+
+  def submitter?(el)
+    (%w[submit image].include? el['type']) || (el.name == 'button')
+  end
 end

data/lib/capybara/result.rb

@@ -32,7 +32,7 @@ module Capybara
 
     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?
@@ -73,28 +73,25 @@ module Capybara
     end
 
     def compare_count
+      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 (count = @query.options[:count])
-        count = Integer(count)
+      if count && (count = Integer(count))
         return load_up_to(count + 1) <=> count
       end
 
-      if (min = @query.options[:minimum])
-        min = Integer(min)
+      if min && (min = Integer(min))
         return -1 if load_up_to(min) < min
       end
 
-      if (max = @query.options[:maximum])
-        max = Integer(max)
+      if max && (max = Integer(max))
         return 1 if load_up_to(max + 1) > max
       end
 
-      if (between = @query.options[:between])
+      if between
         min, max = between.minmax
         size = load_up_to(max + 1)
-        return 0 if between.include? size
-
-        return size <=> min
+        return between.include?(size) ? 0 : size <=> min
       end
 
       0