capybara 2.13.0 → 2.18.0

data/lib/capybara/config.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+require 'forwardable'
+require 'capybara/session/config'
+
+module Capybara
+  class Config
+    extend Forwardable
+
+    OPTIONS = [:app, :reuse_server, :threadsafe, :default_wait_time, :server, :default_driver, :javascript_driver]
+
+    attr_accessor :app
+    attr_reader :reuse_server, :threadsafe
+    attr_reader :session_options
+    attr_writer :default_driver, :javascript_driver
+
+    SessionConfig::OPTIONS.each do |method|
+      def_delegators :session_options, method, "#{method}="
+    end
+
+    def initialize
+      @session_options = Capybara::SessionConfig.new
+    end
+
+    def reuse_server=(bool)
+      @reuse_server = bool
+    end
+
+    def threadsafe=(bool)
+      warn "Capybara.threadsafe == true is a BETA feature and may change in future minor versions" if bool
+      raise "Threadsafe setting cannot be changed once a session is created" if (bool != threadsafe) && Session.instance_created?
+      @threadsafe = bool
+    end
+
+    ##
+    #
+    # Return the proc that Capybara will call to run the Rack application.
+    # The block returned receives a rack app, port, and host/ip and should run a Rack handler
+    # By default, Capybara will try to run webrick.
+    #
+    def server(&block)
+      if block_given?
+        warn "DEPRECATED: Passing a block to Capybara::server is deprecated, please use Capybara::register_server instead"
+        @server = block
+      else
+        @server
+      end
+    end
+
+    ##
+    #
+    # Set the server to use.
+    #
+    #     Capybara.server = :webrick
+    #     Capybara.server = :puma, { Silent: true }
+    #
+    # @overload server=(name)
+    #   @param [Symbol] name     Name of the server type to use
+    # @overload server=([name, options])
+    #   @param [Symbol] name Name of the server type to use
+    #   @param [Hash] options Options to pass to the server block
+    # @see register_server
+    #
+    def server=(name)
+      name, options = *name if name.is_a? Array
+      @server = if name.respond_to? :call
+        name
+      else
+        if options
+          Proc.new { |app, port, host| Capybara.servers[name.to_sym].call(app,port,host,options) }
+        else
+          Capybara.servers[name.to_sym]
+        end
+      end
+    end
+
+    ##
+    #
+    # @return [Symbol]    The name of the driver to use by default
+    #
+    def default_driver
+      @default_driver || :rack_test
+    end
+
+    ##
+    #
+    # @return [Symbol]    The name of the driver used when JavaScript is needed
+    #
+    def javascript_driver
+      @javascript_driver || :selenium
+    end
+
+    # @deprecated Use default_max_wait_time instead
+    def default_wait_time
+      deprecate('default_wait_time', 'default_max_wait_time', true)
+      default_max_wait_time
+    end
+
+    # @deprecated Use default_max_wait_time= instead
+    def default_wait_time=(t)
+      deprecate('default_wait_time=', 'default_max_wait_time=')
+      self.default_max_wait_time = t
+    end
+
+    def deprecate(method, alternate_method, once=false)
+      @deprecation_notified ||= {}
+      warn "DEPRECATED: ##{method} is deprecated, please use ##{alternate_method} instead" unless once and @deprecation_notified[method]
+      @deprecation_notified[method]=true
+    end
+  end
+
+  # @api private
+  class ConfigureDeprecator
+    def initialize(config)
+      @config = config
+    end
+
+    def method_missing(m, *args, &block)
+      if @config.respond_to?(m)
+        @config.public_send(m, *args, &block)
+      elsif Capybara.respond_to?(m)
+        warn "Calling #{m} from Capybara.configure is deprecated - please call it on Capybara directly ( Capybara.#{m}(...) )"
+        Capybara.public_send(m, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(m, include_private = false)
+      @config.respond_to?(m) || Capybara.respond_to?(m) || super
+    end
+  end
+end

data/lib/capybara/cucumber.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'capybara/dsl'
 require 'capybara/rspec/matchers'
+require 'capybara/rspec/matcher_proxies'
 
 World(Capybara::DSL)
 World(Capybara::RSpecMatchers)

data/lib/capybara/driver/base.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 class Capybara::Driver::Base
+  attr_writer :session
+
   def current_url
     raise NotImplementedError
   end
@@ -8,6 +10,10 @@ class Capybara::Driver::Base
     raise NotImplementedError
   end
 
+  def refresh
+    raise NotImplementedError
+  end
+
   def find_xpath(query)
     raise NotImplementedError
   end
@@ -36,6 +42,10 @@ class Capybara::Driver::Base
     raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#evaluate_script'
   end
 
+  def evaluate_async_script(script, *args)
+    raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#evaluate_script_asnyc'
+  end
+
   def save_screenshot(path, options={})
     raise Capybara::NotSupportedByDriverError, 'Capybara::Driver::Base#save_screenshot'
   end
@@ -139,6 +149,10 @@ class Capybara::Driver::Base
     false
   end
 
+  def session_options
+    (@session && @session.config) || Capybara.session_options
+  end
+
   # @deprecated This method is being removed
   def browser_initialized?
     warn "DEPRECATED: #browser_initialized? is deprecated and will be removed in the next version of Capybara"

data/lib/capybara/dsl.rb

@@ -21,12 +21,10 @@ module Capybara
       Capybara.using_session(name, &block)
     end
 
-    ##
-    #
     # Shortcut to using a different wait time.
     #
     def using_wait_time(seconds, &block)
-      Capybara.using_wait_time(seconds, &block)
+      page.using_wait_time(seconds, &block)
     end
 
     ##

data/lib/capybara/helpers.rb

@@ -46,11 +46,11 @@ module Capybara
     # @param [String] html     HTML code to inject into
     # @return [String]         The modified HTML code
     #
-    def inject_asset_host(html)
-      if Capybara.asset_host && Nokogiri::HTML(html).css("base").empty?
+    def inject_asset_host(html, asset_host = Capybara.asset_host)
+      if asset_host && Nokogiri::HTML(html).css("base").empty?
         match = html.match(/<head[^<]*?>/)
         if match
-          return html.clone.insert match.end(0), "<base href='#{Capybara.asset_host}' />"
+          return html.clone.insert match.end(0), "<base href='#{asset_host}' />"
         end
       end
 

data/lib/capybara/minitest/spec.rb

@@ -8,47 +8,24 @@ module Capybara
         infect_an_assertion "refute_#{assertion}", "wont_have_#{assertion}", :reverse
       end
 
-      # Unfortunately infect_an_assertion doesn't pass through the optional filter block so we can't use it for these
-      %w(selector xpath css link button field select table checked_field unchecked_field).each do |assertion|
-        self.class_eval <<-EOM
-          def must_have_#{assertion} *args, &optional_filter_block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).must_have_#{assertion}(*args, &optional_filter_block)
-          end
-
-          def wont_have_#{assertion} *args, &optional_filter_block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).wont_have_#{assertion}(*args, &optional_filter_block)
-          end
-        EOM
-
-        ::Minitest::Expectation.class_eval <<-EOM, __FILE__, __LINE__ + 1
-          def must_have_#{assertion} *args, &optional_filter_block
-            ctx.assert_#{assertion}(target, *args, &optional_filter_block)
-          end
-
-          def wont_have_#{assertion} *args, &optional_filter_block
-            ctx.refute_#{assertion}(target, *args, &optional_filter_block)
-          end
-        EOM
-      end
-
-      %w(selector xpath css).each do |assertion|
-        self.class_eval <<-EOM
-          def must_match_#{assertion} *args, &optional_filter_block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).must_match_#{assertion}(*args, &optional_filter_block)
-          end
-
-          def wont_match_#{assertion} *args, &optional_filter_block
-            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).wont_match_#{assertion}(*args, &optional_filter_block)
+      (%w(selector xpath css link button field select table checked_field unchecked_field).flat_map do |assertion|
+        [["assert_#{assertion}", "must_have_#{assertion}"],
+         ["refute_#{assertion}", "wont_have_#{assertion}"]]
+      end + [["assert_all_of_selectors", "must_have_all_of_selectors"],
+             ["assert_none_of_selectors", "must_have_none_of_selectors"]] +
+      %w(selector xpath css).flat_map do |assertion|
+        [["assert_matches_#{assertion}", "must_match_#{assertion}"],
+         ["refute_matches_#{assertion}", "wont_match_#{assertion}"]]
+      end).each do |(meth, new_name)|
+        self.class_eval <<-EOM, __FILE__, __LINE__ + 1
+          def #{new_name} *args, &block
+            ::Minitest::Expectation.new(self, ::Minitest::Spec.current).#{new_name}(*args, &block)
           end
         EOM
 
         ::Minitest::Expectation.class_eval <<-EOM, __FILE__, __LINE__ + 1
