capybara 2.15.0 → 3.0.0

data/lib/capybara/node/finders.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
     module Finders
-
       ##
       #
       # Find an {Capybara::Node::Element} based on the given arguments. +find+ will raise an error if the element
@@ -28,13 +28,9 @@ module Capybara
       # @return [Capybara::Node::Element]      The found element
       # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
       #
-      def find(*args, &optional_filter_block)
-        if args.last.is_a? Hash
-          args.last[:session_options] = session_options
-        else
-          args.push(session_options: session_options)
-        end
-        synced_resolve Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
+      def find(*args, **options, &optional_filter_block)
+        options[:session_options] = session_options
+        synced_resolve Capybara::Queries::SelectorQuery.new(*args, options, &optional_filter_block)
       end
 
       ##
@@ -57,13 +53,9 @@ module Capybara
       # @return [Capybara::Node::Element]      The found element
       # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
       #
-      def ancestor(*args, &optional_filter_block)
-        if args.last.is_a? Hash
-          args.last[:session_options] = session_options
-        else
-          args.push(session_options: session_options)
-        end
-        synced_resolve Capybara::Queries::AncestorQuery.new(*args, &optional_filter_block)
+      def ancestor(*args, **options, &optional_filter_block)
+        options[:session_options] = session_options
+        synced_resolve Capybara::Queries::AncestorQuery.new(*args, **options, &optional_filter_block)
       end
 
       ##
@@ -87,13 +79,9 @@ module Capybara
       # @return [Capybara::Node::Element]      The found element
       # @raise  [Capybara::ElementNotFound]    If the element can't be found before time expires
       #
-      def sibling(*args, &optional_filter_block)
-        if args.last.is_a? Hash
-          args.last[:session_options] = session_options
-        else
-          args.push(session_options: session_options)
-        end
-        synced_resolve Capybara::Queries::SiblingQuery.new(*args, &optional_filter_block)
+      def sibling(*args, **options, &optional_filter_block)
+        options[:session_options] = session_options
+        synced_resolve Capybara::Queries::SiblingQuery.new(*args, **options, &optional_filter_block)
       end
 
       ##
@@ -123,11 +111,9 @@ module Capybara
       # @return [Capybara::Node::Element]   The found element
       #
 
