capybara 3.13.2 → 3.40.0

data/lib/capybara.rb

@@ -5,6 +5,7 @@ require 'nokogiri'
 require 'xpath'
 require 'forwardable'
 require 'capybara/config'
+require 'capybara/registration_container'
 
 module Capybara
   class CapybaraError < StandardError; end
@@ -38,7 +39,7 @@ module Capybara
     #   See {Capybara.configure}
     # @!method javascript_driver
     #   See {Capybara.configure}
-    # @!method allow_gumbo
+    # @!method use_html5_parsing
     #   See {Capybara.configure}
     Config::OPTIONS.each do |method|
       def_delegators :config, method, "#{method}="
@@ -66,36 +67,49 @@ module Capybara
     #       config.app_host   = 'http://www.google.com'
     #     end
     #
-    # === Configurable options
-    #
-    # [app_host = String/nil]             The default host to use when giving a relative URL to visit, must be a valid URL e.g. http://www.example.com
-    # [always_include_port = Boolean]     Whether the Rack server's port should automatically be inserted into every visited URL unless another port is explicitly specified (Default: false)
-    # [asset_host = String]               Where dynamic assets are hosted - will be prepended to relative asset locations if present (Default: nil)
-    # [run_server = Boolean]              Whether to start a Rack server for the given Rack app (Default: true)
-    # [raise_server_errors = Boolean]     Should errors raised in the server be raised in the tests? (Default: true)
-    # [server_errors = Array\<Class\>]    Error classes that should be raised in the tests if they are raised in the server and Capybara.raise_server_errors is true (Default: [StandardError])
-    # [default_selector = :css/:xpath]    Methods which take a selector use the given type by default (Default: :css)
-    # [default_max_wait_time = Numeric]   The maximum number of seconds to wait for asynchronous processes to finish (Default: 2)
-    # [ignore_hidden_elements = Boolean]  Whether to ignore hidden elements on the page (Default: true)
-    # [automatic_reload = Boolean]        Whether to automatically reload elements as Capybara is waiting (Default: true)
-    # [save_path = String]  Where to put pages saved through save_(page|screenshot), save_and_open_(page|screenshot) (Default: Dir.pwd)
-    # [automatic_label_click = Boolean]   Whether Node#choose, Node#check, Node#uncheck will attempt to click the associated label element if the checkbox/radio button are non-visible (Default: false)
-    # [enable_aria_label = Boolean]  Whether fields, links, and buttons will match against aria-label attribute (Default: false)
-    # [reuse_server = Boolean]  Reuse the server thread between multiple sessions using the same app object (Default: true)
-    # [threadsafe = Boolean]  Whether sessions can be configured individually (Default: false)
-    # [server = Symbol]  The name of the registered server to use when running the app under test (Default: :webrick)
-    # [default_set_options = Hash]  The default options passed to Node::set (Default: {})
-    # [test_id = Symbol/String/nil] Optional attribute to match locator aginst with builtin selectors along with id (Default: nil)
-    # [predicates_wait = Boolean]  Whether Capybaras predicate matchers use waiting behavior by default (Default: true)
-    # [default_normalize_ws = Boolean] Whether text predicates and matchers use normalize whitespace behaviour (Default: false)
-    # [allow_gumbo = Boolean] When `nokogumbo` is available, whether it will be used to parse HTML strings (Default: false)
-    #
-    # === DSL Options
-    #
-    # when using capybara/dsl, the following options are also available:
-    #
-    # [default_driver = Symbol]           The name of the driver to use by default. (Default: :rack_test)
-    # [javascript_driver = Symbol]        The name of a driver to use for JavaScript enabled tests. (Default: :selenium)
+    # #### Configurable options
+    #
+    # - **use_html5_parsing** (Boolean = `false`) - When Nokogiri >= 1.12.0 or `nokogumbo` is installed, whether HTML5 parsing will be used for HTML strings.
+    # - **always_include_port** (Boolean = `false`) - Whether the Rack server's port should automatically be inserted into every visited URL
+    #   unless another port is explicitly specified.
+    # - **app_host** (String, `nil`) - The default host to use when giving a relative URL to visit, must be a valid URL e.g. `http://www.example.com`.
+    # - **asset_host** (String = `nil`) - Where dynamic assets are hosted - will be prepended to relative asset locations if present.
+    # - **automatic_label_click** (Boolean = `false`) - Whether {Capybara::Node::Element#choose Element#choose}, {Capybara::Node::Element#check Element#check},
+    #   {Capybara::Node::Element#uncheck Element#uncheck} will attempt to click the associated `<label>` element if the checkbox/radio button are non-visible.
+    # - **automatic_reload** (Boolean = `true`) - Whether to automatically reload elements as Capybara is waiting.
+    # - **default_max_wait_time** (Numeric = `2`) - The maximum number of seconds to wait for asynchronous processes to finish.
+    # - **default_normalize_ws** (Boolean = `false`) - Whether text predicates and matchers use normalize whitespace behavior.
+    # - **default_retry_interval** (Numeric = `0.01`) - The number of seconds to delay the next check in asynchronous processes.
+    # - **default_selector** (`:css`, `:xpath` = `:css`) - Methods which take a selector use the given type by default. See also {Capybara::Selector}.
+    # - **default_set_options** (Hash = `{}`) - The default options passed to {Capybara::Node::Element#set Element#set}.
+    # - **enable_aria_label** (Boolean = `false`) - Whether fields, links, and buttons will match against `aria-label` attribute.
+    # - **enable_aria_role** (Boolean = `false`) - Selectors will check for relevant aria role (currently only `button`).
+    # - **exact** (Boolean = `false`) - Whether locators are matched exactly or with substrings. Only affects selector conditions
+    #   written using the `XPath#is` method.
+    # - **exact_text** (Boolean = `false`) - Whether the text matchers and `:text` filter match exactly or on substrings.
+    # - **ignore_hidden_elements** (Boolean = `true`) - Whether to ignore hidden elements on the page.
+    # - **match** (`:one`, `:first`, `:prefer_exact`, `:smart` = `:smart`) - The matching strategy to find nodes.
+    # - **predicates_wait** (Boolean = `true`) - Whether Capybara's predicate matchers use waiting behavior by default.
+    # - **raise_server_errors** (Boolean = `true`) - Should errors raised in the server be raised in the tests?
+    # - **reuse_server** (Boolean = `true`) - Whether to reuse the server thread between multiple sessions using the same app object.
+    # - **run_server** (Boolean = `true`) - Whether to start a Rack server for the given Rack app.
+    # - **save_path** (String = `Dir.pwd`) - Where to put pages saved through {Capybara::Session#save_page save_page}, {Capybara::Session#save_screenshot save_screenshot},
+    #   {Capybara::Session#save_and_open_page save_and_open_page}, or {Capybara::Session#save_and_open_screenshot save_and_open_screenshot}.
+    # - **server** (Symbol = `:default` (which uses puma)) - The name of the registered server to use when running the app under test.
+    # - **server_port** (Integer) - The port Capybara will run the application server on, if not specified a random port will be used.
+    # - **server_host** (String = "127.0.0.1") - The IP address Capybara will bind the application server to. If the test application is to be accessed from an external host, you will want to change this to "0.0.0.0" or to a more specific IP address that your test client can reach.
+    # - **server_errors** (Array\<Class> = `[Exception]`) - Error classes that should be raised in the tests if they are raised in the server
+    #   and {configure raise_server_errors} is `true`.
+    # - **test_id** (Symbol, String, `nil` = `nil`) - Optional attribute to match locator against with built-in selectors along with id.
+    # - **threadsafe** (Boolean = `false`) - Whether sessions can be configured individually.
+    # - **w3c_click_offset** (Boolean = 'true') - Whether click offsets should be from element center (true) or top left (false)
+    #
+    # #### DSL Options
+    #
+    # When using `capybara/dsl`, the following options are also available:
+    #
+    # - **default_driver** (Symbol = `:rack_test`) - The name of the driver to use by default.
+    # - **javascript_driver** (Symbol = `:selenium`) - The name of a driver to use for JavaScript enabled tests.
     #
     def configure
       yield config
