capybara 2.5.0 → 2.18.0

data/lib/capybara/node/matchers.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 module Capybara
   module Node
     module Matchers
 
       ##
       #
-      # Checks if a given selector is on the page or current node.
+      # Checks if a given selector is on the page or a descendant of the current node.
       #
       #     page.has_selector?('p#foo')
       #     page.has_selector?(:xpath, './/p[@id="foo"]')
@@ -13,14 +14,14 @@ module Capybara
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_selector?('p.foo', :count => 4)
+      #     page.has_selector?('p.foo', count: 4)
       #
       # This will check if the expression occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
       #
-      #     page.has_selector?('li', :text => 'Horse', :visible => true)
+      #     page.has_selector?('li', text: 'Horse', visible: true)
       #
       # has_selector? can also accept XPath expressions generated by the
       # XPath gem:
@@ -35,29 +36,29 @@ module Capybara
       # @option args [Range]   :between (nil)   Range of times that should contain number of times text occurs
       # @return [Boolean]                       If the expression exists
       #
-      def has_selector?(*args)
-        assert_selector(*args)
+      def has_selector?(*args, &optional_filter_block)
+        assert_selector(*args, &optional_filter_block)
       rescue Capybara::ExpectationNotMet
         return false
       end
 
       ##
       #
-      # Checks if a given selector is not on the page or current node.
+      # Checks if a given selector is not on the page or a descendant of the current node.
       # Usage is identical to Capybara::Node::Matchers#has_selector?
       #
       # @param (see Capybara::Node::Finders#has_selector?)
       # @return [Boolean]
       #
-      def has_no_selector?(*args)
-        assert_no_selector(*args)
+      def has_no_selector?(*args, &optional_filter_block)
+        assert_no_selector(*args, &optional_filter_block)
       rescue Capybara::ExpectationNotMet
         return false
       end
 
       ##
       #
-      # Asserts that a given selector is on the page or current node.
+      # Asserts that a given selector is on the page or a descendant of the current node.
       #
       #     page.assert_selector('p#foo')
       #     page.assert_selector(:xpath, './/p[@id="foo"]')
@@ -66,7 +67,7 @@ module Capybara
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.assert_selector('p#foo', :count => 4)
+      #     page.assert_selector('p#foo', count: 4)
       #
       # This will check if the expression occurs exactly 4 times. See
       # {Capybara::Node::Finders#all} for other available result size options.
@@ -77,7 +78,7 @@ module Capybara
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
       #
-      #     page.assert_selector('li', :text => 'Horse', :visible => true)
+      #     page.assert_selector('li', text: 'Horse', visible: true)
       #
       # `assert_selector` can also accept XPath expressions generated by the
       # XPath gem:
@@ -88,64 +89,108 @@ module Capybara
       # @option options [Integer] :count (nil)    Number of times the expression should occur
       # @raise [Capybara::ExpectationNotMet]      If the selector does not exist
       #
-      def assert_selector(*args)
-        query = Capybara::Query.new(*args)
-        synchronize(query.wait) do
-          result = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(result.size, query.options)
-          unless matches_count && ((result.size > 0) || Capybara::Helpers.expects_none?(query.options))
+      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?)
             raise Capybara::ExpectationNotMet, result.failure_message
           end
         end
-        return true
+      end
+
+      # Asserts that all 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_all_of_selectors(:custom, 'Tom', 'Joe', visible: all)
+      #   page.assert_all_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 all of the locators must be present
+      # within :wait (Defaults to Capybara.default_max_wait_time) seconds.
+      #
+      # @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)
+        synchronize(wait) do
+          args.each do |locator|
+            assert_selector(selector, locator, options, &optional_filter_block)
+          end
+        end
+      end
+
+      # Asserts that none 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_none_of_selectors(:custom, 'Tom', 'Joe', visible: all)
+      #   page.assert_none_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 none of the locators must be present
+      # within :wait (Defaults to Capybara.default_max_wait_time) seconds.
+      #
+      # @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)
+        synchronize(wait) do
+          args.each do |locator|
+            assert_no_selector(selector, locator, options, &optional_filter_block)
+          end
+        end
       end
 
       ##
       #
-      # Asserts that a given selector is not on the page or current node.
+      # Asserts that a given selector is not on the page or a descendant of the current node.
       # Usage is identical to Capybara::Node::Matchers#assert_selector
       #
       # Query options such as :count, :minimum, :maximum, and :between are
       # considered to be an integral part of the selector. This will return
       # true, for example, if a page contains 4 anchors but the query expects 5:
       #
