capybara 2.18.0 → 3.40.0

data/spec/dsl_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 require 'capybara/dsl'
 
@@ -6,20 +7,24 @@ class TestClass
   include Capybara::DSL
 end
 
-Capybara::SpecHelper.run_specs TestClass.new, "DSL", capybara_skip: [
-  :js,
-  :modals,
-  :screenshot,
-  :frames,
-  :windows,
-  :send_keys,
-  :server,
-  :hover,
-  :about_scheme,
-  :psc
-]
+Capybara::SpecHelper.run_specs TestClass.new, 'DSL', capybara_skip: %i[
+  js modals screenshot frames windows send_keys server hover about_scheme psc download css driver scroll spatial html_validation shadow_dom active_element
+] do |example|
+  case example.metadata[:full_description]
+  when /has_css\? should support case insensitive :class and :id options/
+    pending "Nokogiri doesn't support case insensitive CSS attribute matchers"
+  when /#click_button should follow permanent redirects that maintain method/
+    pending "Rack < 2 doesn't support 308" if Gem.loaded_specs['rack'].version < Gem::Version.new('2.0.0')
+  when /#attach_file with multipart form should send prior hidden field if no file submitted/
+    skip 'Rack-test < 2 needs an empty file to detect multipart form' if Gem.loaded_specs['rack-test'].version < Gem::Version.new('2.0.0')
+  end
+end
 
 RSpec.describe Capybara::DSL do
+  before do
+    Capybara.use_default_driver
+  end
+
   after do
     Capybara.session_name = nil
     Capybara.default_driver = nil
@@ -29,42 +34,42 @@ RSpec.describe Capybara::DSL do
   end
 
   describe '#default_driver' do
-    it "should default to rack_test" do
+    it 'should default to rack_test' do
       expect(Capybara.default_driver).to eq(:rack_test)
     end
 
-    it "should be changeable" do
+    it 'should be changeable' do
       Capybara.default_driver = :culerity
       expect(Capybara.default_driver).to eq(:culerity)
     end
   end
 
   describe '#current_driver' do
-    it "should default to the default driver" do
+    it 'should default to the default driver' do
       expect(Capybara.current_driver).to eq(:rack_test)
       Capybara.default_driver = :culerity
       expect(Capybara.current_driver).to eq(:culerity)
     end
 
-    it "should be changeable" do
+    it 'should be changeable' do
       Capybara.current_driver = :culerity
       expect(Capybara.current_driver).to eq(:culerity)
     end
   end
 
   describe '#javascript_driver' do
-    it "should default to selenium" do
+    it 'should default to selenium' do
       expect(Capybara.javascript_driver).to eq(:selenium)
     end
 
-    it "should be changeable" do
+    it 'should be changeable' do
       Capybara.javascript_driver = :culerity
       expect(Capybara.javascript_driver).to eq(:culerity)
     end
   end
 
   describe '#use_default_driver' do
-    it "should restore the default driver" do
+    it 'should restore the default driver' do
       Capybara.current_driver = :culerity
       Capybara.use_default_driver
       expect(Capybara.current_driver).to eq(:rack_test)
@@ -73,7 +78,7 @@ RSpec.describe Capybara::DSL do
 
   describe '#using_driver' do
     before do
-      expect(Capybara.current_driver).not_to eq(:selenium)
+      expect(Capybara.current_driver).not_to eq(:selenium) # rubocop:disable RSpec/ExpectInHook
     end
 
     it 'should set the driver using Capybara.current_driver=' do
@@ -92,8 +97,8 @@ RSpec.describe Capybara::DSL do
     it 'should reset the driver even if an exception occurs' do
       driver_before_block = Capybara.current_driver
       begin
-        Capybara.using_driver(:selenium) { raise "ohnoes!" }
-      rescue Exception
+        Capybara.using_driver(:selenium) { raise 'ohnoes!' }
+      rescue Exception # rubocop:disable Lint/RescueException,Lint/SuppressedException
       end
       expect(Capybara.current_driver).to eq(driver_before_block)
     end
