capybara 2.7.0 → 3.35.3

data/spec/selenium_spec_firefox_remote.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'selenium-webdriver'
+require 'shared_selenium_session'
+require 'shared_selenium_node'
+require 'rspec/shared_spec_matchers'
+
+def selenium_host
+  ENV.fetch('SELENIUM_HOST', '0.0.0.0')
+end
+
+def selenium_port
+  ENV.fetch('SELENIUM_PORT', 4445)
+end
+
+def ensure_selenium_running!
+  timer = Capybara::Helpers.timer(expire_in: 20)
+  begin
+    TCPSocket.open(selenium_host, selenium_port)
+  rescue StandardError
+    if timer.expired?
+      raise 'Selenium is not running. ' \
+          "You can run a selenium server easily with: \n" \
+          '  $ docker-compose up -d selenium_firefox'
+    else
+      puts 'Waiting for Selenium docker instance...'
+      sleep 1
+      retry
+    end
+  end
+end
+
+Capybara.register_driver :selenium_firefox_remote do |app|
+  ensure_selenium_running!
+
+  url = "http://#{selenium_host}:#{selenium_port}/wd/hub"
+  browser_options = ::Selenium::WebDriver::Firefox::Options.new
+
+  Capybara::Selenium::Driver.new app,
+                                 browser: :remote,
+                                 desired_capabilities: :firefox,
+                                 options: browser_options,
+                                 url: url
+end
+
+FIREFOX_REMOTE_DRIVER = :selenium_firefox_remote
+
+module TestSessions
+  RemoteFirefox = Capybara::Session.new(FIREFOX_REMOTE_DRIVER, TestApp)
+end
+
+skipped_tests = %i[response_headers status_code trigger download]
+
+Capybara::SpecHelper.run_specs TestSessions::RemoteFirefox, FIREFOX_REMOTE_DRIVER.to_s, capybara_skip: skipped_tests do |example|
+  case example.metadata[:full_description]
+  when 'Capybara::Session selenium_firefox_remote node #click should allow multiple modifiers'
+    skip "Firefox doesn't generate an event for shift+control+click" if firefox_gte?(62, @session)
+  when 'Capybara::Session selenium_firefox_remote #accept_prompt should accept the prompt with a blank response when there is a default'
+    pending "Geckodriver doesn't set a blank response in FF < 63 - https://bugzilla.mozilla.org/show_bug.cgi?id=1486485" if firefox_lt?(63, @session)
+  when 'Capybara::Session selenium_firefox_remote #attach_file with multipart form should fire change once when uploading multiple files from empty'
+    pending "FF < 62 doesn't support setting all files at once" if firefox_lt?(62, @session)
+  when 'Capybara::Session selenium_firefox_remote #reset_session! removes ALL cookies'
+    pending "Geckodriver doesn't provide a way to remove cookies outside the current domain"
+  when /#accept_confirm should work with nested modals$/
+    # skip because this is timing based and hence flaky when set to pending
+    skip 'Broken in FF 63 - https://bugzilla.mozilla.org/show_bug.cgi?id=1487358' if firefox_gte?(63, @session)
+  end
+end
+
+RSpec.describe 'Capybara::Session with remote firefox' do
+  include Capybara::SpecHelper
+  ['Capybara::Session', 'Capybara::Node', Capybara::RSpecMatchers].each do |examples|
+    include_examples examples, TestSessions::RemoteFirefox, FIREFOX_REMOTE_DRIVER
+  end
+
+  it 'is considered to be firefox' do
+    expect(session.driver.browser.browser).to eq :firefox
+  end
+end

