123456789_123456789_123456789_123456789_123456789_

Module: Capybara::Node::Matchers

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Included In:
Base, Document, Element, Simple
Defined in: lib/capybara/node/matchers.rb

Instance Method Summary

Instance Method Details

#==(other)

[ GitHub ] 

  


# File 'lib/capybara/node/matchers.rb', line 841



def ==(other)
  eql?(other) || (other.respond_to?(:base) && base == other.base)
end


  








  

    #_set_query_session_options(*query_args)   (private)
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 892



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, query_options]
end


  








  

    #_verify_match_result(query_args, optional_filter_block)   (private)
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 874



def _verify_match_result(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
  true
end


  








  

    #_verify_multiple(*args, wait: nil, **options)   (private)
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 851



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


  








  

    #_verify_selector_result(query_args, optional_filter_block, query_type = Capybara::Queries::SelectorQuery)   (private)
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 859



def _verify_selector_result(query_args, optional_filter_block, query_type = Capybara::Queries::SelectorQuery)
  # 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
  true
end


  








  

    #_verify_text(type = nil, expected_text, **query_options)   (private)
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 883



def _verify_text(type = nil, expected_text, **query_options) # rubocop:disable Style/OptionalArguments
  query_options[:session_options] = session_options
  query = Capybara::Queries::TextQuery.new(type, expected_text, **query_options)
  synchronize(query.wait) do
    yield query.resolve_for(self), query
  end
  true
end


  








  

    #assert_all_of_selectors([kind = {Capybara.default_selector]}, *locators, **options)    



  

    

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 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 default_max_wait_time) seconds.


  



  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 159



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


  








  

    #assert_ancestor(*args, &optional_filter_block)  
  



  

    

Asserts that a given selector matches an ancestor of the current node.



element.assert_ancestor('p#foo')



Accepts the same options as #assert_selector


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 766



def assert_ancestor(*args, &optional_filter_block)
  _verify_selector_result(args, optional_filter_block, Capybara::Queries::AncestorQuery) do |result, query|
    unless result.matches_count? && (result.any? || query.expects_none?)
      raise Capybara::ExpectationNotMet, result.failure_message
    end
  end
end


  








  

    #assert_any_of_selectors([kind = {Capybara.default_selector]}, *locators, **options)    



  

    

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 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 default_max_wait_time) seconds.


  



  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 201



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
    res = args.map do |locator|
      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

    true
  end
end


  








  

    #assert_matches_selector(*args, &optional_filter_block)  
  



  

    

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 Finders#all accepts, such as :text and :visible.



node.assert_matches_selector('li', text: 'Horse', visible: true)


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 586



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


  








  

    #assert_matches_style(styles = nil, **options)  
  



  

    

Asserts that an element has the specified CSS styles.



element.assert_matches_style( 'color' => 'rgb(0,0,255)', 'font-size' => /px/ )


  





  
Parameters:


    
  
  • 
    styles
    (Hash)
    (defaults to: nil)
  
    • 



Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 126



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
  true
end


  








  

    #assert_no_ancestor(*args, &optional_filter_block)  
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 774



def assert_no_ancestor(*args, &optional_filter_block)
  _verify_selector_result(args, optional_filter_block, Capybara::Queries::AncestorQuery) do |result, query|
    if result.matches_count? && (!result.empty? || query.expects_none?)
      raise Capybara::ExpectationNotMet, result.negative_failure_message
    end
  end
end


  








  

    #assert_no_selector(*args, &optional_filter_block)  
  



  

    

Asserts that a given selector is not on the page or a descendant of the current node. Usage is identical to #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


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 233



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
end


  








  

    #assert_no_sibling(*args, &optional_filter_block)  
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 817



def assert_no_sibling(*args, &optional_filter_block)
  _verify_selector_result(args, optional_filter_block, Capybara::Queries::SiblingQuery) do |result, query|
    if result.matches_count? && (!result.empty? || query.expects_none?)
      raise Capybara::ExpectationNotMet, result.negative_failure_message
    end
  end
end


  








  

    

      #assert_no_text(type, text, **options)  ⇒ true 
      #assert_no_text(text, **options)  ⇒ true 
    

  



  

    

Asserts that the page or current node doesn’t have the given text content, ignoring any Capybara.HTML tags.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 716



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
  end
end


  








  

    #assert_none_of_selectors([kind = {Capybara.default_selector]}, *locators, **options)    



  

    

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 not 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 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 default_max_wait_time) seconds.


  



  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 180



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


  








  

    #assert_not_matches_selector(*args, &optional_filter_block)  
  



  

    