@@ -112,20 +117,17 @@ RSpec.describe Capybara::DSL do
     it 'should yield the passed block' do
       called = false
       Capybara.using_driver(:selenium) { called = true }
-      expect(called).to eq(true)
+      expect(called).to be(true)
     end
   end
 
+  # rubocop:disable RSpec/InstanceVariable
   describe '#using_wait_time' do
-    before do
-      @previous_wait_time = Capybara.default_max_wait_time
-    end
+    before { @previous_wait_time = Capybara.default_max_wait_time }
 
-    after do
-      Capybara.default_max_wait_time = @previous_wait_time
-    end
+    after { Capybara.default_max_wait_time = @previous_wait_time }
 
-    it "should switch the wait time and switch it back" do
+    it 'should switch the wait time and switch it back' do
       in_block = nil
       Capybara.using_wait_time 6 do
         in_block = Capybara.default_max_wait_time
@@ -134,40 +136,41 @@ RSpec.describe Capybara::DSL do
       expect(Capybara.default_max_wait_time).to eq(@previous_wait_time)
     end
 
-    it "should ensure wait time is reset" do
+    it 'should ensure wait time is reset' do
       expect do
         Capybara.using_wait_time 6 do
-          raise "hell"
+          raise 'hell'
         end
-      end.to raise_error(RuntimeError, "hell")
+      end.to raise_error(RuntimeError, 'hell')
       expect(Capybara.default_max_wait_time).to eq(@previous_wait_time)
     end
   end
+  # rubocop:enable RSpec/InstanceVariable
 
   describe '#app' do
-    it "should be changeable" do
-      Capybara.app = "foobar"
+    it 'should be changeable' do
+      Capybara.app = 'foobar'
       expect(Capybara.app).to eq('foobar')
     end
   end
 
   describe '#current_session' do
-    it "should choose a session object of the current driver type" do
+    it 'should choose a session object of the current driver type' do
       expect(Capybara.current_session).to be_a(Capybara::Session)
     end
 
-    it "should use #app as the application" do
+    it 'should use #app as the application' do
       Capybara.app = proc {}
       expect(Capybara.current_session.app).to eq(Capybara.app)
     end
 
-    it "should change with the current driver" do
+    it 'should change with the current driver' do
       expect(Capybara.current_session.mode).to eq(:rack_test)
       Capybara.current_driver = :selenium
       expect(Capybara.current_session.mode).to eq(:selenium)
     end
 
-    it "should be persistent even across driver changes" do
+    it 'should be persistent even across driver changes' do
       object_id = Capybara.current_session.object_id
       expect(Capybara.current_session.object_id).to eq(object_id)
       Capybara.current_driver = :selenium
@@ -178,7 +181,7 @@ RSpec.describe Capybara::DSL do
       expect(Capybara.current_session.object_id).to eq(object_id)
     end
 
-    it "should change when changing application" do
+    it 'should change when changing application' do
       object_id = Capybara.current_session.object_id
       expect(Capybara.current_session.object_id).to eq(object_id)
       Capybara.app = proc {}
@@ -186,7 +189,7 @@ RSpec.describe Capybara::DSL do
       expect(Capybara.current_session.app).to eq(Capybara.app)
     end
 
-    it "should change when the session name changes" do
+    it 'should change when the session name changes' do
       object_id = Capybara.current_session.object_id
       Capybara.session_name = :administrator
       expect(Capybara.session_name).to eq(:administrator)
@@ -197,8 +200,8 @@ RSpec.describe Capybara::DSL do
     end
   end
 
-  describe "#using_session" do
-    it "should change the session name for the duration of the block" do
+  describe '#using_session' do
+    it 'should change the session name for the duration of the block' do
       expect(Capybara.session_name).to eq(:default)
       Capybara.using_session(:administrator) do
         expect(Capybara.session_name).to eq(:administrator)
