capybara 2.5.0 → 2.18.0

data/lib/capybara/node/simple.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Capybara
   module Node
 
@@ -75,7 +76,7 @@ module Capybara
       #
       def value
         if tag_name == 'textarea'
-          native.content
+          native['_capybara_raw_value']
         elsif tag_name == 'select'
           if native['multiple'] == 'multiple'
             native.xpath(".//option[@selected='selected']").map { |option| option[:value] || option.content  }
@@ -99,6 +100,8 @@ module Capybara
       # @return [Boolean]     Whether the element is visible
       #
       def visible?(check_ancestors = true)
+        return false if (tag_name == 'input') && (native[:type]=="hidden")
+
         if check_ancestors
           #check size because oldest supported nokogiri doesnt support xpath boolean() function
           native.xpath("./ancestor-or-self::*[contains(@style, 'display:none') or contains(@style, 'display: none') or @hidden or name()='script' or name()='head']").size() == 0
@@ -115,7 +118,7 @@ module Capybara
       # @return [Boolean]     Whether the element is checked
       #
       def checked?
-        native[:checked]
+        native.has_attribute?('checked')
       end
 
       ##
@@ -124,7 +127,7 @@ module Capybara
       #
       # @return [Boolean]     Whether the element is disabled
       def disabled?
-        native[:disabled]
+        native.has_attribute?('disabled')
       end
 
       ##
@@ -134,7 +137,7 @@ module Capybara
       # @return [Boolean]     Whether the element is selected
       #
       def selected?
-        native[:selected]
+        native.has_attribute?('selected')
       end
 
       def synchronize(seconds=nil)
@@ -145,6 +148,9 @@ module Capybara
         # no op
       end
 
+      ##
+      #
+      # @return [String]     The title of the document
       def title
         if native.respond_to? :title
           native.title
@@ -167,6 +173,11 @@ module Capybara
       def find_xpath(xpath)
         native.xpath(xpath)
       end
+
+      # @api private
+      def session_options
+        Capybara.session_options
+      end
     end
   end
 end

data/lib/capybara/queries/ancestor_query.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Capybara
+  module Queries
+    class AncestorQuery < MatchQuery
+      # @api private
+      def resolve_for(node, exact = nil)
+        @child_node = node
+        node.synchronize do
+          match_results = super(node.session.current_scope, exact)
+          node.all(:xpath, XPath.ancestor) do |el|
+            match_results.include?(el)
+          end
+        end
+      end
+
+      def description
+        desc = super
+        if @child_node && (child_query = @child_node.instance_variable_get(:@query))
+          desc += " that is an ancestor of #{child_query.description}"
+        end
+        desc
+      end
+    end
+  end
+end

data/lib/capybara/queries/base_query.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Capybara
   # @api private
   module Queries
@@ -5,17 +6,82 @@ module Capybara
       COUNT_KEYS = [:count, :minimum, :maximum, :between]
 
       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
 
       def wait
-        if @options.has_key?(:wait)
-          @options[:wait] || 0
+        self.class.wait(options, session_options.default_max_wait_time)
+      end
+
+      def self.wait(options, default=Capybara.default_max_wait_time)
+        options.fetch(:wait, default) || 0
+      end
+
+      ##
+      #
+      # Checks if a count of 0 is valid for the query
+      # Returns false if query does not have any count options specified.
+      #
+      def expects_none?
+        if COUNT_KEYS.any? { |k| options.has_key? k }
+          matches_count?(0)
         else
-          Capybara.default_max_wait_time
+          false
         end
       end
 
+      ##
+      #
+      # Checks if the given count matches the query count options.
+      # Defaults to true if no count options are specified. If multiple
+      # count options exist, it tests that all conditions are met;
+      # however, if :count is specified, all other options are ignored.
+      #
+      # @param [Integer] count     The actual number. Should be coercible via Integer()
+      #
+      def matches_count?(count)
+        return (Integer(options[:count]) == count)     if options[:count]
+        return false if options[:maximum] && (Integer(options[:maximum]) < count)
+        return false if options[:minimum] && (Integer(options[:minimum]) > count)
+        return false if options[:between] && !(options[:between] === count)
+        return true
+      end
+
+      ##
+      #
+      # Generates a failure message from the query description and count options.
+      #
+      def failure_message
+        String.new("expected to find #{description}") << count_message
+      end
+
+      def negative_failure_message
+        String.new("expected not to find #{description}") << count_message
+      end
+
       private
 
