capybara 3.8.1 → 3.33.0

data/lib/capybara/result.rb

@@ -7,7 +7,7 @@ module Capybara
   # A {Capybara::Result} represents a collection of {Capybara::Node::Element} on the page. It is possible to interact with this
   # collection similar to an Array because it implements Enumerable and offers the following Array methods through delegation:
   #
-  # * []
+  # * \[\]
   # * each()
   # * at()
   # * size()
@@ -16,6 +16,8 @@ module Capybara
   # * first()
   # * last()
   # * empty?()
+  # * values_at()
+  # * sample()
   #
   # @see Capybara::Node::Element
   #
@@ -26,13 +28,15 @@ module Capybara
     def initialize(elements, query)
       @elements = elements
       @result_cache = []
-      @results_enum = lazy_select_elements { |node| query.matches_filters?(node) }
+      @filter_errors = []
+      @results_enum = lazy_select_elements { |node| query.matches_filters?(node, @filter_errors) }
       @query = query
+      @allow_reload = false
     end
 
     def_delegators :full_results, :size, :length, :last, :values_at, :inspect, :sample
 
-    alias :index :find_index
+    alias index find_index
 
     def each(&block)
       return enum_for(:each) unless block_given?
@@ -40,7 +44,7 @@ module Capybara
       @result_cache.each(&block)
       loop do
         next_result = @results_enum.next
-        @result_cache << next_result
+        add_to_cache(next_result)
         yield next_result
       end
       self
@@ -56,7 +60,12 @@ module Capybara
           nil
         end
       when Range
-        idx.max
+        # idx.max is broken with beginless ranges
+        # idx.end && idx.max # endless range will have end == nil
+        max = idx.end
+        max = nil if max&.negative?
+        max -= 1 if max && idx.exclude_end?
+        max
       end
 
       if max_idx.nil?
@@ -73,27 +82,29 @@ module Capybara
     end
 
     def compare_count
+      return 0 unless @query
+
+      count, min, max, between = @query.options.values_at(:count, :minimum, :maximum, :between)
+
       # Only check filters for as many elements as necessary to determine result
-      if (count = @query.options[:count])
-        count = Integer(count)
+      if count && (count = Integer(count))
         return load_up_to(count + 1) <=> count
       end
 
-      if (min = @query.options[:minimum])
-        min = Integer(min)
+      if min && (min = Integer(min))
         return -1 if load_up_to(min) < min
       end
 
-      if (max = @query.options[:maximum])
-        max = Integer(max)
+      if max && (max = Integer(max))
         return 1 if load_up_to(max + 1) > max
       end
 
-      if (between = @query.options[:between])
-        min, max = between.minmax
-        size = load_up_to(max + 1)
-        return 0 if between.include? size
-        return size <=> min
+      if between
+        min, max = (between.begin && between.min) || 1, between.end
+        max -= 1 if max && between.exclude_end?
+
+        size = load_up_to(max ? max + 1 : min)
+        return size <=> min unless between.include?(size)
       end
 
       0
@@ -108,11 +119,13 @@ module Capybara
       if count.zero?
         message << ' but there were no matches'
       else
-        message << ", found #{count} #{Capybara::Helpers.declension('match', 'matches', count)}: " << full_results.map(&:text).map(&:inspect).join(', ')
+        message << ", found #{count} #{Capybara::Helpers.declension('match', 'matches', count)}: " \
+                << full_results.map(&:text).map(&:inspect).join(', ')
       end
       unless rest.empty?
         elements = rest.map { |el| el.text rescue '<<ERROR>>' }.map(&:inspect).join(', ') # rubocop:disable Style/RescueModifier
-        message << '. Also found ' << elements << ', which matched the selector but not all filters.'
+        message << '. Also found ' << elements << ', which matched the selector but not all filters. '
+        message << @filter_errors.join('. ') if (rest.size == 1) && count.zero?
       end
       message
     end
@@ -125,12 +138,26 @@ module Capybara
       @elements.length
     end
 
+    ##
+    # @api private
+    #
+    def allow_reload!
+      @allow_reload = true
+      self
+    end
+
   private
 
+    def add_to_cache(elem)
+      elem.allow_reload!(@result_cache.size) if @allow_reload
+      @result_cache << elem
+    end
+
     def load_up_to(num)
       loop do
         break if @result_cache.size >= num
-        @result_cache << @results_enum.next
+
+        add_to_cache(@results_enum.next)
       end
       @result_cache.size
     end
@@ -144,13 +171,18 @@ module Capybara
       @rest ||= @elements - full_results
     end
 