Asserts that the current node does not match a given selector. Usage is identical to #assert_matches_selector.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 600



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


  








  

    #assert_selector(*args, &optional_filter_block)  
  



  

    

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"]')
page.assert_selector(:foo)



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)



This will check if the expression occurs exactly 4 times. See Finders#all for other available result size options.



If a :count of 0 is specified, it will behave like #assert_no_selector; however, use of that method is preferred over this one.



It also accepts all options that Finders#all accepts, such as :text and :visible.



page.assert_selector('li', text: 'Horse', visible: true)



#assert_selector can also accept ::XPath expressions generated by the ::XPath gem:



page.assert_selector(:xpath, XPath.descendant(:p))


  





  
Parameters:


    
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 



Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 109



def assert_selector(*args, &optional_filter_block)
  _verify_selector_result(args, optional_filter_block) do |result, query|
    unless result.matches_count? && (result.any? || query.expects_none?)
      raise Capybara::ExpectationNotMet, result.failure_message
    end
  end
end


  








  

    #assert_sibling(*args, &optional_filter_block)  
  



  

    

Asserts that a given selector matches a sibling of the current node.



element.assert_sibling('p#foo')



Accepts the same options as #assert_selector


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 809



def assert_sibling(*args, &optional_filter_block)
  _verify_selector_result(args, optional_filter_block, Capybara::Queries::SiblingQuery) do |result, query|
    unless result.matches_count? && (result.any? || query.expects_none?)
      raise Capybara::ExpectationNotMet, result.failure_message
    end
  end
end


  








  

    #assert_style(styles = nil, **options)  
  



  

    
Deprecated. 


Use #assert_matches_style instead.




  



  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 139



def assert_style(styles = nil, **options)
  warn 'assert_style is deprecated, please use assert_matches_style instead'
  assert_matches_style(styles, **options)
end


  








  

    

      #assert_text(type, text, **options)  ⇒ true 
      #assert_text(text, **options)  ⇒ true 
    

  



  

    

Asserts that the page or current node has the given text content, ignoring any Capybara.HTML tags.


  





  
Raises:





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 700



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
  end
end


  








  

    #extract_selector(args)   (private)
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 847



def extract_selector(args)
  args.first.is_a?(Symbol) ? args.shift : session_options.default_selector
end


  








  

    #has_ancestor?(*args, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Predicate version of #assert_ancestor


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 786



def has_ancestor?(*args, **options, &optional_filter_block)
  make_predicate(options) { assert_ancestor(*args, options, &optional_filter_block) }
end


  








  

    #has_button?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has a button with the given text, value or id.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The text, value or id of a button to check for
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 383



def has_button?(locator = nil, **options, &optional_filter_block)
  has_selector?(:button, locator, **options, &optional_filter_block)
end


  








  

    #has_checked_field?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has a radio button or checkbox with the given label, value, id, or test_id attribute that is currently checked.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The label, name or id of a checked field
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 448



def has_checked_field?(locator = nil, **options, &optional_filter_block)
  has_selector?(:field, locator, **options.merge(checked: true), &optional_filter_block)
end


  








  

    #has_content?(*args, **options)  
  



  

    

Alias for #has_text?.


  



  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 741



alias_method :has_content?, :has_text?


  








  

    #has_css?(path, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

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)



This will check if the selector occurs exactly 4 times.



It also accepts all options that Finders#all accepts, such as :text and :visible.



page.has_css?('li', text: 'Horse', visible: true)


  





  
Parameters:


    
  
  • 
    path
    (String)
—    
    

    A CSS selector
    

    
  
    • 
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          :count
          (Integer)
           — default:
              nil          
            — 
    

    Number of times the selector should occur
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    If the selector exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 309



def has_css?(path, **options, &optional_filter_block)
  has_selector?(:css, path, **options, &optional_filter_block)
end


  








  

    #has_element?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has a element with the given local name.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The local name of a element to check for
    

    
  
    • 
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          The
          (String, Regexp)
            — 
    

    attributes values of matching elements
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 334



def has_element?(locator = nil, **options, &optional_filter_block)
  has_selector?(:element, locator, **options, &optional_filter_block)
end


  








  

    #has_field?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has a form field with the given label, name or id.



For text fields and other textual fields, such as textareas and 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')



It is also possible to filter by the field type attribute:



page.has_field?('Email', type: 'email')



NOTE: ‘textarea’ and ‘select’ are valid type values, matching the associated tag names.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The label, name or id of a field to check for
    

    
  
    • 
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          :with
          (String, Regexp)
            — 
    

    The text content of the field or a Regexp to match
    

            
    • 
        
  • 
          :type
          (String)
            — 
    

    The type attribute of the field
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 421