@@ -206,23 +209,23 @@ RSpec.describe Capybara::DSL do
       expect(Capybara.session_name).to eq(:default)
     end
 
-    it "should reset the session to the default, even if an exception occurs" do
+    it 'should reset the session to the default, even if an exception occurs' do
       begin
         Capybara.using_session(:raise) do
           raise
         end
-      rescue Exception
+      rescue Exception # rubocop:disable Lint/RescueException,Lint/SuppressedException
       end
       expect(Capybara.session_name).to eq(:default)
     end
 
-    it "should yield the passed block" do
+    it 'should yield the passed block' do
       called = false
       Capybara.using_session(:administrator) { called = true }
-      expect(called).to eq(true)
+      expect(called).to be(true)
     end
 
-    it "should be nestable" do
+    it 'should be nestable' do
       Capybara.using_session(:outer) do
         expect(Capybara.session_name).to eq(:outer)
         Capybara.using_session(:inner) do
@@ -232,39 +235,57 @@ RSpec.describe Capybara::DSL do
       end
       expect(Capybara.session_name).to eq(:default)
     end
+
+    it 'should allow a session object' do
+      original_session = Capybara.current_session
+      new_session = Capybara::Session.new(:rack_test, proc {})
+      Capybara.using_session(new_session) do
+        expect(Capybara.current_session).to eq(new_session)
+      end
+      expect(Capybara.current_session).to eq(original_session)
+    end
+
+    it 'should pass the new session if block accepts' do
+      original_session = Capybara.current_session
+      Capybara.using_session(:administrator) do |admin_session, prev_session|
+        expect(admin_session).to be(Capybara.current_session)
+        expect(prev_session).to be(original_session)
+        expect(prev_session).not_to be(admin_session)
+      end
+    end
   end
 
-  describe "#session_name" do
-    it "should default to :default" do
+  describe '#session_name' do
+    it 'should default to :default' do
       expect(Capybara.session_name).to eq(:default)
     end
   end
 
   describe 'the DSL' do
-    before do
-      @session = Class.new { include Capybara::DSL }.new
-    end
+    let(:session) { Class.new { include Capybara::DSL }.new }
 
-    it "should be possible to include it in another class" do
-      @session.visit('/with_html')
-      @session.click_link('ullamco')
-      expect(@session.body).to include('Another World')
+    it 'should be possible to include it in another class' do
+      session.visit('/with_html')
+      session.click_link('ullamco')
+      expect(session.body).to include('Another World')
     end
 
     it "should provide a 'page' shortcut for more expressive tests" do
-      @session.page.visit('/with_html')
-      @session.page.click_link('ullamco')
-      expect(@session.page.body).to include('Another World')
+      session.page.visit('/with_html')
+      session.page.click_link('ullamco')
+      expect(session.page.body).to include('Another World')
     end
 
     it "should provide an 'using_session' shortcut" do
-      expect(Capybara).to receive(:using_session).with(:name)
-      @session.using_session(:name)
+      allow(Capybara).to receive(:using_session)
+      session.using_session(:name)
+      expect(Capybara).to have_received(:using_session).with(:name)
     end
 
     it "should provide a 'using_wait_time' shortcut" do
-      expect(Capybara).to receive(:using_wait_time).with(6)
-      @session.using_wait_time(6)
+      allow(Capybara).to receive(:using_wait_time)
+      session.using_wait_time(6)
+      expect(Capybara).to have_received(:using_wait_time).with(6)
     end
   end
 end

data/spec/filter_set_spec.rb

@@ -1,28 +1,46 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe Capybara::Selector::FilterSet do
   after do
-    Capybara::Selector::FilterSet.remove(:test)
+    described_class.remove(:test)
   end
 
