capybara 2.3.0 → 2.4.0

data/lib/capybara/node/matchers.rb

@@ -91,8 +91,11 @@ module Capybara
       def assert_selector(*args)
         query = Capybara::Query.new(*args)
         synchronize(query.wait) do
-          result = all(*args)
-          raise Capybara::ExpectationNotMet, result.failure_message if result.size == 0 && !Capybara::Helpers.expects_none?(query.options)
+          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))
+            raise Capybara::ExpectationNotMet, result.failure_message
+          end
         end
         return true
       end
@@ -116,19 +119,14 @@ module Capybara
       def assert_no_selector(*args)
         query = Capybara::Query.new(*args)
         synchronize(query.wait) do
-          begin
-            result = all(*args)
-          rescue Capybara::ExpectationNotMet => e
-            return true
-          else
-            if result.size > 0 || (result.size == 0 && Capybara::Helpers.expects_none?(query.options))
-              raise(Capybara::ExpectationNotMet, result.negative_failure_message)
-            end
+          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))
+            raise Capybara::ExpectationNotMet, result.negative_failure_message
           end
         end
         return true
       end
-
       alias_method :refute_selector, :assert_no_selector
 
       ##
@@ -215,58 +213,6 @@ module Capybara
         has_no_selector?(:css, path, options)
       end
 
-      ##
-      #
-      # Checks if the page or current node has the given text content,
-      # ignoring any HTML tags and normalizing whitespace.
-      #
-      # 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.
-      #
-      # @overload has_text?([type], text, [options])
-      #   @param [:all, :visible] type               Whether to check for only visible or all text
-      #   @param [String, Regexp] text               The text/regexp to check for
-      #   @param [Hash] options                      additional options
-      #   @option options [Integer] :count (nil)     Number of times the text should occur
-      #   @option options [Integer] :minimum (nil)   Minimum number of times the text should occur
-      #   @option options [Integer] :maximum (nil)   Maximum number of times the text should occur
-      #   @option options [Range]   :between (nil)   Range of times that should contain number of times text occurs
-      #   @return [Boolean]                          Whether it exists
-      #
-      def has_text?(*args)
-        query = Capybara::Query.new(*args)
-        synchronize(query.wait) do
-          raise ExpectationNotMet unless text_found?(*args)
-        end
-        return true
-      rescue Capybara::ExpectationNotMet
-        return false
-      end
-      alias_method :has_content?, :has_text?
-
-      ##
-      #
-      # Checks if the page or current node does not have the given text
-      # content, ignoring any HTML tags and normalizing whitespace.
-      #
-      # @param             (see #has_text?)
-      # @return [Boolean]  Whether it doesn't exist
-      #
-      def has_no_text?(*args)
-        query = Capybara::Query.new(*args)
-        synchronize(query.wait) do
-          raise ExpectationNotMet if text_found?(*args)
-        end
-        return true
-      rescue Capybara::ExpectationNotMet
-        return false
-      end
-      alias_method :has_no_content?, :has_no_text?
-
       ##
       #
       # Checks if the page or current node has a link with the given
@@ -479,18 +425,102 @@ module Capybara
         has_no_selector?(:table, locator, options)
       end
 
-      def ==(other)
-        self.eql?(other) or (other.respond_to?(:base) and base == other.base)
+      ##
+      # 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 [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_wait_time)      Time that Capybara will wait for text to eq/match given string/regexp argument
+      #   @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
+      #     @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_wait_time)      Time that Capybara will wait for text to eq/match given string/regexp argument
+      # @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))
+            raise Capybara::ExpectationNotMet, query.failure_message
+          end
+        end
+        return true
       end
 
-    private
+      ##
+      # Asserts that the page or current node doesn't have the given text content,
+      # ignoring any HTML tags.
+      #
+      # @macro text_query_params
+      # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
+      # @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))
+            raise Capybara::ExpectationNotMet, query.negative_failure_message
+          end
+        end
+        return true
+      end
 