-          def must_match_#{assertion} *args, &optional_filter_block
-            ctx.assert_matches_#{assertion}(target, *args, &optional_filter_block)
-          end
-
-          def wont_match_#{assertion} *args, &optional_filter_block
-            ctx.refute_matches_#{assertion}(target, *args, &optional_filter_block)
+          def #{new_name} *args, &block
+            ctx.#{meth}(target, *args, &block)
           end
         EOM
       end

data/lib/capybara/minitest.rb

@@ -6,141 +6,142 @@ module Capybara
   module Minitest
     module Assertions
       ## Assert text exists
+      #
+      # @!method assert_text
       #  see {Capybara::Node::Matchers#assert_text}
-      def assert_text(*args)
-        self.assertions += 1
-        subject, *args = determine_subject(args)
-        subject.assert_text(*args)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
-      alias_method :assert_content, :assert_text
 
       ## Assert text does not exist
+      #
+      # @!method assert_no_text
       #  see {Capybara::Node::Matchers#assert_no_text}
-      def assert_no_text(*args)
-        self.assertions += 1
-        subject, *args = determine_subject(args)
-        subject.assert_no_text(*args)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
+
+      ##
+      # Assertion that page title does match
+      #
+      # @!method assert_title
+      #   see {Capybara::Node::DocumentMatchers#assert_title}
+
+      ##
+      # Assertion that page title does not match
+      #
+      # @!method refute_title
+      # @!method assert_no_title
+      #   see {Capybara::Node::DocumentMatchers#assert_no_title}
+
+      ##
+      # Assertion that current path matches
+      #
+      # @!method assert_current_path
+      #   see {Capybara::SessionMatchers#assert_current_path}
+
+      ##
+      # Assertion that current page does not match
+      #
+      # @!method refute_current_path
+      # @!method assert_no_current_path
+      #   see {Capybara::SessionMatchers#assert_no_current_path}
+
+
+      %w(assert_text assert_no_text assert_title assert_no_title assert_current_path assert_no_current_path).each do |assertion_name|
+        self.class_eval <<-EOM, __FILE__, __LINE__ + 1
+          def #{assertion_name} *args
+            self.assertions +=1
+            subject, *args = determine_subject(args)
+            subject.#{assertion_name}(*args)
+          rescue Capybara::ExpectationNotMet => e
+            raise ::Minitest::Assertion, e.message
+          end
+        EOM
       end
