capybara 2.5.0 → 2.18.0

data/spec/server_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 RSpec.describe Capybara::Server do
@@ -33,7 +34,7 @@ RSpec.describe Capybara::Server do
     ensure
       Capybara.server_host = nil
     end
-  end
+  end unless ENV['TRAVIS'] and (RUBY_ENGINE == 'jruby') #TODO travis with jruby in container mode has an issue with this test
 
   it "should use specified port" do
     Capybara.server_port = 22789
@@ -71,23 +72,102 @@ RSpec.describe Capybara::Server do
     expect(@res2.body).to include('Hello Second Server')
   end
 
-  it "should use the server if it already running" do
-    @app1 = proc { |env| [200, {}, ["Hello Server!"]]}
-    @app2 = proc { |env| [200, {}, ["Hello Second Server!"]]}
+  context "When Capybara.reuse_server is true" do
+    before do
+      @old_reuse_server = Capybara.reuse_server
+      Capybara.reuse_server = true
+    end
+
+    after do
+      Capybara.reuse_server = @old_reuse_server
+    end
 
-    @server1a = Capybara::Server.new(@app1).boot
-    @server1b = Capybara::Server.new(@app1).boot
-    @server2a = Capybara::Server.new(@app2).boot
-    @server2b = Capybara::Server.new(@app2).boot
+    it "should use the existing server if it already running" do
+      @app = proc { |env| [200, {}, ["Hello Server!"]]}
 
-    @res1 = Net::HTTP.start(@server1b.host, @server1b.port) { |http| http.get('/') }
-    expect(@res1.body).to include('Hello Server')
+      @server1 = Capybara::Server.new(@app).boot
+      @server2 = Capybara::Server.new(@app).boot
 
-    @res2 = Net::HTTP.start(@server2b.host, @server2b.port) { |http| http.get('/') }
-    expect(@res2.body).to include('Hello Second Server')
+      res = Net::HTTP.start(@server1.host, @server1.port) { |http| http.get('/') }
+      expect(res.body).to include('Hello Server')
+
+      res = Net::HTTP.start(@server2.host, @server2.port) { |http| http.get('/') }
+      expect(res.body).to include('Hello Server')
+
+      expect(@server1.port).to eq(@server2.port)
+    end
+
+    it "detects and waits for all reused server sessions pending requests" do
+      done = false
+
+      app = proc do |env|
+        request = Rack::Request.new(env)
+        sleep request.params['wait_time'].to_f
+        done = true
+        [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)
+
+      expect {
+        server1.wait_for_pending_requests
+      }.to change{done}.from(false).to(true)
+      expect(server2.send(:pending_requests?)).to eq(false)
+    end
+
+  end
+
+  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
+    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
+
+      res = Net::HTTP.start(@server1.host, @server1.port) { |http| http.get('/') }
+      expect(res.body).to include('Hello Server')
+
+      res = Net::HTTP.start(@server2.host, @server2.port) { |http| http.get('/') }
+      expect(res.body).to include('Hello Server')
+
+      expect(@server1.port).not_to eq(@server2.port)
+    end
+
+    it "detects and waits for only one sessions pending requests" do
+      done = false
+
+      app = proc do |env|
+        request = Rack::Request.new(env)
+        sleep request.params['wait_time'].to_f
+        done = true
+        [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)
+
+      expect {
+        server1.wait_for_pending_requests
+      }.to change{done}.from(false).to(true)
+      expect(server2.send(:pending_requests?)).to eq(true)
+    end
 
-    expect(@server1a.port).to eq(@server1b.port)
-    expect(@server2a.port).to eq(@server2b.port)
   end
 
   it "should raise server errors when the server errors before the timeout" do
@@ -113,4 +193,12 @@ RSpec.describe Capybara::Server do
     expect(Net::HTTP).to receive(:start).and_raise(SystemCallError.allocate)
     expect(server.responsive?).to eq false
   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.close
+    sleep 0.1
+  end
 end

data/spec/session_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+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."
+  end
+
+  context "current_driver" do
+    it "is global when threadsafe false" do
+      Capybara.threadsafe = false
+      Capybara.current_driver = :selenium
+      thread = Thread.new do
+        Capybara.current_driver = :random
+      end
+      thread.join
+      expect(Capybara.current_driver).to eq :random
+    end
+
+    it "is thread specific threadsafe true" do
+      Capybara.threadsafe = true
+      Capybara.current_driver = :selenium
+      thread = Thread.new do
+        Capybara.current_driver = :random
+      end
+      thread.join
+      expect(Capybara.current_driver).to eq :selenium
+    end
+  end
+
+  context "session_name" do
+    it "is global when threadsafe false" do
+      Capybara.threadsafe = false
+      Capybara.session_name = "sess1"
+      thread = Thread.new do
+        Capybara.session_name = "sess2"
+      end
+      thread.join
+      expect(Capybara.session_name).to eq "sess2"
+    end
+
+    it "is thread specific when threadsafe true" do
+      Capybara.threadsafe = true
+      Capybara.session_name = "sess1"
+      thread = Thread.new do
+        Capybara.session_name = "sess2"
+      end
+      thread.join
+      expect(Capybara.session_name).to eq "sess1"
+    end
+  end
+end

