capybara 2.13.0 → 2.18.0

data/lib/capybara/session/config.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+require 'delegate'
+
+module Capybara
+  class SessionConfig
+    OPTIONS = [: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, :wait_on_first_by_default,
+               :automatic_label_click, :enable_aria_label, :save_path, :exact_options, :asset_host, :default_host, :app_host,
+               :save_and_open_page_path, :server_host, :server_port, :server_errors]
+
+    attr_accessor(*OPTIONS)
+
+    ##
+    #@!method always_include_port
+    #  See {Capybara.configure}
+    #@!method run_server
+    #  See {Capybara.configure}
+    #@!method default_selector
+    #  See {Capybara.configure}
+    #@!method default_max_wait_time
+    #  See {Capybara.configure}
+    #@!method ignore_hidden_elements
+    #  See {Capybara.configure}
+    #@!method automatic_reload
+    #  See {Capybara.configure}
+    #@!method match
+    #  See {Capybara.configure}
+    #@!method exact
+    #  See {Capybara.configure}
+    #@!method raise_server_errors
+    #  See {Capybara.configure}
+    #@!method visible_text_only
+    #  See {Capybara.configure}
+    #@!method wait_on_first_by_default
+    #  See {Capybara.configure}
+    #@!method automatic_label_click
+    #  See {Capybara.configure}
+    #@!method enable_aria_label
+    #  See {Capybara.configure}
+    #@!method save_path
+    #  See {Capybara.configure}
+    #@deprecated
+    #@!method exact_options
+    #  See {Capybara.configure}
+    #@!method asset_host
+    #  See {Capybara.configure}
+    #@!method default_host
+    #  See {Capybara.configure}
+    #@!method app_host
+    #  See {Capybara.configure}
+    #@!method save_and_open_page_path
+    #  See {Capybara.configure}
+    #@!method server_host
+    #  See {Capybara.configure}
+    #@!method server_port
+    #  See {Capybara.configure}
+    #@!method server_errors
+    #  See {Capybara.configure}
+
+    remove_method :server_host
+
+    ##
+    #
+    # @return [String]    The IP address bound by default server
+    #
+    def server_host
+      @server_host || '127.0.0.1'
+    end
+
+    remove_method :server_errors=
+    def server_errors=(errors)
+      (@server_errors ||= []).replace(errors.dup)
+    end
+
+    remove_method :app_host=
+    def app_host=(url)
+      raise ArgumentError.new("Capybara.app_host should be set to a url (http://www.example.com)") unless url.nil? || (url =~ URI::Parser.new.make_regexp)
+      @app_host = url
+    end
+
+    remove_method :default_host=
+    def default_host=(url)
+      raise ArgumentError.new("Capybara.default_host should be set to a url (http://www.example.com)") unless url.nil? || (url =~ URI::Parser.new.make_regexp)
+      @default_host = url
+    end
+
+    remove_method :save_and_open_page_path=
+    def save_and_open_page_path=(path)
+      warn "DEPRECATED: #save_and_open_page_path is deprecated, please use #save_path instead. \n"\
+           "Note: Behavior is slightly different with relative paths - see documentation" unless path.nil?
+      @save_and_open_page_path = path
+    end
+
+    remove_method :exact_options=
+    def exact_options=(opt)
+      @exact_options = opt
+      warn "DEPRECATED: #exact_options is deprecated, please scope your findes/actions and use the `:exact` "\
+           "option if similar functionality is needed."
+    end
+
+    def initialize_copy(other)
+      super
+      @server_errors = @server_errors.dup
+    end
+  end
+
+  class ReadOnlySessionConfig < SimpleDelegator
+    SessionConfig::OPTIONS.each do |m|
+      define_method "#{m}=" do |val|
+        raise "Per session settings are only supported when Capybara.threadsafe == true"
+      end
+    end
+  end
+end

data/lib/capybara/session/matchers.rb

@@ -3,16 +3,18 @@ module Capybara
   module SessionMatchers
     ##
     # Asserts that the page has the given path.