@@ -115,7 +129,7 @@ module Capybara
     # @yieldreturn [Capybara::Driver::Base]   A Capybara driver instance
     #
     def register_driver(name, &block)
-      drivers[name] = block
+      drivers.send(:register, name, block)
     end
 
     ##
@@ -134,7 +148,7 @@ module Capybara
     # @yieldparam host                        The host/ip to bind to
     #
     def register_server(name, &block)
-      servers[name.to_sym] = block
+      servers.send(:register, name.to_sym, block)
     end
 
     ##
@@ -188,11 +202,11 @@ module Capybara
     end
 
     def drivers
-      @drivers ||= {}
+      @drivers ||= RegistrationContainer.new
     end
 
     def servers
-      @servers ||= {}
+      @servers ||= RegistrationContainer.new
     end
 
     # Wraps the given string, which should contain an HTML document or fragment
@@ -201,15 +215,13 @@ module Capybara
     # any string containing HTML in the exact same way you would query the current document in a Capybara
     # session.
     #
-    # Example: A single element
-    #
+    # @example A single element
     #     node = Capybara.string('<a href="foo">bar</a>')
     #     anchor = node.first('a')
     #     anchor[:href] #=> 'foo'
     #     anchor.text #=> 'bar'
     #
-    # Example: Multiple elements
-    #
+    # @example Multiple elements
     #     node = Capybara.string <<-HTML
     #       <ul>
     #         <li id="home">Home</li>
