capybara 2.15.1 → 3.36.0

data/lib/capybara/registrations/patches/puma_ssl.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Puma
+  module MiniSSL
+    class Socket
+      def read_nonblock(size, *_)
+        wait_states = %i[wait_readable wait_writable]
+
+        loop do
+          output = engine_read_all
+          return output if output
+
+          data = @socket.read_nonblock(size, exception: false)
+          raise IO::EAGAINWaitReadable if wait_states.include? data
+          return nil if data.nil?
+
+          @engine.inject(data)
+          output = engine_read_all
+
+          return output if output
+
+          while (neg_data = @engine.extract)
+            @socket.write neg_data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/registrations/servers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+Capybara.register_server :default do |app, port, _host|
+  Capybara.run_default_server(app, port)
+end
+
+Capybara.register_server :webrick do |app, port, host, **options|
+  require 'rack/handler/webrick'
+  options = { Host: host, Port: port, AccessLog: [], Logger: WEBrick::Log.new(nil, 0) }.merge(options)
+  Rack::Handler::WEBrick.run(app, **options)
+end
+
+Capybara.register_server :puma do |app, port, host, **options|
+  begin
+    require 'rack/handler/puma'
+  rescue LoadError
+    raise LoadError, 'Capybara is unable to load `puma` for its server, please add `puma` to your project or specify a different server via something like `Capybara.server = :webrick`.'
+  else
+    unless Rack::Handler::Puma.respond_to?(:config)
+      raise LoadError, 'Capybara requires `puma` version 3.8.0 or higher, please upgrade `puma` or register and specify your own server block'
+    end
+  end
+
+  # If we just run the Puma Rack handler it installs signal handlers which prevent us from being able to interrupt tests.
+  # Therefore construct and run the Server instance ourselves.
+  # Rack::Handler::Puma.run(app, { Host: host, Port: port, Threads: "0:4", workers: 0, daemon: false }.merge(options))
+  default_options = { Host: host, Port: port, Threads: '0:4', workers: 0, daemon: false }
+  options = default_options.merge(options)
+
+  conf = Rack::Handler::Puma.config(app, options)
+  conf.clamp
+  events = conf.options[:Silent] ? ::Puma::Events.strings : ::Puma::Events.stdio
+
+  puma_ver = Gem::Version.new(Puma::Const::PUMA_VERSION)
+  require_relative 'patches/puma_ssl' if Gem::Requirement.new('>=4.0.0', '< 4.1.0').satisfied_by?(puma_ver)
+
+  events.log 'Capybara starting Puma...'
+  events.log "* Version #{Puma::Const::PUMA_VERSION} , codename: #{Puma::Const::CODE_NAME}"
+  events.log "* Min threads: #{conf.options[:min_threads]}, max threads: #{conf.options[:max_threads]}"
+
+  Puma::Server.new(conf.app, events, conf.options).tap do |s|
+    s.binder.parse conf.options[:binds], s.events
+    s.min_threads, s.max_threads = conf.options[:min_threads], conf.options[:max_threads]
+  end.run.join
+end

data/lib/capybara/result.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
+
 require 'forwardable'
 
 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,35 +28,52 @@ 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?
+      return enum_for(:each) unless block
 
       @result_cache.each(&block)
       loop do
         next_result = @results_enum.next
-        @result_cache << next_result
-        block.call(next_result)
+        add_to_cache(next_result)
+        yield next_result
       end
       self
     end
 
     def [](*args)
-      if (args.size == 1) && ((idx = args[0]).is_a? Integer) && (idx >= 0)
-        @result_cache << @results_enum.next while @result_cache.size <= idx
-        @result_cache[idx]
-      else
+      idx, length = args
+      max_idx = case idx
+      when Integer
+        if idx.negative?
+          nil
+        else
+          length.nil? ? idx : idx + length - 1
+        end
+      when Range
+        # 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?
         full_results[*args]
+      else
+        load_up_to(max_idx + 1)
+        @result_cache[*args]
       end
-    rescue StopIteration
-      return nil
     end
     alias :at :[]
 
@@ -62,57 +81,47 @@ module Capybara
       !any?
     end
 
-    def matches_count?
+    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 @query.options[:count]
-        count_opt = Integer(@query.options[:count])
-        loop do
-          break if @result_cache.size > count_opt
-          @result_cache << @results_enum.next
-        end
-        return @result_cache.size == count_opt
+      if count && (count = Integer(count))
+        return load_up_to(count + 1) <=> count
       end
 
-      if @query.options[:minimum]
-        min_opt = Integer(@query.options[:minimum])
-        begin
-          @result_cache << @results_enum.next while @result_cache.size < min_opt
-        rescue StopIteration
-          return false
-        end
-      end
+      return -1 if min && (min = Integer(min)) && (load_up_to(min) < min)
 
-      if @query.options[:maximum]
-        max_opt = Integer(@query.options[:maximum])
-        begin
-          @result_cache << @results_enum.next while @result_cache.size <= max_opt
-          return false
-        rescue StopIteration
-        end
-      end
+      return 1 if max && (max = Integer(max)) && (load_up_to(max + 1) > max)
 
-      if @query.options[:between]
-        max =  Integer(@query.options[:between].max)
-        loop do
-          break if @result_cache.size > max
-          @result_cache << @results_enum.next
-        end
-        return false unless (@query.options[:between] === @result_cache.size)
+      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
 
