capybara 3.30.0 → 3.35.3

data/lib/capybara/node/finders.rb

@@ -24,12 +24,13 @@ module Capybara
       #   @option options [Boolean] normalize_ws
       #     Whether the `text`/`exact_text` options are compared against elment text with whitespace normalized or as returned by the driver.
       #     Defaults to {Capybara.configure default_normalize_ws}.
-      #   @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 [Boolean, Symbol] visible
+      #     Only find elements with the specified visibility. Defaults to behavior indicated by {Capybara.configure ignore_hidden_elements}.
+      #       * 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 [Boolean] obscured  Only find elements with the specified obscured state:
       #                                       * true - only find elements whose centerpoint is not in the viewport or is obscured by another non-descendant element.
       #                                       * false - only find elements whose centerpoint is in the viewport and is not obscured by other non-descendant elements.
@@ -235,13 +236,16 @@ module Capybara
       # @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] allow_reload     Beta feature - May be removed in any version.
+      #   When `true` allows elements to be reloaded if they become stale. This is an advanced behavior and should only be used
+      #   if you fully understand the potential ramifications. The results can be confusing on dynamic pages. Defaults to `false`
       # @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
       #   @yieldreturn [Boolean]                     Should the element be considered in the results?
       # @return [Capybara::Result]                   A collection of found elements
       # @raise [Capybara::ExpectationNotMet]         The number of elements found doesn't match the specified conditions
-      def all(*args, **options, &optional_filter_block)
+      def all(*args, allow_reload: false, **options, &optional_filter_block)
         minimum_specified = options_include_minimum?(options)
         options = { minimum: 1 }.merge(options) unless minimum_specified
         options[:session_options] = session_options
@@ -250,6 +254,7 @@ module Capybara
         begin
           synchronize(query.wait) do
             result = query.resolve_for(self)
+            result.allow_reload! if allow_reload
             raise Capybara::ExpectationNotMet, result.failure_message unless result.matches_count?
 
             result

data/lib/capybara/node/matchers.rb

@@ -60,15 +60,16 @@ module Capybara
       # @param styles [Hash]
       # @return [Boolean]                       If the styles match
       #
-      def matches_style?(styles, **options)
-        make_predicate(options) { assert_matches_style(styles, options) }
+      def matches_style?(styles = nil, **options)
+        styles, options = options, {} if styles.nil?
+        make_predicate(options) { assert_matches_style(styles, **options) }
       end
 
       ##
       # @deprecated Use {#matches_style?} instead.
       #
-      def has_style?(styles, **options)
-        warn 'DEPRECATED: has_style? is deprecated, please use matches_style?'
+      def has_style?(styles = nil, **options)
+        Capybara::Helpers.warn "DEPRECATED: has_style? is deprecated, please use matches_style? : #{Capybara::Helpers.filter_backtrace(caller)}"
         matches_style?(styles, **options)
       end
 
@@ -122,9 +123,10 @@ module Capybara
       # @param styles [Hash]
       # @raise [Capybara::ExpectationNotMet]    If the element doesn't have the specified styles
       #
-      def assert_matches_style(styles, **options)
-        query_args = _set_query_session_options(styles, **options)
-        query = Capybara::Queries::StyleQuery.new(*query_args)
+      def assert_matches_style(styles = nil, **options)
+        styles, options = options, {} if styles.nil?
+        query_args, query_opts = _set_query_session_options(styles, options)
+        query = Capybara::Queries::StyleQuery.new(*query_args, **query_opts)
         synchronize(query.wait) do
           raise Capybara::ExpectationNotMet, query.failure_message unless query.resolves_for?(self)
         end
@@ -134,7 +136,7 @@ module Capybara
       ##
       # @deprecated Use {#assert_matches_style} instead.
       #
-      def assert_style(styles, **options)
+      def assert_style(styles = nil, **options)
         warn 'assert_style is deprecated, please use assert_matches_style instead'
         assert_matches_style(styles, **options)
       end
@@ -201,12 +203,10 @@ module Capybara
         selector = extract_selector(args)
         synchronize(wait) do
           res = args.map do |locator|
