capybara 3.0.0 → 3.40.0

data/lib/capybara/server/animation_disabler.rb

@@ -0,0 +1,80 @@
+# 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_css_markup = format(DISABLE_CSS_MARKUP_TEMPLATE,
+                                     selector: self.class.selector_for(Capybara.disable_animation))
+        @disable_js_markup = +DISABLE_JS_MARKUP_TEMPLATE
+      end
+
+      def call(env)
+        status, headers, body = @app.call(env)
+        return [status, headers, body] unless html_content?(headers)
+
+        nonces = directive_nonces(headers).transform_values { |nonce| "nonce=\"#{nonce}\"" if nonce && !nonce.empty? }
+        response = Rack::Response.new([], status, headers)
+
+        body.each { |html| response.write insert_disable(html, nonces) }
+        body.close if body.respond_to?(:close)
+
+        response.finish
+      end
+
+    private
+
+      attr_reader :disable_css_markup, :disable_js_markup
+
+      def html_content?(headers)
+        /html/.match?(headers['Content-Type']) # rubocop:todo Performance/StringInclude
+      end
+
+      def insert_disable(html, nonces)
+        html.sub(%r{(</head>)}, "<style #{nonces['style-src']}>#{disable_css_markup}</style>\\1")
+            .sub(%r{(</body>)}, "<script #{nonces['script-src']}>#{disable_js_markup}</script>\\1")
+      end
+
+      def directive_nonces(headers)
+        headers.fetch('Content-Security-Policy', '')
+               .split(';')
+               .map(&:split) # rubocop:disable Style/MapToHash
+               .to_h do |s|
+                 [
+                   s[0], s[1..].filter_map do |value|
+                     /^'nonce-(?<nonce>.+)'/ =~ value
+                     nonce
+                   end[0]
+                 ]
+               end
+      end
+
+      DISABLE_CSS_MARKUP_TEMPLATE = <<~CSS
+        %<selector>s, %<selector>s::before, %<selector>s::after {
+           transition: none !important;
+           animation-duration: 0s !important;
+           animation-delay: 0s !important;
+           scroll-behavior: auto !important;
+        }
+      CSS
+
+      DISABLE_JS_MARKUP_TEMPLATE = <<~SCRIPT
+        //<![CDATA[
+          (typeof jQuery !== 'undefined') && (jQuery.fx.off = true);
+        //]]>
+      SCRIPT
+    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) || - 1) }
+        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

@@ -3,56 +3,13 @@
 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, server_errors)
-        @app = app
-        @counter = Counter.new
-        @server_errors = server_errors
-      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 *@server_errors => e
-            @error ||= e
-            raise e
-          ensure
-            @counter.decrement
-          end
-        end
-      end
-    end
-
     class << self
       def ports
         @ports ||= {}
@@ -61,38 +18,55 @@ module Capybara
 
     attr_reader :app, :port, :host
 
-    def initialize(app, port = Capybara.server_port, host = Capybara.server_host, server_errors = Capybara.server_errors)
+    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
+      @extra_middleware = extra_middleware
       @server_thread = nil # suppress warnings
-      @host, @port, @server_errors = host, port, server_errors
+      @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
     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
+      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 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
@@ -103,18 +77,25 @@ module Capybara
           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, @server_errors)
+      @middleware ||= Middleware.new(app, @reportable_errors, @extra_middleware)
     end
 
     def port_key
@@ -127,9 +108,19 @@ module Capybara
 
     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

data/lib/capybara/session/config.rb

@@ -7,7 +7,8 @@ module Capybara
     OPTIONS = %i[always_include_port run_server default_selector default_max_wait_time ignore_hidden_elements
                  automatic_reload match exact exact_text raise_server_errors visible_text_only
                  automatic_label_click enable_aria_label save_path asset_host default_host app_host
-                 server_host server_port server_errors].freeze
+                 server_host server_port server_errors default_set_options disable_animation test_id
+                 predicates_wait default_normalize_ws w3c_click_offset enable_aria_role default_retry_interval].freeze
 
     attr_accessor(*OPTIONS)
 
@@ -20,6 +21,8 @@ module Capybara
     #   See {Capybara.configure}
     # @!method default_max_wait_time
     #   See {Capybara.configure}
+    # @!method default_retry_interval
+    #   See {Capybara.configure}
     # @!method ignore_hidden_elements
     #   See {Capybara.configure}
     # @!method automatic_reload
@@ -36,6 +39,8 @@ module Capybara
     #   See {Capybara.configure}
     # @!method enable_aria_label
     #   See {Capybara.configure}
+    # @!method enable_aria_role
+    #   See {Capybara.configure}
     # @!method save_path
     #   See {Capybara.configure}
     # @!method asset_host
@@ -50,6 +55,16 @@ module Capybara
     #   See {Capybara.configure}
     # @!method server_errors
     #   See {Capybara.configure}
+    # @!method default_set_options
+    #   See {Capybara.configure}
+    # @!method disable_animation
+    #   See {Capybara.configure}
+    # @!method test_id
+    #   See {Capybara.configure}
+    # @!method default_normalize_ws
+    #   See {Capybara.configure}
+    # @!method w3c_click_offset
+    #   See {Capybara.configure}
 
     remove_method :server_host
 
@@ -68,16 +83,35 @@ module Capybara
 
     remove_method :app_host=
     def app_host=(url)
