capybara 2.7.0 → 3.35.3

data/lib/capybara/selenium/patches/action_pauser.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActionPauser
+  def initialize(mouse, keyboard)
+    super
+    @devices[:pauser] = Pauser.new
+  end
+
+  def pause(duration)
+    @actions << [:pauser, :pause, [duration]]
+    self
+  end
+
+  class Pauser
+    def pause(duration)
+      sleep duration
+    end
+  end
+
+  private_constant :Pauser
+end
+
+if defined?(::Selenium::WebDriver::VERSION) && (::Selenium::WebDriver::VERSION.to_f < 4) &&
+   defined?(::Selenium::WebDriver::ActionBuilder)
+  ::Selenium::WebDriver::ActionBuilder.prepend(ActionPauser)
+end

data/lib/capybara/selenium/patches/atoms.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module CapybaraAtoms
+private
+
+  def read_atom(function)
+    @atoms ||= Hash.new do |hash, key|
+      hash[key] = begin
+        File.read(File.expand_path("../../atoms/#{key}.min.js", __FILE__))
+      rescue Errno::ENOENT
+        super
+      end
+    end
+    @atoms[function]
+  end
+end
+
+::Selenium::WebDriver::Remote::Bridge.prepend CapybaraAtoms unless ENV['DISABLE_CAPYBARA_SELENIUM_OPTIMIZATIONS']

data/lib/capybara/selenium/patches/is_displayed.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Selenium
+    module IsDisplayed
+      def commands(command)
+        case command
+        when :is_element_displayed
+          [:get, 'session/:session_id/element/:id/displayed']
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/capybara/selenium/patches/logs.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Selenium
+    module ChromeLogs
+      LOG_MSG = <<~MSG
+        Chromedriver 75+ defaults to W3C mode. Please upgrade to chromedriver >= \
+        75.0.3770.90 if you need to access logs while in W3C compliant mode.
+      MSG
+
+      COMMANDS = {
+        get_available_log_types: [:get, 'session/:session_id/se/log/types'],
+        get_log: [:post, 'session/:session_id/se/log'],
+        get_log_legacy: [:post, 'session/:session_id/log']
+      }.freeze
+
+      def commands(command)
+        COMMANDS[command] || super
+      end
+
+      def available_log_types
+        types = execute :get_available_log_types
+        Array(types).map(&:to_sym)
+      rescue ::Selenium::WebDriver::Error::UnknownCommandError
+        raise NotImplementedError, LOG_MSG
+      end
+
+      def log(type)
+        data = begin
+          execute :get_log, {}, type: type.to_s
+        rescue ::Selenium::WebDriver::Error::UnknownCommandError
+          execute :get_log_legacy, {}, type: type.to_s
+        end
+
+        Array(data).map do |l|
+          ::Selenium::WebDriver::LogEntry.new l.fetch('level', 'UNKNOWN'), l.fetch('timestamp'), l.fetch('message')
+        rescue KeyError
+          next
+        end
+      rescue ::Selenium::WebDriver::Error::UnknownCommandError
+        raise NotImplementedError, LOG_MSG
+      end
+    end
+  end
+end

data/lib/capybara/selenium/patches/pause_duration_fix.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module PauseDurationFix
+  def encode
+    super.tap { |output| output[:duration] ||= 0 }
+  end
+end
+
+::Selenium::WebDriver::Interactions::Pause.prepend PauseDurationFix

data/lib/capybara/selenium/patches/persistent_client.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Selenium
+    class PersistentClient < ::Selenium::WebDriver::Remote::Http::Default
+      def close
+        super
+        @http.finish if @http&.started?
+      end
+
+    private
+
+      def http
+        super.tap do |http|
+          http.start unless http.started?
+        end
+      end
+    end
+  end
+end

