capybara 3.32.0 → 3.35.0

data/spec/rspec_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable RSpec/MultipleDescribes
+
 require 'spec_helper'
 
 RSpec.describe 'capybara/rspec' do
@@ -143,3 +145,5 @@ feature 'Feature DSL' do
     expect(page.body).to include('Another World')
   end
 end
+
+# rubocop:enable RSpec/MultipleDescribes

data/spec/selector_spec.rb

@@ -3,6 +3,7 @@
 require 'spec_helper'
 
 RSpec.describe Capybara do
+  include Capybara::RSpecMatchers
   describe 'Selectors' do
     let :string do
       described_class.string <<-STRING
@@ -326,9 +327,23 @@ RSpec.describe Capybara do
           expect(string.find(:custom_xpath_selector, './/div', class: /dOm WoR/i)[:id]).to eq 'random_words'
         end
 
-        it 'accepts Regexp for CSS base selectors' do
+        it 'accepts Regexp for CSS based selectors' do
           expect(string.find(:custom_css_selector, 'div', class: /random/)[:id]).to eq 'random_words'
         end
+
+        it 'accepts Regexp for individual class names for XPath based selectors' do
+          expect(string.find(:custom_xpath_selector, './/div', class: [/random/, 'some'])[:id]).to eq 'random_words'
+          expect(string.find(:custom_xpath_selector, './/div', class: [/om/, /wor/])[:id]).to eq 'random_words'
+          expect { string.find(:custom_xpath_selector, './/div', class: [/not/, /wor/]) }.to raise_error(Capybara::ElementNotFound)
+          expect { string.find(:custom_xpath_selector, './/div', class: [/dom wor/]) }.to raise_error(Capybara::ElementNotFound)
+        end
+
+        it 'accepts Regexp for individual class names for CSS based selectors' do
+          expect(string.find(:custom_css_selector, 'div', class: [/random/])[:id]).to eq 'random_words'
+          expect(string.find(:custom_css_selector, 'div', class: [/om/, /wor/, 'some'])[:id]).to eq 'random_words'
+          expect { string.find(:custom_css_selector, 'div', class: [/not/, /wor/]) }.to raise_error(Capybara::ElementNotFound)
+          expect { string.find(:custom_css_selector, 'div', class: [/dom wor/]) }.to raise_error(Capybara::ElementNotFound)
+        end
       end
 
       context 'with :style option' do
@@ -476,7 +491,7 @@ RSpec.describe Capybara do
       end
 
       describe ':link_or_button selector' do
-        around(:all) do |example|
+        around do |example|
           described_class.modify_selector(:link_or_button) do
             expression_filter(:random) { |xpath, _| xpath } # do nothing filter
           end

data/spec/selenium_spec_chrome.rb

@@ -19,39 +19,56 @@ browser_options.add_preference('download.default_directory', Capybara.save_path)
 browser_options.add_preference(:download, default_directory: Capybara.save_path)
 
 Capybara.register_driver :selenium_chrome do |app|
-  Capybara::Selenium::Driver.new(app, browser: :chrome, options: browser_options, timeout: 30).tap do |driver|
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  driver_options = { browser: :chrome, timeout: 30 }.tap do |opts|
+    opts[options_key] = browser_options
+  end
+
+  Capybara::Selenium::Driver.new(app, **driver_options).tap do |driver|
     # Set download dir for Chrome < 77
     driver.browser.download_path = Capybara.save_path
   end
 end
 
 Capybara.register_driver :selenium_chrome_not_clear_storage do |app|
-  chrome_options = {
-    browser: :chrome,
-    options: browser_options
-  }
-  Capybara::Selenium::Driver.new(app, **chrome_options.merge(clear_local_storage: false, clear_session_storage: false))
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  chrome_options = { browser: :chrome, clear_local_storage: false, clear_session_storage: false }.tap do |opts|
+    opts[options_key] = browser_options
+  end
+
+  Capybara::Selenium::Driver.new(app, **chrome_options)
 end
 
 Capybara.register_driver :selenium_chrome_not_clear_session_storage do |app|
-  chrome_options = {
-    browser: :chrome,
-    options: browser_options
-  }
-  Capybara::Selenium::Driver.new(app, **chrome_options.merge(clear_session_storage: false))
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  chrome_options = { browser: :chrome, clear_session_storage: false }.tap do |opts|
+    opts[options_key] = browser_options
+  end
+
+  Capybara::Selenium::Driver.new(app, **chrome_options)
 end
 
 Capybara.register_driver :selenium_chrome_not_clear_local_storage do |app|