-            begin
-              assert_selector(selector, locator, options, &optional_filter_block)
-              break nil
-            rescue Capybara::ExpectationNotMet => e
-              e.message
-            end
+            assert_selector(selector, locator, options, &optional_filter_block)
+            break nil
+          rescue Capybara::ExpectationNotMet => e
+            e.message
           end
           raise Capybara::ExpectationNotMet, res.join(' or ') if res
 
@@ -386,7 +386,7 @@ module Capybara
       #
       #     page.has_field?('Email', type: 'email')
       #
-      # Note: 'textarea' and 'select' are valid type values, matching the associated tag names.
+      # NOTE: 'textarea' and 'select' are valid type values, matching the associated tag names.
       #
       # @param [String] locator                  The label, name or id of a field to check for
       # @option options [String, Regexp] :with   The text content of the field or a Regexp to match
@@ -672,8 +672,8 @@ module Capybara
       # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
       # @return [true]
       #
-      def assert_text(*args)
-        _verify_text(*args) do |count, query|
+      def assert_text(type_or_text, *args, **opts)
+        _verify_text(type_or_text, *args, **opts) do |count, query|
           unless query.matches_count?(count) && (count.positive? || query.expects_none?)
             raise Capybara::ExpectationNotMet, query.failure_message
           end
@@ -688,8 +688,8 @@ module Capybara
       # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
       # @return [true]
       #
-      def assert_no_text(*args)
-        _verify_text(*args) do |count, query|
+      def assert_no_text(type_or_text, *args, **opts)
+        _verify_text(type_or_text, *args, **opts) do |count, query|
           if query.matches_count?(count) && (count.positive? || query.expects_none?)
             raise Capybara::ExpectationNotMet, query.negative_failure_message
           end
@@ -711,7 +711,7 @@ module Capybara
       # @return [Boolean]                            Whether it exists
       #
       def has_text?(*args, **options)
-        make_predicate(options) { assert_text(*args, options) }
+        make_predicate(options) { assert_text(*args, **options) }
       end
       alias_method :has_content?, :has_text?
 
@@ -723,7 +723,7 @@ module Capybara
       # @return [Boolean]  Whether it doesn't exist
       #
       def has_no_text?(*args, **options)
-        make_predicate(options) { assert_no_text(*args, options) }
+        make_predicate(options) { assert_no_text(*args, **options) }
       end
       alias_method :has_no_content?, :has_no_text?
 
@@ -832,8 +832,14 @@ module Capybara
       end
 
       def _verify_selector_result(query_args, optional_filter_block, query_type = Capybara::Queries::SelectorQuery)
-        query_args = _set_query_session_options(*query_args)
-        query = query_type.new(*query_args, &optional_filter_block)
+        # query_args, query_opts = if query_args[0].is_a? Symbol
+        #   a,o = _set_query_session_options(*query_args.slice(2..))
+        #   [query_args.slice(0..1).concat(a), o]
+        # else
+        #   _set_query_session_options(*query_args)
+        # end
+        query_args, query_opts = _set_query_session_options(*query_args)
+        query = query_type.new(*query_args, **query_opts, &optional_filter_block)
         synchronize(query.wait) do
           yield query.resolve_for(self), query
         end
@@ -841,8 +847,8 @@ module Capybara
       end
 
       def _verify_match_result(query_args, optional_filter_block)
-        query_args = _set_query_session_options(*query_args)
-        query = Capybara::Queries::MatchQuery.new(*query_args, &optional_filter_block)
+        query_args, query_opts = _set_query_session_options(*query_args)
+        query = Capybara::Queries::MatchQuery.new(*query_args, **query_opts, &optional_filter_block)
         synchronize(query.wait) do
           yield query.resolve_for(parent || session&.document || query_scope)
         end
@@ -858,9 +864,12 @@ module Capybara
         true
       end
 
-      def _set_query_session_options(*query_args, **query_options)
+      def _set_query_session_options(*query_args)
+        query_args, query_options = query_args.dup, {}
+        # query_options = query_args.pop if query_options.empty? && query_args.last.is_a?(Hash)
+        query_options = query_args.pop if query_args.last.is_a?(Hash)
         query_options[:session_options] = session_options
-        query_args.push(query_options)
+        [query_args, query_options]
       end
 
       def make_predicate(options)

data/lib/capybara/node/simple.rb

@@ -100,7 +100,7 @@ module Capybara
       # @param  [Boolean] check_ancestors  Whether to inherit visibility from ancestors
       # @return [Boolean]     Whether the element is visible
       #