data/lib/capybara/server/animation_disabler.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Capybara
+  class Server
+    class AnimationDisabler
+      def self.selector_for(css_or_bool)
+        case css_or_bool
+        when String
+          css_or_bool
+        when true
+          '*'
+        else
+          raise CapybaraError, 'Capybara.disable_animation supports either a String (the css selector to disable) or a boolean'
+        end
+      end
+
+      def initialize(app)
+        @app = app
+        @disable_markup = format(DISABLE_MARKUP_TEMPLATE, selector: self.class.selector_for(Capybara.disable_animation))
+      end
+
+      def call(env)
+        @status, @headers, @body = @app.call(env)
+        return [@status, @headers, @body] unless html_content?
+
+        response = Rack::Response.new([], @status, @headers)
+
+        @body.each { |html| response.write insert_disable(html) }
+        @body.close if @body.respond_to?(:close)
+
+        response.finish
+      end
+
+    private
+
+      attr_reader :disable_markup
+
+      def html_content?
+        /html/.match?(@headers['Content-Type'])
+      end
+
+      def insert_disable(html)
+        html.sub(%r{(</body>)}, "#{disable_markup}\\1")
+      end
+
+      DISABLE_MARKUP_TEMPLATE = <<~HTML
+        <script>
+        //<![CDATA[
+          (typeof jQuery !== 'undefined') && (jQuery.fx.off = true);
+        //]]>
+        </script>
+        <style>
+          %<selector>s, %<selector>s::before, %<selector>s::after {
+             transition: none !important;
+             animation-duration: 0s !important;
+             animation-delay: 0s !important;
+             scroll-behavior: auto !important;
+          }
+        </style>
+      HTML
+    end
+  end
+end

data/lib/capybara/server/checker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Capybara
+  class Server
+    class Checker
+      TRY_HTTPS_ERRORS = [EOFError, Net::ReadTimeout, Errno::ECONNRESET].freeze
+
+      def initialize(host, port)
+        @host, @port = host, port
+        @ssl = false
+      end
+
+      def request(&block)
+        ssl? ? https_request(&block) : http_request(&block)
+      rescue *TRY_HTTPS_ERRORS
+        res = https_request(&block)
+        @ssl = true
+        res
+      end
+
+      def ssl?
+        @ssl
+      end
+
+    private
+
+      def http_request(&block)
+        make_request(read_timeout: 2, &block)
+      end
+
+      def https_request(&block)
+        make_request(**ssl_options, &block)
+      end
+
+      def make_request(**options, &block)
+        Net::HTTP.start(@host, @port, options.merge(max_retries: 0), &block)
+      end
+
+      def ssl_options
+        { use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE }
+      end
+    end
+  end
+end

data/lib/capybara/server/middleware.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Capybara
+  class Server
+    class Middleware
+      class Counter
+        def initialize
+          @value = []
+          @mutex = Mutex.new
+        end
+
+        def increment(uri)
+          @mutex.synchronize { @value.push(uri) }
+        end
+
+        def decrement(uri)
+          @mutex.synchronize { @value.delete_at(@value.index(uri) || @value.length) }
+        end
+
+        def positive?
+          @mutex.synchronize { @value.length.positive? }
+        end
+
+        def value
+          @mutex.synchronize { @value.dup }
+        end
+      end
+
+      attr_reader :error
+
+      def initialize(app, server_errors, extra_middleware = [])
+        @app = app
+        @extended_app = extra_middleware.inject(@app) do |ex_app, klass|
+          klass.new(ex_app)
+        end
+        @counter = Counter.new
+        @server_errors = server_errors
+      end
+
+      def pending_requests
+        @counter.value
+      end
+
+      def pending_requests?
+        @counter.positive?
+      end
+
+      def clear_error
+        @error = nil
+      end
+
+      def call(env)
+        if env['PATH_INFO'] == '/__identify__'
+          [200, {}, [@app.object_id.to_s]]
+        else
+          request_uri = env['REQUEST_URI']
+          @counter.increment(request_uri)
+
+          begin
+            @extended_app.call(env)
+          rescue *@server_errors => e
+            @error ||= e
+            raise e
+          ensure
+            @counter.decrement(request_uri)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/server.rb

@@ -1,56 +1,15 @@
 # frozen_string_literal: true
+
 require 'uri'
 require 'net/http'
 require 'rack'
+require 'capybara/server/middleware'
+require 'capybara/server/animation_disabler'
+require 'capybara/server/checker'
 
 module Capybara
+  # @api private
   class Server
-    class Middleware
-      class Counter
-        attr_reader :value
-
-        def initialize
-          @value = 0
-          @mutex = Mutex.new
-        end
-
-        def increment
-          @mutex.synchronize { @value += 1 }
-        end
-
-        def decrement
-          @mutex.synchronize { @value -= 1 }
-        end
-      end
-
-      attr_accessor :error
-
-      def initialize(app)
-        @app = app
-        @counter = Counter.new
-      end
-
-      def pending_requests?
-        @counter.value > 0
-      end
-
-      def call(env)
-        if env["PATH_INFO"] == "/__identify__"
-          [200, {}, [@app.object_id.to_s]]
-        else
-          @counter.increment
-          begin
-            @app.call(env)
-          rescue *Capybara.server_errors => e
-            @error = e unless @error
-            raise e
-          ensure
-            @counter.decrement
-          end
-        end
-      end
-    end
-
     class << self
       def ports
         @ports ||= {}