-      return true
+      0
+    end
+
+    def matches_count?
+      compare_count.zero?
     end
 
     def failure_message
       message = @query.failure_message
-      if count > 0
-        message << ", found #{count} #{Capybara::Helpers.declension("match", "matches", count)}: " << full_results.map(&:text).map(&:inspect).join(", ")
+      if count.zero?
+        message << ' but there were no matches'
       else
-        message << " but there were no matches"
+        message << ", found #{count} #{Capybara::Helpers.declension('match', 'matches', count)}: " \
+                << full_results.map(&:text).map(&:inspect).join(', ')
       end
       unless rest.empty?
-        elements = rest.map(&:text).map(&:inspect).join(", ")
-        message << ". Also found " << elements << ", which matched the selector but not all filters."
+        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 << @filter_errors.join('. ') if (rest.size == 1) && count.zero?
       end
       message
     end
@@ -121,7 +130,33 @@ module Capybara
       failure_message.sub(/(to find)/, 'not \1')
     end
 
-    private
+    def unfiltered_size
+      @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
+
+        add_to_cache(@results_enum.next)
+      end
+      @result_cache.size
+    end
 
     def full_results
       loop { @result_cache << @results_enum.next }
@@ -132,20 +167,19 @@ 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'
-        @elements.select(&block).to_enum  # non-lazy evaluation
-      elsif @elements.respond_to? :lazy  #Ruby 2.0+
+      # 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
+      end
+    else
+      def lazy_select_elements(&block)
         @elements.lazy.select(&block)
-      else
-        Enumerator.new do |yielder|
-          @elements.each do |val|
-            yielder.yield(val) if block.call(val)
-          end
-        end
       end
     end
   end

data/lib/capybara/rspec/features.rb

@@ -1,56 +1,23 @@
 # frozen_string_literal: true
-if RSpec::Core::Version::STRING.to_f >= 3.0
-  RSpec.shared_context "Capybara Features", capybara_feature: true do
-    instance_eval do
-      alias background before
-      alias given let
-      alias given! let!
-    end
-  end
-
-  # ensure shared_context is included if default shared_context_metadata_behavior is changed
-  if RSpec::Core::Version::STRING.to_f >= 3.5
-    RSpec.configure do |config|
-      config.include_context "Capybara Features", capybara_feature: true
-    end
-  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_to :scenario
-    config.alias_example_to :xscenario, skip: "Temporarily disabled with xscenario"
-    config.alias_example_to :fscenario, focus: true
+RSpec.shared_context 'Capybara Features', capybara_feature: true do
+  instance_eval do
+    alias background before
+    alias given let
+    alias given! let!
   end
-else
-  module Capybara
-    module Features
-      def self.included(base)
-        base.instance_eval do
-          alias :background :before
-          alias :scenario :it
-          alias :xscenario :xit
-          alias :given :let
-          alias :given! :let!
-          alias :feature :describe
-        end
-      end
-    end
-  end
-
-  def self.feature(*args, &block)
-    options = if args.last.is_a?(Hash) then args.pop else {} end
-    options[:capybara_feature] = true
-    options[:type] = :feature
-    options[:caller] ||= caller
-    args.push(options)
+end
 
-    #call describe on RSpec in case user has expose_dsl_globally set to false
-    RSpec.describe(*args, &block)
-  end
+# ensure shared_context is included if default shared_context_metadata_behavior is changed
+RSpec.configure do |config|
+  config.include_context 'Capybara Features', capybara_feature: true if config.respond_to?(:include_context)
+end
 
-  RSpec.configure do |config|
-    config.include(Capybara::Features, capybara_feature: true)
-  end
+RSpec.configure do |config|
+  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
 end

data/lib/capybara/rspec/matcher_proxies.rb

@@ -1,45 +1,82 @@
 # frozen_string_literal: true
+
 module Capybara
   module RSpecMatcherProxies
-    def all(*args)
+    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)
+        find_all(*args, **kwargs, &block)
       end
     end
 
-    def within(*args)
-      if block_given?
-        within_element(*args, &Proc.new)
+    def within(*args, **kwargs, &block)
+      if block
+        within_element(*args, **kwargs, &block)
       else
         be_within(*args)
       end
     end
   end
+end
 
-  module DSL
-    class <<self
+if RUBY_ENGINE == 'jruby'
+  # :nocov:
+  module Capybara::DSL
+    class << self
       remove_method :included
 
       def included(base)
-        warn "including Capybara::DSL in the global scope is not recommended!" if base == Object
-
+        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
-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
 
-if defined?(::RSpec::Matchers)
-  module  ::RSpec::Matchers
-    def self.included(base)
-      base.send(:include, ::Capybara::RSpecMatcherProxies) if base.include?(::Capybara::DSL)
-      super
+    def self.prepended(base)
+      class << base
+        prepend ClassMethods
+      end
+    end
+  end
+
+  module Capybara::RSpecMatcherProxyInstaller
+    module ClassMethods
+      def included(base)
+        base.include(::Capybara::RSpecMatcherProxies) if base.include?(::Capybara::DSL)
+        super
+      end
+    end
+
+    def self.prepended(base)
+      class << base
+        prepend ClassMethods
+      end
     end
   end
+
+  Capybara::DSL.prepend ::Capybara::DSLRSpecProxyInstaller
+
+  ::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