+      def count_message
+        message = String.new()
+        if options[:count]
+          message << " #{options[:count]} #{Capybara::Helpers.declension('time', 'times', options[:count])}"
+        elsif options[:between]
+          message << " between #{options[:between].first} and #{options[:between].last} times"
+        elsif options[:maximum]
+          message << " at most #{options[:maximum]} #{Capybara::Helpers.declension('time', 'times', options[:maximum])}"
+        elsif options[:minimum]
+          message << " at least #{options[:minimum]} #{Capybara::Helpers.declension('time', 'times', options[:minimum])}"
+        end
+        message
+      end
+
       def assert_valid_keys
         invalid_keys = @options.keys - valid_keys
         unless invalid_keys.empty?

data/lib/capybara/queries/current_path_query.rb

@@ -1,30 +1,39 @@
+# frozen_string_literal: true
+require 'addressable/uri'
+
 module Capybara
   # @api private
   module Queries
     class CurrentPathQuery < BaseQuery
       def initialize(expected_path, options = {})
+        super(options)
         @expected_path = expected_path
+        warn "DEPRECATED: The :only_path option is deprecated in favor of the :ignore_query option" if options.has_key?(:only_path)
+
         @options = {
-          url: false,
-          only_path: false }.merge(options)
+          url: !@expected_path.is_a?(Regexp) && !::Addressable::URI.parse(@expected_path || "").hostname.nil?,
+          only_path: false,
+          ignore_query: false }.merge(options)
         assert_valid_keys
       end
 
       def resolves_for?(session)
+        uri = ::Addressable::URI.parse(session.current_url)
+        uri.query = nil if uri && options[:ignore_query]
         @actual_path = if options[:url]
-          session.current_url
+          uri.to_s
         else
           if options[:only_path]
-            URI.parse(session.current_url).path
+            uri && uri.path
           else
-            URI.parse(session.current_url).request_uri
+            uri && uri.request_uri
           end
         end
 
         if @expected_path.is_a? Regexp
-          @actual_path.match(@expected_path)
+          @actual_path.to_s.match(@expected_path)
         else
-          @expected_path == @actual_path
+          ::Addressable::URI.parse(@expected_path) == ::Addressable::URI.parse(@actual_path)
         end
       end
 
@@ -44,7 +53,7 @@ module Capybara
       end
 
       def valid_keys
-        [:wait, :url, :only_path]
+        [:wait, :url, :only_path, :ignore_query]
       end
 
       def assert_valid_keys

data/lib/capybara/queries/match_query.rb

@@ -0,0 +1,19 @@
+module Capybara
+  module Queries
+    class MatchQuery < Capybara::Queries::SelectorQuery
+      def visible
+        if options.has_key?(:visible)
+          super
+        else
+          :all
+        end
+      end
+
+      private
+
+      def valid_keys
+        super - COUNT_KEYS
+      end
+    end
+  end
+end