-      def visible?(check_ancestors = true)
+      def visible?(check_ancestors = true) # rubocop:disable Style/OptionalBooleanParameter
         return false if (tag_name == 'input') && (native[:type] == 'hidden')
         return false if tag_name == 'template'
 
@@ -148,11 +148,15 @@ module Capybara
         native.has_attribute?('multiple')
       end
 
+      def readonly?
+        native.has_attribute?('readonly')
+      end
+
       def synchronize(_seconds = nil)
         yield # simple nodes don't need to wait
       end
 
-      def allow_reload!
+      def allow_reload!(*)
         # no op
       end
 

data/lib/capybara/queries/ancestor_query.rb

@@ -16,7 +16,7 @@ module Capybara
         end
       end
 
-      def description(applied = false)
+      def description(applied = false) # rubocop:disable Style/OptionalBooleanParameter
         child_query = @child_node&.instance_variable_get(:@query)
         desc = super
         desc += " that is an ancestor of #{child_query.description}" if child_query

data/lib/capybara/queries/base_query.rb

@@ -79,7 +79,8 @@ module Capybara
         if count
           message << " #{occurrences count}"
         elsif between
-          message << " between #{between.first} and #{between.end ? between.last : 'infinite'} times"
+          message << " between #{between.begin ? between.first : 1} and" \
+                     " #{between.end ? between.last : 'infinite'} times"
         elsif maximum
           message << " at most #{occurrences maximum}"
         elsif minimum

data/lib/capybara/queries/current_path_query.rb

@@ -6,26 +6,30 @@ module Capybara
   # @api private
   module Queries
     class CurrentPathQuery < BaseQuery
-      def initialize(expected_path, **options)
+      def initialize(expected_path, **options, &optional_filter_block)
         super(options)
         @expected_path = expected_path
         @options = {
           url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || '').hostname.nil?,
           ignore_query: false
         }.merge(options)
+        @filter_block = optional_filter_block
         assert_valid_keys
       end
 
       def resolves_for?(session)
         uri = ::Addressable::URI.parse(session.current_url)
-        uri&.query = nil if options[:ignore_query]
-        @actual_path = options[:url] ? uri&.to_s : uri&.request_uri
+        @actual_path = (options[:ignore_query] ? uri&.omit(:query) : uri).yield_self do |u|
+          options[:url] ? u&.to_s : u&.request_uri
+        end
 
-        if @expected_path.is_a? Regexp
+        res = if @expected_path.is_a? Regexp
           @actual_path.to_s.match?(@expected_path)
         else
           ::Addressable::URI.parse(@expected_path) == ::Addressable::URI.parse(@actual_path)
         end
+
+        res && matches_filter_block?(uri)
       end
 
       def failure_message
@@ -38,6 +42,12 @@ module Capybara
 
     private
 
+      def matches_filter_block?(url)
+        return true unless @filter_block
+
+        @filter_block.call(url)
+      end
+
       def failure_message_helper(negated = '')
         verb = @expected_path.is_a?(Regexp) ? 'match' : 'equal'
         "expected #{@actual_path.inspect}#{negated} to #{verb} #{@expected_path.inspect}"

data/lib/capybara/queries/selector_query.rb

@@ -6,6 +6,7 @@ module Capybara
   module Queries
     class SelectorQuery < Queries::BaseQuery
       attr_reader :expression, :selector, :locator, :options
+
       SPATIAL_KEYS = %i[above below left_of right_of near].freeze
       VALID_KEYS = SPATIAL_KEYS + COUNT_KEYS +
                    %i[text id class style visible obscured exact exact_text normalize_ws match wait filter_set]