@@ -248,7 +260,7 @@ module Capybara
     #
     def current_driver
       if threadsafe
-        Thread.current['capybara_current_driver']
+        Thread.current.thread_variable_get :capybara_current_driver
       else
         @current_driver
       end || default_driver
@@ -257,7 +269,7 @@ module Capybara
 
     def current_driver=(name)
       if threadsafe
-        Thread.current['capybara_current_driver'] = name
+        Thread.current.thread_variable_set :capybara_current_driver, name
       else
         @current_driver = name
       end
@@ -297,7 +309,7 @@ module Capybara
 
     ##
     #
-    # The current Capybara::Session based on what is set as Capybara.app and Capybara.current_driver
+    # The current {Capybara::Session} based on what is set as {app} and {current_driver}.
     #
     # @return [Capybara::Session]     The currently used session
     #
@@ -324,7 +336,8 @@ module Capybara
     #
     def session_name
       if threadsafe
-        Thread.current['capybara_session_name'] ||= :default
+        Thread.current.thread_variable_get(:capybara_session_name) ||
+          Thread.current.thread_variable_set(:capybara_session_name, :default)
       else
         @session_name ||= :default
       end
@@ -332,7 +345,7 @@ module Capybara
 
     def session_name=(name)
       if threadsafe
-        Thread.current['capybara_session_name'] = name
+        Thread.current.thread_variable_set :capybara_session_name, name
       else
         @session_name = name
       end
@@ -340,9 +353,10 @@ module Capybara
 
     ##
     #
-    # Yield a block using a specific session name or Capybara::Session instance.
+    # Yield a block using a specific session name or {Capybara::Session} instance.
     #