+
+      alias_method :refute_title, :assert_no_title
       alias_method :refute_text, :assert_no_text
       alias_method :refute_content, :refute_text
+      alias_method :refute_current_path, :assert_no_current_path
+      alias_method :assert_content, :assert_text
       alias_method :assert_no_content, :refute_text
 
       ## Assert selector exists on page
-      #  see {Capybara::Node::Matchers#assert_selector}
-      def assert_selector(*args, &optional_filter_block)
-        self.assertions +=1
-        subject, *args = determine_subject(args)
-        subject.assert_selector(*args, &optional_filter_block)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
+      #
+      # @!method assert_selector
+      #   see {Capybara::Node::Matchers#assert_selector}
 
       ## Assert selector does not exist on page
-      #  see {Capybara::Node::Matchers#assert_no_selector}
-      def assert_no_selector(*args, &optional_filter_block)
-        self.assertions +=1
-        subject, *args = determine_subject(args)
-        subject.assert_no_selector(*args, &optional_filter_block)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
-      alias_method :refute_selector, :assert_no_selector
+      #
+      # @!method assert_no_selector
+      #   see {Capybara::Node::Matchers#assert_no_selector}
 
       ## Assert element matches selector
-      #  see {Capybara::Node::Matchers#assert_matches_selector}
-      def assert_matches_selector(*args, &optional_filter_block)
-        self.assertions += 1
-        subject, *args = determine_subject(args)
-        subject.assert_matches_selector(*args, &optional_filter_block)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
+      #
+      # @!method assert_matches_selector
+      #   see {Capybara::Node::Matchers#assert_matches_selector}
 
       ## Assert element does not match selector