data/lib/capybara/queries/selector_query.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+module Capybara
+  module Queries
+    class SelectorQuery < Queries::BaseQuery
+      attr_accessor :selector, :locator, :options, :expression, :find, :negative
+
+      VALID_KEYS = COUNT_KEYS + [:text, :id, :class, :visible, :exact, :exact_text, :match, :wait, :filter_set]
+      VALID_MATCH = [:first, :smart, :prefer_exact, :one]
+
+      def initialize(*args, &filter_block)
+        @resolved_node = nil
+        @options = if args.last.is_a?(Hash) then args.pop.dup else {} end
+        super(@options)
+
+        @filter_block = filter_block
+
+        if args[0].is_a?(Symbol)
+          @selector = Selector.all.fetch(args.shift) do |selector_type|
+            raise ArgumentError, "Unknown selector type (:#{selector_type})"
+          end
+          @locator = args.shift
+        else
+          @selector = Selector.all.values.find { |s| s.match?(args[0]) }
+          @locator = args.shift
+        end
+        @selector ||= Selector.all[session_options.default_selector]
+
+        warn "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
+
+        # for compatibility with Capybara 2.0
+        if session_options.exact_options and @selector == Selector.all[:option]
+          @options[:exact] = true
+        end
+
+        @expression = @selector.call(@locator, @options.merge(enable_aria_label: session_options.enable_aria_label))
+
+        warn_exact_usage
+
+        assert_valid_keys
+      end
+
+      def name; selector.name; end
+      def label; selector.label or selector.name; end
+
+      def description
+        @description = String.new()
+        @description << "visible " if visible == :visible
+        @description << "non-visible " if visible == :hidden
+        @description << "#{label} #{locator.inspect}"
+        @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 << selector.description(options)
+        @description << " that also matches the custom filter block" if @filter_block
+        @description << " within #{@resolved_node.inspect}" if describe_within?
+        @description
+      end
+
+      def matches_filters?(node)
+        if options[:text]
+          regexp = if options[:text].is_a?(Regexp)
+            options[:text]
+          else
+            if exact_text == true
+              /\A#{Regexp.escape(options[:text].to_s)}\z/
+            else
+              Regexp.escape(options[:text].to_s)
+            end
+          end
+          text_visible = visible
+          text_visible = :all if text_visible == :hidden
+          return false if not node.text(text_visible).match(regexp)
+        end
+
+        if exact_text.is_a?(String)
+          regexp = /\A#{Regexp.escape(options[:exact_text])}\z/
+          text_visible = visible
+          text_visible = :all if text_visible == :hidden
+          return false if not node.text(text_visible).match(regexp)
+        end
+
+        case visible
+          when :visible then return false unless node.visible?
+          when :hidden then return false if node.visible?
+        end
+
+        res = node_filters.all? do |name, filter|
+          if options.has_key?(name)
+            filter.matches?(node, options[name])
+          elsif filter.default?
+            filter.matches?(node, filter.default)
+          else
+            true
+          end
+        end
+
+        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
+        case (vis = options.fetch(:visible){ @selector.default_visibility(session_options.ignore_hidden_elements) })
+          when true then :visible
+          when false then :all
+          else vis
+        end
+      end
+
+      def exact?
+        return false if !supports_exact?
+        options.fetch(:exact, session_options.exact)
+      end
+
+      def match
+        options.fetch(:match, session_options.match)
+      end
+
+      def xpath(exact=nil)
+        exact = self.exact? if exact.nil?
+        expr = apply_expression_filters(@expression)
+        expr = if expr.respond_to?(:to_xpath) and exact
+          expr.to_xpath(:exact)
+        else
+          expr.to_s
+        end
+        filtered_xpath(expr)
+      end
+
+      def css
+        filtered_css(apply_expression_filters(@expression))
+      end
+
+      # @api private
+      def resolve_for(node, exact = nil)
+        @resolved_node = node
+        node.synchronize do
+          children = if selector.format == :css
+            node.find_css(self.css)
+          else
+            node.find_xpath(self.xpath(exact))
+          end.map do |child|
+            if node.is_a?(Capybara::Node::Base)
+              Capybara::Node::Element.new(node.session, child, node, self)
+            else
+              Capybara::Node::Simple.new(child)
+            end
+          end
+          Capybara::Result.new(children, self)
+        end
+      end
+
+      # @api private
+      def supports_exact?
+        @expression.respond_to? :to_xpath
+      end
+
+      private
+
+      def valid_keys
+        VALID_KEYS + custom_keys
+      end
+
+      def node_filters
+        if options.has_key?(:filter_set)
+          ::Capybara::Selector::FilterSet.all[options[:filter_set]].node_filters
+        else
+          @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 ||= node_filters.keys + expression_filters.keys
+      end
+
+      def assert_valid_keys
+        super
+        unless VALID_MATCH.include?(match)
+          raise ArgumentError, "invalid option #{match.inspect} for :match, should be one of #{VALID_MATCH.map(&:inspect).join(", ")}"
+        end
+      end
+
+      def filtered_xpath(expr)
+        if options.has_key?(:id) || options.has_key?(:class)
+          expr = "(#{expr})"
+          expr = "#{expr}[#{XPath.attr(:id) == options[:id]}]" if options.has_key?(:id) && !custom_keys.include?(:id)
+          if options.has_key?(:class) && !custom_keys.include?(:class)
+            class_xpath = Array(options[:class]).map do |klass|
+              "contains(concat(' ',normalize-space(@class),' '),' #{klass} ')"
+            end.join(" and ")
+            expr = "#{expr}[#{class_xpath}]"
+          end
+        end
+        expr
+      end
+
+      def filtered_css(expr)
+        if options.has_key?(:id) || options.has_key?(:class)
+          css_selectors = expr.split(',').map(&:rstrip)
+          expr = css_selectors.map do |sel|
+           sel += "##{Capybara::Selector::CSS.escape(options[:id])}" if options.has_key?(:id) && !custom_keys.include?(:id)
+           sel += Array(options[:class]).map { |k| ".#{Capybara::Selector::CSS.escape(k)}"}.join if options.has_key?(:class) && !custom_keys.include?(:class)
+           sel
+          end.join(", ")
+        end
+        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}\" has no effect."
+        end
+      end
+
+      def exact_text
+        options.fetch(:exact_text, session_options.exact_text)
+      end
+
+      def describe_within?
+        @resolved_node && !(@resolved_node.is_a?(::Capybara::Node::Document) ||
+                            (@resolved_node.is_a?(::Capybara::Node::Simple) && @resolved_node.path == '/'))
+      end
+    end
+  end
+end