-      #     page.assert_no_selector('a', :minimum => 1) # Found, raises Capybara::ExpectationNotMet
-      #     page.assert_no_selector('a', :count => 4)   # Found, raises Capybara::ExpectationNotMet
-      #     page.assert_no_selector('a', :count => 5)   # Not Found, returns true
+      #     page.assert_no_selector('a', minimum: 1) # Found, raises Capybara::ExpectationNotMet
+      #     page.assert_no_selector('a', count: 4)   # Found, raises Capybara::ExpectationNotMet
+      #     page.assert_no_selector('a', count: 5)   # Not Found, returns true
       #
       # @param (see Capybara::Node::Finders#assert_selector)
       # @raise [Capybara::ExpectationNotMet]      If the selector exists
       #
-      def assert_no_selector(*args)
-        query = Capybara::Query.new(*args)
-        synchronize(query.wait) do
-          result = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(result.size, query.options)
-          if matches_count && ((result.size > 0) || Capybara::Helpers.expects_none?(query.options))
+      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?)
             raise Capybara::ExpectationNotMet, result.negative_failure_message
           end
         end
-        return true
       end
       alias_method :refute_selector, :assert_no_selector
 
       ##
       #
-      # Checks if a given XPath expression is on the page or current node.
+      # Checks if a given XPath expression is on the page or a descendant of the current node.
       #
       #     page.has_xpath?('.//p[@id="foo"]')
       #
       # By default it will check if the expression occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_xpath?('.//p[@id="foo"]', :count => 4)
+      #     page.has_xpath?('.//p[@id="foo"]', count: 4)
       #
       # This will check if the expression occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
       #
-      #     page.has_xpath?('.//li', :text => 'Horse', :visible => true)
+      #     page.has_xpath?('.//li', text: 'Horse', visible: true)
       #
       # has_xpath? can also accept XPath expressions generate by the
       # XPath gem:
@@ -158,59 +203,59 @@ 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={})
-        has_selector?(:xpath, path, options)
+      def has_xpath?(path, options={}, &optional_filter_block)
+        has_selector?(:xpath, path, options, &optional_filter_block)
       end
 
       ##
       #
-      # Checks if a given XPath expression is not on the page or current node.
+      # Checks if a given XPath expression is not on the page or a descendant of the current node.
       # Usage is identical to Capybara::Node::Matchers#has_xpath?
       #
       # @param (see Capybara::Node::Finders#has_xpath?)
       # @return [Boolean]
       #
-      def has_no_xpath?(path, options={})
-        has_no_selector?(:xpath, path, options)
+      def has_no_xpath?(path, options={}, &optional_filter_block)
+        has_no_selector?(:xpath, path, options, &optional_filter_block)
       end
 
       ##
       #
-      # Checks if a given CSS selector is on the page or current node.
+      # Checks if a given CSS selector is on the page or a descendant of the current node.
       #
       #     page.has_css?('p#foo')
       #
       # By default it will check if the selector occurs at least once,
       # but a different number can be specified.
       #
-      #     page.has_css?('p#foo', :count => 4)
+      #     page.has_css?('p#foo', count: 4)
       #
       # This will check if the selector occurs exactly 4 times.
       #
       # It also accepts all options that {Capybara::Node::Finders#all} accepts,
       # such as :text and :visible.
       #
-      #     page.has_css?('li', :text => 'Horse', :visible => true)
+      #     page.has_css?('li', text: 'Horse', visible: true)
       #
       # @param [String] path                      A CSS selector
       # @param options                            (see Capybara::Node::Finders#all)
       # @option options [Integer] :count (nil)    Number of times the selector should occur
       # @return [Boolean]                         If the selector exists
       #
-      def has_css?(path, options={})
-        has_selector?(:css, path, options)
+      def has_css?(path, options={}, &optional_filter_block)
+        has_selector?(:css, path, options, &optional_filter_block)
       end
 
       ##
       #
-      # Checks if a given CSS selector is not on the page or current node.
+      # Checks if a given CSS selector is not on the page or a descendant of the current node.
       # Usage is identical to Capybara::Node::Matchers#has_css?
       #
       # @param (see Capybara::Node::Finders#has_css?)
       # @return [Boolean]
       #
-      def has_no_css?(path, options={})
-        has_no_selector?(:css, path, options)
+      def has_no_css?(path, options={}, &optional_filter_block)
+        has_no_selector?(:css, path, options, &optional_filter_block)
       end
 
       ##