def has_field?(locator = nil, **options, &optional_filter_block)
  has_selector?(:field, locator, **options, &optional_filter_block)
end


  








  

    #has_link?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has a link with the given text or id.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The text or id of a link to check for
    

    
  
    • 
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          :href
          (String, Regexp)
            — 
    

    The value the href attribute must be
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 359



def has_link?(locator = nil, **options, &optional_filter_block)
  has_selector?(:link, locator, **options, &optional_filter_block)
end


  








  

    #has_no_ancestor?(*args, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Predicate version of #assert_no_ancestor


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 794



def has_no_ancestor?(*args, **options, &optional_filter_block)
  make_predicate(options) { assert_no_ancestor(*args, options, &optional_filter_block) }
end


  








  

    #has_no_button?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has no button with the given text, value or id.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The text, value or id of a button to check for
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 395



def has_no_button?(locator = nil, **options, &optional_filter_block)
  has_no_selector?(:button, locator, **options, &optional_filter_block)
end


  








  

    #has_no_checked_field?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has no radio button or checkbox with the given label, value or id, or test_id attribute that is currently checked.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The label, name or id of a checked field
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 461



def has_no_checked_field?(locator = nil, **options, &optional_filter_block)
  has_no_selector?(:field, locator, **options.merge(checked: true), &optional_filter_block)
end


  








  

    #has_no_content?(*args, **options)  
  



  

    

Alias for #has_no_text?.


  



  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 753



alias_method :has_no_content?, :has_no_text?


  








  

    #has_no_css?(path, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if a given CSS selector is not on the page or a descendant of the current node. Usage is identical to #has_css?.


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 321



def has_no_css?(path, **options, &optional_filter_block)
  has_no_selector?(:css, path, **options, &optional_filter_block)
end


  








  

    #has_no_element?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has no element with the given local name.


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 346



def has_no_element?(locator = nil, **options, &optional_filter_block)
  has_no_selector?(:element, locator, **options, &optional_filter_block)
end


  








  

    #has_no_field?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has no form field with the given label, name or id. See #has_field?.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The label, name or id of a field to check for
    

    
  
    • 
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          :with
          (String, Regexp)
            — 
    

    The text content of the field or a Regexp to match
    

            
    • 
        
  • 
          :type
          (String)
            — 
    

    The type attribute of the field
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 435



def has_no_field?(locator = nil, **options, &optional_filter_block)
  has_no_selector?(:field, locator, **options, &optional_filter_block)
end


  








  

    #has_no_link?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has no link with the given text or id.


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 371



def has_no_link?(locator = nil, **options, &optional_filter_block)
  has_no_selector?(:link, locator, **options, &optional_filter_block)
end


  








  

    #has_no_select?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has no select field with the given label, name or id. See #has_select?.


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 532



def has_no_select?(locator = nil, **options, &optional_filter_block)
  has_no_selector?(:select, locator, **options, &optional_filter_block)
end


  








  

    #has_no_selector?(*args, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if a given selector is not on the page or a descendant of the current node. Usage is identical to #has_selector?.


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 50



def has_no_selector?(*args, **options, &optional_filter_block)
  make_predicate(options) { assert_no_selector(*args, options, &optional_filter_block) }
end


  








  

    #has_no_sibling?(*args, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Predicate version of #assert_no_sibling


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 837



def has_no_sibling?(*args, **options, &optional_filter_block)
  make_predicate(options) { assert_no_sibling(*args, options, &optional_filter_block) }
end


  








  

    #has_no_table?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has no table with the given id or caption. See #has_table?.


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 566



def has_no_table?(locator = nil, **options, &optional_filter_block)
  has_no_selector?(:table, locator, **options, &optional_filter_block)
end


  








  

    

      #has_no_text?(type, text, **options)  ⇒ Boolean 
      #has_no_text?(text, **options)  ⇒ Boolean 
    

    Also known as: #has_no_content?
  



  

    

Checks if the page or current node does not have the given text content, ignoring any Capybara.HTML tags and normalizing whitespace.


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 750



def has_no_text?(*args, **options)
  make_predicate(options) { assert_no_text(*args, **options) }
end


  








  

    #has_no_unchecked_field?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has no radio button or checkbox with the given label, value or id, or test_id attribute that is currently unchecked.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The label, name or id of an unchecked field
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it doesn’t exist
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 487



