capybara 3.32.2

data/spec/capybara_spec.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Capybara do
+  describe 'default_max_wait_time' do
+    before { @previous_default_time = described_class.default_max_wait_time }
+
+    after { described_class.default_max_wait_time = @previous_default_time } # rubocop:disable RSpec/InstanceVariable
+
+    it 'should be changeable' do
+      expect(described_class.default_max_wait_time).not_to eq(5)
+      described_class.default_max_wait_time = 5
+      expect(described_class.default_max_wait_time).to eq(5)
+    end
+  end
+
+  describe '.register_driver' do
+    it 'should add a new driver' do
+      described_class.register_driver :schmoo do |app|
+        Capybara::RackTest::Driver.new(app)
+      end
+      session = Capybara::Session.new(:schmoo, TestApp)
+      session.visit('/')
+      expect(session.body).to include('Hello world!')
+    end
+  end
+
+  describe '.register_server' do
+    it 'should add a new server' do
+      described_class.register_server :blob do |_app, _port, _host|
+        # do nothing
+      end
+
+      expect(described_class.servers).to have_key(:blob)
+    end
+  end
+
+  describe '.server' do
+    after do
+      described_class.server = :default
+    end
+
+    it 'should default to a proc that calls run_default_server' do
+      mock_app = Object.new
+      allow(described_class).to receive(:run_default_server).and_return(true)
+      described_class.server.call(mock_app, 8000)
+      expect(described_class).to have_received(:run_default_server).with(mock_app, 8000)
+    end
+
+    it 'should return a custom server proc' do
+      server = ->(_app, _port) {}
+      described_class.register_server :custom, &server
+      described_class.server = :custom
+      expect(described_class.server).to eq(server)
+    end
+
+    it 'should have :webrick registered' do
+      expect(described_class.servers[:webrick]).not_to be_nil
+    end
+
+    it 'should have :puma registered' do
+      expect(described_class.servers[:puma]).not_to be_nil
+    end
+  end
+
+  describe 'server=' do
+    after do
+      described_class.server = :default
+    end
+
+    it 'accepts a proc' do
+      server = ->(_app, _port) {}
+      described_class.server = server
+      expect(described_class.server).to eq server
+    end
+  end
+
+  describe 'app_host' do
+    after do
+      described_class.app_host = nil
+    end
+
+    it 'should warn if not a valid URL' do
+      expect { described_class.app_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.app_host should be set to a url/)
+    end
+
+    it 'should not warn if a valid URL' do
+      expect { described_class.app_host = 'http://www.example.com' }.not_to raise_error
+    end
+
+    it 'should not warn if nil' do
+      expect { described_class.app_host = nil }.not_to raise_error
+    end
+  end
+
+  describe 'default_host' do
+    around do |test|
+      old_default = described_class.default_host
+      test.run
+      described_class.default_host = old_default
+    end
+
+    it 'should raise if not a valid URL' do
+      expect { described_class.default_host = 'www.example.com' }.to raise_error(ArgumentError, /Capybara\.default_host should be set to a url/)
+    end
+
+    it 'should not warn if a valid URL' do
+      expect { described_class.default_host = 'http://www.example.com' }.not_to raise_error
+    end
+  end
+end