@@ -223,8 +268,9 @@ module Capybara
       # @option options [String, Regexp] :href    The value the href attribute must be
       # @return [Boolean]                 Whether it exists
       #
-      def has_link?(locator, options={})
-        has_selector?(:link, locator, options)
+      def has_link?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:link, locator, options, &optional_filter_block)
       end
 
       ##
@@ -235,8 +281,9 @@ module Capybara
       # @param (see Capybara::Node::Finders#has_link?)
       # @return [Boolean]            Whether it doesn't exist
       #
-      def has_no_link?(locator, options={})
-        has_no_selector?(:link, locator, options)
+      def has_no_link?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:link, locator, options, &optional_filter_block)
       end
 
       ##
@@ -247,8 +294,9 @@ 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, options={})
-        has_selector?(:button, locator, options)
+      def has_button?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:button, locator, options, &optional_filter_block)
       end
 
       ##
@@ -259,8 +307,9 @@ 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, options={})
-        has_no_selector?(:button, locator, options)
+      def has_no_button?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:button, locator, options, &optional_filter_block)
       end
 
       ##
@@ -272,21 +321,22 @@ module Capybara
       # HTML5 email/url/etc. fields, it's possible to specify a :with
       # option to specify the text the field should contain:
       #
-      #     page.has_field?('Name', :with => 'Jonas')
+      #     page.has_field?('Name', with: 'Jonas')
       #
       # It is also possible to filter by the field type attribute:
       #
-      #     page.has_field?('Email', :type => 'email')
+      #     page.has_field?('Email', type: 'email')
       #
       # 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] :with    The text content of the field
-      # @option options [String] :type    The type attribute of the field
-      # @return [Boolean]                 Whether it exists
+      # @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
+      # @option options [String] :type           The type attribute of the field
+      # @return [Boolean]                        Whether it exists
       #
-      def has_field?(locator, options={})
-        has_selector?(:field, locator, options)
+      def has_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:field, locator, options, &optional_filter_block)
       end
 
       ##
@@ -294,13 +344,14 @@ module Capybara
       # Checks if the page or current node has no form field with the given
       # label, name or id. See {Capybara::Node::Matchers#has_field?}.
       #
-      # @param [String] locator           The label, name or id of a field to check for
-      # @option options [String] :with    The text content of the field
-      # @option options [String] :type    The type attribute of the field
-      # @return [Boolean]                 Whether it doesn't exist
+      # @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
+      # @option options [String] :type           The type attribute of the field
+      # @return [Boolean]                        Whether it doesn't exist
       #
-      def has_no_field?(locator, options={})
-        has_no_selector?(:field, locator, options)
+      def has_no_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:field, locator, options, &optional_filter_block)
       end
 
       ##
@@ -312,8 +363,9 @@ module Capybara
       # @param [String] locator           The label, name or id of a checked field
       # @return [Boolean]                 Whether it exists
       #
-      def has_checked_field?(locator, options={})
-        has_selector?(:field, locator, options.merge(:checked => true))
+      def has_checked_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:field, locator, options.merge(checked: true), &optional_filter_block)
       end
 
       ##
@@ -325,8 +377,9 @@ 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, options={})
-        has_no_selector?(:field, locator, options.merge(:checked => true))
+      def has_no_checked_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:field, locator, options.merge(checked: true), &optional_filter_block)
       end
 
       ##
@@ -338,8 +391,9 @@ module Capybara
       # @param [String] locator           The label, name or id of an unchecked field
       # @return [Boolean]                 Whether it exists
       #
-      def has_unchecked_field?(locator, options={})
-        has_selector?(:field, locator, options.merge(:unchecked => true))
+      def has_unchecked_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:field, locator, options.merge(unchecked: true), &optional_filter_block)
       end
 
       ##
@@ -351,8 +405,9 @@ 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, options={})
-        has_no_selector?(:field, locator, options.merge(:unchecked => true))
+      def has_no_unchecked_field?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:field, locator, options.merge(unchecked: true), &optional_filter_block)
       end
 
       ##
@@ -362,29 +417,31 @@ module Capybara
       #
       # It can be specified which option should currently be selected:
       #
-      #     page.has_select?('Language', :selected => 'German')
+      #     page.has_select?('Language', selected: 'German')
       #
       # For multiple select boxes, several options may be specified:
       #
-      #     page.has_select?('Language', :selected => ['English', 'German'])
+      #     page.has_select?('Language', selected: ['English', 'German'])
       #
       # It's also possible to check if the exact set of options exists for
       # this select box:
       #