-    def lazy_select_elements(&block)
-      # JRuby has an issue with lazy enumerators which
+    if RUBY_PLATFORM == 'java'
+      # JRuby < 9.2.8.0 has an issue with lazy enumerators which
       # causes a concurrency issue with network requests here
       # https://github.com/jruby/jruby/issues/4212
-      if RUBY_PLATFORM == 'java'
+      # while JRuby >= 9.2.8.0 leaks threads when using lazy enumerators
+      # https://github.com/teamcapybara/capybara/issues/2349
+      # so disable the use and JRuby users will need to pay a performance penalty
+      def lazy_select_elements(&block)
         @elements.select(&block).to_enum # non-lazy evaluation
-      else
+      end
+    else
+      def lazy_select_elements(&block)
         @elements.lazy.select(&block)
       end
     end

data/lib/capybara/rspec/features.rb

@@ -14,10 +14,10 @@ RSpec.configure do |config|
 end
 
 RSpec.configure do |config|
-  config.alias_example_group_to :feature, capybara_feature: true, type: :feature
-  config.alias_example_group_to :xfeature, capybara_feature: true, type: :feature, skip: 'Temporarily disabled with xfeature'
-  config.alias_example_group_to :ffeature, capybara_feature: true, type: :feature, focus: true
+  config.alias_example_group_to :feature, :capybara_feature, type: :feature
+  config.alias_example_group_to :xfeature, :capybara_feature, type: :feature, skip: 'Temporarily disabled with xfeature'
+  config.alias_example_group_to :ffeature, :capybara_feature, :focus, type: :feature
   config.alias_example_to :scenario
   config.alias_example_to :xscenario, skip: 'Temporarily disabled with xscenario'
-  config.alias_example_to :fscenario, focus: true
+  config.alias_example_to :fscenario, :focus
 end

data/lib/capybara/rspec/matcher_proxies.rb

@@ -2,32 +2,57 @@
 
 module Capybara
   module RSpecMatcherProxies
-    def all(*args, &block)
+    def all(*args, **kwargs, &block)
       if defined?(::RSpec::Matchers::BuiltIn::All) && args.first.respond_to?(:matches?)
         ::RSpec::Matchers::BuiltIn::All.new(*args)
       else
-        find_all(*args, &block)
+        find_all(*args, **kwargs, &block)
       end
     end
 
-    def within(*args)
+    def within(*args, **kwargs, &block)
       if block_given?
-        within_element(*args, &Proc.new)
+        within_element(*args, **kwargs, &block)
       else
         be_within(*args)
       end
     end
   end
+end
+
+if RUBY_ENGINE == 'jruby'
+  # :nocov:
+  module Capybara::DSL
+    class <<self
+      remove_method :included
 
-  module DSLRSpecProxyInstaller
-    module ClassMethods
       def included(base)
-        if defined?(::RSpec::Matchers)
-          base.include(::Capybara::RSpecMatcherProxies) if base.include?(::RSpec::Matchers)
+        warn 'including Capybara::DSL in the global scope is not recommended!' if base == Object
+        if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
+          base.send(:include, ::Capybara::RSpecMatcherProxies)
         end
         super
       end
     end
+  end
+
+  if defined?(::RSpec::Matchers)
+    module ::RSpec::Matchers
+      def self.included(base)
+        base.send(:include, ::Capybara::RSpecMatcherProxies) if base.include?(::Capybara::DSL)
+        super
+      end
+    end
+  end
+  # :nocov:
+else
+  module Capybara::DSLRSpecProxyInstaller
+    module ClassMethods
+      def included(base)
+        base.include(::Capybara::RSpecMatcherProxies) if defined?(::RSpec::Matchers) && base.include?(::RSpec::Matchers)
+        super
+      end
+    end
 
     def self.prepended(base)
       class <<base
@@ -36,7 +61,7 @@ module Capybara
     end
   end
 
-  module RSpecMatcherProxyInstaller
+  module Capybara::RSpecMatcherProxyInstaller
     module ClassMethods
       def included(base)
         base.include(::Capybara::RSpecMatcherProxies) if base.include?(::Capybara::DSL)
@@ -51,11 +76,7 @@ module Capybara
     end
   end
 
-  DSL.prepend ::Capybara::DSLRSpecProxyInstaller
-end
+  Capybara::DSL.prepend ::Capybara::DSLRSpecProxyInstaller
 
-if defined?(::RSpec::Matchers)
-  module ::RSpec::Matchers
-    prepend ::Capybara::RSpecMatcherProxyInstaller
-  end
+  ::RSpec::Matchers.prepend ::Capybara::RSpecMatcherProxyInstaller if defined?(::RSpec::Matchers)
 end