-    def using_session(name_or_session)
+    def using_session(name_or_session, &block)
+      previous_session = current_session
       previous_session_info = {
         specified_session: specified_session,
         session_name: session_name,
@@ -355,7 +369,12 @@ module Capybara
       else
         self.session_name = name_or_session
       end
-      yield
+
+      if block.arity.zero?
+        yield
+      else
+        yield current_session, previous_session
+      end
     ensure
       self.session_name, self.specified_session = previous_session_info.values_at(:session_name, :specified_session)
       self.current_driver, self.app = previous_session_info.values_at(:current_driver, :app) if threadsafe
@@ -369,18 +388,21 @@ module Capybara
     # @return [Nokogiri::HTML::Document]      HTML document
     #
     def HTML(html) # rubocop:disable Naming/MethodName
-      if Nokogiri.respond_to?(:HTML5) && Capybara.allow_gumbo # Nokogumbo installed and allowed for use
-        Nokogiri::HTML5(html).tap do |document|
-          document.xpath('//textarea').each do |textarea|
-            # The Nokogumbo HTML5 parser already returns spec compliant contents
-            textarea['_capybara_raw_value'] = textarea.content
-          end
-        end
+      # Nokogiri >= 1.12.0 or Nokogumbo installed and allowed for use
+      html_parser, using_html5 = if defined?(Nokogiri::HTML5) && Capybara.use_html5_parsing
+        [Nokogiri::HTML5, true]
       else
-        Nokogiri::HTML(html).tap do |document|
-          document.xpath('//textarea').each do |textarea|
-            textarea['_capybara_raw_value'] = textarea.content.sub(/\A\n/, '')
-          end
+        [defined?(Nokogiri::HTML4) ? Nokogiri::HTML4 : Nokogiri::HTML, false]
+      end
+
+      html_parser.parse(html).tap do |document|
+        document.xpath('//template').each do |template|
+          # template elements content is not part of the document
+          template.inner_html = ''
+        end
+        document.xpath('//textarea').each do |textarea|
+          # The Nokogiri HTML5 parser already returns spec compliant contents
+          textarea['_capybara_raw_value'] = using_html5 ? textarea.content : textarea.content.delete_prefix("\n")
         end
       end
     end
@@ -403,7 +425,7 @@ module Capybara
 
     def specified_session
       if threadsafe
-        Thread.current['capybara_specified_session']
+        Thread.current.thread_variable_get :capybara_specified_session
       else
         @specified_session ||= nil
       end
@@ -411,7 +433,7 @@ module Capybara
 
     def specified_session=(session)
       if threadsafe
-        Thread.current['capybara_specified_session'] = session
+        Thread.current.thread_variable_set :capybara_specified_session, session
       else
         @specified_session = session
       end
@@ -443,6 +465,7 @@ module Capybara
   require 'capybara/queries/ancestor_query'
   require 'capybara/queries/sibling_query'
   require 'capybara/queries/style_query'
+  require 'capybara/queries/active_element_query'
 
   require 'capybara/node/finders'
   require 'capybara/node/matchers'
@@ -460,48 +483,14 @@ module Capybara
   require 'capybara/rack_test/node'
   require 'capybara/rack_test/form'
   require 'capybara/rack_test/browser'
-  require 'capybara/rack_test/css_handlers.rb'
+  require 'capybara/rack_test/css_handlers'
 
   require 'capybara/selenium/node'
   require 'capybara/selenium/driver'
 end
 
-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))
-  options = { Host: host, Port: port, Threads: '0:4', workers: 0, daemon: false }.merge(options)
-  conf = Rack::Handler::Puma.config(app, options)
-  events = conf.options[:Silent] ? ::Puma::Events.strings : ::Puma::Events.stdio
-
-  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
+require 'capybara/registrations/servers'
+require 'capybara/registrations/drivers'
 
 Capybara.configure do |config|
   config.always_include_port = false
@@ -509,6 +498,7 @@ Capybara.configure do |config|
   config.server = :default
   config.default_selector = :css
   config.default_max_wait_time = 2
+  config.default_retry_interval = 0.01
   config.ignore_hidden_elements = true
   config.default_host = 'http://www.example.com'
   config.automatic_reload = true
@@ -516,41 +506,16 @@ Capybara.configure do |config|
   config.exact = false
   config.exact_text = false
   config.raise_server_errors = true
-  config.server_errors = [StandardError]
+  config.server_errors = [Exception]
   config.visible_text_only = false
   config.automatic_label_click = false
   config.enable_aria_label = false
+  config.enable_aria_role = false
   config.reuse_server = true
   config.default_set_options = {}
   config.test_id = nil
   config.predicates_wait = true
   config.default_normalize_ws = false
-  config.allow_gumbo = false
-end
-
-Capybara.register_driver :rack_test do |app|
-  Capybara::RackTest::Driver.new(app)
-end
-
-Capybara.register_driver :selenium do |app|
-  Capybara::Selenium::Driver.new(app)
-end
-
-Capybara.register_driver :selenium_headless do |app|
-  Capybara::Selenium::Driver.load_selenium
-  browser_options = ::Selenium::WebDriver::Firefox::Options.new
-  browser_options.args << '-headless'
-  Capybara::Selenium::Driver.new(app, browser: :firefox, options: browser_options)
-end
-
-Capybara.register_driver :selenium_chrome do |app|
-  Capybara::Selenium::Driver.new(app, browser: :chrome)
-end
-
-Capybara.register_driver :selenium_chrome_headless do |app|
-  Capybara::Selenium::Driver.load_selenium
-  browser_options = ::Selenium::WebDriver::Chrome::Options.new
-  browser_options.args << '--headless'
-  browser_options.args << '--disable-gpu' if Gem.win_platform?
-  Capybara::Selenium::Driver.new(app, browser: :chrome, options: browser_options)
+  config.use_html5_parsing = false
+  config.w3c_click_offset = true
 end

data/spec/basic_node_spec.rb

@@ -3,9 +3,10 @@
 require 'spec_helper'
 
 RSpec.describe Capybara do
+  include Capybara::RSpecMatchers
   describe '.string' do
     let :string do
-      Capybara.string <<-STRING
+      described_class.string <<-STRING
         <html>
           <head>
             <title>simple_node</title>