-      #     page.has_select?('Language', :options => ['English', 'German', 'Spanish'])
+      #     page.has_select?('Language', options: ['English', 'German', 'Spanish'])
       #
       # You can also check for a partial set of options:
       #
-      #     page.has_select?('Language', :with_options => ['English', 'German'])
+      #     page.has_select?('Language', with_options: ['English', 'German'])
       #
-      # @param [String] locator                      The label, name or id of a select box
-      # @option options [Array] :options             Options which should be contained in this select box
-      # @option options [Array] :with_options        Partial set of options which should be contained in this select box
-      # @option options [String, Array] :selected    Options which should be selected
-      # @return [Boolean]                            Whether it exists
+      # @param [String] locator                         The label, name or id of a select box
+      # @option options [Array] :options                Options which should be contained in this select box
+      # @option options [Array] :with_options           Partial set of options which should be contained in this select box
+      # @option options [String, Array] :selected       Options which should be selected
+      # @option options [String, Array] :with_selected  Partial set of options which should minimally be selected
+      # @return [Boolean]                               Whether it exists
       #
-      def has_select?(locator, options={})
-        has_selector?(:select, locator, options)
+      def has_select?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:select, locator, options, &optional_filter_block)
       end
 
       ##
@@ -395,8 +452,9 @@ module Capybara
       # @param (see Capybara::Node::Matchers#has_select?)
       # @return [Boolean]     Whether it doesn't exist
       #
-      def has_no_select?(locator, options={})
-        has_no_selector?(:select, locator, options)
+      def has_no_select?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:select, locator, options, &optional_filter_block)
       end
 
       ##
@@ -409,8 +467,9 @@ module Capybara
       # @param [String] locator                        The id or caption of a table
       # @return [Boolean]                              Whether it exist
       #
-      def has_table?(locator, options={})
-        has_selector?(:table, locator, options)
+      def has_table?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_selector?(:table, locator, options, &optional_filter_block)
       end
 
       ##
@@ -421,23 +480,126 @@ module Capybara
       # @param (see Capybara::Node::Matchers#has_table?)
       # @return [Boolean]       Whether it doesn't exist
       #