-      def text_found?(*args)
-        type = args.shift if args.first.is_a?(Symbol) or args.first.nil?
-        content, options = args
-        count = Capybara::Helpers.normalize_whitespace(text(type)).scan(Capybara::Helpers.to_regexp(content)).count
+      ##
+      # Checks if the page or current node has the given text content,
+      # ignoring any HTML tags.
+      #
+      # Whitespaces are normalized in both node's text and passed text parameter.
+      # Note that whitespace isn't normalized in passed regexp as normalizing whitespace
+      # in regexp isn't easy and doesn't seem to be worth it.
+      #
+      # 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.
+      #
+      # @macro text_query_params
+      # @return [Boolean]                            Whether it exists
+      #
+      def has_text?(*args)
+        assert_text(*args)
+      rescue Capybara::ExpectationNotMet
+        return false
+      end
+      alias_method :has_content?, :has_text?
 
-        Capybara::Helpers.matches_count?(count, {:minimum=>1}.merge(options || {}))
+      ##
+      # Checks if the page or current node does not have the given text
+      # content, ignoring any HTML tags and normalizing whitespace.
+      #
+      # @macro text_query_params
+      # @return [Boolean]  Whether it doesn't exist
+      #
+      def has_no_text?(*args)
+        assert_no_text(*args)
+      rescue Capybara::ExpectationNotMet
+        return false
+      end
+      alias_method :has_no_content?, :has_no_text?
+
+      def ==(other)
+        self.eql?(other) || (other.respond_to?(:base) && base == other.base)
       end
     end
   end

data/lib/capybara/node/simple.rb

@@ -14,6 +14,7 @@ module Capybara
     class Simple
       include Capybara::Node::Finders
       include Capybara::Node::Matchers
+      include Capybara::Node::DocumentMatchers
 
       attr_reader :native
 
@@ -148,25 +149,18 @@ module Capybara
         native.xpath("//title").first.text
       end
 