data/lib/capybara/rspec/matchers/base.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/compound'
+require 'capybara/rspec/matchers/count_sugar'
+require 'capybara/rspec/matchers/spatial_sugar'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class Base
+        include ::Capybara::RSpecMatchers::Matchers::Compound if defined?(::Capybara::RSpecMatchers::Matchers::Compound)
+
+        attr_reader :failure_message, :failure_message_when_negated
+
+        def initialize(*args, **kw_args, &filter_block)
+          @args = args.dup
+          @kw_args = kw_args || {}
+          @filter_block = filter_block
+        end
+
+      private
+
+        def session_query_args
+          # if @args.last.is_a? Hash
+          #   @args.last[:session_options] = session_options
+          # else
+          #   @args.push(session_options: session_options)
+          # end
+          @args
+        end
+
+        def session_query_options
+          @kw_args[:session_options] = session_options
+          @kw_args
+        end
+
+        def session_options
+          @context_el ||= nil
+          if @context_el.respond_to? :session_options
+            @context_el.session_options
+          elsif @context_el.respond_to? :current_scope
+            @context_el.current_scope.session_options
+          else
+            Capybara.session_options
+          end
+        end
+      end
+
+      class WrappedElementMatcher < Base
+        def matches?(actual)
+          element_matches?(wrap(actual))
+        rescue Capybara::ExpectationNotMet => e
+          @failure_message = e.message
+          false
+        end
+
+        def does_not_match?(actual)
+          element_does_not_match?(wrap(actual))
+        rescue Capybara::ExpectationNotMet => e
+          @failure_message_when_negated = e.message
+          false
+        end
+
+      private
+
+        def wrap(actual)
+          actual = actual.to_capybara_node if actual.respond_to?(:to_capybara_node)
+          @context_el = if actual.respond_to?(:has_selector?)
+            actual
+          else
+            Capybara.string(actual.to_s)
+          end
+        end
+      end
+
+      class CountableWrappedElementMatcher < WrappedElementMatcher
+        include ::Capybara::RSpecMatchers::CountSugar
+        include ::Capybara::RSpecMatchers::SpatialSugar
+      end
+
+      class NegatedMatcher
+        include ::Capybara::RSpecMatchers::Matchers::Compound if defined?(::Capybara::RSpecMatchers::Matchers::Compound)
+
+        def initialize(matcher)
+          super()
+          @matcher = matcher
+        end
+
+        def matches?(actual)
+          @matcher.does_not_match?(actual)
+        end
+
+        def does_not_match?(actual)
+          @matcher.matches?(actual)
+        end
+
+        def description
+          "not #{@matcher.description}"
+        end
+
+        def failure_message
+          @matcher.failure_message_when_negated
+        end
+
+        def failure_message_when_negated
+          @matcher.failure_message
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/become_closed.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class BecomeClosed
+        def initialize(options)
+          @options = options
+        end
+
+        def matches?(window)
+          @window = window
+          @wait_time = Capybara::Queries::BaseQuery.wait(@options, window.session.config.default_max_wait_time)
+          timer = Capybara::Helpers.timer(expire_in: @wait_time)
+          while window.exists?
+            return false if timer.expired?
+
+            sleep 0.01
+          end
+          true
+        end
+
+        def failure_message
+          "expected #{@window.inspect} to become closed after #{@wait_time} seconds"
+        end
+
+        def failure_message_when_negated
+          "expected #{@window.inspect} not to become closed after #{@wait_time} seconds"
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/compound.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+if defined?(::RSpec::Expectations::Version)
+  module Capybara
+    module RSpecMatchers
+      module Matchers
+        module Compound
+          include ::RSpec::Matchers::Composable
+
+          def and(matcher)
+            And.new(self, matcher)
+          end
+
+          def and_then(matcher)
+            ::RSpec::Matchers::BuiltIn::Compound::And.new(self, matcher)
+          end
+
+          def or(matcher)
+            Or.new(self, matcher)
+          end
+
+          class CapybaraEvaluator
+            def initialize(actual)
+              @actual = actual
+              @match_results = Hash.new { |hsh, matcher| hsh[matcher] = matcher.matches?(@actual) }
+            end
+
+            def matcher_matches?(matcher)
+              @match_results[matcher]
+            end
+
+            def reset
+              @match_results.clear
+            end
+          end
+
+          # @api private
+          module Synchronizer
+            def match(_expected, actual)
+              @evaluator = CapybaraEvaluator.new(actual)
+              syncer = sync_element(actual)
+              begin
+                syncer.synchronize do
+                  @evaluator.reset
+                  raise ::Capybara::ElementNotFound unless synchronized_match?
+
+                  true
+                end
+              rescue StandardError
+                false
+              end
+            end
+
+            def sync_element(el)
+              if el.respond_to? :synchronize
+                el
+              elsif el.respond_to? :current_scope
+                el.current_scope
+              else
+                Capybara.string(el)
+              end
+            end
+          end
+
+          class And < ::RSpec::Matchers::BuiltIn::Compound::And
+            include Synchronizer
+
+          private
+
+            def synchronized_match?
+              [matcher_1_matches?, matcher_2_matches?].all?
+            end
+          end
+
+          class Or < ::RSpec::Matchers::BuiltIn::Compound::Or
+            include Synchronizer
+
+          private
+
+            def synchronized_match?
+              [matcher_1_matches?, matcher_2_matches?].any?
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/count_sugar.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Capybara
+  module RSpecMatchers
+    module CountSugar
+      def once; exactly(1); end
+      def twice; exactly(2); end
+      def thrice; exactly(3); end
+
+      def exactly(number)
+        options[:count] = number
+        self
+      end
+
+      def at_most(number)
+        options[:maximum] = number
+        self
+      end
+
+      def at_least(number)
+        options[:minimum] = number
+        self
+      end
+
+      def times
+        self
+      end
+
+    private
+
+      def options
+        # (@args.last.is_a?(Hash) ? @args : @args.push({})).last
+        @kw_args
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_ancestor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class HaveAncestor < CountableWrappedElementMatcher
+        def element_matches?(el)
+          el.assert_ancestor(*@args, **session_query_options, &@filter_block)
+        end
+
+        def element_does_not_match?(el)
+          el.assert_no_ancestor(*@args, **session_query_options, &@filter_block)
+        end
+
+        def description
+          "have ancestor #{query.description}"
+        end
+
+        def query
+          # @query ||= Capybara::Queries::AncestorQuery.new(*session_query_args, &@filter_block)
+          @query ||= Capybara::Queries::AncestorQuery.new(*session_query_args, **session_query_options, &@filter_block)
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_current_path.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class HaveCurrentPath < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_current_path(current_path, **@kw_args)
+        end
+
+        def element_does_not_match?(el)
+          el.assert_no_current_path(current_path, **@kw_args)
+        end
+
+        def description
+          "have current path #{current_path.inspect}"
+        end
+
+      private
+
+        def current_path
+          @args.first
+        end
+      end
+    end
+  end
+end