-      raise ArgumentError, "Capybara.app_host should be set to a url (http://www.example.com). Attempted to set #{url.inspect}." if url && url !~ URI::DEFAULT_PARSER.make_regexp
+      unless url.nil? || url.match?(URI::DEFAULT_PARSER.make_regexp)
+        raise ArgumentError, "Capybara.app_host should be set to a url (http://www.example.com). Attempted to set #{url.inspect}."
+      end
+
       @app_host = url
     end
 
     remove_method :default_host=
     def default_host=(url)
-      raise ArgumentError, "Capybara.default_host should be set to a url (http://www.example.com). Attempted to set #{url.inspect}." if url && url !~ URI::DEFAULT_PARSER.make_regexp
+      unless url.nil? || url.match?(URI::DEFAULT_PARSER.make_regexp)
+        raise ArgumentError, "Capybara.default_host should be set to a url (http://www.example.com). Attempted to set #{url.inspect}."
+      end
+
       @default_host = url
     end
 
+    remove_method :test_id=
+    ##
+    #
+    # Set an attribute to be optionally matched against the locator for builtin selector types.
+    # This attribute will be checked by builtin selector types whenever id would normally be checked.
+    # If `nil` then it will be ignored.
+    #
+    # @param [String, Symbol, nil] id Name of the attribute to use as the test id
+    #
+    def test_id=(id)
+      @test_id = id&.to_sym
+    end
+
     def initialize_copy(other)
       super
       @server_errors = @server_errors.dup
@@ -85,9 +119,9 @@ module Capybara
   end
 
   class ReadOnlySessionConfig < SimpleDelegator
-    SessionConfig::OPTIONS.each do |m|
-      define_method "#{m}=" do |_|
-        raise "Per session settings are only supported when Capybara.threadsafe == true"
+    SessionConfig::OPTIONS.each do |option|
+      define_method "#{option}=" do |_|
+        raise 'Per session settings are only supported when Capybara.threadsafe == true'
       end
     end
   end

data/lib/capybara/session/matchers.rb

@@ -6,21 +6,23 @@ module Capybara
     # Asserts that the page has the given path.
     # By default, if passed a full url this will compare against the full url,
     # if passed a path only the path+query portion will be compared, if passed a regexp
-    # the comparison will depend on the :url option
+    # the comparison will depend on the :url option (path+query by default)
     #
     # @!macro current_path_query_params
-    #   @overload $0(string, options = {})
+    #   @overload $0(string, **options)
     #     @param string [String]           The string that the current 'path' should equal
-    #   @overload $0(regexp, options = {})
+    #   @overload $0(regexp, **options)
     #     @param regexp [Regexp]           The regexp that the current 'path' should match to
-    #   @option options [Boolean] :url (true if `string` ia a full url, otherwise false) Whether the compare should be done against the full current url or just the path
+    #   @option options [Boolean] :url (true if `string` is a full url, otherwise false) Whether the comparison should be done against the full current url or just the path
     #   @option options [Boolean] :ignore_query (false)  Whether the query portion of the current url/path should be ignored
     #   @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum time that Capybara will wait for the current url/path to eq/match given string/regexp argument
     # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
     # @return [true]
     #
-    def assert_current_path(path, **options)
-      _verify_current_path(path, options) { |query| raise Capybara::ExpectationNotMet, query.failure_message unless query.resolves_for?(self) }
+    def assert_current_path(path, **options, &optional_filter_block)
+      _verify_current_path(path, optional_filter_block, **options) do |query|
+        raise Capybara::ExpectationNotMet, query.failure_message unless query.resolves_for?(self)
+      end
     end
 
     ##
@@ -33,8 +35,10 @@ module Capybara
     # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
     # @return [true]
     #
-    def assert_no_current_path(path, **options)
-      _verify_current_path(path, options) { |query| raise Capybara::ExpectationNotMet, query.negative_failure_message if query.resolves_for?(self) }
+    def assert_no_current_path(path, **options, &optional_filter_block)
+      _verify_current_path(path, optional_filter_block, **options) do |query|
+        raise Capybara::ExpectationNotMet, query.negative_failure_message if query.resolves_for?(self)
+      end
     end
 
     ##
@@ -46,10 +50,8 @@ module Capybara
     # @macro current_path_query_params
     # @return [Boolean]
     #
-    def has_current_path?(path, **options)
-      assert_current_path(path, options)
-    rescue Capybara::ExpectationNotMet
-      return false
+    def has_current_path?(path, **options, &optional_filter_block)
+      make_predicate(options) { assert_current_path(path, **options, &optional_filter_block) }
     end
 
     ##
@@ -61,20 +63,25 @@ module Capybara
     # @macro current_path_query_params
     # @return [Boolean]
     #
-    def has_no_current_path?(path, **options)
-      assert_no_current_path(path, options)
-    rescue Capybara::ExpectationNotMet
-      return false
+    def has_no_current_path?(path, **options, &optional_filter_block)
+      make_predicate(options) { assert_no_current_path(path, **options, &optional_filter_block) }
     end
 
   private
 
-    def _verify_current_path(path, options)
-      query = Capybara::Queries::CurrentPathQuery.new(path, options)
+    def _verify_current_path(path, filter_block, **options)
+      query = Capybara::Queries::CurrentPathQuery.new(path, **options, &filter_block)
       document.synchronize(query.wait) do
         yield(query)
       end
-      return true
+      true
+    end
+
+    def make_predicate(options)
+      options[:wait] = 0 unless options.key?(:wait) || config.predicates_wait
+      yield
+    rescue Capybara::ExpectationNotMet
+      false
     end
   end
 end