data/spec/css_builder_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# rubocop:disable RSpec/InstanceVariable
+RSpec.describe Capybara::Selector::CSSBuilder do
+  let :builder do
+    ::Capybara::Selector::CSSBuilder.new(@css)
+  end
+
+  context 'add_attribute_conditions' do
+    it 'adds a single string condition to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: 'abc')
+      expect(selector).to eq %(div[random='abc'])
+    end
+
+    it 'adds multiple string conditions to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: 'abc', other: 'def')
+      expect(selector).to eq %(div[random='abc'][other='def'])
+    end
+
+    it 'adds a single string condition to a multiple selector' do
+      @css = 'div, ul'
+      selector = builder.add_attribute_conditions(random: 'abc')
+      expect(selector).to eq %(div[random='abc'], ul[random='abc'])
+    end
+
+    it 'adds multiple string conditions to a multiple selector' do
+      @css = 'div, ul'
+      selector = builder.add_attribute_conditions(random: 'abc', other: 'def')
+      expect(selector).to eq %(div[random='abc'][other='def'], ul[random='abc'][other='def'])
+    end
+
+    it 'adds simple regexp conditions to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: /abc/, other: /def/)
+      expect(selector).to eq %(div[random*='abc'][other*='def'])
+    end
+
+    it 'adds wildcard regexp conditions to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: /abc.*def/, other: /def.*ghi/)
+      expect(selector).to eq %(div[random*='abc'][random*='def'][other*='def'][other*='ghi'])
+    end
+
+    it 'adds alternated regexp conditions to a single selector' do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(random: /abc|def/, other: /def|ghi/)
+      expect(selector).to eq %(div[random*='abc'][other*='def'], div[random*='abc'][other*='ghi'], div[random*='def'][other*='def'], div[random*='def'][other*='ghi'])
+    end
+
+    it 'adds alternated regexp conditions to a multiple selector' do
+      @css = 'div,ul'
+      selector = builder.add_attribute_conditions(other: /def.*ghi|jkl/)
+      expect(selector).to eq %(div[other*='def'][other*='ghi'], div[other*='jkl'], ul[other*='def'][other*='ghi'], ul[other*='jkl'])
+    end
+
+    it "returns original selector when regexp can't be substringed" do
+      @css = 'div'
+      selector = builder.add_attribute_conditions(other: /.+/)
+      expect(selector).to eq 'div'
+    end
+
+    context ':class' do
+      it 'handles string with CSS .' do
+        @css = 'a'
+        selector = builder.add_attribute_conditions(class: 'my_class')
+        expect(selector).to eq 'a.my_class'
+      end
+
+      it 'handles negated string with CSS .' do
+        @css = 'a'
+        selector = builder.add_attribute_conditions(class: '!my_class')
+        expect(selector).to eq 'a:not(.my_class)'
+      end
+
+      it 'handles array of string with CSS .' do
+        @css = 'a'
+        selector = builder.add_attribute_conditions(class: %w[my_class my_other_class])
+        expect(selector).to eq 'a.my_class.my_other_class'
+      end
+
+      it 'handles array of string with CSS . when negated included' do
+        @css = 'a'
+        selector = builder.add_attribute_conditions(class: %w[my_class !my_other_class])
+        expect(selector).to eq 'a.my_class:not(.my_other_class)'
+      end
+    end
+
+    context ':id' do
+      it 'handles string with CSS #' do
+        @css = 'ul'
+        selector = builder.add_attribute_conditions(id: 'my_id')
+        expect(selector).to eq 'ul#my_id'
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/InstanceVariable

