capybara 2.14.0 → 2.14.1

data/lib/capybara/queries/base_query.rb

@@ -8,6 +8,10 @@ module Capybara
       attr_reader :options
       attr_writer :session_options
 
+      def initialize(options)
+        @session_options = options.delete(:session_options)
+      end
+
       def session_options
         @session_options || Capybara.session_options
       end

data/lib/capybara/queries/current_path_query.rb

@@ -6,6 +6,7 @@ module Capybara
   module Queries
     class CurrentPathQuery < BaseQuery
       def initialize(expected_path, options = {})
+        super(options)
         @expected_path = expected_path
         @options = {
           url: false,

data/lib/capybara/queries/selector_query.rb

@@ -9,7 +9,7 @@ module Capybara
 
       def initialize(*args, &filter_block)
         @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-        self.session_options = @options.delete(:session_options)
+        super(@options)
 
         @filter_block = filter_block
 
@@ -47,7 +47,7 @@ module Capybara
         @description << " with#{" exact" if exact_text == true} text #{options[:text].inspect}" if options[:text]
         @description << " with exact text #{options[:exact_text]}" if options[:exact_text].is_a?(String)
         @description << " with id #{options[:id]}" if options[:id]
-        @description << " with classes #{Array(options[:class]).join(',')}]" if options[:class]
+        @description << " with classes [#{Array(options[:class]).join(',')}]" if options[:class]
         @description << selector.description(options)
         @description << " that also matches the custom filter block" if @filter_block
         @description
@@ -81,7 +81,7 @@ module Capybara
           when :hidden then return false if node.visible?
         end
 
-        res = query_filters.all? do |name, filter|
+        res = node_filters.all? do |name, filter|
           if options.has_key?(name)
             filter.matches?(node, options[name])
           elsif filter.default?
@@ -91,8 +91,16 @@ module Capybara
           end
         end
 
-        res &&= node.session.using_wait_time(0){ @filter_block.call(node)} unless @filter_block.nil?
+        res &&= if node.respond_to?(:session)
+          node.session.using_wait_time(0){ @filter_block.call(node) }
+        else
+          @filter_block.call(node)
+        end unless @filter_block.nil?
+
         res
+
+      rescue *(node.respond_to?(:session) ? node.session.driver.invalid_element_errors : [])
+        return false
       end
 
       def visible
@@ -114,16 +122,17 @@ module Capybara
 
       def xpath(exact=nil)
         exact = self.exact? if exact.nil?
-        expr = if @expression.respond_to?(:to_xpath) and exact
-          @expression.to_xpath(:exact)
+        expr = apply_expression_filters(@expression)
+        expr = if expr.respond_to?(:to_xpath) and exact
+          expr.to_xpath(:exact)
         else
-          @expression.to_s
+          expr.to_s
         end
         filtered_xpath(expr)
       end
 
       def css
-        filtered_css(@expression)
+        filtered_css(apply_expression_filters(@expression))
       end
 
       # @api private
@@ -155,16 +164,22 @@ module Capybara
         VALID_KEYS + custom_keys
       end
 
-      def query_filters
+      def node_filters
         if options.has_key?(:filter_set)
-          Capybara::Selector::FilterSet.all[options[:filter_set]].filters
+          ::Capybara::Selector::FilterSet.all[options[:filter_set]].node_filters
         else
-          @selector.custom_filters
+          @selector.node_filters
         end
       end
 
+      def expression_filters
+        filters = @selector.expression_filters
+        filters.merge ::Capybara::Selector::FilterSet.all[options[:filter_set]].expression_filters if options.has_key?(:filter_set)
+        filters
+      end
+
       def custom_keys
-        @custom_keys ||= query_filters.keys + @selector.expression_filters
+        @custom_keys ||= node_filters.keys + expression_filters.keys
       end
 
       def assert_valid_keys
@@ -200,6 +215,18 @@ module Capybara
         expr
       end
 
+      def apply_expression_filters(expr)
+        expression_filters.inject(expr) do |memo, (name, ef)|
+          if options.has_key?(name)
+            ef.apply_filter(memo, options[name])
+          elsif ef.default?
+            ef.apply_filter(memo, ef.default)
+          else
+            memo
+          end
+        end
+      end
+
       def warn_exact_usage
         if options.has_key?(:exact) && !supports_exact?
           warn "The :exact option only has an effect on queries using the XPath#is method. Using it with the query \"#{expression.to_s}\" has no effect."

data/lib/capybara/queries/text_query.rb

@@ -7,7 +7,7 @@ module Capybara
         @type = (args.first.is_a?(Symbol) || args.first.nil?) ? args.shift : nil
         # @type = (Capybara.ignore_hidden_elements or Capybara.visible_text_only) ? :visible : :all if @type.nil?
         @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
-        self.session_options = @options.delete(:session_options)
+        super(@options)
 
         @type = (session_options.ignore_hidden_elements or session_options.visible_text_only) ? :visible : :all if @type.nil?
 

data/lib/capybara/queries/title_query.rb

@@ -6,6 +6,7 @@ module Capybara
       def initialize(expected_title, options = {})
         @expected_title = expected_title
         @options = options
+        super(@options)
         unless @expected_title.is_a?(Regexp)
           @expected_title = Capybara::Helpers.normalize_whitespace(@expected_title)
         end

data/lib/capybara/rack_test/driver.rb

@@ -15,6 +15,7 @@ class Capybara::RackTest::Driver < Capybara::Driver::Base
 
   def initialize(app, options={})
     raise ArgumentError, "rack-test requires a rack application, but none was given" unless app
+    @session = nil
     @app = app
     @options = DEFAULT_OPTIONS.merge(options)
   end

data/lib/capybara/rspec/matcher_proxies.rb

@@ -19,14 +19,18 @@ module Capybara
   end
 
   module DSL
-    def self.included(base)
-      warn "including Capybara::DSL in the global scope is not recommended!" if base == Object
+    class <<self
+      remove_method :included
 
-      if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
-        base.send(:include, ::Capybara::RSpecMatcherProxies)
-      end
+      def included(base)
+        warn "including Capybara::DSL in the global scope is not recommended!" if base == Object
 
-      super
+        if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
+          base.send(:include, ::Capybara::RSpecMatcherProxies)
+        end
+
+        super
+      end
     end
   end
 end

data/lib/capybara/rspec/matchers.rb

@@ -44,6 +44,7 @@ module Capybara
       end
 
       def session_options
+        @context_el ||= nil
         @context_el ? @context_el.session_options : Capybara.session_options
       end
     end
@@ -195,10 +196,14 @@ module Capybara
       alias_method :failure_message_for_should_not, :failure_message_when_negated
     end
 
+    # RSpec matcher for whether the element(s) matching a given selector exist
+    # See {Capybara::Node::Matcher#assert_selector}
     def have_selector(*args, &optional_filter_block)
       HaveSelector.new(*args, &optional_filter_block)
     end
 
+    # RSpec matcher for whether the current element matches a given selector
+    # See {Capybara::Node::Matchers#assert_matches_selector}
     def match_selector(*args, &optional_filter_block)
       MatchSelector.new(*args, &optional_filter_block)
     end
@@ -207,22 +212,30 @@ module Capybara
     ::RSpec::Matchers.define_negated_matcher :not_match_selector, :match_selector if defined?(::RSpec::Expectations::Version) && (Gem::Version.new(RSpec::Expectations::Version::STRING) >= Gem::Version.new('3.1'))
 
 
+    # RSpec matcher for whether elements(s) matching a given xpath selector exist
+    # See {Capybara::Node::Matchers#has_xpath?}
     def have_xpath(xpath, options={}, &optional_filter_block)
       HaveSelector.new(:xpath, xpath, options, &optional_filter_block)
     end
 
+    # RSpec matcher for whether the current element matches a given xpath selector
     def match_xpath(xpath, options={}, &optional_filter_block)
       MatchSelector.new(:xpath, xpath, options, &optional_filter_block)
     end
 
+    # RSpec matcher for whether elements(s) matching a given css selector exist
+    # See {Capybara::Node::Matchers#has_css?}
     def have_css(css, options={}, &optional_filter_block)
       HaveSelector.new(:css, css, options, &optional_filter_block)
     end
 
+    # RSpec matcher for whether the current element matches a given css selector
     def match_css(css, options={}, &optional_filter_block)
       MatchSelector.new(:css, css, options, &optional_filter_block)
     end
 
+    # RSpec matcher for text on the page
+    # See {Capybara::SessionMatchers#assert_text}
     def have_text(*args)
       HaveText.new(*args)
     end
@@ -232,40 +245,56 @@ module Capybara
       HaveTitle.new(title, options)
     end
 
+    # RSpec matcher for the current path
+    # See {Capybara::SessionMatchers#assert_current_path}
     def have_current_path(path, options = {})
       HaveCurrentPath.new(path, options)
     end
 
+    # RSpec matcher for links
+    # See {Capybara::Node::Matchers#has_link?}
     def have_link(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:link, locator, options, &optional_filter_block)
     end
 
+    # RSpec matcher for buttons
+    # See {Capybara::Node::Matchers#has_button?}
     def have_button(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:button, locator, options, &optional_filter_block)
     end
 
+    # RSpec matcher for links
+    # See {Capybara::Node::Matchers#has_field?}
     def have_field(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:field, locator, options, &optional_filter_block)
     end
 
+    # RSpec matcher for checked fields
+    # See {Capybara::Node::Matchers#has_checked_field?}
     def have_checked_field(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:field, locator, options.merge(checked: true), &optional_filter_block)
     end
 
+    # RSpec matcher for unchecked fields
+    # See {Capybara::Node::Matchers#has_unchecked_field?}
     def have_unchecked_field(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:field, locator, options.merge(unchecked: true), &optional_filter_block)
     end
 
+    # RSpec matcher for select elements
+    # See {Capybara::Node::Matchers#has_select?}
     def have_select(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:select, locator, options, &optional_filter_block)
     end
 
+    # RSpec matcher for table elements
+    # See {Capybara::Node::Matchers#has_table?}
     def have_table(locator=nil, options={}, &optional_filter_block)
       locator, options = nil, locator if locator.is_a? Hash
       HaveSelector.new(:table, locator, options, &optional_filter_block)

data/lib/capybara/selector.rb

@@ -6,6 +6,9 @@ Capybara::Selector::FilterSet.add(:_field) do
   filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| not(value ^ node.disabled?) }
   filter(:multiple, :boolean) { |node, value| !(value ^ node.multiple?) }
 