-  it "allows node filters" do
-    fs = Capybara::Selector::FilterSet.add(:test) do
-      filter(:node_test, :boolean) { |node, value| true }
-      expression_filter(:expression_test, :boolean) { |expr, value| true }
+  it 'allows node filters' do
+    fs = described_class.add(:test) do
+      node_filter(:node_test, :boolean) { |_node, _value| true }
+      expression_filter(:expression_test, :boolean) { |_expr, _value| true }
     end
 
     expect(fs.node_filters.keys).to include(:node_test)
     expect(fs.node_filters.keys).not_to include(:expression_test)
   end
 
-  it "allows expression filters" do
-    fs = Capybara::Selector::FilterSet.add(:test) do
-      filter(:node_test, :boolean) { |node, value| true }
-      expression_filter(:expression_test, :boolean) { |expr, value| true }
+  it 'allows expression filters' do
+    fs = described_class.add(:test) do
+      node_filter(:node_test, :boolean) { |_node, _value| true }
+      expression_filter(:expression_test, :boolean) { |_expr, _value| true }
     end
 
     expect(fs.expression_filters.keys).to include(:expression_test)
     expect(fs.expression_filters.keys).not_to include(:node_test)
   end
+
+  it 'allows node filter and expression filter with the same name' do
+    fs = described_class.add(:test) do
+      node_filter(:test, :boolean) { |_node, _value| true }
+      expression_filter(:test, :boolean) { |_expr, _value| true }
+    end
+
+    expect(fs.expression_filters[:test]).not_to eq fs.node_filters[:test]
+  end
+
+  it 'allows `filter` as an alias of `node_filter`' do
+    fs = described_class.add(:test) do
+      filter(:node_test, :boolean) { |_node, _value| true }
+    end
+
+    expect(fs.node_filters.keys).to include(:node_test)
+  end
 end

data/spec/fixtures/certificate.pem

@@ -0,0 +1,25 @@
+-----BEGIN CERTIFICATE-----
+MIIEITCCAwmgAwIBAgIJALROkwd1gZHQMA0GCSqGSIb3DQEBBQUAMGgxCzAJBgNV
+BAYTAlVTMQswCQYDVQQIEwJDQTERMA8GA1UEChMIQ2FweWJhcmExFjAUBgNVBAMT
+DWNhcHliYXJhLnRlc3QxITAfBgkqhkiG9w0BCQEWEnR3YWxwb2xlQGdtYWlsLmNv
+bTAeFw0xODA1MDEyMDI5NDVaFw0yODA0MjgyMDI5NDVaMGgxCzAJBgNVBAYTAlVT
+MQswCQYDVQQIEwJDQTERMA8GA1UEChMIQ2FweWJhcmExFjAUBgNVBAMTDWNhcHli
+YXJhLnRlc3QxITAfBgkqhkiG9w0BCQEWEnR3YWxwb2xlQGdtYWlsLmNvbTCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL7icqMv9uApxRXlcIQ3hSEfmULk
+7CLT1aUAjEmTiqy8TkFqOeSuA3elnbVBhOW+emrb1uUyje20LvEOHbqYYw90ezlV
+jqNWUapawqjxb+q7KVNpA5uDCtOHIC/1Z1kxQ+yZP/8St4SvnLGUMsUhu0h+ywJa
+iGZ2xy8wdfjABUiUImRESdNkT7Xs0wxQGY0/FZ4K5Sec4kroOuvdxKKhyf5Js5xS
+NRv2tXSMWlKHbYEvYzsVtFgv/4GjqN4wVvbfJmsS8thcyrSYSMN7eE0R6dcbJaLM
+P/GTiw669zPJP164K84QoabLClgwyG+7mqjm7jutq9qXipwyrGsf/WR5fkUCAwEA
+AaOBzTCByjAdBgNVHQ4EFgQU4ut9c0oB2OGMlN/nvn0Y7twBzJowgZoGA1UdIwSB
+kjCBj4AU4ut9c0oB2OGMlN/nvn0Y7twBzJqhbKRqMGgxCzAJBgNVBAYTAlVTMQsw
+CQYDVQQIEwJDQTERMA8GA1UEChMIQ2FweWJhcmExFjAUBgNVBAMTDWNhcHliYXJh
+LnRlc3QxITAfBgkqhkiG9w0BCQEWEnR3YWxwb2xlQGdtYWlsLmNvbYIJALROkwd1
+gZHQMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEBAANtqdDrdehBt20s
+IVOsVzOp+tJI8pn6G62WJcZWGsvLLfx6Y6eJSP24r5NW4v39cqCgE76J2znzKxeo
+VIShAJ1SLodR0GwzFGsl3TVKVoce6gBWZNXgkZyJTNqKGWeme8CH1EG3TqYlcybt
+EXWLQ6wKndD+uHJIfqUy7HfaUv+TghJGLkv8QYqcAWILQko4xqZ1NULDQ2uhjxei
+oaQlK9teHlVaH87dONesAg3f5rh9j6nvzGiC/T8ycdEhn/DxJMxRS2+mVZqKkk7U
+60+e9Foc6qTW8UaMShIFYMspoRnr9baBxzxh9V9LZznwqVTf3vuEIck2l2j2KL/R
+SOBenCM=
+-----END CERTIFICATE-----