-      #  see {Capybara::Node::Matchers#assert_not_matches_selector}
-      def assert_not_matches_selector(*args, &optional_filter_block)
-        self.assertions += 1
-        subject, *args = determine_subject(args)
-        subject.assert_not_matches_selector(*args, &optional_filter_block)
-      rescue Capybara::ExpectationNotMet => e
-        raise ::Minitest::Assertion, e.message
-      end
-      alias_method :refute_matches_selector, :assert_not_matches_selector
-
-      %w(title current_path).each do |selector_type|
-        define_method "assert_#{selector_type}" do |*args|
-          begin
-            self.assertions += 1
-            subject, *args = determine_subject(args)
-            subject.public_send("assert_#{selector_type}",*args)
-          rescue Capybara::ExpectationNotMet => e
-            raise ::Minitest::Assertion, e.message
-          end
-        end
-
-        define_method "assert_no_#{selector_type}" do |*args|
-          begin
-            self.assertions += 1
+      #
+      # @!method assert_xpath
+      #   see {Capybara::Node::Matchers#assert_not_matches_selector}
+
+      %w(assert_selector assert_no_selector
+         assert_all_of_selectors assert_none_of_selectors
+         assert_matches_selector assert_not_matches_selector).each do |assertion_name|
+        self.class_eval <<-EOM, __FILE__, __LINE__ + 1
+          def #{assertion_name} *args, &optional_filter_block
+            self.assertions +=1
             subject, *args = determine_subject(args)
-            subject.public_send("assert_no_#{selector_type}",*args)
+            subject.#{assertion_name}(*args, &optional_filter_block)
           rescue Capybara::ExpectationNotMet => e
             raise ::Minitest::Assertion, e.message
           end
-        end
-        alias_method "refute_#{selector_type}", "assert_no_#{selector_type}"
+        EOM
       end
 
+      alias_method :refute_selector, :assert_no_selector
+      alias_method :refute_matches_selector, :assert_not_matches_selector
+
       %w(xpath css link button field select table).each do |selector_type|
         define_method "assert_#{selector_type}" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          locator, options = *args, {}
-          locator, options = nil, locator if locator.is_a? Hash
+          locator, options = extract_locator(args)
           assert_selector(subject, selector_type.to_sym, locator, options, &optional_filter_block)
         end
 
         define_method "assert_no_#{selector_type}" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          locator, options = *args, {}
-          locator, options = nil, locator if locator.is_a? Hash
+          locator, options = extract_locator(args)
           assert_no_selector(subject, selector_type.to_sym, locator, options, &optional_filter_block)
         end
         alias_method "refute_#{selector_type}", "assert_no_#{selector_type}"
       end
 
-      %w(xpath css).each do |selector_type|
-        define_method "assert_matches_#{selector_type}" do |*args, &optional_filter_block|
+      %w(checked unchecked).each do |field_type|
+        define_method "assert_#{field_type}_field" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          assert_matches_selector(subject, selector_type.to_sym, *args, &optional_filter_block)
+          locator, options = extract_locator(args)
+          assert_selector(subject, :field, locator, options.merge(field_type.to_sym => true), &optional_filter_block)
         end
 
-        define_method "assert_not_matches_#{selector_type}" do |*args, &optional_filter_block|
+        define_method "assert_no_#{field_type}_field" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          assert_not_matches_selector(subject, selector_type.to_sym, *args, &optional_filter_block)
+          locator, options = extract_locator(args)
+          assert_no_selector(subject, :field, locator, options.merge(field_type.to_sym => true), &optional_filter_block)
         end
-        alias_method "refute_matches_#{selector_type}", "assert_not_matches_#{selector_type}"
+        alias_method "refute_#{field_type}_field", "assert_no_#{field_type}_field"
       end
 
