capybara 2.15.1 → 3.35.3

data/spec/session_spec.rb

@@ -1,15 +1,30 @@
 # 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."
+  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
@@ -19,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
@@ -30,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,83 @@
+# 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
+      pending "Chromedriver < 76.0.3809.25 doesn't support native displayed in W3C mode" if chrome_lt?(76, session) && (ENV['W3C'] != 'false')
+
+      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
+      skip 'Non-W3C uses native' if chrome?(session) && (ENV['W3C'] == 'false')
+
+      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

data/spec/shared_selenium_session.rb

@@ -1,169 +1,558 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
-require "selenium-webdriver"
+require 'selenium-webdriver'
 
-RSpec.shared_examples "Capybara::Session" do |session, mode|
-  let(:session) {session}
+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)
+      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)
+      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
+    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
+    describe 'exit codes' do
+      let(:env) { { 'SELENIUM_BROWSER' => session.driver.options[:browser].to_s } }
+      let!(:orig_dir) { Dir.getwd }
+
       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)
+        Dir.chdir(orig_dir)
+      end
+
+      it 'should have return code 1 when running selenium_driver_rspec_failure.rb' do
+        skip 'only setup for local non-headless' if headless_or_remote?
+        skip 'Not setup for edge' if edge?(session)
+
+        system(env, 'rspec spec/fixtures/selenium_driver_rspec_failure.rb', out: File::NULL, err: File::NULL)
+        expect($CHILD_STATUS.exitstatus).to eq(1)
+      end
+
+      it 'should have return code 0 when running selenium_driver_rspec_success.rb' do
+        skip 'only setup for local non-headless' if headless_or_remote?
+        skip 'Not setup for edge' if edge?(session)
+
+        system(env, 'rspec spec/fixtures/selenium_driver_rspec_success.rb', out: File::NULL, err: File::NULL)
+        expect($CHILD_STATUS.exitstatus).to eq(0)
       end
+    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)
+    describe '#accept_alert', requires: [:modals] 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 "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)
+      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
 
-    describe "#accept_alert" do
-      it "supports a blockless mode" do
-        skip "Headless Chrome doesn't support blockless modal methods" if @session.driver.send(:headless_chrome?)
-        @session.visit('/with_js')
-        @session.click_link('Open alert')
-        @session.accept_alert
-        expect{@session.driver.browser.switch_to.alert}.to raise_error(Selenium::WebDriver::Error::NoAlertPresentError)
+    describe '#fill_in_with empty string and no options' do
+      it 'should trigger change when clearing a field' do
+        pending "safaridriver doesn't trigger change for clear" if safari?(session)
+        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
+    describe '#fill_in with { :clear => :backspace } fill_option', requires: [:js] do
+      before do
+        # Firefox has an issue with change events if the main window doesn't think it's focused
+        session.execute_script('window.focus()')
+      end
+
       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')
+        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 fill in a field, replacing an existing value, even with caret position' do
+        session.visit('/form')
+        session.find(:css, '#form_first_name').execute_script <<-JS
+          this.focus();
+          this.setSelectionRange(0, 0);
+        JS
+
+        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 fill in if the option is set via global option' do
+        Capybara.default_set_options = { clear: :backspace }
+        session.visit('/form')
+        session.fill_in('form_first_name', with: 'Thomas')
+        expect(session.find(:fillable_field, 'form_first_name').value).to eq('Thomas')
       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 })
+        session.visit('/with_js')
+        sleep 2 if safari?(session) # Safari needs a delay (to load event handlers maybe ???)
+        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'
+        session.find(:css, '#with_focus_event').click
+        expect(session.find(:css, '.change_event_triggered', match: :one, wait: 5)).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 })
+        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, '#with_focus_event').click
+        expect(session).to have_selector(:css, '.change_event_triggered', match: :one, wait: 5)
+      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_selector(:css, '.change_event_triggered', match: :one)
+        # session.find(:css, 'body').click
+        session.find(:css, 'h1', text: 'FooBar').click
+        expect(session).to have_xpath('//p[@class="input_event_triggered"]', count: 13)
       end
     end
 
-    context "#fill_in with { clear: :none } fill_options" do
+    describe '#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')
+        pending 'Safari overwrites by default - need to figure out a workaround' if safari?(session)
+
+        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
+
+      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
 