-  chrome_options = {
-    browser: :chrome,
-    options: browser_options
-  }
-  Capybara::Selenium::Driver.new(app, **chrome_options.merge(clear_local_storage: false))
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  chrome_options = { browser: :chrome, clear_local_storage: false }.tap do |opts|
+    opts[options_key] = browser_options
+  end
+  Capybara::Selenium::Driver.new(app, **chrome_options)
 end
 
 Capybara.register_driver :selenium_driver_subclass_with_chrome do |app|
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
   subclass = Class.new(Capybara::Selenium::Driver)
-  subclass.new(app, browser: :chrome, options: browser_options, timeout: 30)
+  chrome_options = { browser: :chrome, timeout: 30 }.tap do |opts|
+    opts[options_key] = browser_options
+  end
+
+  subclass.new(app, **chrome_options)
 end
 
 module TestSessions
@@ -70,8 +87,6 @@ Capybara::SpecHelper.run_specs TestSessions::Chrome, CHROME_DRIVER.to_s, capybar
     pending "Chrome headless doesn't support maximize" if ENV['HEADLESS']
   when /Capybara::Window#fullscreen should be able to fullscreen the window/
     skip 'Chromedriver hangs on attempts to fullscreen in headless mode' if ENV['HEADLESS']
-  when /details non-summary descendants should be non-visible/
-    pending 'Chromedriver built-in is_displayed is currently broken' if ENV['W3C'] == 'false'
   when /node #right_click delay should delay the mouse up/
     skip "Legacy selenium doesn't support separate right button down/up" if ENV['W3C'] == 'false'
   end
@@ -173,7 +188,7 @@ RSpec.describe 'Capybara::Session with chrome' do
     before { skip 'Only makes sense in W3C mode' if ENV['W3C'] == 'false' }
 
     it 'does not error getting log types' do
-      skip if Gem::Version.new(session.driver.browser.capabilities['chrome']['chromedriverVersion'].split[0]) < Gem::Version.new('75.0.3770.90')
+      skip if Gem::Requirement.new('< 75.0.3770.90').satisfied_by? chromedriver_version
       expect do
         session.driver.browser.manage.logs.available_types
       end.not_to raise_error
@@ -185,4 +200,8 @@ RSpec.describe 'Capybara::Session with chrome' do
       end.not_to raise_error
     end
   end
+
+  def chromedriver_version
+    Gem::Version.new(session.driver.browser.capabilities['chrome']['chromedriverVersion'].split[0])
+  end
 end

data/spec/selenium_spec_chrome_remote.rb

@@ -81,7 +81,7 @@ RSpec.describe 'Capybara::Session with remote Chrome' do
     before { skip 'Only makes sense in W3C mode' if ENV['W3C'] == 'false' }
 
     it 'does not error when getting log types' do
-      skip if Gem::Version.new(session.driver.browser.capabilities['chrome']['chromedriverVersion'].split[0]) < Gem::Version.new('75.0.3770.90')
+      skip unless Gem::Requirement.new('>= 75.0.3770.90').satisfied_by? chromedriver_version
       expect do
         session.driver.browser.manage.logs.available_types
       end.not_to raise_error
@@ -93,4 +93,8 @@ RSpec.describe 'Capybara::Session with remote Chrome' do
       end.not_to raise_error
     end
   end
+
+  def chromedriver_version
+    Gem::Version.new(session.driver.browser.capabilities['chrome']['chromedriverVersion'].split[0])
+  end
 end

data/spec/selenium_spec_firefox.rb

@@ -14,28 +14,30 @@ browser_options.profile = Selenium::WebDriver::Firefox::Profile.new.tap do |prof
   profile['browser.download.dir'] = Capybara.save_path
   profile['browser.download.folderList'] = 2
   profile['browser.helperApps.neverAsk.saveToDisk'] = 'text/csv'
+  profile['browser.startup.homepage'] = 'about:blank' # workaround bug in Selenium 4 alpha4-7
 end
 
 Capybara.register_driver :selenium_firefox do |app|
   # ::Selenium::WebDriver.logger.level = "debug"
-  Capybara::Selenium::Driver.new(
-    app,
-    browser: :firefox,
-    options: browser_options,
-    timeout: 31
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  driver_options = { browser: :firefox, timeout: 31 }.tap do |opts|
+    opts[options_key] = browser_options
     # Get a trace level log from geckodriver
     # :driver_opts => { args: ['-vv'] }
-  )
+  end
+
+  Capybara::Selenium::Driver.new(app, **driver_options)
 end
 
 Capybara.register_driver :selenium_firefox_not_clear_storage do |app|
-  Capybara::Selenium::Driver.new(
-    app,
-    browser: :firefox,
-    clear_local_storage: false,
-    clear_session_storage: false,
-    options: browser_options
-  )
+  version = Capybara::Selenium::Driver.load_selenium
+  options_key = Capybara::Selenium::Driver::CAPS_VERSION.satisfied_by?(version) ? :capabilities : :options
+  driver_options = { browser: :firefox, clear_local_storage: false, clear_session_storage: false }.tap do |opts|
+    opts[options_key] = browser_options
+  end
+
+  Capybara::Selenium::Driver.new(app, **driver_options)
 end
 
 module TestSessions