+  expression_filter(:name) { |xpath, val| xpath[XPath.attr(:name).equals(val)] }
+  expression_filter(:placeholder) { |xpath, val| xpath[XPath.attr(:placeholder).equals(val)] }
+
   describe do |options|
     desc, states = String.new, []
     states << 'checked' if options[:checked] || (options[:unchecked] == false)
@@ -65,21 +68,21 @@ end
 # @filter [Boolean] :disabled Match disabled field?
 # @filter [Boolean] :multiple Match fields that accept multiple values
 Capybara.add_selector(:field) do
-  xpath(:name, :placeholder, :type) do |locator, options|
+  xpath do |locator, options|
     xpath = XPath.descendant(:input, :textarea, :select)[~XPath.attr(:type).one_of('submit', 'image', 'hidden')]
-    if options[:type]
-      type=options[:type].to_s
-      if ['textarea', 'select'].include?(type)
-        xpath = XPath.descendant(type.to_sym)
-      else
-        xpath = xpath[XPath.attr(:type).equals(type)]
-      end
+    locate_field(xpath, locator, options)
+  end
+
+  expression_filter(:type) do |expr, type|
+    type = type.to_s
+    if ['textarea', 'select'].include?(type)
+      expr.axis(:self, type.to_sym)
+    else
+      expr[XPath.attr(:type).equals(type)]
     end