@@ -59,65 +18,109 @@ module Capybara
 
     attr_reader :app, :port, :host
 
-    def initialize(app, port=Capybara.server_port, host=Capybara.server_host)
+    def initialize(app,
+                   *deprecated_options,
+                   port: Capybara.server_port,
+                   host: Capybara.server_host,
+                   reportable_errors: Capybara.server_errors,
+                   extra_middleware: [])
+      unless deprecated_options.empty?
+        warn 'Positional arguments, other than the application, to Server#new are deprecated, please use keyword arguments'
+      end
       @app = app
-      @middleware = Middleware.new(@app)
+      @extra_middleware = extra_middleware
       @server_thread = nil # suppress warnings
-      @host, @port = host, port
-      @port ||= Capybara::Server.ports[Capybara.reuse_server ? @app.object_id : @middleware.object_id]
+      @host = deprecated_options[1] || host
+      @reportable_errors = deprecated_options[2] || reportable_errors
+      @port = deprecated_options[0] || port
+      @port ||= Capybara::Server.ports[port_key]
       @port ||= find_available_port(host)
+      @checker = Checker.new(@host, @port)
     end
 
     def reset_error!
-      @middleware.error = nil
+      middleware.clear_error
     end
 
     def error
-      @middleware.error
+      middleware.error
+    end
+
+    def using_ssl?
+      @checker.ssl?
     end
 
     def responsive?
-      return false if @server_thread && @server_thread.join(0)
+      return false if @server_thread&.join(0)
 
-      res = Net::HTTP.start(host, @port) { |http| http.get('/__identify__') }
+      res = @checker.request { |http| http.get('/__identify__') }
 
-      if res.is_a?(Net::HTTPSuccess) or res.is_a?(Net::HTTPRedirection)
-        return res.body == @app.object_id.to_s
-      end
-    rescue SystemCallError
-      return false
+      return res.body == app.object_id.to_s if res.is_a?(Net::HTTPSuccess) || res.is_a?(Net::HTTPRedirection)
+    rescue SystemCallError, Net::ReadTimeout, OpenSSL::SSL::SSLError
+      false
     end
 
     def wait_for_pending_requests
-      Timeout.timeout(60) { sleep(0.01) while @middleware.pending_requests? }
-    rescue Timeout::Error
-      raise "Requests did not finish in 60 seconds"
+      timer = Capybara::Helpers.timer(expire_in: 60)
+      while pending_requests?
+        raise "Requests did not finish in 60 seconds: #{middleware.pending_requests}" if timer.expired?
+
+        sleep 0.01
+      end
     end
 
     def boot
       unless responsive?
-        Capybara::Server.ports[Capybara.reuse_server ? @app.object_id : @middleware.object_id] = @port
+        Capybara::Server.ports[port_key] = port
 
         @server_thread = Thread.new do
-          Capybara.server.call(@middleware, @port, @host)
+          Capybara.server.call(middleware, port, host)
         end
 
-        Timeout.timeout(60) { @server_thread.join(0.1) until responsive? }
+        timer = Capybara::Helpers.timer(expire_in: 60)
+        until responsive?
+          raise 'Rack application timed out during boot' if timer.expired?
+
+          @server_thread.join(0.1)
+        end
       end
-    rescue Timeout::Error
-      raise "Rack application timed out during boot"
-    else
+
       self
     end
 
+    def base_url
+      "http#{'s' if using_ssl?}://#{host}:#{port}"
+    end
+
   private
 
+    def middleware
+      @middleware ||= Middleware.new(app, @reportable_errors, @extra_middleware)
+    end
+
+    def port_key
+      Capybara.reuse_server ? app.object_id : middleware.object_id
+    end
+
+    def pending_requests?
+      middleware.pending_requests?
+    end
+
     def find_available_port(host)
       server = TCPServer.new(host, 0)
-      server.addr[1]
+      port = server.addr[1]
+      server.close
+
+      # Workaround issue where some platforms (mac, ???) when passed a host
+      # of '0.0.0.0' will return a port that is only available on one of the
+      # ip addresses that resolves to, but the next binding to that port requires
+      # that port to be available on all ips
+      server = TCPServer.new(host, port)
+      port
+    rescue Errno::EADDRINUSE
+      retry
     ensure
-      server.close if server
+      server&.close
     end
-
   end
 end