data/spec/server_spec.rb

@@ -75,25 +75,21 @@ RSpec.describe Capybara::Server do
   end
 
   it 'should handle that getting available ports fails randomly' do
-    begin
-      # 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|
-        begin
-          call_count.zero? ? d_server : m.call(*args)
-        ensure
-          call_count += 1
-        end
-      end
-
-      port = described_class.new(Object.new, host: '0.0.0.0').port
-      expect(port).not_to eq(server_port)
+    # 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
-      server&.close
+      call_count += 1
     end
+
+    port = described_class.new(Object.new, host: '0.0.0.0').port
+    expect(port).not_to eq(server_port)
+  ensure
+    server&.close
   end
 
   it 'should return its #base_url' do
@@ -103,30 +99,47 @@ RSpec.describe Capybara::Server do
     expect(uri.to_hash).to include(scheme: 'http', host: server.host, port: server.port)
   end
 
-  it 'should support SSL' do
-    begin
-      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
+  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
 
-      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)
+  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
 
-      res = Net::HTTP.start(server.host, server.port, use_ssl: true, verify_mode: OpenSSL::SSL::VERIFY_NONE) do |https|
-        https.get('/')
-      end
+    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)
 
-      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
+    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
@@ -224,19 +237,17 @@ RSpec.describe Capybara::Server do
   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
-
-      expect do
-        described_class.new(proc { |e| }).boot
-      end.to raise_error(RuntimeError, 'kaboom')
-    ensure
-      Capybara.server = :default
+    Capybara.register_server :kaboom do
+      sleep 0.1
+      raise 'kaboom'
     end
+    Capybara.server = :kaboom
+
+    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

data/spec/shared_selenium_node.rb

@@ -35,6 +35,16 @@ RSpec.shared_examples 'Capybara::Node' do |session, _mode|
     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)

data/spec/shared_selenium_session.rb

@@ -160,6 +160,15 @@ RSpec.shared_examples 'Capybara::Session' do |session, mode|
                         fill_options: { clear: :none })
         expect(session.find(:fillable_field, 'form_first_name').value).to eq('JohnHarry')
       end
+
+      it 'works with rapid fill' do
+        pending 'Safari overwrites by default - need to figure out a workaround' if safari?(session)
+
+        long_string = (0...60).map { |i| ((i % 26) + 65).chr }.join
+        session.visit('/form')
+        session.fill_in('form_first_name', with: long_string, fill_options: { clear: :none })
+        expect(session.find(:fillable_field, 'form_first_name').value).to eq("John#{long_string}")
+      end
     end
 
     describe '#fill_in with Date' do
@@ -205,6 +214,26 @@ RSpec.shared_examples 'Capybara::Session' do |session, mode|
       end
     end
 
+    describe '#fill_in with Emoji' do
+      it 'sends emojis' do
+        session.visit('/form')
+        session.fill_in('form_first_name', with: 'a😀cd😴 🛌🏽🇵🇹 e🤾🏽‍♀️f')
+        expect(session.find(:fillable_field, 'form_first_name').value).to eq('a😀cd😴 🛌🏽🇵🇹 e🤾🏽‍♀️f')
+      end
+    end
+
+    describe '#send_keys' do
+      it 'defaults to sending keys to the document.activeElement' do
+        session.visit('/form')
+
+        expect(session.evaluate_script('document.activeElement')).to eq(session.find('//body'))
+
+        session.send_keys(:tab)
+
+        expect(session.evaluate_script('document.activeElement')).to eq(session.first(:field))
+      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
@@ -360,15 +389,64 @@ RSpec.shared_examples 'Capybara::Session' do |session, mode|
 
         it 'should disable CSS animations (set to 0s)' do
           @animation_session.visit('with_animation')
+          sleep 1
           @animation_session.click_link('animate me away')
           expect(@animation_session).to have_no_link('animate me away', wait: 0.5)
         end
 
         it 'should disable CSS animations on pseudo elements (set to 0s)' do
           @animation_session.visit('with_animation')
+          sleep 1
           @animation_session.find_link('animate me away').right_click
           expect(@animation_session).to have_content('Animation Ended', wait: 0.1)
         end