@@ -14,6 +15,7 @@ module Capybara
       def initialize(*args,
                      session_options:,
                      enable_aria_label: session_options.enable_aria_label,
+                     enable_aria_role: session_options.enable_aria_role,
                      test_id: session_options.test_id,
                      selector_format: nil,
                      order: nil,
@@ -30,7 +32,11 @@ module Capybara
 
         @selector = Selector.new(
           find_selector(args[0].is_a?(Symbol) ? args.shift : args[0]),
-          config: { enable_aria_label: enable_aria_label, test_id: test_id },
+          config: {
+            enable_aria_label: enable_aria_label,
+            enable_aria_role: enable_aria_role,
+            test_id: test_id
+          },
           format: selector_format
         )
 
@@ -49,7 +55,7 @@ module Capybara
       def name; selector.name; end
       def label; selector.label || selector.name; end
 
-      def description(only_applied = false)
+      def description(only_applied = false) # rubocop:disable Style/OptionalBooleanParameter
         desc = +''
         show_for = show_for_stage(only_applied)
 
@@ -89,11 +95,9 @@ module Capybara
         desc << ' that also matches the custom filter block' if @filter_block && show_for[:node]
 
         desc << " within #{@resolved_node.inspect}" if describe_within?
-        if locator.is_a?(String) && locator.start_with?('#', './/', '//')
-          unless selector.raw_locator?
-            desc << "\nNote: It appears you may be passing a CSS selector or XPath expression rather than a locator. " \
-                    "Please see the documentation for acceptable locator values.\n\n"
-          end
+        if locator.is_a?(String) && locator.start_with?('#', './/', '//') && !selector.raw_locator?
+          desc << "\nNote: It appears you may be passing a CSS selector or XPath expression rather than a locator. " \
+                  "Please see the documentation for acceptable locator values.\n\n"
         end
         desc
       end
@@ -233,17 +237,18 @@ module Capybara
         hints[:styles] = options[:style] if use_default_style_filter?
         hints[:position] = true if use_spatial_filter?
 
-        if selector_format == :css
-          if node.method(:find_css).arity != 1
-            node.find_css(css, **hints)
-          else
+        case selector_format
+        when :css
+          if node.method(:find_css).arity == 1
             node.find_css(css)
-          end
-        elsif selector_format == :xpath
-          if node.method(:find_xpath).arity != 1
-            node.find_xpath(xpath(exact), **hints)
           else
+            node.find_css(css, **hints)
+          end
+        when :xpath
+          if node.method(:find_xpath).arity == 1
             node.find_xpath(xpath(exact))
+          else
+            node.find_xpath(xpath(exact), **hints)
           end
         else
           raise ArgumentError, "Unknown format: #{selector_format}"
@@ -477,9 +482,25 @@ module Capybara
       end
 
       def matches_class_filter?(node)
-        return true unless use_default_class_filter? && options[:class].is_a?(Regexp)
+        return true unless use_default_class_filter? && need_to_process_classes?
 
-        options[:class].match? node[:class]
+        if options[:class].is_a? Regexp
+          options[:class].match? node[:class]
+        else
+          classes = (node[:class] || '').split
+          options[:class].select { |c| c.is_a? Regexp }.all? do |r|
+            classes.any? { |cls| r.match? cls }
+          end
+        end
+      end
+
+      def need_to_process_classes?
+        case options[:class]
+        when Regexp then true
+        when Array then options[:class].any?(Regexp)
+        else
+          false
+        end
       end
 
       def matches_style_filter?(node)
@@ -575,6 +596,7 @@ module Capybara
 
       class Rectangle
         attr_reader :top, :bottom, :left, :right
+
         def initialize(position)
           # rubocop:disable Style/RescueModifier
           @top = position['top'] rescue position['y']
@@ -645,7 +667,7 @@ module Capybara
 
           d = u.dot w
           e = v.dot w
-          cap_d = (a * c) - (b * b)
+          cap_d = (a * c) - (b**2)
           sD = tD = cap_d
 
           # compute the line parameters of the two closest points

data/lib/capybara/queries/sibling_query.rb

@@ -15,7 +15,7 @@ module Capybara
         end
       end
 
-      def description(applied = false)
+      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

data/lib/capybara/queries/style_query.rb

@@ -34,7 +34,7 @@ module Capybara
     private
 
       def stringify_keys(hsh)
-        hsh.each_with_object({}) { |(k, v), str_keys| str_keys[k.to_s] = v }
+        hsh.transform_keys(&:to_s)
       end
 
       def valid_keys

data/lib/capybara/queries/text_query.rb

@@ -6,13 +6,15 @@ module Capybara
     class TextQuery < BaseQuery
       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.'
+               "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
@@ -89,6 +91,10 @@ module Capybara
         COUNT_KEYS + %i[wait exact normalize_ws]
       end
 
+      def valid_types
+        %i[all visible]
+      end
+
       def check_visible_text?
         @type == :visible
       end