-      def has_title?(content)
-        title.match(Capybara::Helpers.to_regexp(content))
+      def inspect
+        %(#<Capybara::Node::Simple tag="#{tag_name}" path="#{path}">)
       end
 
-      def has_no_title?(content)
-        not has_title?(content)
+      # @api private
+      def find_css(css)
+        native.css(css)
       end
 
-    private
-
-      def resolve_query(query, exact=nil)
-        elements = if query.selector.format == :css
-          native.css(query.css)
-        else
-          native.xpath(query.xpath(exact))
-        end.map do |node|
-          self.class.new(node)
-        end
-        Capybara::Result.new(elements, query)
+      # @api private
+      def find_xpath(xpath)
+        native.xpath(xpath)
       end
     end
   end

data/lib/capybara/queries/base_query.rb

@@ -0,0 +1,29 @@
+module Capybara
+  # @api private
+  module Queries
+    class BaseQuery
+      COUNT_KEYS = [:count, :minimum, :maximum, :between]
+
+      attr_reader :options
+
+      def wait
+        if @options.has_key?(:wait)
+          @options[:wait] || 0
+        else
+          Capybara.default_wait_time
+        end
+      end
+
+      private
+
+      def assert_valid_keys
+        invalid_keys = @options.keys - valid_keys
+        unless invalid_keys.empty?
+          invalid_names = invalid_keys.map(&:inspect).join(", ")
+          valid_names = valid_keys.map(&:inspect).join(", ")
+          raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
+        end
+      end
+    end
+  end
+end

data/lib/capybara/queries/text_query.rb

@@ -0,0 +1,56 @@
+module Capybara
+  # @api private
+  module Queries
+    class TextQuery < BaseQuery
+      def initialize(*args)
+        @type = args.shift if args.first.is_a?(Symbol) || args.first.nil?
+        @expected_text, @options = args
+        unless @expected_text.is_a?(Regexp)
+          @expected_text = Capybara::Helpers.normalize_whitespace(@expected_text)
+        end
+        @search_regexp = Capybara::Helpers.to_regexp(@expected_text)
+        @options ||= {}
+        assert_valid_keys
+
+        # this is needed to not break existing tests that may use keys supported by `Query` but not supported by `TextQuery`
+        # can be removed in next minor version (> 2.4)
+        invalid_keys = @options.keys - (COUNT_KEYS + [:wait])
+        unless invalid_keys.empty?
+          invalid_names = invalid_keys.map(&:inspect).join(", ")
+          valid_names = valid_keys.map(&:inspect).join(", ")
+          warn "invalid keys #{invalid_names}, should be one of #{valid_names}"
+        end
+      end
+
+      def resolve_for(node)
+        @actual_text = Capybara::Helpers.normalize_whitespace(node.text(@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
+
+        message = Capybara::Helpers.failure_message(description, @options)
+        unless (COUNT_KEYS & @options.keys).empty?
+          message << " but found #{@count} #{Capybara::Helpers.declension('time', 'times', @count)}"
+        end
+        message << " in #{@actual_text.inspect}"
+      end
+
+      def negative_failure_message
+        failure_message.sub(/(to find)/, 'not \1')
+      end
+
+      private
+
+      def valid_keys
+        Capybara::Query::VALID_KEYS # can be changed to COUNT_KEYS + [:wait] in next minor version (> 2.4)
+      end
+    end
+  end
+end

data/lib/capybara/queries/title_query.rb

@@ -0,0 +1,40 @@
+module Capybara
+  # @api private
+  module Queries
+    class TitleQuery < BaseQuery
+      def initialize(expected_title, options = {})
+        @expected_title = expected_title
+        @options = options
+        unless @expected_title.is_a?(Regexp)
+          @expected_title = Capybara::Helpers.normalize_whitespace(@expected_title)
+        end
+        @search_regexp = Capybara::Helpers.to_regexp(@expected_title)
+        assert_valid_keys
+      end
+
+      def resolves_for?(node)
+        @actual_title = node.title
+        @actual_title.match(@search_regexp)
+      end
+
+      def failure_message
+        failure_message_helper
+      end
+
+      def negative_failure_message
+        failure_message_helper(' not')
+      end
+
+      private
+
+      def failure_message_helper(negated = '')
+        verb = (@expected_title.is_a?(Regexp))? 'match' : 'include'
+        "expected #{@actual_title.inspect}#{negated} to #{verb} #{@expected_title.inspect}"
+      end
+
+      def valid_keys
+        [:wait]
+      end
+    end
+  end
+end

data/lib/capybara/query.rb

@@ -1,5 +1,7 @@
 module Capybara
-  class Query
+  # @deprecated This class and its methods are not supposed to be used by users of Capybara's public API.
+  #   It may be removed in future versions of Capybara.
+  class Query < Queries::BaseQuery
     attr_accessor :selector, :locator, :options, :expression, :find, :negative
 
     VALID_KEYS = [:text, :visible, :between, :count, :maximum, :minimum, :exact, :match, :wait]
@@ -23,7 +25,7 @@ module Capybara
       end
 
       @expression = @selector.call(@locator)
-      assert_valid_keys!
+      assert_valid_keys
     end
 
     def name; selector.name; end
@@ -32,7 +34,7 @@ module Capybara
     def description
       @description = "#{label} #{locator.inspect}"
       @description << " with text #{options[:text].inspect}" if options[:text]
-      @description << " with value #{options[:with].inspect}" if options[:with]
+      @description << selector.description(options)
       @description
     end
 
@@ -70,14 +72,6 @@ module Capybara
       end
     end
 
-    def wait
-      if options.has_key?(:wait)
-        @options[:wait] or 0
-      else
-        Capybara.default_wait_time
-      end
-    end
-
     def exact?
       if options.has_key?(:exact)
         @options[:exact]
@@ -107,16 +101,32 @@ module Capybara
       @expression
     end
 
-  private
-
-    def assert_valid_keys!
-      valid_keys = VALID_KEYS + @selector.custom_filters.keys
-      invalid_keys = @options.keys - valid_keys
-      unless invalid_keys.empty?
-        invalid_names = invalid_keys.map(&:inspect).join(", ")
-        valid_names = valid_keys.map(&:inspect).join(", ")
-        raise ArgumentError, "invalid keys #{invalid_names}, should be one of #{valid_names}"
+    # @api private
+    def resolve_for(node, exact = nil)
+      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
+
+    private
+
+    def valid_keys
+      COUNT_KEYS + [:text, :visible, :exact, :match, :wait] + @selector.custom_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