def has_no_unchecked_field?(locator = nil, **options, &optional_filter_block)
  has_no_selector?(:field, locator, **options.merge(unchecked: true), &optional_filter_block)
end


  








  

    #has_no_xpath?(path, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if a given ::XPath expression is not on the page or a descendant of the current node. Usage is identical to #has_xpath?.


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 282



def has_no_xpath?(path, **options, &optional_filter_block)
  has_no_selector?(:xpath, path, **options, &optional_filter_block)
end


  








  

    #has_select?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has a select field with the given label, name or id.



It can be specified which option should currently be selected:



page.has_select?('Language', selected: 'German')



For multiple select boxes, several options may be specified:



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'])



You can also check for a partial set of options:



page.has_select?('Language', with_options: ['English', 'German'])


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The label, name or id of a select box
    

    
  
    • 
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          :options
          (Array)
            — 
    

    Options which should be contained in this select box
    

            
    • 
        
  • 
          :with_options
          (Array)
            — 
    

    Partial set of options which should be contained in this select box
    

            
    • 
        
  • 
          :selected
          (String, Array)
            — 
    

    Options which should be selected
    

            
    • 
        
  • 
          :with_selected
          (String, Array)
            — 
    

    Partial set of options which should minimally be selected
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 520



def has_select?(locator = nil, **options, &optional_filter_block)
  has_selector?(:select, locator, **options, &optional_filter_block)
end


  








  

    #has_selector?(*args, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

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"]')
page.has_selector?(:foo)



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)



This will check if the expression occurs exactly 4 times.



It also accepts all options that Finders#all accepts, such as :text and :visible.



page.has_selector?('li', text: 'Horse', visible: true)



#has_selector? can also accept ::XPath expressions generated by the ::XPath gem:



page.has_selector?(:xpath, XPath.descendant(:p))


  





  
Parameters:


    
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          :count
          (Integer)
           — default:
              nil          
            — 
    

    Number of matching elements that should exist
    

            
    • 
        
  • 
          :minimum
          (Integer)
           — default:
              nil          
            — 
    

    Minimum number of matching elements that should exist
    

            
    • 
        
  • 
          :maximum
          (Integer)
           — default:
              nil          
            — 
    

    Maximum number of matching elements that should exist
    

            
    • 
        
  • 
          :between
          (Range)
           — default:
              nil          
            — 
    

    Range of number of matching elements that should exist
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    If the expression exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 38



def has_selector?(*args, **options, &optional_filter_block)
  make_predicate(options) { assert_selector(*args, options, &optional_filter_block) }
end


  








  

    #has_sibling?(*args, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Predicate version of #assert_sibling


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 829



def has_sibling?(*args, **options, &optional_filter_block)
  make_predicate(options) { assert_sibling(*args, options, &optional_filter_block) }
end


  








  

    #has_style?(styles = nil, **options)  ⇒ Boolean 
  



  

    
Deprecated. 


Use #matches_style? instead.




  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 71



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


  








  

    #has_table?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has a table with the given id or caption:



page.has_table?('People')


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The id or caption of a table
    

    
  
    • 
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          :rows
          (Array<Array<String>>)
            — 
    

    Text which should be contained in the tables ‘<td>` elements organized by row (`<td>` visibility is not considered)
    

            
    • 
        
  • 
          :with_rows
          (Array<Array<String>>, Array<Hash<String,String>>)
            — 
    

    Partial set of text which should be contained in the tables ‘<td>` elements organized by row (`<td>` visibility is not considered)
    

            
    • 
        
  • 
          :cols
          (Array<Array<String>>)
            — 
    

    Text which should be contained in the tables ‘<td>` elements organized by column (`<td>` visibility is not considered)
    

            
    • 
        
  • 
          :with_cols
          (Array<Array<String>>, Array<Hash<String,String>>)
            — 
    

    Partial set of text which should be contained in the tables ‘<td>` elements organized by column (`<td>` visibility is not considered)
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 554



def has_table?(locator = nil, **options, &optional_filter_block)
  has_selector?(:table, locator, **options, &optional_filter_block)
end


  








  

    

      #has_text?(type, text, **options)  ⇒ Boolean 
      #has_text?(text, **options)  ⇒ Boolean 
    

    Also known as: #has_content?
  



  

    

Checks if the page or current node has the given text content, ignoring any Capybara.HTML tags.



By default it will check if the text occurs at least once, but a different number can be specified.



page.has_text?('lorem ipsum', between: 2..4)



This will check if the text occurs from 2 to 4 times.


  





  
Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 738



def has_text?(*args, **options)
  make_predicate(options) { assert_text(*args, **options) }