-      def has_no_table?(locator, options={})
-        has_no_selector?(:table, locator, options)
+      def has_no_table?(locator=nil, options={}, &optional_filter_block)
+        locator, options = nil, locator if locator.is_a? Hash
+        has_no_selector?(:table, locator, options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Asserts that the current_node matches a given selector
+      #
+      #     node.assert_matches_selector('p#foo')
+      #     node.assert_matches_selector(:xpath, '//p[@id="foo"]')
+      #     node.assert_matches_selector(:foo)
+      #
+      # It also accepts all options that {Capybara::Node::Finders#all} accepts,
+      # such as :text and :visible.
+      #
+      #     node.assert_matches_selector('li', text: 'Horse', visible: true)
+      #
+      # @param (see Capybara::Node::Finders#all)
+      # @raise [Capybara::ExpectationNotMet]      If the selector does not match
+      #
+      def assert_matches_selector(*args, &optional_filter_block)
+        _verify_match_result(args, optional_filter_block) do |result|
+          raise Capybara::ExpectationNotMet, "Item does not match the provided selector" unless result.include? self
+        end
+      end
+
+      def assert_not_matches_selector(*args, &optional_filter_block)
+        _verify_match_result(args, optional_filter_block) do |result|
+          raise Capybara::ExpectationNotMet, 'Item matched the provided selector' if result.include? self
+        end
+      end
+      alias_method :refute_matches_selector, :assert_not_matches_selector
+
+      ##
+      #
+      # Checks if the current node matches given selector
+      #
+      # @param (see Capybara::Node::Finders#has_selector?)
+      # @return [Boolean]
+      #
+      def matches_selector?(*args, &optional_filter_block)
+        assert_matches_selector(*args, &optional_filter_block)
+      rescue Capybara::ExpectationNotMet
+        return false
+      end
+
+      ##
+      #
+      # Checks if the current node matches given XPath expression
+      #
+      # @param [String, XPath::Expression] xpath The XPath expression to match against the current code
+      # @return [Boolean]
+      #
+      def matches_xpath?(xpath, options={}, &optional_filter_block)
+        matches_selector?(:xpath, xpath, options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Checks if the current node matches given CSS selector
+      #
+      # @param [String] css The CSS selector to match against the current code
+      # @return [Boolean]
+      #
+      def matches_css?(css, options={}, &optional_filter_block)
+        matches_selector?(:css, css, options, &optional_filter_block)
       end
 
+      ##
+      #
+      # Checks if the current node does not match given selector
+      # Usage is identical to Capybara::Node::Matchers#has_selector?
+      #
+      # @param (see Capybara::Node::Finders#has_selector?)
+      # @return [Boolean]
+      #
+      def not_matches_selector?(*args, &optional_filter_block)
+        assert_not_matches_selector(*args, &optional_filter_block)
+      rescue Capybara::ExpectationNotMet
+        return false
+      end
+
+      ##
+      #
+      # Checks if the current node does not match given XPath expression
+      #
+      # @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)
+        not_matches_selector?(:xpath, xpath, options, &optional_filter_block)
+      end
+
+      ##
+      #
+      # Checks if the current node does not match given CSS selector
+      #
+      # @param [String] css The CSS selector to match against the current code
+      # @return [Boolean]
+      #
+      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.
       #
       # @!macro text_query_params
       #   @overload $0(type, text, options = {})
-      #     @param [:all, :visible] type               Whether to check for only visible or all text
+      #     @param [:all, :visible] type               Whether to check for only visible or all text. If this parameter is missing or nil then we use the value of `Capybara.ignore_hidden_elements`, which defaults to `true`, corresponding to `:visible`.
       #     @param [String, Regexp] text               The string/regexp to check for. If it's a string, text is expected to include it. If it's a regexp, text is expected to match it.
       #     @option options [Integer] :count (nil)     Number of times the text is expected to occur
       #     @option options [Integer] :minimum (nil)   Minimum number of times the text is expected to occur
       #     @option options [Integer] :maximum (nil)   Maximum number of times the text is expected to occur
       #     @option options [Range]   :between (nil)   Range of times that is expected to contain number of times text occurs
       #     @option options [Numeric] :wait (Capybara.default_max_wait_time)      Maximum time that Capybara will wait for text to eq/match given string/regexp argument
+      #     @option options [Boolean] :exact (Capybara.exact_text) Whether text must be an exact match or just substring
       #   @overload $0(text, options = {})
       #     @param [String, Regexp] text               The string/regexp to check for. If it's a string, text is expected to include it. If it's a regexp, text is expected to match it.
       #     @option options [Integer] :count (nil)     Number of times the text is expected to occur
@@ -445,19 +607,16 @@ module Capybara
       #     @option options [Integer] :maximum (nil)   Maximum number of times the text is expected to occur
       #     @option options [Range]   :between (nil)   Range of times that is expected to contain number of times text occurs
       #     @option options [Numeric] :wait (Capybara.default_max_wait_time)      Maximum time that Capybara will wait for text to eq/match given string/regexp argument
+      #     @option options [Boolean] :exact (Capybara.exact_text) Whether text must be an exact match or just substring
       # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
       # @return [true]
       #
       def assert_text(*args)
-        query = Capybara::Queries::TextQuery.new(*args)
-        synchronize(query.wait) do
-          count = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(count, query.options)
-          unless matches_count && ((count > 0) || Capybara::Helpers.expects_none?(query.options))
+        _verify_text(args) do |count, query|
+          unless query.matches_count?(count) && ((count > 0) || query.expects_none?)
             raise Capybara::ExpectationNotMet, query.failure_message
           end
         end
-        return true
       end
 
       ##
@@ -469,15 +628,11 @@ module Capybara
       # @return [true]
       #
       def assert_no_text(*args)
-        query = Capybara::Queries::TextQuery.new(*args)
-        synchronize(query.wait) do
-          count = query.resolve_for(self)
-          matches_count = Capybara::Helpers.matches_count?(count, query.options)
-          if matches_count && ((count > 0) || Capybara::Helpers.expects_none?(query.options))
+        _verify_text(args) do |count, query|
+          if query.matches_count?(count) && ((count > 0) || query.expects_none?)
             raise Capybara::ExpectationNotMet, query.negative_failure_message
           end
         end
-        return true
       end
 
       ##
@@ -522,6 +677,47 @@ module Capybara
       def ==(other)
         self.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)
+        query = Capybara::Queries::SelectorQuery.new(*query_args, &optional_filter_block)
+        synchronize(query.wait) do
+          result = query.resolve_for(self)
+          result_block.call(result, query)
+        end
+        return true
+      end
+
+      def _verify_match_result(query_args, optional_filter_block, &result_block)
+        _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)
+        end
+        return true
+      end
+
+      def _verify_text(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
+      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
+      end
     end
   end
 end