data/spec/shared_selenium_session.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+require 'spec_helper'
+require "selenium-webdriver"
+
+RSpec.shared_examples "Capybara::Session" do |session, mode|
+  let(:session) {session}
+
+  context 'with selenium driver' do
+    before do
+      @session = session
+    end
+
+    describe '#driver' do
+      it "should be a selenium driver" do
+        expect(@session.driver).to be_an_instance_of(Capybara::Selenium::Driver)
+      end
+    end
+
+    describe '#mode' do
+      it "should remember the mode" do
+        expect(@session.mode).to eq(mode)
+      end
+    end
+
+    describe "#reset!" do
+      it "freshly reset session should not be touched" do
+        @session.instance_variable_set(:@touched, true)
+        @session.reset!
+        expect(@session.instance_variable_get(:@touched)).to eq false
+      end
+    end
+
+    describe "exit codes" do
+      before do
+        @current_dir = Dir.getwd
+        Dir.chdir(File.join(File.dirname(__FILE__), '..'))
+        @env = { 'SELENIUM_BROWSER' => @session.driver.options[:browser].to_s }
+        @env['LEGACY_FIREFOX'] = 'TRUE' if mode == :selenium_firefox
+      end
+
+      after do
+        Dir.chdir(@current_dir)
+      end
+
+      it "should have return code 1 when running selenium_driver_rspec_failure.rb" do
+        skip if ENV['HEADLESS']
+        system(@env, 'rspec spec/fixtures/selenium_driver_rspec_failure.rb', out: File::NULL, err: File::NULL)
+        expect($?.exitstatus).to eq(1)
+      end
+
+      it "should have return code 0 when running selenium_driver_rspec_success.rb" do
+        skip if ENV['HEADLESS']
+        system(@env, 'rspec spec/fixtures/selenium_driver_rspec_success.rb', out: File::NULL, err: File::NULL)
+        expect($?.exitstatus).to eq(0)
+      end
+    end
+
+    describe "#accept_alert" do
+      it "supports a blockless mode" do
+        @session.visit('/with_js')
+        @session.click_link('Open alert')
+        @session.accept_alert
+        expect{@session.driver.browser.switch_to.alert}.to raise_error(@session.driver.send(:modal_error))
+      end
+
+      it "can be called before visiting" do
+        @session.accept_alert "Initial alert" do
+          @session.visit('/initial_alert')
+        end
+        expect(@session).to have_text('Initial alert page')
+      end
+    end
+
+    context '#fill_in_with empty string and no options' do
+      it 'should trigger change when clearing a field' do
+        @session.visit('/with_js')
+        @session.fill_in('with_change_event', with: '')
+        # click outside the field to trigger the change event
+        @session.find(:css, 'body').click
+        expect(@session).to have_selector(:css, '.change_event_triggered', match: :one)
+      end
+    end
+
+    context "#fill_in with { :clear => :backspace } fill_option", requires: [:js] do
+      it 'should fill in a field, replacing an existing value' do
+        @session.visit('/form')
+        @session.fill_in('form_first_name', with: 'Harry',
+                          fill_options: { clear: :backspace} )
+        expect(@session.find(:fillable_field, 'form_first_name').value).to eq('Harry')
+      end
+
+      it 'should only trigger onchange once' do
+        @session.visit('/with_js')
+        @session.fill_in('with_change_event', with: 'some value',
+                         fill_options: { :clear => :backspace })
+        # click outside the field to trigger the change event
+        @session.find(:css, 'body').click
+        expect(@session.find(:css, '.change_event_triggered', match: :one)).to have_text 'some value'
+      end
+
+      it 'should trigger change when clearing field' do
+        @session.visit('/with_js')
+        @session.fill_in('with_change_event', with: '',
+                         fill_options: { :clear => :backspace })
+        # click outside the field to trigger the change event
+        @session.find(:css, 'body').click
+        expect(@session).to have_selector(:css, '.change_event_triggered', match: :one)
+      end
+
+      it 'should trigger input event field_value.length times' do
+        @session.visit('/with_js')
+        @session.fill_in('with_change_event', with: '',
+                         fill_options: { :clear => :backspace })
+        # click outside the field to trigger the change event
+        @session.find(:css, 'body').click
+        expect(@session).to have_xpath('//p[@class="input_event_triggered"]', count: 13)
+      end
+    end
+
+    context "#fill_in with { clear: :none } fill_options" do
+      it 'should append to content in a field' do
+        @session.visit('/form')
+        @session.fill_in('form_first_name', with: 'Harry',
+                          fill_options: { clear: :none} )
+        expect(@session.find(:fillable_field, 'form_first_name').value).to eq('JohnHarry')
+      end
+    end
+
+    context "#fill_in with { clear: Array } fill_options" do
+      it 'should pass the array through to the element' do
+        pending "selenium-webdriver/geckodriver doesn't support complex sets of characters" if marionette?(@session)
+        #this is mainly for use with [[:control, 'a'], :backspace] - however since that is platform dependant I'm testing with something less useful
+        @session.visit('/form')
+        @session.fill_in('form_first_name', with: 'Harry',
+                          fill_options: { clear: [[:shift, 'abc'], :backspace] } )
+        expect(@session.find(:fillable_field, 'form_first_name').value).to eq('JohnABHarry')
+      end
+    end
+
+    describe "#path" do
+      it "returns xpath" do
+        # this is here because it is testing for an XPath that is specific to the algorithm used in the selenium driver
+        @session.visit('/path')
+        element = @session.find(:link, 'Second Link')
+        expect(element.path).to eq('/html/body/div[2]/a[1]')
+      end
+    end
+
+    describe "all with disappearing elements" do
+      it "ignores stale elements in results" do
+        @session.visit('/path')
+        elements = @session.all(:link) { |node| raise Selenium::WebDriver::Error::StaleElementReferenceError }
+        expect(elements.size).to eq 0
+      end
+    end
+
+    describe "#evaluate_script" do
+      it "can return an element" do
+        @session.visit('/form')
+        element = @session.evaluate_script("document.getElementById('form_title')")
+        expect(element).to eq @session.find(:id, 'form_title')
+      end
+
+      it "can return arrays of nested elements" do
+        @session.visit('/form')
+        elements = @session.evaluate_script('document.querySelectorAll("#form_city option")')
+        elements.each do |el|
+          expect(el).to be_instance_of Capybara::Node::Element
+        end
+        expect(elements).to eq @session.find(:css, '#form_city').all(:css, 'option').to_a
+      end
+
+      it "can return hashes with elements" do
+        @session.visit('/form')
+        result = @session.evaluate_script("{ a: document.getElementById('form_title'), b: {c: document.querySelectorAll('#form_city option')}}")
+        expect(result).to eq({
+          'a' => @session.find(:id, 'form_title'),
+          'b' => {
+            'c' => @session.find(:css, '#form_city').all(:css, 'option').to_a
+          }
+        })
+      end
+
+      describe "#evaluate_async_script" do
+        it "will timeout if the script takes too long" do
+          @session.visit('/with_js')
+          expect do
+            @session.using_wait_time(1) do
+              @session.evaluate_async_script("var cb = arguments[0]; setTimeout(function(){ cb(null) }, 3000)")
+            end
+          end.to raise_error Selenium::WebDriver::Error::ScriptTimeoutError
+        end
+      end
+    end
+
+    describe "Element#inspect" do
+      it "outputs obsolete elements" do
+        @session.visit('/form')
+        el = @session.find(:button, 'Click me!').click
+        expect(@session).to have_no_button('Click me!')
+        expect(el).not_to receive(:synchronize)
+        expect(el.inspect).to eq "Obsolete #<Capybara::Node::Element>"
+      end
+    end
+
+    describe "Element#click" do
+      it "should handle fixed headers/footers" do
+        @session.visit('/with_fixed_header_footer')
+        # @session.click_link('Go to root')
+        @session.find(:link, 'Go to root').click
+        expect(@session).to have_current_path('/')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,14 @@
+# frozen_string_literal: true
 require 'rspec/expectations'
 require "capybara/spec/spec_helper"
 require "pry"
 
 RSpec.configure do |config|
   Capybara::SpecHelper.configure(config)
+  config.filter_run_including focus_: true unless ENV['TRAVIS']
+  config.run_all_when_everything_filtered = true
+end
+
+def rspec2?
+  !defined?(::RSpec::Expectations::Version) || (Gem::Version.new(RSpec::Expectations::Version::STRING) < Gem::Version.new('3.0'))
 end