data/spec/css_splitter_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Capybara::Selector::CSS::Splitter do
+  let :splitter do
+    ::Capybara::Selector::CSS::Splitter.new
+  end
+
+  context 'split not needed' do
+    it 'normal CSS selector' do
+      css = 'div[id="abc"]'
+      expect(splitter.split(css)).to eq [css]
+    end
+
+    it 'comma in strings' do
+      css = 'div[id="a,bc"]'
+      expect(splitter.split(css)).to eq [css]
+    end
+
+    it 'comma in pseudo-selector' do
+      css = 'div.class1:not(.class1, .class2)'
+      expect(splitter.split(css)).to eq [css]
+    end
+  end
+
+  context 'split needed' do
+    it 'root level comma' do
+      css = 'div.class1, span, p.class2'
+      expect(splitter.split(css)).to eq ['div.class1', 'span', 'p.class2']
+    end
+
+    it 'root level comma when quotes and pseudo selectors' do
+      css = 'div.class1[id="abc\\"def,ghi"]:not(.class3, .class4), span[id=\'a"c\\\'de\'], section, #abc\\,def'
+      expect(splitter.split(css)).to eq ['div.class1[id="abc\\"def,ghi"]:not(.class3, .class4)', 'span[id=\'a"c\\\'de\']', 'section', '#abc\\,def']
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'capybara/dsl'
+
+class TestClass
+  include Capybara::DSL
+end
+
+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
+] 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')
+  end
+end
+
+RSpec.describe Capybara::DSL do
+  after do
+    Capybara.session_name = nil
+    Capybara.default_driver = nil
+    Capybara.javascript_driver = nil
+    Capybara.use_default_driver
+    Capybara.app = TestApp
+  end
+
+  describe '#default_driver' do
+    it 'should default to rack_test' do
+      expect(Capybara.default_driver).to eq(:rack_test)
+    end
+
+    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
+      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
+      Capybara.current_driver = :culerity
+      expect(Capybara.current_driver).to eq(:culerity)
+    end
+  end
+
+  describe '#javascript_driver' do
+    it 'should default to selenium' do
+      expect(Capybara.javascript_driver).to eq(:selenium)
+    end
+
+    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
+      Capybara.current_driver = :culerity
+      Capybara.use_default_driver
+      expect(Capybara.current_driver).to eq(:rack_test)
+    end
+  end
+
+  describe '#using_driver' do
+    before do
+      expect(Capybara.current_driver).not_to eq(:selenium) # rubocop:disable RSpec/ExpectInHook
+    end
+
+    it 'should set the driver using Capybara.current_driver=' do
+      driver = nil
+      Capybara.using_driver(:selenium) { driver = Capybara.current_driver }
+      expect(driver).to eq(:selenium)
+    end
+
+    it 'should return the driver to default if it has not been changed' do
+      Capybara.using_driver(:selenium) do
+        expect(Capybara.current_driver).to eq(:selenium)
+      end
+      expect(Capybara.current_driver).to eq(Capybara.default_driver)
+    end
+
+    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 # rubocop:disable Lint/RescueException,Lint/SuppressedException
+      end
+      expect(Capybara.current_driver).to eq(driver_before_block)
+    end
+
+    it 'should return the driver to what it was previously' do
+      Capybara.current_driver = :selenium
+      Capybara.using_driver(:culerity) do
+        Capybara.using_driver(:rack_test) do
+          expect(Capybara.current_driver).to eq(:rack_test)
+        end
+        expect(Capybara.current_driver).to eq(:culerity)
+      end
+      expect(Capybara.current_driver).to eq(:selenium)
+    end
+
+    it 'should yield the passed block' do
+      called = false
+      Capybara.using_driver(:selenium) { called = true }
+      expect(called).to eq(true)
+    end
+  end
+
+  # rubocop:disable RSpec/InstanceVariable
+  describe '#using_wait_time' do
+    before { @previous_wait_time = Capybara.default_max_wait_time }
+
+    after { Capybara.default_max_wait_time = @previous_wait_time }
+
+    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
+      end
+      expect(in_block).to eq(6)
+      expect(Capybara.default_max_wait_time).to eq(@previous_wait_time)
+    end
+
+    it 'should ensure wait time is reset' do
+      expect do
+        Capybara.using_wait_time 6 do
+          raise 'hell'
+        end
+      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'
+      expect(Capybara.app).to eq('foobar')
+    end
+  end
+
+  describe '#current_session' 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
+      Capybara.app = proc {}
+      expect(Capybara.current_session.app).to eq(Capybara.app)
+    end
+
+    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
+      object_id = Capybara.current_session.object_id
+      expect(Capybara.current_session.object_id).to eq(object_id)
+      Capybara.current_driver = :selenium
+      expect(Capybara.current_session.mode).to eq(:selenium)
+      expect(Capybara.current_session.object_id).not_to eq(object_id)
+
+      Capybara.current_driver = :rack_test
+      expect(Capybara.current_session.object_id).to eq(object_id)
+    end
+
+    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 {}
+      expect(Capybara.current_session.object_id).not_to eq(object_id)
+      expect(Capybara.current_session.app).to eq(Capybara.app)
+    end
+
+    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)
+      expect(Capybara.current_session.object_id).not_to eq(object_id)
+      Capybara.session_name = :default
+      expect(Capybara.session_name).to eq(:default)
+      expect(Capybara.current_session.object_id).to eq(object_id)
+    end
+  end
+
+  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)
+      end
+      expect(Capybara.session_name).to eq(:default)
+    end
+
+    it 'should reset the session to the default, even if an exception occurs' do
+      begin
+        Capybara.using_session(:raise) do
+          raise
+        end
+      rescue Exception # rubocop:disable Lint/RescueException,Lint/SuppressedException
+      end
+      expect(Capybara.session_name).to eq(:default)
+    end
+
+    it 'should yield the passed block' do
+      called = false
+      Capybara.using_session(:administrator) { called = true }
+      expect(called).to eq(true)
+    end
+
+    it 'should be nestable' do
+      Capybara.using_session(:outer) do
+        expect(Capybara.session_name).to eq(:outer)
+        Capybara.using_session(:inner) do
+          expect(Capybara.session_name).to eq(:inner)
+        end
+        expect(Capybara.session_name).to eq(:outer)
+      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
+  end
+
+  describe '#session_name' do
+    it 'should default to :default' do
+      expect(Capybara.session_name).to eq(:default)
+    end
+  end
+
+  describe 'the DSL' do
+    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')
+    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')
+    end
+
+    it "should provide an 'using_session' shortcut" do
+      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
+      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