+
+        it 'should scroll the page instantly', requires: [:js] do
+          @animation_session.visit('with_animation')
+          scroll_y = @animation_session.evaluate_script(<<~JS)
+            (function(){
+              window.scrollTo(0,500);
+              return window.scrollY;
+            })()
+          JS
+          expect(scroll_y).to eq 500
+        end
+
+        it 'should scroll the page instantly without jquery animation', requires: [:js] do
+          @animation_session.visit('with_jquery_animation')
+          @animation_session.click_link('scroll top 500')
+          scroll_y = @animation_session.evaluate_script('window.scrollY')
+          expect(scroll_y).to eq 500
+        end
+      end
+
+      context 'when set to `false`' do
+        before(:context) do # rubocop:disable RSpec/BeforeAfterAll
+          skip "Safari doesn't support multiple sessions" if safari?(session)
+          # NOTE: Although Capybara.SpecHelper.reset! sets Capybara.disable_animation to false,
+          # it doesn't affect any of these tests because the settings are applied per-session
+          Capybara.disable_animation = false
+          @animation_session = Capybara::Session.new(session.mode, TestApp.new)
+        end
+
+        it 'should scroll the page with a smooth animation', requires: [:js] do
+          @animation_session.visit('with_animation')
+          scroll_y = @animation_session.evaluate_script(<<~JS)
+            (function(){
+              window.scrollTo(0,500);
+              return window.scrollY;
+            })()
+          JS
+          # measured over 0.5 seconds: 0, 75, 282, 478, 500
+          expect(scroll_y).to be < 500
+        end
+
+        it 'should scroll the page with jquery animation', requires: [:js] do
+          @animation_session.visit('with_jquery_animation')
+          @animation_session.click_link('scroll top 500')
+          scroll_y = @animation_session.evaluate_script('window.scrollY')
+          expect(scroll_y).to be < 500
+        end
       end
 
       context 'if we pass in css that matches elements' do
@@ -382,12 +460,14 @@ RSpec.shared_examples 'Capybara::Session' do |session, mode|
 
         it 'should disable CSS transitions' do
           @animation_session_with_matching_css.visit('with_animation')
+          sleep 1
           @animation_session_with_matching_css.click_link('transition me away')
           expect(@animation_session_with_matching_css).to have_no_link('transition me away', wait: 0.5)
         end
 
         it 'should disable CSS animations' do
           @animation_session_with_matching_css.visit('with_animation')
+          sleep 1
           @animation_session_with_matching_css.click_link('animate me away')
           expect(@animation_session_with_matching_css).to have_no_link('animate me away', wait: 0.5)
         end
@@ -404,6 +484,7 @@ RSpec.shared_examples 'Capybara::Session' do |session, mode|
 
         it 'should not disable CSS transitions' do
           @animation_session_without_matching_css.visit('with_animation')
+          sleep 1
           @animation_session_without_matching_css.click_link('transition me away')
           sleep 0.5 # Wait long enough for click to have been processed
           expect(@animation_session_without_matching_css).to have_link('transition me away', wait: false)
@@ -412,6 +493,7 @@ RSpec.shared_examples 'Capybara::Session' do |session, mode|
 
         it 'should not disable CSS animations' do
           @animation_session_without_matching_css.visit('with_animation')
+          sleep 1
           @animation_session_without_matching_css.click_link('animate me away')
           sleep 0.5 # Wait long enough for click to have been processed
           expect(@animation_session_without_matching_css).to have_link('animate me away', wait: false)
@@ -425,7 +507,7 @@ RSpec.shared_examples 'Capybara::Session' do |session, mode|
       it 'can find html5 svg elements' do
         session.visit('with_html5_svg')
         expect(session).to have_selector(:element, :svg)
-        expect(session).to have_selector(:element, :rect, visible: true)
+        expect(session).to have_selector(:element, :rect, visible: :visible)
         expect(session).to have_selector(:element, :circle)
         expect(session).to have_selector(:element, :linearGradient, visible: :all)
       end
@@ -441,21 +523,30 @@ RSpec.shared_examples 'Capybara::Session' do |session, mode|
       context 'controlled components' do
         it 'can set and clear a text field' do
           skip "This test doesn't support older browsers" if ie?(session)
-          # session.visit 'https://reactjs.org/docs/forms.html'
-          # session.all(:css, 'h2#controlled-components ~ p a', text: 'Try it on CodePen')[0].click
-          # copied into local view
+
           session.visit 'react'
-          # Not necessary when accessed locally
-          # session.within_frame(:css, 'iframe.result-iframe:not([src=""])', wait: 10) do
+
           session.fill_in('Name:', with: 'abc')
           session.accept_prompt 'A name was submitted: abc' do
             session.click_button('Submit')
           end
+
           session.fill_in('Name:', with: '')
           session.accept_prompt(/A name was submitted: $/) do
             session.click_button('Submit')
           end
-          # end
+        end
+
+        it 'works with rapid fill' do
+          skip "This test doesn't support older browsers" if ie?(session)
+
+          session.visit 'react'
+          long_string = (0...60).map { |i| ((i % 26) + 65).chr }.join
+
+          session.fill_in('Name:', with: long_string)
+          session.accept_prompt "A name was submitted: #{long_string}" do
+            session.click_button('Submit')
+          end
         end
       end
     end