-    context "#fill_in with { clear: Array } fill_options" do
+    describe '#fill_in with Date' do
+      before do
+        session.visit('/form')
+        session.find(:css, '#form_date').execute_script <<-JS
+          window.capybara_formDateFiredEvents = [];
+          var fd = this;
+          ['focus', 'input', 'change'].forEach(function(eventType) {
+            fd.addEventListener(eventType, function() { window.capybara_formDateFiredEvents.push(eventType); });
+          });
+        JS
+        # work around weird FF issue where it would create an extra focus issue in some cases
+        session.find(:css, 'h1', text: 'Form').click
+        # session.find(:css, 'body').click
+      end
+
+      it 'should generate standard events on changing value' do
+        pending "IE 11 doesn't support date input type" if ie?(session)
+        pending "Safari doesn't support date input type" if safari?(session)
+        session.fill_in('form_date', with: Date.today)
+        expect(session.evaluate_script('window.capybara_formDateFiredEvents')).to eq %w[focus input change]
+      end
+
+      it 'should not generate input and change events if the value is not changed' do
+        pending "IE 11 doesn't support date input type" if ie?(session)
+        pending "Safari doesn't support date input type" if safari?(session)
+        session.fill_in('form_date', with: Date.today)
+        session.fill_in('form_date', with: Date.today)
+        # Chrome adds an extra focus for some reason - ok for now
+        expect(session.evaluate_script('window.capybara_formDateFiredEvents')).to eq(%w[focus input change])
+      end
+    end
+
+    describe '#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')
+        # 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 '#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 "#path" do
-      it "returns xpath" do
+    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
-        @session.visit('/path')
-        element = @session.find(:link, 'Second Link')
-        expect(element.path).to eq('/html/body/div[2]/a[1]')
+        session.visit('/path')
+        element = session.find(:link, 'Second Link')
+        expect(element.path).to eq('/HTML/BODY[1]/DIV[2]/A[1]')
+      end
+
+      it 'handles namespaces in xhtml' do
+        pending "IE 11 doesn't handle all XPath querys (namespace-uri, etc)" if ie?(session)
+        session.visit '/with_namespace'
+        rect = session.find(:css, 'div svg rect:first-of-type')
+        expect(rect.path).to eq("/HTML/BODY[1]/DIV[1]/*[local-name()='svg' and namespace-uri()='http://www.w3.org/2000/svg'][1]/*[local-name()='rect' and namespace-uri()='http://www.w3.org/2000/svg'][1]")
+        expect(session.find(:xpath, rect.path)).to eq rect
+      end
+
+      it 'handles default namespaces in html5' do
+        pending "IE 11 doesn't handle all XPath querys (namespace-uri, etc)" if ie?(session)
+        session.visit '/with_html5_svg'
+        rect = session.find(:css, 'div svg rect:first-of-type')
+        expect(rect.path).to eq("/HTML/BODY[1]/DIV[1]/*[local-name()='svg' and namespace-uri()='http://www.w3.org/2000/svg'][1]/*[local-name()='rect' and namespace-uri()='http://www.w3.org/2000/svg'][1]")
+        expect(session.find(:xpath, rect.path)).to eq rect
+      end
+
+      it 'handles case sensitive element names' do
+        pending "IE 11 doesn't handle all XPath querys (namespace-uri, etc)" if ie?(session)
+        session.visit '/with_namespace'
+        els = session.all(:css, 'div *', visible: :all)
+        expect { els.map(&:path) }.not_to raise_error
+        lg = session.find(:css, 'div linearGradient', visible: :all)
+        expect(session.find(:xpath, lg.path, visible: :all)).to eq lg
       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 }