data/lib/capybara/queries/sibling_query.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module Capybara
+  module Queries
+    class SiblingQuery < MatchQuery
+      # @api private
+      def resolve_for(node, exact = nil)
+        @sibling_node = node
+        node.synchronize do
+          match_results = super(node.session.current_scope, exact)
+          node.all(:xpath, XPath.preceding_sibling.union(XPath.following_sibling)) do |el|
+            match_results.include?(el)
+          end
+        end
+      end
+
+      def description
+        desc = super
+        if @sibling_node && (sibling_query = @sibling_node.instance_variable_get(:@query))
+          desc += " that is a sibling of #{sibling_query.description}"
+        end
+        desc
+      end
+    end
+  end
+end

data/lib/capybara/queries/text_query.rb

@@ -1,46 +1,97 @@
+# frozen_string_literal: true
 module Capybara
   # @api private
   module Queries
     class TextQuery < BaseQuery
       def initialize(*args)
         @type = (args.first.is_a?(Symbol) || args.first.nil?) ? args.shift : nil
-        @expected_text, @options = args
+        # @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
+        super(@options)
+
+        @type = (session_options.ignore_hidden_elements or session_options.visible_text_only) ? :visible : :all if @type.nil?
+
+        @expected_text = args.shift
         unless @expected_text.is_a?(Regexp)
           @expected_text = Capybara::Helpers.normalize_whitespace(@expected_text)
         end
-        @search_regexp = Capybara::Helpers.to_regexp(@expected_text)
-        @options ||= {}
+        @search_regexp = Capybara::Helpers.to_regexp(@expected_text, nil, exact?)
+        warn "Unused parameters passed to #{self.class.name} : #{args}" unless args.empty?
         assert_valid_keys
       end
 
       def resolve_for(node)
-        @actual_text = Capybara::Helpers.normalize_whitespace(node.text(@type))
+        @node = node
+        @actual_text = text(node, @type)
         @count = @actual_text.scan(@search_regexp).size
       end
 
       def failure_message
-        description =
-          if @expected_text.is_a?(Regexp)
-            "text matching #{@expected_text.inspect}"
-          else
-            "text #{@expected_text.inspect}"
-          end
+        super << build_message(true)
+      end
+
+      def negative_failure_message
+        super << build_message(false)
+      end
+
+      def description
+        if @expected_text.is_a?(Regexp)
+          "text matching #{@expected_text.inspect}"
+        else
+          "#{"exact " if exact?}text #{@expected_text.inspect}"
+        end
+      end
+
+      private
+
+      def exact?
+        options.fetch(:exact, session_options.exact_text)
+      end
 
-        message = Capybara::Helpers.failure_message(description, @options)
+      def build_message(report_on_invisible)
+        message = String.new()
         unless (COUNT_KEYS & @options.keys).empty?
           message << " but found #{@count} #{Capybara::Helpers.declension('time', 'times', @count)}"
         end
         message << " in #{@actual_text.inspect}"
+
+        details_message = []
+
+        if @node and !@expected_text.is_a? Regexp
+          insensitive_regexp = Capybara::Helpers.to_regexp(@expected_text, Regexp::IGNORECASE)
+          insensitive_count = @actual_text.scan(insensitive_regexp).size
+          if insensitive_count != @count
+            details_message << "it was found #{insensitive_count} #{Capybara::Helpers.declension("time", "times", insensitive_count)} using a case insensitive search"
+          end
+        end
+
+        if @node and check_visible_text? and report_on_invisible
+          begin
+            invisible_text = text(@node, :all)
+            invisible_count = invisible_text.scan(@search_regexp).size
+            if invisible_count != @count
+              details_message << "it was found #{invisible_count} #{Capybara::Helpers.declension("time", "times", invisible_count)} including non-visible text"
+            end
+          rescue
+            # An error getting the non-visible text (if element goes out of scope) should not affect the response
+          end
+        end
+
+        message << ". (However, #{details_message.join(' and ')}.)" unless details_message.empty?
+
+        message
       end
 
-      def negative_failure_message
-        failure_message.sub(/(to find)/, 'not \1')
+      def valid_keys
+        COUNT_KEYS + [:wait, :exact]
       end
 
-      private
+      def check_visible_text?
+        @type == :visible
+      end
 
-      def valid_keys
-        COUNT_KEYS + [:wait]
+      def text(node, query_type)
+        Capybara::Helpers.normalize_whitespace(node.text(query_type))
       end
     end
   end

data/lib/capybara/queries/title_query.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Capybara
   # @api private
   module Queries
@@ -5,10 +6,11 @@ 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
-        @search_regexp = Capybara::Helpers.to_regexp(@expected_title)
+        @search_regexp = Capybara::Helpers.to_regexp(@expected_title, nil, options.fetch(:exact, false))
         assert_valid_keys
       end
 
@@ -33,7 +35,7 @@ module Capybara
       end
 
       def valid_keys
-        [:wait]
+        [:wait, :exact]
       end
     end
   end