-      def find_field(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def find_field(locator = nil, **options, &optional_filter_block)
         find(:field, locator, options, &optional_filter_block)
       end
-      alias_method :field_labeled, :find_field
 
       ##
       #
@@ -145,8 +131,7 @@ module Capybara
       #   @option options [String, Array<String>] class    Match links that match the class(es) provided
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_link(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def find_link(locator = nil, **options, &optional_filter_block)
         find(:link, locator, options, &optional_filter_block)
       end
 
@@ -171,11 +156,10 @@ module Capybara
       #   @option options [String] id                 Match buttons with the id provided
       #   @option options [String] title              Match buttons with the title provided
       #   @option options [String] value              Match buttons with the value provided
-      #   @option options [String, Array<String>] class    Match links that match the class(es) provided
+      #   @option options [String, Array<String>] class    Match buttons that match the class(es) provided
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_button(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def find_button(locator = nil, **options, &optional_filter_block)
         find(:button, locator, options, &optional_filter_block)
       end
 
@@ -189,7 +173,7 @@ module Capybara
       #
       # @return [Capybara::Node::Element]   The found element
       #
-      def find_by_id(id, options={}, &optional_filter_block)
+      def find_by_id(id, **options, &optional_filter_block)
         find(:id, id, options, &optional_filter_block)
       end
 
@@ -221,10 +205,11 @@ module Capybara
       #     page.all('a', text: 'Home')
       #     page.all('#menu li', visible: true)
       #
-      # By default if no elements are found, an empty array is returned;
-      # however, expectations can be set on the number of elements to be found which
-      # will trigger Capybara's waiting behavior for the expectations to match.The
-      # expectations can be set using
+      # By default Capybara's waiting behavior will wait up to `Capybara.default_max_wait_time`
+      # seconds for matching elements to be available and then return an empty result if none
+      # are available. It is possible to set expectations on the number of results located and
+      # Capybara will raise an exception if the number of elements located don't satisfy the
+      # specified conditions.  The expectations can be set using
       #
       #     page.assert_selector('p#foo', count: 4)
       #     page.assert_selector('p#foo', maximum: 10)
@@ -235,9 +220,9 @@ module Capybara
       # count matching.
       #
       # @param [Symbol] kind                       Optional selector type (:css, :xpath, :field, etc.) - Defaults to Capybara.default_selector
-      # @param [String] locator                    The 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 string the elements contained text must match exactly, when Boolean controls whether the :text option must match exactly
+      # @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, Symbol] visible  Only find elements with the specified visibility:
       #                                              * true - only finds visible elements.
       #                                              * false - finds invisible _and_ visible elements.
@@ -249,24 +234,28 @@ module Capybara
       # @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] wait (Capybara.default_max_wait_time)  The time to wait for element count expectations to become true
+      # @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
       #   @yieldreturn [Boolean]                     Should the element be considered in the results?
       # @return [Capybara::Result]                   A collection of found elements
-      #
-      def all(*args, &optional_filter_block)
-        if args.last.is_a? Hash
-          args.last[:session_options] = session_options
-        else
-          args.push(session_options: session_options)
-        end
-        query = Capybara::Queries::SelectorQuery.new(*args, &optional_filter_block)
-        synchronize(query.wait) do
-          result = query.resolve_for(self)
-          raise Capybara::ExpectationNotMet, result.failure_message unless result.matches_count?
-          result
+      # @raise [Capybara::ExpectationNotMet]         The number of elements found doesn't match the specified conditions
+      def all(*args, **options, &optional_filter_block)
+        minimum_specified = options_include_minimum?(options)
+        options = { minimum: 1 }.merge(options) unless minimum_specified
+        options[:session_options] = session_options
+        query = Capybara::Queries::SelectorQuery.new(*args.push(options), &optional_filter_block)
+        result = nil
+        begin
+          synchronize(query.wait) do
+            result = query.resolve_for(self)
+            raise Capybara::ExpectationNotMet, result.failure_message unless result.matches_count?
+            result
+          end
+        rescue Capybara::ExpectationNotMet
+          raise if minimum_specified || (result.compare_count == 1)
+          Result.new([], nil)
         end
       end
       alias_method :find_all, :all
@@ -274,47 +263,51 @@ module Capybara
       ##
       #
       # Find the first element on the page matching the given selector
-      # and options, or nil if no element matches.  By default no waiting
-      # behavior occurs, however if {Capybara.wait_on_first_by_default} is set to true
-      # it will trigger Capybara's waiting behavior for a minimum of 1 matching element to be found and
-      # return the first.  Waiting behavior can also be triggered by passing in any of the count
-      # expectation options.
+      # and options. By default `first` will wait up to `Capybara.default_max_wait_time`
+      # seconds for matching elements to appear and then raise an error if no matching
+      # element is found, or `nil` if the provided count options allow for empty results.
       #
       # @overload first([kind], locator, options)
       #   @param [:css, :xpath] kind                 The type of selector
       #   @param [String] locator                    The selector
       #   @param [Hash] options                      Additional options; see {#all}
       # @return [Capybara::Node::Element]            The found element or nil
+      # @raise  [Capybara::ElementNotFound]          If element(s) matching the provided options can't be found before time expires
       #
-      def first(*args, &optional_filter_block)
-        if session_options.wait_on_first_by_default
-          options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-          args.push({minimum: 1}.merge(options))
-        end
-        all(*args, &optional_filter_block).first
-      rescue Capybara::ExpectationNotMet
-        nil
+      def first(*args, **options, &optional_filter_block)
+        options = { minimum: 1 }.merge(options) unless options_include_minimum?(options)
+        all(*args, **options, &optional_filter_block).first
       end
 
-      private
+    private
 
       def synced_resolve(query)
         synchronize(query.wait) do
-          if (query.match == :smart or query.match == :prefer_exact)
+          if prefer_exact?(query)
             result = query.resolve_for(self, true)
             result = query.resolve_for(self, false) if result.empty? && query.supports_exact? && !query.exact?
           else
             result = query.resolve_for(self)
           end
-          if query.match == :one or query.match == :smart and result.size > 1
-            raise Capybara::Ambiguous.new("Ambiguous match, found #{result.size} elements matching #{query.description}")
-          end
-          if result.empty?
-            raise Capybara::ElementNotFound.new("Unable to find #{query.description}")
-          end
+
+          raise Capybara::Ambiguous, "Ambiguous match, found #{result.size} elements matching #{query.description}" if ambiguous?(query, result)
+          raise Capybara::ElementNotFound, "Unable to find #{query.description}" if result.empty?
+
           result.first
         end.tap(&:allow_reload!)
       end
+
+      def ambiguous?(query, result)
+        query.match == :one or query.match == :smart and result.size > 1
+      end
+
+      def prefer_exact?(query)
+        query.match == :smart or query.match == :prefer_exact
+      end
+
+      def options_include_minimum?(opts)
+        %i[count minimum between].any? { |k| opts.key?(k) }
+      end
     end
   end
 end

data/lib/capybara/node/matchers.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 module Capybara
   module Node
     module Matchers
-
       ##
       #
       # Checks if a given selector is on the page or a descendant of the current node.
@@ -39,7 +39,7 @@ module Capybara
       def has_selector?(*args, &optional_filter_block)
         assert_selector(*args, &optional_filter_block)
       rescue Capybara::ExpectationNotMet
-        return false
+        false
       end
 
       ##
@@ -53,7 +53,7 @@ module Capybara
       def has_no_selector?(*args, &optional_filter_block)
         assert_no_selector(*args, &optional_filter_block)
       rescue Capybara::ExpectationNotMet
-        return false
+        false
       end
 
       ##
@@ -91,7 +91,7 @@ module Capybara
       #
       def assert_selector(*args, &optional_filter_block)
         _verify_selector_result(args, optional_filter_block) do |result, query|
-          unless result.matches_count? && ((!result.empty?) || query.expects_none?)
+          unless result.matches_count? && (!result.empty? || query.expects_none?)
             raise Capybara::ExpectationNotMet, result.failure_message
           end
         end
@@ -112,10 +112,9 @@ module Capybara
       #
       # @overload assert_all_of_selectors([kind = Capybara.default_selector], *locators, options = {})
       #
-      def assert_all_of_selectors(*args, &optional_filter_block)
-        options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-        selector = if args.first.is_a?(Symbol) then args.shift else session_options.default_selector end
-        wait = options.fetch(:wait, session_options.default_max_wait_time)
+      def assert_all_of_selectors(*args, wait: nil, **options, &optional_filter_block)
+        wait = session_options.default_max_wait_time if wait.nil?
+        selector = args.first.is_a?(Symbol) ? args.shift : session_options.default_selector
         synchronize(wait) do
           args.each do |locator|
             assert_selector(selector, locator, options, &optional_filter_block)
@@ -138,10 +137,9 @@ module Capybara
       #
       # @overload assert_none_of_selectors([kind = Capybara.default_selector], *locators, options = {})
       #
-      def assert_none_of_selectors(*args, &optional_filter_block)
-        options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-        selector = if args.first.is_a?(Symbol) then args.shift else session_options.default_selector end
-        wait = options.fetch(:wait, session_options.default_max_wait_time)
+      def assert_none_of_selectors(*args, wait: nil, **options, &optional_filter_block)
+        wait = session_options.default_max_wait_time if wait.nil?
+        selector = args.first.is_a?(Symbol) ? args.shift : session_options.default_selector
         synchronize(wait) do
           args.each do |locator|
             assert_no_selector(selector, locator, options, &optional_filter_block)
@@ -167,7 +165,7 @@ module Capybara
       #
       def assert_no_selector(*args, &optional_filter_block)
         _verify_selector_result(args, optional_filter_block) do |result, query|
-          if result.matches_count? && ((!result.empty?) || query.expects_none?)
+          if result.matches_count? && (!result.empty? || query.expects_none?)
             raise Capybara::ExpectationNotMet, result.negative_failure_message
           end
         end
@@ -203,7 +201,7 @@ module Capybara
       # @option options [Integer] :count (nil)    Number of times the expression should occur
       # @return [Boolean]                         If the expression exists
       #
-      def has_xpath?(path, options={}, &optional_filter_block)
+      def has_xpath?(path, **options, &optional_filter_block)
         has_selector?(:xpath, path, options, &optional_filter_block)
       end
 
@@ -215,7 +213,7 @@ module Capybara
       # @param (see Capybara::Node::Finders#has_xpath?)
       # @return [Boolean]
       #
-      def has_no_xpath?(path, options={}, &optional_filter_block)
+      def has_no_xpath?(path, **options, &optional_filter_block)
         has_no_selector?(:xpath, path, options, &optional_filter_block)
       end
 
@@ -242,7 +240,7 @@ module Capybara
       # @option options [Integer] :count (nil)    Number of times the selector should occur
       # @return [Boolean]                         If the selector exists
       #
-      def has_css?(path, options={}, &optional_filter_block)
+      def has_css?(path, **options, &optional_filter_block)
         has_selector?(:css, path, options, &optional_filter_block)
       end
 
@@ -254,7 +252,7 @@ module Capybara
       # @param (see Capybara::Node::Finders#has_css?)
       # @return [Boolean]
       #
-      def has_no_css?(path, options={}, &optional_filter_block)
+      def has_no_css?(path, **options, &optional_filter_block)
         has_no_selector?(:css, path, options, &optional_filter_block)
       end
 
@@ -268,8 +266,7 @@ module Capybara
       # @option options [String, Regexp] :href    The value the href attribute must be
       # @return [Boolean]                 Whether it exists
       #
-      def has_link?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_link?(locator = nil, **options, &optional_filter_block)
         has_selector?(:link, locator, options, &optional_filter_block)
       end
 
@@ -281,8 +278,7 @@ module Capybara
       # @param (see Capybara::Node::Finders#has_link?)
       # @return [Boolean]            Whether it doesn't exist
       #
-      def has_no_link?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_no_link?(locator = nil, **options, &optional_filter_block)
         has_no_selector?(:link, locator, options, &optional_filter_block)
       end
 
@@ -294,8 +290,7 @@ module Capybara
       # @param [String] locator      The text, value or id of a button to check for
       # @return [Boolean]            Whether it exists
       #
-      def has_button?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_button?(locator = nil, **options, &optional_filter_block)
         has_selector?(:button, locator, options, &optional_filter_block)
       end
 
@@ -307,8 +302,7 @@ module Capybara
       # @param [String] locator      The text, value or id of a button to check for
       # @return [Boolean]            Whether it doesn't exist
       #
-      def has_no_button?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_no_button?(locator = nil, **options, &optional_filter_block)
         has_no_selector?(:button, locator, options, &optional_filter_block)
       end
 
@@ -334,8 +328,7 @@ module Capybara
       # @option options [String] :type           The type attribute of the field
       # @return [Boolean]                        Whether it exists
       #
-      def has_field?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_field?(locator = nil, **options, &optional_filter_block)
         has_selector?(:field, locator, options, &optional_filter_block)
       end
 
@@ -349,8 +342,7 @@ module Capybara
       # @option options [String] :type           The type attribute of the field
       # @return [Boolean]                        Whether it doesn't exist
       #
-      def has_no_field?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_no_field?(locator = nil, **options, &optional_filter_block)
         has_no_selector?(:field, locator, options, &optional_filter_block)
       end
 
@@ -363,8 +355,7 @@ module Capybara
       # @param [String] locator           The label, name or id of a checked field
       # @return [Boolean]                 Whether it exists
       #
-      def has_checked_field?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_checked_field?(locator = nil, **options, &optional_filter_block)
         has_selector?(:field, locator, options.merge(checked: true), &optional_filter_block)
       end
 
@@ -377,8 +368,7 @@ module Capybara
       # @param [String] locator           The label, name or id of a checked field
       # @return [Boolean]                 Whether it doesn't exist
       #
-      def has_no_checked_field?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_no_checked_field?(locator = nil, **options, &optional_filter_block)
         has_no_selector?(:field, locator, options.merge(checked: true), &optional_filter_block)
       end
 
@@ -391,8 +381,7 @@ module Capybara
       # @param [String] locator           The label, name or id of an unchecked field
       # @return [Boolean]                 Whether it exists
       #
-      def has_unchecked_field?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_unchecked_field?(locator = nil, **options, &optional_filter_block)
         has_selector?(:field, locator, options.merge(unchecked: true), &optional_filter_block)
       end
 
@@ -405,8 +394,7 @@ module Capybara
       # @param [String] locator           The label, name or id of an unchecked field
       # @return [Boolean]                 Whether it doesn't exist
       #
-      def has_no_unchecked_field?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_no_unchecked_field?(locator = nil, **options, &optional_filter_block)
         has_no_selector?(:field, locator, options.merge(unchecked: true), &optional_filter_block)
       end
 
@@ -439,8 +427,7 @@ module Capybara
       # @option options [String, Array] :with_selected  Partial set of options which should minimally be selected
       # @return [Boolean]                               Whether it exists
       #
-      def has_select?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_select?(locator = nil, **options, &optional_filter_block)
         has_selector?(:select, locator, options, &optional_filter_block)
       end
 
@@ -452,8 +439,7 @@ module Capybara
       # @param (see Capybara::Node::Matchers#has_select?)
       # @return [Boolean]     Whether it doesn't exist
       #
-      def has_no_select?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_no_select?(locator = nil, **options, &optional_filter_block)
         has_no_selector?(:select, locator, options, &optional_filter_block)
       end
 
@@ -467,8 +453,7 @@ module Capybara
       # @param [String] locator                        The id or caption of a table
       # @return [Boolean]                              Whether it exist
       #
-      def has_table?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_table?(locator = nil, **options, &optional_filter_block)
         has_selector?(:table, locator, options, &optional_filter_block)
       end
 
@@ -480,8 +465,7 @@ module Capybara
       # @param (see Capybara::Node::Matchers#has_table?)
       # @return [Boolean]       Whether it doesn't exist
       #
-      def has_no_table?(locator=nil, options={}, &optional_filter_block)
-        locator, options = nil, locator if locator.is_a? Hash
+      def has_no_table?(locator = nil, **options, &optional_filter_block)
         has_no_selector?(:table, locator, options, &optional_filter_block)
       end
 
@@ -534,7 +518,7 @@ module Capybara
       # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
       # @return [Boolean]
       #
-      def matches_xpath?(xpath, options={}, &optional_filter_block)
+      def matches_xpath?(xpath, **options, &optional_filter_block)
         matches_selector?(:xpath, xpath, options, &optional_filter_block)
       end
 
@@ -545,7 +529,7 @@ module Capybara
       # @param [String] css The CSS selector to match against the current code
       # @return [Boolean]
       #
-      def matches_css?(css, options={}, &optional_filter_block)
+      def matches_css?(css, **options, &optional_filter_block)
         matches_selector?(:css, css, options, &optional_filter_block)
       end
 
@@ -570,7 +554,7 @@ module Capybara
       # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
       # @return [Boolean]
       #
-      def not_matches_xpath?(xpath, options={}, &optional_filter_block)
+      def not_matches_xpath?(xpath, **options, &optional_filter_block)
         not_matches_selector?(:xpath, xpath, options, &optional_filter_block)
       end
 
@@ -581,11 +565,10 @@ module Capybara
       # @param [String] css The CSS selector to match against the current code
       # @return [Boolean]
       #
-      def not_matches_css?(css, options={}, &optional_filter_block)
+      def not_matches_css?(css, **options, &optional_filter_block)
         not_matches_selector?(:css, css, options, &optional_filter_block)
       end
 
-
       ##
       # Asserts that the page or current node has the given text content,
       # ignoring any HTML tags.
@@ -656,7 +639,7 @@ module Capybara
       def has_text?(*args)
         assert_text(*args)
       rescue Capybara::ExpectationNotMet
-        return false
+        false
       end
       alias_method :has_content?, :has_text?
 
@@ -670,53 +653,49 @@ module Capybara
       def has_no_text?(*args)
         assert_no_text(*args)
       rescue Capybara::ExpectationNotMet
-        return false
+        false
       end
       alias_method :has_no_content?, :has_no_text?
 
       def ==(other)
-        self.eql?(other) || (other.respond_to?(:base) && base == other.base)
+        eql?(other) || (other.respond_to?(:base) && base == other.base)
       end
 
     private
 
-      def _verify_selector_result(query_args, optional_filter_block, &result_block)
-        _set_query_session_options(query_args)
+      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)
         synchronize(query.wait) do
           result = query.resolve_for(self)
-          result_block.call(result, query)
+          yield result, query
         end
-        return true
+        true
       end
 
-      def _verify_match_result(query_args, optional_filter_block, &result_block)
-        _set_query_session_options(query_args)
+      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)
         synchronize(query.wait) do
-          result = query.resolve_for(self.query_scope)
-          result_block.call(result)
+          result = query.resolve_for(query_scope)
+          yield result
         end
-        return true
+        true
       end
 
       def _verify_text(query_args)
-        _set_query_session_options(query_args)
+        query_args = _set_query_session_options(*query_args)
         query = Capybara::Queries::TextQuery.new(*query_args)
         synchronize(query.wait) do
           count = query.resolve_for(self)
           yield(count, query)
         end
-        return true
+        true
       end
 
-      def _set_query_session_options(query_args)
-        if query_args.last.is_a? Hash
-          query_args.last[:session_options] = session_options
-        else
-          query_args.push(session_options: session_options)
-        end
-        query_args
+      def _set_query_session_options(*query_args, **query_options)
+        query_options[:session_options] = session_options
+        query_args.push(query_options)
       end
     end
   end