data/spec/fixtures/key.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEAvuJyoy/24CnFFeVwhDeFIR+ZQuTsItPVpQCMSZOKrLxOQWo5
+5K4Dd6WdtUGE5b56atvW5TKN7bQu8Q4duphjD3R7OVWOo1ZRqlrCqPFv6rspU2kD
+m4MK04cgL/VnWTFD7Jk//xK3hK+csZQyxSG7SH7LAlqIZnbHLzB1+MAFSJQiZERJ
+02RPtezTDFAZjT8VngrlJ5ziSug6693EoqHJ/kmznFI1G/a1dIxaUodtgS9jOxW0
+WC//gaOo3jBW9t8maxLy2FzKtJhIw3t4TRHp1xslosw/8ZOLDrr3M8k/XrgrzhCh
+pssKWDDIb7uaqObuO62r2peKnDKsax/9ZHl+RQIDAQABAoIBABhZepYmgC+IJIPu
+iLPVAT6AcWR/H0AyFYa+0yZvk7kFLFZb3pa1O+v/TGbavMEx0xvef0Mtd71ixrop
+OtGarshB65Ycu91KHZDFkx9J7STcSyFAvB0SUkc5bXmwrEZMaoW75tX65T4fyLU+
+WlubOfC9e9gJBG1NqYrze5kHpaTkR8pBaSxECns5y2HLaMvs1t1kK7snqtGHFRAb
+deAUl0ONENaO6PF797yM3bsIEgnljdKvaVP3kYq/eAzH4jyw+qG/xq0bZ+nalJzM
+IL7xRSR/Yak7WZ3QUh99t3dng/z3De4yvhBLq/mc2mIVvt7aERPo/aDG4SrmQ9Jw
+f1GUT+ECgYEA+i96w2zPHkq0djuuhNaa/R0vybD9hVCdB7enQ8skBzQAQyhp9X9W
+by38VAbFRVIMrzdfbvwSFrE3Nd9BvyLWl16G+MVu+hq0jhM9p44a62vXvfgQmfFh
+iXyGkzCTufeLEzOFnP8S+ezacodK1hbQTjllUndn6NUhXcbfozTPfx8CgYEAw1Il
+xqfU7NkVX6UP/FvTx9aBKqwrD8YOPn9nj26Q45zVbmHJZZIvywlsMDCiJ6JJawEa
+GSkiZTDpypEvS/2UtLEY0zfbSbQGkBTnagHIFAuVh0AD1EP+kCcnrxA5Vjr8v0WE
+B0HBfMgoZxa8rmHMpPhrlCCo1ectRgu+dgzEKhsCgYAQ17lwBpc69tSHUSVClCAD
+AkABWAT5QKARsO91xOs8AOgznTjk6hmrinD+RyZosEliUlv+YMHm/S82VT1b3MCN
+mDOF8+SwubOGDQ2NhieRycTQaS7U7kcetl9o8VBAqMWYGVPZaeKhKKzcIPeMyiRj
+38FOd/Nq3U5NveG4XwnJCQKBgGrzmnfTAsbGf+uliMFYzviIPqZNLC8w9i/Gt8BU
+fMYF5ODSbuNNTxpQiItCtigZtzX+nnnUil76j6o6IbnsmvbuWneeCFetWkKfD7B+
+VT6UsUYkCXS73rK0nghATAUpu6hIumj22qonN+hrDNo390UGOnIcCBdIxQOr/pjJ
+mMitAoGAB3tFzlzZHpCE38IqdHL7CKIML9cYJSOm07nFIEUAKN2bUHGsvMH/tMS1
+I3hyeHxMmYCrOLn7xLqiOVgRjbYS9JiQVdDojqeSvvnLCtY9/lHWi50pqbPfwyfK
+Og6QoFyxjBEsoSilc6dai58VTO6ufhoJXbXX9PcIl7le4dVPnzE=
+-----END RSA PRIVATE KEY-----