-    xpath=locate_field(xpath, locator, options)
-    xpath
   end
 
-  filter_set(:_field) # checked/unchecked/disabled/multiple
+  filter_set(:_field) # checked/unchecked/disabled/multiple/name/placeholder
 
   filter(:readonly, :boolean) { |node, value| not(value ^ node.readonly?) }
   filter(:with) do |node, with|
@@ -87,7 +90,7 @@ Capybara.add_selector(:field) do
   end
   describe do |options|
     desc = String.new
-    (expression_filters - [:type]).each { |ef| desc << " with #{ef} #{options[ef]}" if options.has_key?(ef) }
+    (expression_filters.keys - [:type]).each { |ef| desc << " with #{ef} #{options[ef]}" if options.has_key?(ef) }
     desc << " of type #{options[:type].inspect}" if options[:type]
     desc << " with value #{options[:with].to_s.inspect}" if options.has_key?(:with)
     desc
@@ -107,7 +110,7 @@ end
 Capybara.add_selector(:fieldset) do
   xpath(:legend) do |locator, options|
     xpath = XPath.descendant(:fieldset)
-    xpath = xpath[XPath.attr(:id).equals(locator.to_s) | XPath.child(:legend)[XPath.string.n.is(locator.to_s)]] unless locator.nil?
+    xpath = xpath[XPath.attr(:id).equals(locator.to_s).or XPath.child(:legend)[XPath.string.n.is(locator.to_s)]] unless locator.nil?
     xpath = xpath[XPath.child(:legend)[XPath.string.n.is(options[:legend])]] if options[:legend]
     xpath
   end