data/spec/selenium_spec_ie.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'selenium-webdriver'
+require 'shared_selenium_session'
+require 'shared_selenium_node'
+require 'rspec/shared_spec_matchers'
+
+# if ENV['CI']
+#   if ::Selenium::WebDriver::Service.respond_to? :driver_path=
+#     ::Selenium::WebDriver::IE::Service
+#   else
+#     ::Selenium::WebDriver::IE
+#   end.driver_path = 'C:\Tools\WebDriver\IEDriverServer.exe'
+# end
+
+def selenium_host
+  ENV.fetch('SELENIUM_HOST', '192.168.56.102')
+end
+
+def selenium_port
+  ENV.fetch('SELENIUM_PORT', 4444)
+end
+
+def server_host
+  ENV.fetch('SERVER_HOST', '10.24.4.135')
+end
+
+Capybara.register_driver :selenium_ie do |app|
+  # ::Selenium::WebDriver.logger.level = "debug"
+  options = ::Selenium::WebDriver::IE::Options.new
+  # options.require_window_focus = true
+  # options.add_option("log", {"level": "trace"})
+
+  if ENV['REMOTE']
+    Capybara.server_host = server_host
+
+    url = "http://#{selenium_host}:#{selenium_port}/wd/hub"
+    Capybara::Selenium::Driver.new(app,
+                                   browser: :remote,
+                                   options: options,
+                                   url: url)
+  else
+    Capybara::Selenium::Driver.new(
+      app,
+      browser: :ie,
+      options: options
+    )
+  end
+end
+
+module TestSessions
+  SeleniumIE = Capybara::Session.new(:selenium_ie, TestApp)
+end
+
+TestSessions::SeleniumIE.current_window.resize_to(800, 500)
+
+skipped_tests = %i[response_headers status_code trigger modals hover form_attribute windows]
+
+Capybara::SpecHelper.log_selenium_driver_version(Selenium::WebDriver::IE) if ENV['CI']
+
+TestSessions::SeleniumIE.current_window.resize_to(1600, 1200)
+
+Capybara::SpecHelper.run_specs TestSessions::SeleniumIE, 'selenium', capybara_skip: skipped_tests do |example|
+  case example.metadata[:full_description]
+  when /#refresh it reposts$/
+    skip 'IE insists on prompting without providing a way to suppress'
+  when /#click_link can download a file$/
+    skip 'Not sure how to configure IE for automatic downloading'
+  when /#fill_in with Date /
+    pending "IE 11 doesn't support date input types"
+  when /#click_link_or_button with :disabled option happily clicks on links which incorrectly have the disabled attribute$/
+    skip 'IE 11 obeys non-standard disabled attribute on anchor tag'
+  when /#right_click should allow modifiers$/
+    skip "Windows can't :meta click because :meta triggers start menu"
+  when /#click should allow modifiers$/
+    pending "Doesn't work with IE for some unknown reason$"
+  when /#double_click should allow modifiers$/
+    pending "Doesn't work with IE for some unknown reason$"
+  when /#click should allow multiple modifiers$/
+    skip "Windows can't :meta click because :meta triggers start menu"
+  when /#double_click should allow multiple modifiers$/
+    skip "Windows can't :alt double click due to being properties shortcut"
+  when /#has_css\? should support case insensitive :class and :id options$/
+    pending "IE doesn't support case insensitive CSS selectors"
+  when /#reset_session! removes ALL cookies$/
+    pending "IE driver doesn't provide a way to remove ALL cookies"
+  when /#click_button should send button in document order$/
+    pending "IE 11 doesn't support the 'form' attribute"
+  when /#click_button should follow permanent redirects that maintain method$/
+    pending "Window 7 and 8.1 don't support 308 http status code"
+  when /#scroll_to can scroll an element to the center of the viewport$/,
+       /#scroll_to can scroll an element to the center of the scrolling element$/
+    pending " IE doesn't support ScrollToOptions"
+  when /#attach_file with multipart form should fire change once for each set of files uploaded$/,
+       /#attach_file with multipart form should fire change once when uploading multiple files from empty$/,
+       /#attach_file with multipart form should not break when using HTML5 multiple file input uploading multiple files$/
+    pending "IE requires all files be uploaded from same directory. Selenium doesn't provide that." if ENV['REMOTE']
+  when %r{#attach_file with multipart form should send content type image/jpeg when uploading an image$}
+    pending 'IE gets text/plain type for some reason'
+  # when /#click should not retry clicking when wait is disabled$/
+  #   Fixed in IEDriverServer 3.141.0.5
+  #   pending "IE driver doesn't error when clicking on covered elements, it just clicks the wrong element"
+  when /#click should go to the same page if href is blank$/
+    pending 'IE treats blank href as a parent request (against HTML spec)'
+  when /#attach_file with a block/
+    skip 'Hangs IE testing for unknown reason'
+  when /drag_to.*HTML5/
+    pending "IE doesn't support a DataTransfer constuctor"
+  when /template elements should not be visible/
+    skip "IE doesn't support template elements"
+  when /Element#drop/
+    pending "IE doesn't support DataTransfer constructor"
+  end
+end
+
+RSpec.describe 'Capybara::Session with Internet Explorer', capybara_skip: skipped_tests do # rubocop:disable RSpec/MultipleDescribes
+  include Capybara::SpecHelper
+  ['Capybara::Session', 'Capybara::Node', Capybara::RSpecMatchers].each do |examples|
+    include_examples examples, TestSessions::SeleniumIE, :selenium_ie
+  end
+end
+
+RSpec.describe Capybara::Selenium::Node do
+  it '#right_click should allow modifiers' do
+    # pending "Actions API doesn't appear to work for this"
+    session = TestSessions::SeleniumIE
+    session.visit('/with_js')
+    el = session.find(:css, '#click-test')
+    el.right_click(:control)
+    expect(session).to have_link('Has been control right clicked')
+  end
+
+  it '#click should allow multiple modifiers' do
+    # pending "Actions API doesn't appear to work for this"
+    session = TestSessions::SeleniumIE
+    session.visit('with_js')
+    # IE triggers system behavior with :meta so can't use those here
+    session.find(:css, '#click-test').click(:ctrl, :shift, :alt)
+    expect(session).to have_link('Has been alt control shift clicked')
+  end
+
+  it '#double_click should allow modifiers' do
+    # pending "Actions API doesn't appear to work for this"
+    session = TestSessions::SeleniumIE
+    session.visit('/with_js')
+    session.find(:css, '#click-test').double_click(:shift)
+    expect(session).to have_link('Has been shift double clicked')
+  end
+end

data/spec/selenium_spec_safari.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'selenium-webdriver'
+require 'shared_selenium_session'
+require 'shared_selenium_node'
+require 'rspec/shared_spec_matchers'
+
+SAFARI_DRIVER = :selenium_safari
+
+if ::Selenium::WebDriver::Service.respond_to? :driver_path=
+  ::Selenium::WebDriver::Safari::Service
+else
+  ::Selenium::WebDriver::Safari
+end.driver_path = '/Applications/Safari Technology Preview.app/Contents/MacOS/safaridriver'
+
+browser_options = ::Selenium::WebDriver::Safari::Options.new
+# browser_options.headless! if ENV['HEADLESS']
+# browser_options.add_option(:w3c, !!ENV['W3C'])
+
+Capybara.register_driver :selenium_safari do |app|
+  Capybara::Selenium::Driver.new(app, browser: :safari, options: browser_options, timeout: 30).tap do |driver|
+    # driver.browser.download_path = Capybara.save_path
+  end
+end
+
+Capybara.register_driver :selenium_safari_not_clear_storage do |app|
+  safari_options = {
+    browser: :safari,
+    options: browser_options
+  }
+  Capybara::Selenium::Driver.new(app, safari_options.merge(clear_local_storage: false, clear_session_storage: false))
+end
+
+module TestSessions
+  Safari = Capybara::Session.new(SAFARI_DRIVER, TestApp)
+end
+
+skipped_tests = %i[response_headers status_code trigger windows drag]
+
+Capybara::SpecHelper.log_selenium_driver_version(Selenium::WebDriver::Safari) if ENV['CI']
+
+Capybara::SpecHelper.run_specs TestSessions::Safari, SAFARI_DRIVER.to_s, capybara_skip: skipped_tests do |example|
+  case example.metadata[:full_description]
+  when /click_link can download a file/
+    skip "safaridriver doesn't provide a way to set the download directory"
+  when /Capybara::Session selenium_safari Capybara::Window#maximize/
+    pending "Safari headless doesn't support maximize" if ENV['HEADLESS']
+  when /Capybara::Session selenium_safari #visit without a server/,
+       /Capybara::Session selenium_safari #visit with Capybara.app_host set should override server/,
+       /Capybara::Session selenium_safari #reset_session! When reuse_server == false raises any standard errors caught inside the server during a second session/
+    skip "Safari webdriver doesn't support multiple sessions"
+  when /Capybara::Session selenium_safari #click_link with alternative text given to a contained image/,
+       'Capybara::Session selenium_safari #click_link_or_button with enable_aria_label should click on link'
+    pending 'safaridriver thinks these links are non-interactable for some unknown reason'
+  when /Capybara::Session selenium_safari #attach_file with a block can upload by clicking the file input/
+    skip "safaridriver doesn't allow clicking on file inputs"
+  when /Capybara::Session selenium_safari #within_frame works if the frame is closed/,
+       /Capybara::Session selenium_safari #switch_to_frame works if the frame is closed/
+    skip 'Safari has a race condition when clicking an element that causes the frame to close. It will sometimes raise a NoSuchFrameError'
+  when /Capybara::Session selenium_safari #reset_session! removes ALL cookies/
+    skip 'Safari webdriver can only remove cookies for the current domain'
+  when /Capybara::Session selenium_safari #refresh it reposts/
+    skip "Safari opens an alert that can't be closed"
+  when 'Capybara::Session selenium_safari node #double_click should allow to adjust the offset',
+       'Capybara::Session selenium_safari node #double_click should double click an element'
+    pending "safardriver doesn't generate a double click event"
+  when 'Capybara::Session selenium_safari node #click should allow multiple modifiers',
+       /Capybara::Session selenium_safari node #(click|right_click|double_click) should allow modifiers/
+    pending "safaridriver doesn't take key state into account when clicking"
+  when 'Capybara::Session selenium_safari #fill_in on a pre-populated textfield with a reformatting onchange should trigger change when clearing field'
+    pending "safardriver clear doesn't generate change event"
+  when 'Capybara::Session selenium_safari #go_back should fetch a response from the driver from the previous page',
+       'Capybara::Session selenium_safari #go_forward should fetch a response from the driver from the previous page'
+    skip 'safaridriver loses the ability to find elements in the document after `go_back`'
+  when /drag_to.*HTML5/
+    pending "Safari doesn't support"
+  end
+end
+
+RSpec.describe 'Capybara::Session with safari' do
+  include Capybara::SpecHelper
+  ['Capybara::Session', 'Capybara::Node', Capybara::RSpecMatchers].each do |examples|
+    include_examples examples, TestSessions::Safari, SAFARI_DRIVER
+  end
+
+  context 'storage' do
+    describe '#reset!' do
+      it 'clears storage by default' do
+        session = TestSessions::Safari
+        session.visit('/with_js')
+        session.find(:css, '#set-storage').click
+        session.reset!
+        session.visit('/with_js')
+        expect(session.evaluate_script('Object.keys(localStorage)')).to be_empty
+        expect(session.evaluate_script('Object.keys(sessionStorage)')).to be_empty
+      end
+
+      it 'does not clear storage when false' do
+        skip "Safari webdriver doesn't support multiple sessions"
+        session = Capybara::Session.new(:selenium_safari_not_clear_storage, TestApp)
+        session.visit('/with_js')
+        session.find(:css, '#set-storage').click
+        session.reset!
+        session.visit('/with_js')
+        expect(session.evaluate_script('Object.keys(localStorage)')).not_to be_empty
+        expect(session.evaluate_script('Object.keys(sessionStorage)')).not_to be_empty
+      end
+    end
+  end
+
+  context 'timeout' do
+    it 'sets the http client read timeout' do
+      expect(TestSessions::Safari.driver.browser.send(:bridge).http.read_timeout).to eq 30
+    end
+  end
+
+  describe 'filling in Safari-specific date and time fields with keystrokes' do
+    let(:datetime) { Time.new(1983, 6, 19, 6, 30) }
+    let(:session) { TestSessions::Safari }
+
+    before do
+      session.visit('/form')
+    end
+
+    it 'should fill in a date input with a String' do
+      pending "Safari doesn't support date inputs"
+      session.fill_in('form_date', with: '06/19/1983')
+      session.click_button('awesome')
+      expect(Date.parse(extract_results(session)['date'])).to eq datetime.to_date
+    end
+
+    it 'should fill in a time input with a String' do
+      # Safari doesn't support time inputs - so this is just a text input
+      session.fill_in('form_time', with: '06:30A')
+      session.click_button('awesome')
+      results = extract_results(session)['time']
+      expect(Time.parse(results).strftime('%r')).to eq datetime.strftime('%r')
+    end
+
+    it 'should fill in a datetime input with a String' do
+      pending "Safari doesn't support datetime inputs"
+      session.fill_in('form_datetime', with: "06/19/1983\t06:30A")
+      session.click_button('awesome')
+      expect(Time.parse(extract_results(session)['datetime'])).to eq datetime
+    end
+  end
+end

data/spec/server_spec.rb

@@ -1,203 +1,302 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Capybara::Server do
+  it 'should spool up a rack server' do
+    app = proc { |_env| [200, {}, ['Hello Server!']] }
+    server = described_class.new(app).boot
 
-  it "should spool up a rack server" do
-    @app = proc { |env| [200, {}, ["Hello Server!"]]}
-    @server = Capybara::Server.new(@app).boot
-
-    @res = Net::HTTP.start(@server.host, @server.port) { |http| http.get('/') }
+    res = Net::HTTP.start(server.host, server.port) { |http| http.get('/') }
 
-    expect(@res.body).to include('Hello Server')
+    expect(res.body).to include('Hello Server')
   end
 
-  it "should do nothing when no server given" do
+  it 'should do nothing when no server given' do
     expect do
-      @server = Capybara::Server.new(nil).boot
+      described_class.new(nil).boot
     end.not_to raise_error
   end
 
-  it "should bind to the specified host" do
+  it 'should bind to the specified host' do
+    # TODO: travis with jruby in container mode has an issue with this test
+    skip 'This platform has an issue with this test' if (ENV['TRAVIS'] && (RUBY_ENGINE == 'jruby')) || Gem.win_platform?
+
     begin
-      app = proc { |env| [200, {}, ['Hello Server!']] }
+      app = proc { |_env| [200, {}, ['Hello Server!']] }
 
       Capybara.server_host = '127.0.0.1'
-      server = Capybara::Server.new(app).boot
+      server = described_class.new(app).boot
       res = Net::HTTP.get(URI("http://127.0.0.1:#{server.port}"))
       expect(res).to eq('Hello Server!')
 
       Capybara.server_host = '0.0.0.0'
-      server = Capybara::Server.new(app).boot
+      server = described_class.new(app).boot
       res = Net::HTTP.get(URI("http://127.0.0.1:#{server.port}"))
       expect(res).to eq('Hello Server!')
     ensure
       Capybara.server_host = nil
     end
-  end unless ENV['TRAVIS'] and (RUBY_ENGINE == 'jruby') #TODO travis with jruby in container mode has an issue with this test
+  end
 
-  it "should use specified port" do
+  it 'should use specified port' do
     Capybara.server_port = 22789
 
-    @app = proc { |env| [200, {}, ["Hello Server!"]]}
-    @server = Capybara::Server.new(@app).boot
+    app = proc { |_env| [200, {}, ['Hello Server!']] }
+    server = described_class.new(app).boot
 
-    @res = Net::HTTP.start(@server.host, 22789) { |http| http.get('/') }
-    expect(@res.body).to include('Hello Server')
+    res = Net::HTTP.start(server.host, 22789) { |http| http.get('/') }
+    expect(res.body).to include('Hello Server')
 
     Capybara.server_port = nil
   end
 
-  it "should use given port" do
-    @app = proc { |env| [200, {}, ["Hello Server!"]]}
-    @server = Capybara::Server.new(@app, 22790).boot
+  it 'should use given port' do
+    app = proc { |_env| [200, {}, ['Hello Server!']] }
+    server = described_class.new(app, port: 22790).boot
 
-    @res = Net::HTTP.start(@server.host, 22790) { |http| http.get('/') }
-    expect(@res.body).to include('Hello Server')
+    res = Net::HTTP.start(server.host, 22790) { |http| http.get('/') }
+    expect(res.body).to include('Hello Server')
 
     Capybara.server_port = nil
   end
 
-  it "should find an available port" do
-    @app1 = proc { |env| [200, {}, ["Hello Server!"]]}
-    @app2 = proc { |env| [200, {}, ["Hello Second Server!"]]}
+  it 'should find an available port' do
+    responses = ['Hello Server!', 'Hello Second Server!']
+    apps = responses.map do |response|
+      proc { |_env| [200, {}, [response]] }
+    end
+    servers = apps.map { |app| described_class.new(app).boot }
+
+    servers.each_with_index do |server, idx|
+      result = Net::HTTP.start(server.host, server.port) { |http| http.get('/') }
+      expect(result.body).to include(responses[idx])
+    end
+  end
+
+  it 'should handle that getting available ports fails randomly' do
+    # Use a port to force a EADDRINUSE error to be generated
+    server = TCPServer.new('0.0.0.0', 0)
+    server_port = server.addr[1]
+    d_server = instance_double('TCPServer', addr: [nil, server_port, nil, nil], close: nil)
+    call_count = 0
+    allow(TCPServer).to receive(:new).and_wrap_original do |m, *args|
+      call_count.zero? ? d_server : m.call(*args)
+    ensure
+      call_count += 1
+    end
 
-    @server1 = Capybara::Server.new(@app1).boot
-    @server2 = Capybara::Server.new(@app2).boot
+    port = described_class.new(Object.new, host: '0.0.0.0').port
+    expect(port).not_to eq(server_port)
+  ensure
+    server&.close
+  end
 
-    @res1 = Net::HTTP.start(@server1.host, @server1.port) { |http| http.get('/') }
-    expect(@res1.body).to include('Hello Server')
+  it 'should return its #base_url' do
+    app = proc { |_env| [200, {}, ['Hello Server!']] }
+    server = described_class.new(app).boot
+    uri = ::Addressable::URI.parse(server.base_url)
+    expect(uri.to_hash).to include(scheme: 'http', host: server.host, port: server.port)
+  end
 
-    @res2 = Net::HTTP.start(@server2.host, @server2.port) { |http| http.get('/') }
-    expect(@res2.body).to include('Hello Second Server')
+  it 'should call #clamp on the puma configuration to ensure that environment is a string' do
+    Capybara.server = :puma
+    app_proc = proc { |_env| [200, {}, ['Hello Puma!']] }
+    require 'puma'
+    allow(Puma::Server).to receive(:new).and_wrap_original do |method, app, events, options|
+      # If #clamp is not called on the puma config then this will be a Proc
+      expect(options.fetch(:environment)).to be_a(String)
+      method.call(app, events, options)
+    end
+    server = described_class.new(app_proc).boot
+    expect(Puma::Server).to have_received(:new).with(
+      anything,
+      anything,
+      satisfy { |opts| opts.final_options[:Port] == server.port }
+    )
+  ensure
+    Capybara.server = :default
   end
 
-  context "When Capybara.reuse_server is true" do
+  it 'should support SSL' do
+    key = File.join(Dir.pwd, 'spec', 'fixtures', 'key.pem')
+    cert = File.join(Dir.pwd, 'spec', 'fixtures', 'certificate.pem')
+    Capybara.server = :puma, { Host: "ssl://#{Capybara.server_host}?key=#{key}&cert=#{cert}" }
+    app = proc { |_env| [200, {}, ['Hello SSL Server!']] }
+    server = described_class.new(app).boot
+
+    expect do
+      Net::HTTP.start(server.host, server.port, max_retries: 0) { |http| http.get('/__identify__') }
+    end.to(raise_error do |e|
+      expect(e.is_a?(EOFError) || e.is_a?(Net::ReadTimeout)).to be true
+    end)
+
+    res = Net::HTTP.start(server.host, server.port, use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE) do |https|
+      https.get('/')
+    end
+
+    expect(res.body).to include('Hello SSL Server!')
+    uri = ::Addressable::URI.parse(server.base_url)
+    expect(uri.to_hash).to include(scheme: 'https', host: server.host, port: server.port)
+  ensure
+    Capybara.server = :default
+  end
+
+  context 'When Capybara.reuse_server is true' do
+    let!(:old_reuse_server) { Capybara.reuse_server }
+
     before do
-      @old_reuse_server = Capybara.reuse_server
       Capybara.reuse_server = true
     end
 
     after do
-      Capybara.reuse_server = @old_reuse_server
+      Capybara.reuse_server = old_reuse_server
     end
 
-    it "should use the existing server if it already running" do
-      @app = proc { |env| [200, {}, ["Hello Server!"]]}
-
-      @server1 = Capybara::Server.new(@app).boot
-      @server2 = Capybara::Server.new(@app).boot
+    it 'should use the existing server if it already running' do
+      app = proc { |_env| [200, {}, ['Hello Server!']] }
 
-      res = Net::HTTP.start(@server1.host, @server1.port) { |http| http.get('/') }
-      expect(res.body).to include('Hello Server')
+      servers = Array.new(2) { described_class.new(app).boot }
 
-      res = Net::HTTP.start(@server2.host, @server2.port) { |http| http.get('/') }
-      expect(res.body).to include('Hello Server')
+      servers.each do |server|
+        res = Net::HTTP.start(server.host, server.port) { |http| http.get('/') }
+        expect(res.body).to include('Hello Server')
+      end
 
-      expect(@server1.port).to eq(@server2.port)
+      expect(servers[0].port).to eq(servers[1].port)
     end
 
-    it "detects and waits for all reused server sessions pending requests" do
-      done = false
+    it 'detects and waits for all reused server sessions pending requests' do
+      done = 0
 
       app = proc do |env|
         request = Rack::Request.new(env)
         sleep request.params['wait_time'].to_f
-        done = true
-        [200, {}, ["Hello Server!"]]
+        done += 1
+        [200, {}, ['Hello Server!']]
       end
 
-      server1 = Capybara::Server.new(app).boot
-      server2 = Capybara::Server.new(app).boot
-
-      start_request(server1, 0.5)
-      start_request(server2, 1.0)
+      server1 = described_class.new(app).boot
+      server2 = described_class.new(app).boot
 
-      expect {
+      expect do
+        start_request(server1, 1.0)
+        start_request(server2, 3.0)
         server1.wait_for_pending_requests
-      }.to change{done}.from(false).to(true)
-      expect(server2.instance_variable_get('@middleware').pending_requests?).to eq(false)
+      end.to change { done }.from(0).to(2)
+      expect(server2.send(:pending_requests?)).to eq(false)
     end
-
   end
 
-  context "When Capybara.reuse_server is false" do
+  context 'When Capybara.reuse_server is false' do
     before do
       @old_reuse_server = Capybara.reuse_server
       Capybara.reuse_server = false
     end
 
     after do
-      Capybara.reuse_server = @old_reuse_server
+      Capybara.reuse_server = @old_reuse_server # rubocop:disable RSpec/InstanceVariable
     end
 
-    it "should not reuse an already running server" do
-      @app = proc { |env| [200, {}, ["Hello Server!"]]}
-
-      @server1 = Capybara::Server.new(@app).boot
-      @server2 = Capybara::Server.new(@app).boot
+    it 'should not reuse an already running server' do
+      app = proc { |_env| [200, {}, ['Hello Server!']] }
 
-      res = Net::HTTP.start(@server1.host, @server1.port) { |http| http.get('/') }
-      expect(res.body).to include('Hello Server')
+      servers = Array.new(2) { described_class.new(app).boot }
 
-      res = Net::HTTP.start(@server2.host, @server2.port) { |http| http.get('/') }
-      expect(res.body).to include('Hello Server')
+      servers.each do |server|
+        res = Net::HTTP.start(server.host, server.port) { |http| http.get('/') }
+        expect(res.body).to include('Hello Server')
+      end
 
-      expect(@server1.port).not_to eq(@server2.port)
+      expect(servers[0].port).not_to eq(servers[1].port)
     end
 
-    it "detects and waits for only one sessions pending requests" do
-      done = false
+    it 'detects and waits for only one sessions pending requests' do
+      done = 0
 
       app = proc do |env|
         request = Rack::Request.new(env)
         sleep request.params['wait_time'].to_f
-        done = true
-        [200, {}, ["Hello Server!"]]
+        done += 1
+        [200, {}, ['Hello Server!']]
       end
 
-      server1 = Capybara::Server.new(app).boot
-      server2 = Capybara::Server.new(app).boot
-
-      start_request(server1, 0.5)
-      start_request(server2, 1.0)
+      server1 = described_class.new(app).boot
+      server2 = described_class.new(app).boot
 
-      expect {
+      expect do
+        start_request(server1, 1.0)
+        start_request(server2, 3.0)
         server1.wait_for_pending_requests
-      }.to change{done}.from(false).to(true)
-      expect(server2.instance_variable_get('@middleware').pending_requests?).to eq(true)
+      end.to change { done }.from(0).to(1)
+      expect(server2.send(:pending_requests?)).to eq(true)
+      expect do
+        server2.wait_for_pending_requests
+      end.to change { done }.from(1).to(2)
     end
-
   end
 
-  it "should raise server errors when the server errors before the timeout" do
-    begin
-      Capybara.server do
-        sleep 0.1
-        raise 'kaboom'
-      end
+  it 'should raise server errors when the server errors before the timeout' do
+    Capybara.register_server :kaboom do
+      sleep 0.1
+      raise 'kaboom'
+    end
+    Capybara.server = :kaboom
 
-      expect do
-        Capybara::Server.new(proc {|e|}).boot
-      end.to raise_error(RuntimeError, 'kaboom')
-    ensure
-      # TODO refactor out the defaults so it's reliant on unset state instead of
-      # a one-time call in capybara.rb
-      Capybara.server {|app, port| Capybara.run_default_server(app, port)}
+    expect do
+      described_class.new(proc { |e| }).boot
+    end.to raise_error(RuntimeError, 'kaboom')
+  ensure
+    Capybara.server = :default
+  end
+
+  it 'should raise an error when there are pending requests' do
+    app = proc do |env|
+      request = Rack::Request.new(env)
+      sleep request.params['wait_time'].to_f
+      [200, {}, ['Hello Server!']]
     end
+
+    server = described_class.new(app).boot
+
+    expect do
+      start_request(server, 59.0)
+      server.wait_for_pending_requests
+    end.not_to raise_error
+
+    expect do
+      start_request(server, 61.0)
+      server.wait_for_pending_requests
+    end.to raise_error('Requests did not finish in 60 seconds: ["/?wait_time=61.0"]')
   end
 
-  it "is not #responsive? when Net::HTTP raises a SystemCallError" do
-    app = lambda { [200, {}, ['Hello, world']] }
-    server = Capybara::Server.new(app)
-    expect(Net::HTTP).to receive(:start).and_raise(SystemCallError.allocate)
+  it 'is not #responsive? when Net::HTTP raises a SystemCallError' do
+    app = -> { [200, {}, ['Hello, world']] }
+    server = described_class.new(app)
+    allow(Net::HTTP).to receive(:start).and_raise(SystemCallError.allocate)
     expect(server.responsive?).to eq false
   end
 
+  [EOFError, Net::ReadTimeout].each do |err|
+    it "should attempt an HTTPS connection if HTTP connection returns #{err}" do
+      app = -> { [200, {}, ['Hello, world']] }
+      ordered_errors = [Errno::ECONNREFUSED, err]
+      allow(Net::HTTP).to receive(:start).with(anything, anything, hash_excluding(:use_ssl)) do
+        raise ordered_errors.shift
+      end
+      response = Net::HTTPSuccess.allocate
+      allow(response).to receive(:body).and_return app.object_id.to_s
+      allow(Net::HTTP).to receive(:start).with(anything, anything, hash_including(use_ssl: true)).and_return(response).once
+      described_class.new(app).boot
+      expect(Net::HTTP).to have_received(:start).exactly(3).times
+    end
+  end
+
   def start_request(server, wait_time)
     # Start request, but don't wait for it to finish
     socket = TCPSocket.new(server.host, server.port)
-    socket.write "GET /?wait_time=#{wait_time.to_s} HTTP/1.0\r\n\r\n"
+    socket.write "GET /?wait_time=#{wait_time} HTTP/1.0\r\n\r\n"
+    sleep 0.1
     socket.close
     sleep 0.1
   end