data/spec/fixtures/selenium_driver_rspec_failure.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 require 'selenium-webdriver'
 
 RSpec.describe Capybara::Selenium::Driver do
-  it "should exit with a non-zero exit status" do
-    options = { browser: (ENV['SELENIUM_BROWSER'] || :firefox).to_sym }
-    options[:desired_capabilities] = Selenium::WebDriver::Remote::Capabilities.firefox(marionette: false) if ENV['LEGACY_FIREFOX']
-    browser = Capybara::Selenium::Driver.new(TestApp, options).browser
-    expect(true).to eq(false)
+  it 'should exit with a non-zero exit status' do
+    options = { browser: ENV.fetch('SELENIUM_BROWSER', :firefox).to_sym }
+    browser = described_class.new(TestApp, options).browser
+    expect(browser).to be_truthy
+    expect(true).to be(false) # rubocop:disable RSpec/ExpectActual
   end
 end

data/spec/fixtures/selenium_driver_rspec_success.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 require 'selenium-webdriver'
 
 RSpec.describe Capybara::Selenium::Driver do
-  it "should exit with a zero exit status" do
-    options = { browser: (ENV['SELENIUM_BROWSER'] || :firefox).to_sym }
-    options[:desired_capabilities] = Selenium::WebDriver::Remote::Capabilities.firefox(marionette: false) if ENV['LEGACY_FIREFOX']
-    browser = Capybara::Selenium::Driver.new(TestApp, options ).browser
-    expect(true).to eq(true)
+  it 'should exit with a zero exit status' do
+    options = { browser: ENV.fetch('SELENIUM_BROWSER', :firefox).to_sym }
+    browser = described_class.new(TestApp, **options).browser
+    expect(browser).to be_truthy
+    expect(true).to be(true) # rubocop:disable RSpec/ExpectActual,RSpec/IdenticalEqualityAssertion
   end
 end

data/spec/minitest_spec.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 require 'capybara/minitest'
 
@@ -14,8 +15,12 @@ class MinitestTest < Minitest::Test
     Capybara.reset_sessions!
   end
 
+  def self.test_order
+    :sorted
+  end
+
   def test_assert_text
-    assert_text('Form')
+    assert_text('Form', normalize_ws: false)
     assert_no_text('Not on the page')
     refute_text('Also Not on the page')
   end
@@ -29,15 +34,16 @@ class MinitestTest < Minitest::Test
 
   def test_assert_current_path
     assert_current_path('/form')
+    assert_current_path('/form') { |url| url.query.nil? }
     assert_no_current_path('/not_form')
     refute_current_path('/not_form')
   end
 
   def test_assert_xpath
     assert_xpath('.//select[@id="form_title"]')