@@ -135,11 +138,11 @@ Capybara.add_selector(:link) do
     end
     unless locator.nil?
       locator = locator.to_s
-      matchers = XPath.attr(:id).equals(locator) |
-                 XPath.string.n.is(locator) |
-                 XPath.attr(:title).is(locator) |
-                 XPath.descendant(:img)[XPath.attr(:alt).is(locator)]
-      matchers |= XPath.attr(:'aria-label').is(locator) if options[:enable_aria_label]
+      matchers = XPath.attr(:id).equals(locator).or(
+                 XPath.string.n.is(locator)).or(
+                 XPath.attr(:title).is(locator)).or(
+                 XPath.descendant(:img)[XPath.attr(:alt).is(locator)])
+      matchers = matchers.or XPath.attr(:'aria-label').is(locator) if options[:enable_aria_label]
       xpath = xpath[matchers]
     end
     xpath = [:title].inject(xpath) { |memo, ef| memo[find_by_attr(ef, options[ef])] }
@@ -184,21 +187,21 @@ Capybara.add_selector(:button) do
 
     unless locator.nil?
       locator = locator.to_s
-      locator_matches = XPath.attr(:id).equals(locator) | XPath.attr(:value).is(locator) | XPath.attr(:title).is(locator)
-      locator_matches |= XPath.attr(:'aria-label').is(locator) if options[:enable_aria_label]
+      locator_matches = XPath.attr(:id).equals(locator).or XPath.attr(:value).is(locator).or XPath.attr(:title).is(locator)
+      locator_matches = locator_matches.or XPath.attr(:'aria-label').is(locator) if options[:enable_aria_label]
 
       input_btn_xpath = input_btn_xpath[locator_matches]
 