-      %w(checked unchecked).each do |field_type|
-        define_method "assert_#{field_type}_field" do |*args, &optional_filter_block|
+      %w(xpath css).each do |selector_type|
+        define_method "assert_matches_#{selector_type}" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          locator, options = *args, {}
-          locator, options = nil, locator if locator.is_a? Hash
-          assert_selector(subject, :field, locator, options.merge(field_type.to_sym => true), &optional_filter_block)
+          assert_matches_selector(subject, selector_type.to_sym, *args, &optional_filter_block)
         end
 
-        define_method "assert_no_#{field_type}_field" do |*args, &optional_filter_block|
+        define_method "assert_not_matches_#{selector_type}" do |*args, &optional_filter_block|
           subject, *args = determine_subject(args)
-          locator, options = *args, {}
-          locator, options = nil, locator if locator.is_a? Hash
-          assert_no_selector(subject, :field, locator, options.merge(field_type.to_sym => true), &optional_filter_block)
+          assert_not_matches_selector(subject, selector_type.to_sym, *args, &optional_filter_block)
         end
-        alias_method "refute_#{field_type}_field", "assert_no_#{field_type}_field"
+        alias_method "refute_matches_#{selector_type}", "assert_not_matches_#{selector_type}"
       end
 
+
       ##
       # Assertion that there is xpath
       #
@@ -216,7 +217,7 @@ module Capybara
       # Assertion that there is no checked_field
       #
       # @!method assert_no_checked_field
-      # @!method refute_chceked_field
+      # @!method refute_checked_field
 
       ##
       # Assertion that there is unchecked_field
@@ -228,7 +229,7 @@ module Capybara
       # Assertion that there is no unchecked_field
       #
       # @!method assert_no_unchecked_field
-      # @!method refute_unchceked_field
+      # @!method refute_unchecked_field
 
       ##
       # Assertion that there is select
@@ -256,32 +257,6 @@ module Capybara
       # @!method assert_no_table
       #   see {Capybara::Node::Matchers#has_no_table?}
 
-      ##
-      # Assertion that page title does match
-      #
-      # @!method assert_title
-      #   see {Capybara::Node::DocumentMatchers#assert_title}
-
-      ##
-      # Assertion that page title does not match
-      #
-      # @!method refute_title
-      # @!method assert_no_title
-      #   see {Capybara::Node::DocumentMatchers#assert_no_title}
-
-      ##
-      # Assertion that current path matches
-      #
-      # @!method assert_current_path
-      #   see {Capybara::SessionMatchers#assert_current_path}
-
-      ##
-      # Assertion that current page does not match
-      #
-      # @!method refute_current_path
-      # @!method assert_no_current_path
-      #   see {Capybara::SessionMatchers#assert_no_current_path}
-
       private
 
       def determine_subject(args)
@@ -292,6 +267,12 @@ module Capybara
           [page, *args]
         end
       end
+
+      def extract_locator(args)
+        locator, options = *args, {}
+        locator, options = nil, locator if locator.is_a? Hash
+        [locator, options]
+      end
     end
   end
 end

data/lib/capybara/node/actions.rb

@@ -5,8 +5,8 @@ module Capybara
 
       ##
       #
-      # Finds a button or link by id, text or value and clicks it. Also looks at image
-      # alt text inside the link.
+      # Finds a button or link and clicks it.  See {Capybara::Node::Actions#click_button} and
+      # {Capybara::Node::Actions#click_link} for what locator will match against for each type of element
       # @!macro waiting_behavior
       #   If the driver is capable of executing JavaScript, +$0+ will wait for a set amount of time
       #   and continuously retry finding the element until either the element is found or the time
@@ -16,7 +16,7 @@ module Capybara
       #
       # @overload click_link_or_button([locator], options)
       #
-      #   @param [String] locator      Text, id or value of link or button
+      #   @param [String] locator      See {Capybara::Node::Actions#click_button} and {Capybara::Node::Actions#click_link}
       #
       # @return [Capybara::Node::Element]  The element clicked
       #
@@ -80,7 +80,7 @@ module Capybara
       #   @option options [String] :id             Match fields that match the id attribute
       #   @option options [String] :name           Match fields that match the name attribute
       #   @option options [String] :placeholder    Match fields that match the placeholder attribute
