capybara 3.0.0 → 3.40.0

data/spec/server_spec.rb

@@ -3,194 +3,305 @@
 require 'spec_helper'
 
 RSpec.describe Capybara::Server do
-  it "should spool up a rack server" do
-    @app = proc { |_env| [200, {}, ["Hello Server!"]] }
-    @server = Capybara::Server.new(@app).boot
+  it 'should spool up a rack server' do
+    app = proc { |_env| [200, {}, ['Hello Server!']] }
+    server = described_class.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.fetch('TRAVIS', nil) && (RUBY_ENGINE == 'jruby')) || Gem.win_platform?
+
     begin
       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'] && (RUBY_ENGINE == 'jruby') or Gem.win_platform?
+  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 }
 
-    @server1 = Capybara::Server.new(@app1).boot
-    @server2 = Capybara::Server.new(@app2).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
 
-    @res1 = Net::HTTP.start(@server1.host, @server1.port) { |http| http.get('/') }
-    expect(@res1.body).to include('Hello Server')
+  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
 
-    @res2 = Net::HTTP.start(@server2.host, @server2.port) { |http| http.get('/') }
-    expect(@res2.body).to include('Hello Second Server')
+    port = described_class.new(Object.new, host: '0.0.0.0').port
+    expect(port).not_to eq(server_port)
+  ensure
+    server&.close
   end
 
-  context "When Capybara.reuse_server is true" do
+  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
+
+  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
+
+  it 'should not emit any warnings when booting puma' do
+    Capybara.server = :puma
+    app_proc = proc { |_env| [200, {}, ['Hello Puma!']] }
+    require 'puma'
+
+    expect do
+      described_class.new(app_proc).boot
+    end.not_to output.to_stderr
+  ensure
+    Capybara.server = :default
+  end
+
+  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
+    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 += 1
-        [200, {}, ["Hello Server!"]]
+        [200, {}, ['Hello Server!']]
       end
 
-      server1 = Capybara::Server.new(app).boot
-      server2 = Capybara::Server.new(app).boot
+      server1 = described_class.new(app).boot
+      server2 = described_class.new(app).boot
 
       expect do
         start_request(server1, 1.0)
         start_request(server2, 3.0)
         server1.wait_for_pending_requests
       end.to change { done }.from(0).to(2)