end


  








  

    #has_unchecked_field?(locator = nil, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the page or current node has a radio button or checkbox with the given label, value or id, or test_id attribute that is currently unchecked.


  





  
Parameters:


    
  
  • 
    locator
    (String)
    (defaults to: nil)
—    
    

    The label, name or id of an unchecked field
    

    
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    Whether it exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 474



def has_unchecked_field?(locator = nil, **options, &optional_filter_block)
  has_selector?(:field, locator, **options.merge(unchecked: true), &optional_filter_block)
end


  








  

    #has_xpath?(path, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

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)



This will check if the expression occurs exactly 4 times.



It also accepts all options that Finders#all accepts, such as :text and :visible.



page.has_xpath?('.//li', text: 'Horse', visible: true)



#has_xpath? can also accept ::XPath expressions generated by the ::XPath gem:



xpath = XPath.generate { |x| x.descendant(:p) }
page.has_xpath?(xpath)


  





  
Parameters:


    
  
  • 
    path
    (String)
—    
    

    An XPath expression
    

    
  
    • 
  
  • 
    options
    (Hash)
—    
    

    a customizable set of options
    

    
  
    • 


    
Options Hash (**options):

    
    
        
  • 
          :count
          (Integer)
           — default:
              nil          
            — 
    

    Number of times the expression should occur
    

            
    • 
    


Returns:


    
  
  • 
    (Boolean)
—    
    

    If the expression exists
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 270



def has_xpath?(path, **options, &optional_filter_block)
  has_selector?(:xpath, path, **options, &optional_filter_block)
end


  








  

    #make_predicate(options)   (private)
  

  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 900



def make_predicate(options)
  options[:wait] = 0 unless options.key?(:wait) || session_options.predicates_wait
  yield
rescue Capybara::ExpectationNotMet
  false
end


  








  

    #matches_css?(css, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the current node matches given CSS selector.


  





  
Parameters:


    
  
  • 
    css
    (String)
—    
    

    The CSS selector to match against the current code
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 635



def matches_css?(css, **options, &optional_filter_block)
  matches_selector?(:css, css, **options, &optional_filter_block)
end


  








  

    #matches_selector?(*args, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the current node matches given selector.


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 613



def matches_selector?(*args, **options, &optional_filter_block)
  make_predicate(options) { assert_matches_selector(*args, options, &optional_filter_block) }
end


  








  

    #matches_style?(styles = nil, **options)  ⇒ Boolean 
  



  

    

Checks if a an element has the specified CSS styles.



element.matches_style?( 'color' => 'rgb(0,0,255)', 'font-size' => /px/ )


  





  
Parameters:


    
  
  • 
    styles
    (Hash)
    (defaults to: nil)
  
    • 



Returns:


    
  
  • 
    (Boolean)
—    
    

    If the styles match
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 63



def matches_style?(styles = nil, **options)
  styles, options = options, {} if styles.nil?
  make_predicate(options) { assert_matches_style(styles, **options) }
end


  








  

    #matches_xpath?(xpath, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the current node matches given ::XPath expression.


  





  
Parameters:


    
  
  • 
    xpath
    (String, XPath::Expression)
—    
    

    The XPath expression to match against the current code
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 624



def matches_xpath?(xpath, **options, &optional_filter_block)
  matches_selector?(:xpath, xpath, **options, &optional_filter_block)
end


  








  

    #not_matches_css?(css, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the current node does not match given CSS selector.


  





  
Parameters:


    
  
  • 
    css
    (String)
—    
    

    The CSS selector to match against the current code
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 669



def not_matches_css?(css, **options, &optional_filter_block)
  not_matches_selector?(:css, css, **options, &optional_filter_block)
end


  








  

    #not_matches_selector?(*args, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the current node does not match given selector. Usage is identical to #has_selector?.


  





  


  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 647



def not_matches_selector?(*args, **options, &optional_filter_block)
  make_predicate(options) { assert_not_matches_selector(*args, options, &optional_filter_block) }
end


  








  

    #not_matches_xpath?(xpath, **options, &optional_filter_block)  ⇒ Boolean 
  



  

    

Checks if the current node does not match given ::XPath expression.


  





  
Parameters:


    
  
  • 
    xpath
    (String, XPath::Expression)
—    
    

    The XPath expression to match against the current code
    

    
  
    • 





  [ GitHub ]


  

  


# File 'lib/capybara/node/matchers.rb', line 658



def not_matches_xpath?(xpath, **options, &optional_filter_block)
  not_matches_selector?(:xpath, xpath, **options, &optional_filter_block)
end