-      btn_xpath = btn_xpath[locator_matches | XPath.string.n.is(locator) | XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
+      btn_xpath = btn_xpath[locator_matches.or XPath.string.n.is(locator).or XPath.descendant(:img)[XPath.attr(:alt).is(locator)]]
 
       alt_matches = XPath.attr(:alt).is(locator)
-      alt_matches |= XPath.attr(:'aria-label').is(locator) if options[:enable_aria_label]
+      alt_matches = alt_matches.or XPath.attr(:'aria-label').is(locator) if options[:enable_aria_label]
       image_btn_xpath = image_btn_xpath[alt_matches]
     end
 
-    res_xpath = input_btn_xpath + btn_xpath + image_btn_xpath
+    res_xpath = input_btn_xpath.union(btn_xpath).union(image_btn_xpath)
 
-    res_xpath = expression_filters.inject(res_xpath) { |memo, ef| memo[find_by_attr(ef, options[ef])] }
+    res_xpath = expression_filters.keys.inject(res_xpath) { |memo, ef| memo[find_by_attr(ef, options[ef])] }
 
     res_xpath
   end
@@ -220,7 +223,7 @@ end
 Capybara.add_selector(:link_or_button) do
   label "link or button"
   xpath do |locator, options|
-    self.class.all.values_at(:link, :button).map {|selector| selector.xpath.call(locator, options)}.reduce(:+)
+    self.class.all.values_at(:link, :button).map {|selector| selector.xpath.call(locator, options)}.reduce(:union)
   end
 
   filter(:disabled, :boolean, default: false, skip_if: :all) { |node, value| node.tag_name == "a" or not(value ^ node.disabled?) }
@@ -244,20 +247,21 @@ end
 #
 Capybara.add_selector(:fillable_field) do
   label "field"
-  xpath(:name, :placeholder, :type) do |locator, options|
+  xpath do |locator, options|
     xpath = XPath.descendant(:input, :textarea)[~XPath.attr(:type).one_of('submit', 'image', 'radio', 'checkbox', 'hidden', 'file')]
-    if options[:type]
-      type=options[:type].to_s
-      if ['textarea'].include?(type)
-        xpath = XPath.descendant(type.to_sym)
-      else
-        xpath = xpath[XPath.attr(:type).equals(type)]
-      end
-    end
     locate_field(xpath, locator, options)
   end
 
-  filter_set(:_field, [:disabled, :multiple])
+  expression_filter(:type) do |expr, type|
+    type = type.to_s
+    if ['textarea'].include?(type)
+      expr.axis(:self, type.to_sym)
+    else
+      expr[XPath.attr(:type).equals(type)]
+    end
+  end
+
+  filter_set(:_field, [:disabled, :multiple, :name, :placeholder])
 
   filter(:with) do |node, with|
     with.is_a?(Regexp) ? node.value =~ with : node.value == with.to_s
@@ -286,12 +290,12 @@ end
 #
 Capybara.add_selector(:radio_button) do
   label "radio button"
-  xpath(:name) do |locator, options|
+  xpath do |locator, options|
     xpath = XPath.descendant(:input)[XPath.attr(:type).equals('radio')]
     locate_field(xpath, locator, options)
   end
 
-  filter_set(:_field, [:checked, :unchecked, :disabled])
+  filter_set(:_field, [:checked, :unchecked, :disabled, :name])
 
   filter(:option)  { |node, value|  node.value == value.to_s }
 
@@ -317,12 +321,12 @@ end
 # @filter [String] :option Match the value
 #
 Capybara.add_selector(:checkbox) do
-  xpath(:name) do |locator, options|
+  xpath do |locator, options|
     xpath = XPath.descendant(:input)[XPath.attr(:type).equals('checkbox')]
     locate_field(xpath, locator, options)
   end
 
-  filter_set(:_field, [:checked, :unchecked, :disabled])
+  filter_set(:_field, [:checked, :unchecked, :disabled, :name])
 
   filter(:option)  { |node, value|  node.value == value.to_s }
 
@@ -348,15 +352,16 @@ end
 # @filter [Array<String>] :options Exact match options
 # @filter [Array<String>] :with_options Partial match options
 # @filter [String, Array<String>] :selected Match the selection(s)
+# @filter [String, Array<String>] :with_selected Partial match the selection(s)
 #
 Capybara.add_selector(:select) do
   label "select box"
-  xpath(:name, :placeholder) do |locator, options|
+  xpath do |locator, options|
     xpath = XPath.descendant(:select)
     locate_field(xpath, locator, options)
   end
 
-  filter_set(:_field, [:disabled, :multiple])
+  filter_set(:_field, [:disabled, :multiple, :name, :placeholder])
 
   filter(:options) do |node, options|
     if node.visible?
@@ -376,8 +381,13 @@ Capybara.add_selector(:select) do
   end
 
   filter(:selected) do |node, selected|
-    actual = node.all(:xpath, './/option', visible: false).select { |option| option.selected? }.map { |option| option.text(:all) }
-    [selected].flatten.sort == actual.sort
+    actual = node.all(:xpath, './/option', visible: false).select(&:selected?).map { |option| option.text(:all) }
+    Array(selected).sort == actual.sort
+  end
+
+  filter(:with_selected) do |node, selected|
+    actual = node.all(:xpath, './/option', visible: false).select(&:selected?).map { |option| option.text(:all) }
+    (Array(selected) - actual).empty?
   end
 
   describe do |options|
@@ -385,6 +395,7 @@ Capybara.add_selector(:select) do
     desc << " with options #{options[:options].inspect}" if options[:options]
     desc << " with at least options #{options[:with_options].inspect}" if options[:with_options]
     desc << " with #{options[:selected].inspect} selected" if options[:selected]
+    desc << " with at least #{options[:with_selected].inspect} selected" if options[:with_selected]
     desc << describe_all_expression_filters(options)
     desc
   end
@@ -429,12 +440,12 @@ end
 #
 Capybara.add_selector(:file_field) do
   label "file field"
-  xpath(:name) do |locator, options|
+  xpath do |locator, options|
     xpath = XPath.descendant(:input)[XPath.attr(:type).equals('file')]
     locate_field(xpath, locator, options)
   end
 
-  filter_set(:_field, [:disabled, :multiple])
+  filter_set(:_field, [:disabled, :multiple, :name])
 
   describe do |options|
     desc = String.new
@@ -454,7 +465,7 @@ Capybara.add_selector(:label) do
   label "label"
   xpath(:for) do |locator, options|
     xpath = XPath.descendant(:label)
-    xpath = xpath[XPath.string.n.is(locator.to_s) | XPath.attr(:id).equals(locator.to_s)] unless locator.nil?
+    xpath = xpath[XPath.string.n.is(locator.to_s).or XPath.attr(:id).equals(locator.to_s)] unless locator.nil?
     if options.has_key?(:for) && !options[:for].is_a?(Capybara::Node::Element)
       xpath = xpath[XPath.attr(:for).equals(options[:for].to_s).or((~XPath.attr(:for)).and(XPath.descendant()[XPath.attr(:id).equals(options[:for].to_s)]))]
     end
@@ -493,7 +504,7 @@ end
 Capybara.add_selector(:table) do
   xpath(:caption) do |locator, options|
     xpath = XPath.descendant(:table)
-    xpath = xpath[XPath.attr(:id).equals(locator.to_s) | XPath.descendant(:caption).is(locator.to_s)] unless locator.nil?
+    xpath = xpath[XPath.attr(:id).equals(locator.to_s).or XPath.descendant(:caption).is(locator.to_s)] unless locator.nil?
     xpath = xpath[XPath.descendant(:caption).equals(options[:caption])] if options[:caption]
     xpath
   end
@@ -516,9 +527,9 @@ end
 #
 Capybara.add_selector(:frame) do
   xpath(:name) do |locator, options|
-    xpath = XPath.descendant(:iframe) + XPath.descendant(:frame)
-    xpath = xpath[XPath.attr(:id).equals(locator.to_s) | XPath.attr(:name).equals(locator)] unless locator.nil?
-    xpath = expression_filters.inject(xpath) { |memo, ef| memo[find_by_attr(ef, options[ef])] }
+    xpath = XPath.descendant(:iframe).union(XPath.descendant(:frame))
+    xpath = xpath[XPath.attr(:id).equals(locator.to_s).or XPath.attr(:name).equals(locator)] unless locator.nil?
+    xpath = expression_filters.keys.inject(xpath) { |memo, ef| memo[find_by_attr(ef, options[ef])] }
     xpath
   end