-    # By default this will compare against the path+query portion of the full url
+    # 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
     #
     # @!macro current_path_query_params
     #   @overload $0(string, options = {})
     #     @param string [String]           The string that the current 'path' should equal
     #   @overload $0(regexp, options = {})
     #     @param regexp [Regexp]           The regexp that the current 'path' should match to
-    #   @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum time that Capybara will wait for the current path to eq/match given string/regexp argument
-    #   @option options [Boolean] :url  (false)  Whether the compare should be done against the full url
-    #   @option options [Boolean] :only_path (false)  Whether the compare should be done against just the path protion of the url
+    #   @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] :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]
     #
@@ -22,6 +24,9 @@ module Capybara
 
     ##
     # Asserts that the page doesn't have 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
     #
     # @macro current_path_query_params
     # @raise [Capybara::ExpectationNotMet] if the assertion hasn't succeeded during wait time
@@ -33,6 +38,9 @@ module Capybara
 
     ##
     # Checks if 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
     #
     # @macro current_path_query_params
     # @return [Boolean]
@@ -45,6 +53,9 @@ module Capybara
 
     ##
     # Checks if the page doesn't have 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
     #
     # @macro current_path_query_params
     # @return [Boolean]

data/lib/capybara/session.rb

@@ -17,6 +17,14 @@ module Capybara
   #     session = Capybara::Session.new(:culerity)
   #     session.visit('http://www.google.com')
   #
+  # When Capybara.threadsafe == true the sessions options will be initially set to the
+  # current values of the global options and a configuration block can be passed to the session initializer.
+  # For available options see {Capybara::SessionConfig::OPTIONS}
+  #
+  #     session = Capybara::Session.new(:driver, MyRackApp) do |config|
+  #       config.app_host = "http://my_host.dev"
+  #     end
+  #
   # Session provides a number of methods for controlling the navigation of the page, such as +visit+,
   # +current_path, and so on. It also delegate a number of methods to a Capybara::Document, representing
   # the current HTML document. This allows interaction:
@@ -50,7 +58,7 @@ module Capybara
     ]
     SESSION_METHODS = [
       :body, :html, :source, :current_url, :current_host, :current_path,
-      :execute_script, :evaluate_script, :visit, :go_back, :go_forward,
+      :execute_script, :evaluate_script, :visit, :refresh, :go_back, :go_forward,
       :within, :within_element, :within_fieldset, :within_table, :within_frame, :switch_to_frame,
       :current_window, :windows, :open_new_window, :switch_to_window, :within_window, :window_opened_by,
       :save_page, :save_and_open_page, :save_screenshot,
@@ -69,10 +77,15 @@ module Capybara
 
     def initialize(mode, app=nil)
       raise TypeError, "The second parameter to Session::new should be a rack app if passed." if app && !app.respond_to?(:call)
+      @@instance_created = true
       @mode = mode
       @app = app
-      if Capybara.run_server and @app and driver.needs_server?
-        @server = Capybara::Server.new(@app).boot
+      if block_given?
+        raise "A configuration block is only accepted when Capybara.threadsafe == true" unless Capybara.threadsafe
+        yield config if block_given?
+      end
+      if config.run_server and @app and driver.needs_server?
+        @server = Capybara::Server.new(@app, config.server_port, config.server_host, config.server_errors).boot
       else
         @server = nil
       end
@@ -85,7 +98,9 @@ module Capybara
           other_drivers = Capybara.drivers.keys.map { |key| key.inspect }
           raise Capybara::DriverNotFoundError, "no driver called #{mode.inspect} was found, available drivers: #{other_drivers.join(', ')}"
         end
-        Capybara.drivers[mode].call(app)
+        driver = Capybara.drivers[mode].call(app)
+        driver.session = self if driver.respond_to?(:session=)
+        driver
       end
     end
 
@@ -126,7 +141,7 @@ module Capybara
       if @server and @server.error
         # Force an explanation for the error being raised as the exception cause
         begin
-          if Capybara.raise_server_errors
+          if config.raise_server_errors
             raise CapybaraError, "Your application server raised an error - It has been raised in your test code because Capybara.raise_server_errors == true"
           end
         rescue CapybaraError
@@ -232,28 +247,42 @@ module Capybara
       raise_server_error!
       @touched = true
 
-      visit_uri = URI.parse(visit_uri.to_s)
+      visit_uri = ::Addressable::URI.parse(visit_uri.to_s)
 
       uri_base = if @server
-        visit_uri.port = @server.port if Capybara.always_include_port && (visit_uri.port == visit_uri.default_port)
-        URI.parse(Capybara.app_host || "http://#{@server.host}:#{@server.port}")
+        ::Addressable::URI.parse(config.app_host || "http://#{@server.host}:#{@server.port}")
       else
-        Capybara.app_host && URI.parse(Capybara.app_host)
+        config.app_host && ::Addressable::URI.parse(config.app_host)
       end
 
-      # TODO - this is only for compatability with previous 2.x behavior that concatenated
-      # Capybara.app_host and a "relative" path - Consider removing in 3.0
-      # @abotalov brought up a good point about this behavior potentially being useful to people
-      # deploying to a subdirectory and/or single page apps where only the url fragment changes
-      if visit_uri.scheme.nil? && uri_base
-        visit_uri.path = uri_base.path + visit_uri.path
-      end
+      if uri_base && [nil, 'http', 'https'].include?(visit_uri.scheme)
+        if visit_uri.relative?
+          uri_base.port ||= @server.port if @server && config.always_include_port
 
-      visit_uri = uri_base.merge(visit_uri) unless uri_base.nil?
+          visit_uri_parts = visit_uri.to_hash.delete_if { |k,v| v.nil? }
+
+          # Useful to people deploying to a subdirectory
+          # and/or single page apps where only the url fragment changes
+          visit_uri_parts[:path] = uri_base.path + visit_uri.path
+
+          visit_uri = uri_base.merge(visit_uri_parts)
+        else
+          visit_uri.port ||= @server.port if @server && config.always_include_port
+        end
+      end
 
       driver.visit(visit_uri.to_s)
     end
 
+    ##
+    #
+    # Refresh the page
+    #
+    def refresh
+      raise_server_error!
+      driver.refresh
+    end
+
     ##
     #
     # Move back a single entry in the browser's history.
@@ -457,14 +486,14 @@ module Capybara
     #   @raise [Capybara::WindowError]     if no window matches given block
     # @overload switch_to_window(window)
     #   @param window [Capybara::Window]   window that should be switched to
-    #   @raise [Capybara::Driver::Base#no_such_window_error] if unexistent (e.g. closed) window was passed
+    #   @raise [Capybara::Driver::Base#no_such_window_error] if nonexistent (e.g. closed) window was passed
     #
     # @return [Capybara::Window]         window that has been switched to
-    # @raise [Capybara::ScopeError]        if this method is invoked inside `within`,
-    #   `within_frame` or `within_window` methods
+    # @raise [Capybara::ScopeError]        if this method is invoked inside `within` or
+    #   `within_frame` methods
     # @raise [ArgumentError]               if both or neither arguments were provided
     #
-    def switch_to_window(window = nil, options= {})
+    def switch_to_window(window = nil, options= {}, &window_locator)
       options, window = window, nil if window.is_a? Hash
 
       block_given = block_given?
@@ -472,34 +501,12 @@ module Capybara
         raise ArgumentError, "`switch_to_window` can take either a block or a window, not both"
       elsif !window && !block_given
         raise ArgumentError, "`switch_to_window`: either window or block should be provided"
-      elsif scopes.size > 1
+      elsif !scopes.last.nil?
         raise Capybara::ScopeError, "`switch_to_window` is not supposed to be invoked from "\
-                                    "`within`'s, `within_frame`'s' or `within_window`'s' block."
+                                    "`within` or `within_frame` blocks."
       end
 
-      if window
-        driver.switch_to_window(window.handle)
-        window
-      else
-        wait_time = Capybara::Queries::BaseQuery.wait(options)
-        document.synchronize(wait_time, errors: [Capybara::WindowError]) do
-          original_window_handle = driver.current_window_handle
-          begin
-            driver.window_handles.each do |handle|
-              driver.switch_to_window handle
-              if yield
-                return Window.new(self, handle)
-              end
-            end
-          rescue => e
-            driver.switch_to_window(original_window_handle)
-            raise e
-          else
-            driver.switch_to_window(original_window_handle)
-            raise Capybara::WindowError, "Could not find a window matching block/lambda"
-          end
-        end
-      end
+      _switch_to_window(window, options, &window_locator)
     end
 
     ##
@@ -512,7 +519,7 @@ module Capybara
     # @overload within_window(window) { do_something }
     #   @param window [Capybara::Window]       instance of `Capybara::Window` class
     #     that will be switched to
-    #   @raise [driver#no_such_window_error] if unexistent (e.g. closed) window was passed
+    #   @raise [driver#no_such_window_error] if nonexistent (e.g. closed) window was passed
     # @overload within_window(proc_or_lambda) { do_something }
     #   @param lambda [Proc]                  lambda. First window for which lambda
     #     returns a value other than false or nil will be switched to.
@@ -523,30 +530,35 @@ module Capybara
     #   @deprecated                            Pass window or lambda instead
     #   @param [String]                        handle, name, url or title of the window
     #
-    # @raise [Capybara::ScopeError]        if this method is invoked inside `within`,
-    #   `within_frame` or `within_window` methods
+    # @raise [Capybara::ScopeError]        if this method is invoked inside `within_frame` method
     # @return                              value returned by the block
     #
     def within_window(window_or_handle)
       if window_or_handle.instance_of?(Capybara::Window)
         original = current_window
-        switch_to_window(window_or_handle) unless original == window_or_handle
         scopes << nil
         begin
-          yield
+          _switch_to_window(window_or_handle) unless original == window_or_handle
+          begin
+            yield
+          ensure
+            _switch_to_window(original) unless original == window_or_handle
+          end
         ensure
-          @scopes.pop
-          switch_to_window(original) unless original == window_or_handle
+          scopes.pop
         end
       elsif window_or_handle.is_a?(Proc)
         original = current_window
-        switch_to_window { window_or_handle.call }
         scopes << nil
         begin
-          yield
+          _switch_to_window { window_or_handle.call }
+          begin
+            yield
+          ensure
+            _switch_to_window(original)
+          end
         ensure
-          @scopes.pop
-          switch_to_window(original)
+          scopes.pop
         end
       else
         offending_line = caller.first
@@ -557,7 +569,7 @@ module Capybara
           scopes << nil
           driver.within_window(window_or_handle) { yield }
         ensure
-          @scopes.pop
+          scopes.pop
         end
       end
     end
@@ -578,7 +590,7 @@ module Capybara
       old_handles = driver.window_handles
       block.call
 
-      wait_time = Capybara::Queries::BaseQuery.wait(options)
+      wait_time = Capybara::Queries::BaseQuery.wait(options, config.default_max_wait_time)
       document.synchronize(wait_time, errors: [Capybara::WindowError]) do
         opened_handles = (driver.window_handles - old_handles)
         if opened_handles.size != 1
@@ -628,18 +640,45 @@ module Capybara
       element_script_result(result)
     end
 
+    ##
+    #
+    # Evaluate the given JavaScript and obtain the result from a callback function which will be passed as the last argument to the script.
+    #
+    # @param  [String] script   A string of JavaScript to evaluate
+    # @return [Object]          The result of the evaluated JavaScript (may be driver specific)
+    #
+    def evaluate_async_script(script, *args)
+      @touched = true
+      result = if args.empty?
+        driver.evaluate_async_script(script)
+      else
+        raise Capybara::NotSupportedByDriverError, "The current driver does not support evaluate_async_script arguments" if driver.method(:evaluate_async_script).arity == 1
+        driver.evaluate_async_script(script, *args.map { |arg| arg.is_a?(Capybara::Node::Element) ?  arg.base : arg} )
+      end
+      element_script_result(result)
+    end
+
     ##
     #
     # Execute the block, accepting a alert.
     #
     # @!macro modal_params
+    #   Expects a block whose actions will trigger the display modal to appear
+    #   @example
+    #     $0 do
+    #       click_link('link that triggers appearance of system modal')
+    #     end
     #   @overload $0(text, options = {}, &blk)
     #     @param text [String, Regexp]  Text or regex to match against the text in the modal.  If not provided any modal is matched
+    #     @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum time to wait for the modal to appear after executing the block.
+    #     @yield Block whose actions will trigger the system modal
     #   @overload $0(options = {}, &blk)
-    #   @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum time to wait for the modal to appear after executing the block.
+    #     @option options [Numeric] :wait (Capybara.default_max_wait_time) Maximum time to wait for the modal to appear after executing the block.
+    #     @yield Block whose actions will trigger the system modal
     #   @return [String]  the message shown in the modal
     #   @raise [Capybara::ModalNotFound]  if modal dialog hasn't been found
     #
+    #
     def accept_alert(text_or_options=nil, options={}, &blk)
       accept_modal(:alert, text_or_options, options, &blk)
     end
@@ -701,7 +740,7 @@ module Capybara
     #
     def save_page(path = nil)
       path = prepare_path(path, 'html')
-      File.write(path, Capybara::Helpers.inject_asset_host(body), mode: 'wb')
+      File.write(path, Capybara::Helpers.inject_asset_host(body, config.asset_host), mode: 'wb')
       path
     end
 
@@ -786,7 +825,49 @@ module Capybara
       scope
     end
 
+    ##
+    #
+    # Yield a block using a specific wait time
+    #
+    def using_wait_time(seconds)
+      if Capybara.threadsafe
+        begin
+          previous_wait_time = config.default_max_wait_time
+          config.default_max_wait_time = seconds
+          yield
+        ensure
+          config.default_max_wait_time = previous_wait_time
+        end
+      else
+        Capybara.using_wait_time(seconds) { yield }
+      end
+    end
+
+    ##
+    #
+    #  Accepts a block to set the configuration options if Capybara.threadsafe == true. Note that some options only have an effect
+    #  if set at initialization time, so look at the configuration block that can be passed to the initializer too
+    #
+    def configure
+      raise "Session configuration is only supported when Capybara.threadsafe == true" unless Capybara.threadsafe
+      yield config
+    end
+
+    def self.instance_created?
+      @@instance_created
+    end
+
+    def config
+      @config ||= if Capybara.threadsafe
+        Capybara.session_options.dup
+      else
+        Capybara::ReadOnlySessionConfig.new(Capybara.session_options)
+      end
+    end
   private
+
+    @@instance_created = false
+
     def accept_modal(type, text_or_options, options, &blk)
       driver.accept_modal(type, modal_options(text_or_options, options), &blk)
     end
@@ -798,7 +879,7 @@ module Capybara
     def modal_options(text_or_options, options)
       text_or_options, options = nil, text_or_options if text_or_options.is_a?(Hash)
       options[:text] ||= text_or_options unless text_or_options.nil?
-      options[:wait] ||= Capybara.default_max_wait_time
+      options[:wait] ||= config.default_max_wait_time
       options
     end
 
@@ -814,10 +895,10 @@ module Capybara
     end
 
     def prepare_path(path, extension)
-      if Capybara.save_path || Capybara.save_and_open_page_path.nil?
-        path = File.expand_path(path || default_fn(extension), Capybara.save_path)
+      if config.save_path || config.save_and_open_page_path.nil?
+        path = File.expand_path(path || default_fn(extension), config.save_path)
       else
-        path = File.expand_path(default_fn(extension), Capybara.save_and_open_page_path) if path.nil?
+        path = File.expand_path(default_fn(extension), config.save_and_open_page_path) if path.nil?
       end
       FileUtils.mkdir_p(File.dirname(path))
       path
@@ -862,5 +943,37 @@ module Capybara
         end
       end
     end
+
+    def _switch_to_window(window = nil, options= {})
+      options, window = window, nil if window.is_a? Hash
+
+      raise Capybara::ScopeError, "Window cannot be switched inside a `within_frame` block" if scopes.include?(:frame)
+      raise Capybara::ScopeError, "Window cannot be switch inside a `within` block" unless scopes.last.nil?
+
+      if window
+        driver.switch_to_window(window.handle)
+        window
+      else
+        wait_time = Capybara::Queries::BaseQuery.wait(options, config.default_max_wait_time)
+        document.synchronize(wait_time, errors: [Capybara::WindowError]) do
+          original_window_handle = driver.current_window_handle
+          begin
+            driver.window_handles.each do |handle|
+              driver.switch_to_window handle
+              if yield
+                return Window.new(self, handle)
+              end
+            end
+          rescue => e
+            driver.switch_to_window(original_window_handle)
+            raise e
+          else
+            driver.switch_to_window(original_window_handle)
+            raise Capybara::WindowError, "Could not find a window matching block/lambda"
+          end
+        end
+      end
+    end
+
   end
 end

data/lib/capybara/spec/fixtures/no_extension

@@ -0,0 +1 @@
+ThisFileHAsNoExtension

data/lib/capybara/spec/public/test.js

@@ -1,8 +1,8 @@
 var activeRequests = 0;
 $(function() {
   $('#change').text('I changed it');
-  $('#drag').draggable();
-  $('#drop').droppable({
+  $('#drag, #drag_scroll').draggable();
+  $('#drop, #drop_scroll').droppable({
     drop: function(event, ui) {
       ui.draggable.remove();
       $(this).html('Dropped!');
@@ -37,6 +37,9 @@ $(function() {
   $('#with_change_event').change(function() {
     $('body').append($('<p class="change_event_triggered"></p>').text(this.value));
   });
+  $('#with_change_event').on('input', function() {
+    $('body').append($('<p class="input_event_triggered"></p>').text(this.value));
+  });
   $('#checkbox_with_event').click(function() {
     $('body').append('<p id="checkbox_event_triggered">Checkbox event triggered</p>');
   });
@@ -58,7 +61,7 @@ $(function() {
   $('#change-title').click(function() {
     setTimeout(function() {
       $('title').text('changed title')
-    }, 250)
+    }, 400)
   });
   $('#click-test').on({
     dblclick: function() {
@@ -87,6 +90,10 @@ $(function() {
       $(link).attr('opened', 'true');
     }, 3000);
   });
+  $('#alert-page-change').click(function() {
+    alert('Page is changing');
+    return true;
+  });
   $('#open-confirm').click(function() {
     if(confirm('Confirm opened')) {
       $(this).attr('confirmed', 'true');
@@ -102,6 +109,14 @@ $(function() {
       $(this).attr('response', response);
     }
   });
+  $('#open-prompt-with-default').click(function() {
+    var response = prompt('Prompt opened', 'Default value!');
+    if(response === null) {
+      $(this).attr('response', 'dismissed');
+    } else {
+      $(this).attr('response', response);
+    }
+  });
   $('#open-twice').click(function() {
     if (confirm('Are you sure?')) {
       if (!confirm('Are you really sure?')) {

data/lib/capybara/spec/session/accept_alert_spec.rb

@@ -47,6 +47,14 @@ Capybara::SpecHelper.spec '#accept_alert', requires: [:modals] do
     expect(message).to eq('Alert opened [*Yay?*]')
   end
 
+  it "should handle the alert if the page changes" do
+    @session.accept_alert do
+      @session.click_link('Alert page change')
+      sleep 1 # ensure page change occurs before the accept_alert block exits
+    end
+    expect(@session).to have_current_path('/with_html')
+  end
+
   context "with an asynchronous alert" do
     it "should accept the alert" do
       @session.accept_alert do
@@ -63,7 +71,7 @@ Capybara::SpecHelper.spec '#accept_alert', requires: [:modals] do
     end
 
     it "should allow to adjust the delay" do
-      @session.accept_alert wait: 4 do
+      @session.accept_alert wait: 10 do
         @session.click_link('Open slow alert')
       end
       expect(@session).to have_xpath("//a[@id='open-slow-alert' and @opened='true']")