@@ -52,7 +53,7 @@ RSpec.describe Capybara do
     end
 
     it 'allows using custom matchers' do
-      Capybara.add_selector :lifeform do
+      described_class.add_selector :lifeform do
         xpath { |name| ".//option[contains(.,'#{name}')]" }
       end
       expect(string).to have_selector(:id, 'page')
@@ -62,7 +63,7 @@ RSpec.describe Capybara do
     end
 
     it 'allows custom matcher using css' do
-      Capybara.add_selector :section do
+      described_class.add_selector :section do
         css { |css_class| "section .#{css_class}" }
       end
       expect(string).to     have_selector(:section, 'subsection')
@@ -110,15 +111,28 @@ RSpec.describe Capybara do
       expect(string.find('//form/input[@name="meh"]')).not_to be_disabled
     end
 
+    it 'allows finding siblings' do
+      h1 = string.find(:css, 'h1')
+      expect(h1).to have_sibling(:css, 'p', text: 'Yes it is')
+      expect(h1).not_to have_sibling(:css, 'p', text: 'Jonas Nicklas')
+    end
+
+    it 'allows finding ancestor' do
+      h1 = string.find(:css, 'h1')
+      expect(h1).to have_ancestor(:css, '#content')
+      expect(h1).not_to have_ancestor(:css, '#footer')
+    end
+
     it 'drops illegal fragments when using gumbo' do
       skip 'libxml is less strict than Gumbo' unless Nokogiri.respond_to?(:HTML5)
-      expect(Capybara.string('<td>1</td>')).not_to have_css('td')
+      described_class.use_html5_parsing = true
+      expect(described_class.string('<td>1</td>')).not_to have_css('td')
     end
 
-    it 'can disable use of gumbo' do
-      skip "Test doesn't make sense unlesss nokogumbo is loaded" unless Nokogiri.respond_to?(:HTML5)
-      Capybara.allow_gumbo = false
-      expect(Capybara.string('<td>1</td>')).to have_css('td')
+    it 'can disable use of HTML5 parsing' do
+      skip "Test doesn't make sense unlesss HTML5 parsing is loaded (Nokogumbo or Nokogiri >= 1.12.0)" unless Nokogiri.respond_to?(:HTML5)
+      described_class.use_html5_parsing = false
+      expect(described_class.string('<td>1</td>')).to have_css('td')
     end
 
     describe '#title' do
@@ -129,25 +143,25 @@ RSpec.describe Capybara do
 
     describe '#has_title?' do
       it 'returns whether the page has the given title' do
-        expect(string.has_title?('simple_node')).to be_truthy
-        expect(string.has_title?('monkey')).to be_falsey
+        expect(string.has_title?('simple_node')).to be true
+        expect(string.has_title?('monkey')).to be false
       end
 
       it 'allows regexp matches' do
-        expect(string.has_title?(/s[a-z]+_node/)).to be_truthy
-        expect(string.has_title?(/monkey/)).to be_falsey
+        expect(string.has_title?(/s[a-z]+_node/)).to be true
+        expect(string.has_title?(/monkey/)).to be false
       end
     end
 
     describe '#has_no_title?' do
       it 'returns whether the page does not have the given title' do
-        expect(string.has_no_title?('simple_node')).to be_falsey
-        expect(string.has_no_title?('monkey')).to be_truthy
+        expect(string.has_no_title?('simple_node')).to be false
+        expect(string.has_no_title?('monkey')).to be true
       end
 
       it 'allows regexp matches' do
-        expect(string.has_no_title?(/s[a-z]+_node/)).to be_falsey
-        expect(string.has_no_title?(/monkey/)).to be_truthy
+        expect(string.has_no_title?(/s[a-z]+_node/)).to be false
+        expect(string.has_no_title?(/monkey/)).to be true
       end
     end
   end

data/spec/capybara_spec.rb

@@ -4,20 +4,32 @@ require 'spec_helper'
 
 RSpec.describe Capybara do
   describe 'default_max_wait_time' do
-    after do
-      Capybara.default_max_wait_time = @previous_default_time
+    before { @previous_default_time = described_class.default_max_wait_time }
+
+    after { described_class.default_max_wait_time = @previous_default_time } # rubocop:disable RSpec/InstanceVariable
+
+    it 'should be changeable' do
+      expect(described_class.default_max_wait_time).not_to eq(5)
+      described_class.default_max_wait_time = 5
+      expect(described_class.default_max_wait_time).to eq(5)
     end