-      expect(server2.send(:pending_requests?)).to eq(false)
+      expect(server2.send(:pending_requests?)).to be(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
+    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 += 1
-        [200, {}, ["Hello Server!"]]
+        [200, {}, ['Hello Server!']]
       end
 
-      server1 = Capybara::Server.new(app).boot
-      server2 = Capybara::Server.new(app).boot
+      server1 = described_class.new(app).boot
+      server2 = described_class.new(app).boot
 
       expect do
         start_request(server1, 1.0)
         start_request(server2, 3.0)
         server1.wait_for_pending_requests
       end.to change { done }.from(0).to(1)
-      expect(server2.send(:pending_requests?)).to eq(true)
+      expect(server2.send(:pending_requests?)).to be(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.register_server :kaboom do
-        sleep 0.1
-        raise 'kaboom'
-      end
-      Capybara.server = :kaboom
+  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
-      Capybara.server = :default
+    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
+  it 'is not #responsive? when Net::HTTP raises a SystemCallError' do
     app = -> { [200, {}, ['Hello, world']] }
-    server = Capybara::Server.new(app)
-    expect(Net::HTTP).to receive(:start).and_raise(SystemCallError.allocate)
-    expect(server.responsive?).to eq false
+    server = described_class.new(app)
+    allow(Net::HTTP).to receive(:start).and_raise(SystemCallError.allocate)
+    expect(server.responsive?).to be 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)

data/spec/session_spec.rb

@@ -3,14 +3,28 @@
 require 'spec_helper'
 
 RSpec.describe Capybara::Session do
-  it "verifies a passed app is a rack app" do
-    expect do
-      Capybara::Session.new(:unknown, random: "hash")
-    end.to raise_error TypeError, "The second parameter to Session::new should be a rack app if passed."
+  describe '#new' do
+    it 'should raise an error if passed non-existent driver' do
+      expect do
+        described_class.new(:quox, TestApp).driver
+      end.to raise_error(Capybara::DriverNotFoundError)
+    end
+
+    it 'verifies a passed app is a rack app' do
+      expect do
+        described_class.new(:unknown, random: 'hash')
+      end.to raise_error TypeError, 'The second parameter to Session::new should be a rack app if passed.'
+    end
   end
 
-  context "current_driver" do
-    it "is global when threadsafe false" do
+  context 'current_driver' do
+    around do |example|
+      orig_driver = Capybara.current_driver
+      example.run
+      Capybara.current_driver = orig_driver
+    end
+
+    it 'is global when threadsafe false' do
       Capybara.threadsafe = false
       Capybara.current_driver = :selenium
       thread = Thread.new do
@@ -20,7 +34,7 @@ RSpec.describe Capybara::Session do
       expect(Capybara.current_driver).to eq :random
     end
 
-    it "is thread specific threadsafe true" do
+    it 'is thread specific threadsafe true' do
       Capybara.threadsafe = true
       Capybara.current_driver = :selenium
       thread = Thread.new do
@@ -31,25 +45,47 @@ RSpec.describe Capybara::Session do
     end
   end
 
-  context "session_name" do
-    it "is global when threadsafe false" do
+  context 'session_name' do
+    around do |example|
+      orig_name = Capybara.session_name
+      example.run
+      Capybara.session_name = orig_name
+    end
+
+    it 'is global when threadsafe false' do
       Capybara.threadsafe = false
-      Capybara.session_name = "sess1"
+      Capybara.session_name = 'sess1'
       thread = Thread.new do
-        Capybara.session_name = "sess2"
+        Capybara.session_name = 'sess2'
       end
       thread.join
-      expect(Capybara.session_name).to eq "sess2"
+      expect(Capybara.session_name).to eq 'sess2'
     end
 
-    it "is thread specific when threadsafe true" do
+    it 'is thread specific when threadsafe true' do
       Capybara.threadsafe = true
-      Capybara.session_name = "sess1"
+      Capybara.session_name = 'sess1'
       thread = Thread.new do
-        Capybara.session_name = "sess2"
+        Capybara.session_name = 'sess2'
       end
       thread.join
-      expect(Capybara.session_name).to eq "sess1"
+      expect(Capybara.session_name).to eq 'sess1'
+    end
+  end
+
+  context 'quit' do
+    it 'will reset the driver' do
+      session = described_class.new(:rack_test, TestApp)
+      driver = session.driver
+      session.quit
+      expect(session.driver).not_to eql driver
+    end
+
+    it 'resets the document' do
+      session = described_class.new(:rack_test, TestApp)
+      document = session.document
+      session.quit
+      expect(session.document.base).not_to eql document.base
     end
   end
 end

data/spec/shared_selenium_node.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'selenium-webdriver'
+
+RSpec.shared_examples 'Capybara::Node' do |session, _mode|
+  let(:session) { session }
+
+  describe '#content_editable?' do
+    it 'returns true when the element is content editable' do
+      session.visit('/with_js')
+      expect(session.find(:css, '#existing_content_editable').base.content_editable?).to be true
+      expect(session.find(:css, '#existing_content_editable_child').base.content_editable?).to be true
+    end
+
+    it 'returns false when the element is not content editable' do
+      session.visit('/with_js')
+      expect(session.find(:css, '#drag').base.content_editable?).to be false
+    end
+  end
+
+  describe '#send_keys' do
+    it 'should process space' do
+      session.visit('/form')
+      session.find(:css, '#address1_city').send_keys('ocean', [:shift, :space, 'side'])
+      expect(session.find(:css, '#address1_city').value).to eq 'ocean SIDE'
+    end
+  end
+
+  describe '#[]' do
+    it 'should work for spellcheck' do
+      session.visit('/with_html')
+      expect(session.find('//input[@spellcheck="TRUE"]')[:spellcheck]).to eq('true')
+      expect(session.find('//input[@spellcheck="FALSE"]')[:spellcheck]).to eq('false')
+    end
+  end
+
+  describe '#set' do
+    it 'respects maxlength when using rapid set' do
+      session.visit('/form')
+      inp = session.find(:css, '#long_length')
+      value = (0...50).map { |i| ((i % 26) + 65).chr }.join
+      inp.set(value, rapid: true)
+      expect(inp.value).to eq value[0...35]
+    end
+  end
+
+  describe '#visible?' do
+    let(:bridge) do
+      session.driver.browser.send(:bridge)
+    end
+
+    around do |example|
+      native_displayed = session.driver.options[:native_displayed]
+      example.run
+      session.driver.options[:native_displayed] = native_displayed
+    end
+
+    before do
+      allow(bridge).to receive(:execute_atom).and_call_original
+    end
+
+    it 'will use native displayed if told to' do
+      session.driver.options[:native_displayed] = true
+      session.visit('/form')
+      session.find(:css, '#address1_city', visible: true)
+
+      expect(bridge).not_to have_received(:execute_atom)
+    end
+
+    it "won't use native displayed if told not to" do
+      session.driver.options[:native_displayed] = false
+      session.visit('/form')
+      session.find(:css, '#address1_city', visible: true)
+
+      expect(bridge).to have_received(:execute_atom).with(:isDisplayed, any_args)
+    end
+  end
+end