-    assert_xpath('.//select', count: 1) { |el| el[:id] == "form_title" }
+    assert_xpath('.//select', count: 1) { |el| el[:id] == 'form_title' }
     assert_no_xpath('.//select[@id="not_form_title"]')
-    assert_no_xpath('.//select') { |el| el[:id] == "not_form_title"}
+    assert_no_xpath('.//select') { |el| el[:id] == 'not_form_title' }
     refute_xpath('.//select[@id="not_form_title"]')
   end
 
@@ -46,16 +52,31 @@ class MinitestTest < Minitest::Test
     assert_no_css('select#not_form_title')
   end
 
+  def test_assert_selector
+    assert_selector(:css, 'select#form_title')
+    assert_selector(:xpath, './/select[@id="form_title"]')
+    assert_no_selector(:css, 'select#not_form_title')
+    assert_no_selector(:xpath, './/select[@id="not_form_title"]')
+    refute_selector(:css, 'select#not_form_title')
+  end
+
+  def test_assert_element
+    visit('/with_html')
+    assert_element('a', text: 'A link')
+    assert_element(count: 1) { |el| el.text == 'A link' }
+    assert_no_element(text: 'Not on page')
+  end
+
   def test_assert_link
     visit('/with_html')
     assert_link('A link')
-    assert_link(count: 1){ |el| el.text == 'A link'}
+    assert_link(count: 1) { |el| el.text == 'A link' }
     assert_no_link('Not on page')
   end
 
   def test_assert_button
     assert_button('fresh_btn')
-    assert_button(count: 1){ |el| el[:id] == 'fresh_btn' }
+    assert_button(count: 1) { |el| el[:id] == 'fresh_btn' }
     assert_no_button('not_btn')
   end
 
@@ -96,6 +117,10 @@ class MinitestTest < Minitest::Test
     assert_none_of_selectors(:css, 'input#not_on_page', 'input#also_not_on_page')
   end
 
+  def test_assert_any_of_selectors
+    assert_any_of_selectors(:css, 'input#not_on_page', 'select#form_other_title')
+  end
+
   def test_assert_matches_selector
     assert_matches_selector(find(:field, 'customer_email'), :field, 'customer_email')
     assert_not_matches_selector(find(:select, 'form_title'), :field, 'customer_email')
@@ -111,6 +136,22 @@ class MinitestTest < Minitest::Test
     assert_matches_xpath(find(:select, 'form_title'), './/select[@id="form_title"]')
     refute_matches_xpath(find(:select, 'form_title'), './/select[@id="form_other_title"]')
   end
+
+  def test_assert_matches_style
+    skip "Rack test doesn't support style" if Capybara.current_driver == :rack_test
+    visit('/with_html')
+    assert_matches_style(find(:css, '#second'), display: 'inline')
+  end
+
+  def test_assert_ancestor
+    option = find(:option, 'Finnish')
+    assert_ancestor(option, :css, '#form_locale')
+  end
+
+  def test_assert_sibling
+    option = find(:css, '#form_title').find(:option, 'Mrs')
+    assert_sibling(option, :option, 'Mr')
+  end
 end
 
 RSpec.describe 'capybara/minitest' do
@@ -119,12 +160,16 @@ RSpec.describe 'capybara/minitest' do
     Capybara.app = TestApp
   end
 
-  it "should support minitest" do
+  after do
+    Capybara.use_default_driver
+  end
+
+  it 'should support minitest' do
     output = StringIO.new
     reporter = Minitest::SummaryReporter.new(output)
     reporter.start
     MinitestTest.run reporter, {}
     reporter.report
-    expect(output.string).to include("17 runs, 44 assertions, 0 failures, 0 errors, 0 skips")
+    expect(output.string).to include('23 runs, 56 assertions, 0 failures, 0 errors, 1 skips')
   end
 end