data/lib/capybara/rspec/matchers/have_selector.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'capybara/rspec/matchers/base'
+
+module Capybara
+  module RSpecMatchers
+    module Matchers
+      class HaveSelector < CountableWrappedElementMatcher
+        def initialize(*args, **kw_args, &filter_block)
+          super
+          if (RUBY_VERSION >= '2.7') && (@args.size < 2) && @kw_args.keys.any?(String) # rubocop:disable Style/GuardClause
+            @args.push(@kw_args)
+            @kw_args = {}
+          end
+        end
+
+        def element_matches?(el)
+          el.assert_selector(*@args, **session_query_options, &@filter_block)
+        end
+
+        def element_does_not_match?(el)
+          el.assert_no_selector(*@args, **session_query_options, &@filter_block)
+        end
+
+        def description
+          "have #{query.description}"
+        end
+
+        def query
+          @query ||= Capybara::Queries::SelectorQuery.new(*session_query_args, **session_query_options, &@filter_block)
+        end
+      end
+
+      class HaveAllSelectors < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_all_of_selectors(*@args, **session_query_options, &@filter_block)
+        end
+
+        def does_not_match?(_actual)
+          raise ArgumentError, 'The have_all_selectors matcher does not support use with not_to/should_not'
+        end
+
+        def description
+          'have all selectors'
+        end
+      end
+
+      class HaveNoSelectors < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_none_of_selectors(*@args, **session_query_options, &@filter_block)
+        end
+
+        def does_not_match?(_actual)
+          raise ArgumentError, 'The have_none_of_selectors matcher does not support use with not_to/should_not'
+        end
+
+        def description
+          'have no selectors'
+        end
+      end
+
+      class HaveAnySelectors < WrappedElementMatcher
+        def element_matches?(el)
+          el.assert_any_of_selectors(*@args, **session_query_options, &@filter_block)
+        end
+
+        def does_not_match?(_actual)
+          el.assert_none_of_selectors(*@args, **session_query_options, &@filter_block)
+        end
+
+        def description
+          'have any selectors'
+        end
+      end
+    end
+  end
+end