-      #   @option options [String, Array<String>] :class    Match links that match the class(es) provided
+      #   @option options [String, Array<String>] :class    Match fields that match the class(es) provided
       #
       # @return [Capybara::Node::Element]  The element filled_in
       def fill_in(locator, options={})
@@ -108,7 +108,7 @@ module Capybara
       #   @option options [String] :option  Value of the radio_button to choose
       #   @option options [String] :id             Match fields that match the id attribute
       #   @option options [String] :name           Match fields that match the name attribute
-      #   @option options [String, Array<String>] :class    Match links that match the class(es) provided
+      #   @option options [String, Array<String>] :class    Match fields that match the class(es) provided
       #   @macro waiting_behavior
       #   @macro label_click
       #
@@ -131,7 +131,7 @@ module Capybara
       #   @option options [String] :option  Value of the checkbox to select
       #   @option options [String] id       Match fields that match the id attribute
       #   @option options [String] name     Match fields that match the name attribute
-      #   @option options [String, Array<String>] :class    Match links that match the class(es) provided
+      #   @option options [String, Array<String>] :class    Match fields that match the class(es) provided
       #   @macro label_click
       #   @macro waiting_behavior
       #
@@ -154,7 +154,7 @@ module Capybara
       #   @option options [String] :option  Value of the checkbox to deselect
       #   @option options [String] id       Match fields that match the id attribute
       #   @option options [String] name     Match fields that match the name attribute
-      #   @option options [String, Array<String>] :class    Match links that match the class(es) provided
+      #   @option options [String, Array<String>] :class    Match fields that match the class(es) provided
       #   @macro label_click
       #   @macro waiting_behavior
       #
@@ -229,7 +229,7 @@ module Capybara
       # @option options [Boolean] multiple Match field which allows multiple file selection
       # @option options [String] id             Match fields that match the id attribute
       # @option options [String] name           Match fields that match the name attribute
-      # @option options [String, Array<String>] :class    Match links that match the class(es) provided
+      # @option options [String, Array<String>] :class    Match fields that match the class(es) provided
       # @option options [true, Hash] make_visible   A Hash of CSS styles to change before attempting to attach the file, if `true` { opacity: 1, display: 'block', visibility: 'visible' } is used (may not be supported by all drivers)
       #
       # @return [Capybara::Node::Element]  The file field element
@@ -293,9 +293,9 @@ module Capybara
 
       def _check_with_label(selector, checked, locator, options)
         locator, options = nil, locator if locator.is_a? Hash
-        allow_label_click = options.delete(:allow_label_click) { Capybara.automatic_label_click }
+        allow_label_click = options.delete(:allow_label_click) { session_options.automatic_label_click }
 
-        synchronize(Capybara::Queries::BaseQuery::wait(options)) do
+        synchronize(Capybara::Queries::BaseQuery.wait(options, session_options.default_max_wait_time)) do
           begin
             el = find(selector, locator, options)
             el.set(checked)

data/lib/capybara/node/base.rb

@@ -74,7 +74,7 @@ module Capybara
       # @return [Object]                  The result of the given block
       # @raise  [Capybara::FrozenInTime]  If the return value of `Time.now` appears stuck
       #
-      def synchronize(seconds=Capybara.default_max_wait_time, options = {})
+      def synchronize(seconds=session_options.default_max_wait_time, options = {})
         start_time = Capybara::Helpers.monotonic_time
 
         if session.synchronized
@@ -90,7 +90,7 @@ module Capybara
             raise e if (Capybara::Helpers.monotonic_time - start_time) >= seconds
             sleep(0.05)
             raise Capybara::FrozenInTime, "time appears to be frozen, Capybara does not work with libraries which freeze time, consider using time travelling instead" if Capybara::Helpers.monotonic_time == start_time
-            reload if Capybara.automatic_reload
+            reload if session_options.automatic_reload
             retry
           ensure
             session.synchronized = false
@@ -114,6 +114,11 @@ module Capybara
         query_scope
       end
 
+      # @api private
+      def session_options
+        session.config
+      end
+
     protected
 
       def catch_error?(error, errors = nil)