+    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')
+    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
+      it 'can return arrays of nested elements' do
+        session.visit('/form')
+        elements = session.evaluate_script('document.querySelectorAll("#form_city option")')
+        expect(elements).to all(be_instance_of Capybara::Node::Element)
+        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'),
+      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
+            '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
+          skip 'safaridriver returns the wrong error type' if safari?(session)
+          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!')
+        allow(el).to receive(:synchronize)
+        expect(el.inspect).to eq 'Obsolete #<Capybara::Node::Element>'
+        expect(el).not_to have_received(:synchronize)
+      end
+    end
+
+    describe 'Element#click' do
+      it 'should handle fixed headers/footers' do
+        session.visit('/with_fixed_header_footer')
+        session.using_wait_time(2) do
+          session.find(:link, 'Go to root').click
+        end
+        expect(session).to have_current_path('/')
+      end
+    end
+
+    describe 'Capybara#Node#attach_file' do
+      it 'can attach a directory' do
+        pending "Geckodriver doesn't support uploading a directory" if firefox?(session)
+        pending "Selenium remote doesn't support transferring a directory" if remote?(session)
+        pending "Headless Chrome doesn't support directory upload - https://bugs.chromium.org/p/chromedriver/issues/detail?id=2521&q=directory%20upload&colspec=ID%20Status%20Pri%20Owner%20Summary" if chrome?(session) && ENV['HEADLESS']
+        pending "IE doesn't support uploading a directory" if ie?(session)
+        pending 'Chrome/chromedriver 73 breaks this' if chrome?(session) && chrome_gte?(73, session) && chrome_lt?(75, session)
+        pending "Safari doesn't support uploading a directory" if safari?(session)
+        # pending "Edge/msedgedriver doesn't support directory upload" if edge?(session) && edge_gte?(75, session)
+
+        session.visit('/form')
+        test_file_dir = File.expand_path('./fixtures', File.dirname(__FILE__))
+        session.attach_file('Directory Upload', test_file_dir)
+        session.click_button('Upload Multiple')
+        expect(session.body).to include('5 | ') # number of files
+      end
+
+      it 'can attach a relative file' do
+        pending 'Geckdoriver on windows requires alternate file separator which path expansion replaces' if Gem.win_platform? && firefox?(session)
+
+        session.visit('/form')
+        session.attach_file('Single Document', 'spec/fixtures/capybara.csv')
+        session.click_button('Upload Single')
+        expect(session.body).to include('Content-type: text/csv')
       end
     end
 
-    describe "Element#inspect" do
-      it "outputs obsolete elements" do
-        @session.visit('/form')
-        el = @session.find(:button, 'Click me!').click
-        sleep 2
-        expect(el.inspect).to eq "Obsolete #<Capybara::Node::Element>"
+    context 'Windows' do
+      it "can't close the primary window" do
+        expect do
+          session.current_window.close
+        end.to raise_error(ArgumentError, 'Not allowed to close the primary window')
       end
     end
+
+    # rubocop:disable RSpec/InstanceVariable
+    describe 'Capybara#disable_animation' do
+      context 'when set to `true`' 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 = true
+          @animation_session = Capybara::Session.new(session.mode, TestApp.new)
+        end
+
+        it 'should disable CSS transitions' do
+          @animation_session.visit('with_animation')
+          @animation_session.click_link('transition me away')
+          expect(@animation_session).to have_no_link('transition me away', wait: 0.5)
+        end
+
+        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
+        before(:context) do # rubocop:disable RSpec/BeforeAfterAll
+          skip "safaridriver 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 = '#with_animation a'
+          @animation_session_with_matching_css = Capybara::Session.new(session.mode, TestApp.new)
+        end
+
+        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
+      end
+
+      context 'if we pass in css that does not match elements' 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 = '.this-class-matches-nothing'
+          @animation_session_without_matching_css = Capybara::Session.new(session.mode, TestApp.new)
+        end
+
+        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)
+          expect(@animation_session_without_matching_css).to have_no_link('transition me away', wait: 5)
+        end
+
+        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)
+          expect(@animation_session_without_matching_css).to have_no_link('animate me away', wait: 5)
+        end
+      end
+    end
+    # rubocop:enable RSpec/InstanceVariable
+
+    describe ':element selector' do
+      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: :visible)
+        expect(session).to have_selector(:element, :circle)
+        expect(session).to have_selector(:element, :linearGradient, visible: :all)
+      end
+
+      it 'can query attributes with strange characters' do
+        session.visit('/form')
+        expect(session).to have_selector(:element, "{custom}": true)
+        expect(session).to have_selector(:element, "{custom}": 'abcdef')
+      end
+    end
+
+    describe 'with react' do
+      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 'react'
+
+          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
+
+        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
+  end
+
+  def headless_or_remote?
+    !ENV['HEADLESS'].nil? || session.driver.options[:browser] == :remote
   end
 end