+  end
+
+  describe 'default_retry_interval' do
+    before { @previous_default_interval = described_class.default_retry_interval }
+
+    after { described_class.default_retry_interval = @previous_default_interval } # rubocop:disable RSpec/InstanceVariable
 
     it 'should be changeable' do
-      @previous_default_time = Capybara.default_max_wait_time
-      Capybara.default_max_wait_time = 5
-      expect(Capybara.default_max_wait_time).to eq(5)
+      expect(described_class.default_retry_interval).not_to eq(0.1)
+      described_class.default_retry_interval = 0.1
+      expect(described_class.default_retry_interval).to eq(0.1)
     end
   end
 
   describe '.register_driver' do
     it 'should add a new driver' do
-      Capybara.register_driver :schmoo do |app|
+      described_class.register_driver :schmoo do |app|
         Capybara::RackTest::Driver.new(app)
       end
       session = Capybara::Session.new(:schmoo, TestApp)
@@ -28,85 +40,85 @@ RSpec.describe Capybara do
 
   describe '.register_server' do
     it 'should add a new server' do
-      Capybara.register_server :blob do |_app, _port, _host|
+      described_class.register_server :blob do |_app, _port, _host|
         # do nothing
       end
 
-      expect(Capybara.servers).to have_key(:blob)
+      expect(described_class.servers[:blob]).to be_truthy
     end
   end
 
   describe '.server' do
     after do
-      Capybara.server = :default
+      described_class.server = :default
     end
 
     it 'should default to a proc that calls run_default_server' do
       mock_app = Object.new
-      allow(Capybara).to receive(:run_default_server).and_return(true)
-      Capybara.server.call(mock_app, 8000)
-      expect(Capybara).to have_received(:run_default_server).with(mock_app, 8000)
+      allow(described_class).to receive(:run_default_server).and_return(true)
+      described_class.server.call(mock_app, 8000)
+      expect(described_class).to have_received(:run_default_server).with(mock_app, 8000)
     end
 
     it 'should return a custom server proc' do
       server = ->(_app, _port) {}
-      Capybara.register_server :custom, &server
-      Capybara.server = :custom
-      expect(Capybara.server).to eq(server)
+      described_class.register_server :custom, &server
+      described_class.server = :custom
+      expect(described_class.server).to eq(server)
     end
 
     it 'should have :webrick registered' do
-      expect(Capybara.servers[:webrick]).not_to be_nil
+      expect(described_class.servers[:webrick]).not_to be_nil
     end
 
     it 'should have :puma registered' do
-      expect(Capybara.servers[:puma]).not_to be_nil
+      expect(described_class.servers[:puma]).not_to be_nil
     end
   end
 
   describe 'server=' do
     after do
-      Capybara.server = :default
+      described_class.server = :default
     end
 
     it 'accepts a proc' do
       server = ->(_app, _port) {}
-      Capybara.server = server
-      expect(Capybara.server).to eq server
+      described_class.server = server
+      expect(described_class.server).to eq server
     end
   end
 
   describe 'app_host' do
     after do
-      Capybara.app_host = nil
+      described_class.app_host = nil
     end
 
     it 'should warn if not a valid URL' do
-      expect { Capybara.app_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.app_host should be set to a url/)
+      expect { described_class.app_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.app_host should be set to a url/)
     end
 
     it 'should not warn if a valid URL' do
-      expect { Capybara.app_host = 'http://www.example.com' }.not_to raise_error
+      expect { described_class.app_host = 'http://www.example.com' }.not_to raise_error
     end
 
     it 'should not warn if nil' do
-      expect { Capybara.app_host = nil }.not_to raise_error
+      expect { described_class.app_host = nil }.not_to raise_error
     end
   end
 
   describe 'default_host' do
     around do |test|
-      old_default = Capybara.default_host
+      old_default = described_class.default_host
       test.run
-      Capybara.default_host = old_default
+      described_class.default_host = old_default
     end
 
     it 'should raise if not a valid URL' do
-      expect { Capybara.default_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.default_host should be set to a url/)
+      expect { described_class.default_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.default_host should be set to a url/)
     end
 
     it 'should not warn if a valid URL' do
-      expect { Capybara.default_host = 'http://www.example.com' }.not_to raise_error
+      expect { described_class.default_host = 'http://www.example.com' }.not_to raise_error
     end
   end
 end