capybara 3.32.2

data/spec/result_spec.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Capybara::Result do
+  let :string do
+    Capybara.string <<-STRING
+      <ul>
+        <li>Alpha</li>
+        <li>Beta</li>
+        <li>Gamma</li>
+        <li>Delta</li>
+      </ul>
+    STRING
+  end
+
+  let :result do
+    string.all '//li', minimum: 0 # pass minimum: 0 so lazy evaluation doesn't get triggered yet
+  end
+
+  it 'has a length' do
+    expect(result.length).to eq(4)
+  end
+
+  it 'has a first element' do
+    result.first.text == 'Alpha'
+  end
+
+  it 'has a last element' do
+    result.last.text == 'Delta'
+  end
+
+  it 'can supports values_at method' do
+    expect(result.values_at(0, 2).map(&:text)).to eq(%w[Alpha Gamma])
+  end
+
+  it 'can return an element by its index' do
+    expect(result.at(1).text).to eq('Beta')
+    expect(result[2].text).to eq('Gamma')
+  end
+
+  it 'can be mapped' do
+    expect(result.map(&:text)).to eq(%w[Alpha Beta Gamma Delta])
+  end
+
+  it 'can be selected' do
+    expect(result.count do |element|
+      element.text.include? 't'
+    end).to eq(2)
+  end
+
+  it 'can be reduced' do
+    expect(result.reduce('') do |memo, element|
+      memo + element.text[0]
+    end).to eq('ABGD')
+  end
+
+  it 'can be sampled' do
+    expect(result).to include(result.sample)
+  end
+
+  it 'can be indexed' do
+    expect(result.index do |el|
+      el.text == 'Gamma'
+    end).to eq(2)
+  end
+
+  def recalc_result
+    string.all '//li', minimum: 0 # pass minimum: 0 so lazy evaluation doesn't get triggered yet
+  end
+
+  it 'supports all modes of []' do
+    expect(recalc_result[1].text).to eq 'Beta'
+    expect(recalc_result[0, 2].map(&:text)).to eq %w[Alpha Beta]
+    expect(recalc_result[1..3].map(&:text)).to eq %w[Beta Gamma Delta]
+    expect(recalc_result[-1].text).to eq 'Delta'
+    expect(recalc_result[-2, 3].map(&:text)).to eq %w[Gamma Delta]
+    expect(recalc_result[1...3].map(&:text)).to eq %w[Beta Gamma]
+    expect(recalc_result[1..7].map(&:text)).to eq %w[Beta Gamma Delta]
+    expect(recalc_result[2...-1].map(&:text)).to eq %w[Gamma]
+    expect(recalc_result[2..-1].map(&:text)).to eq %w[Gamma Delta]
+  end
+
+  eval <<~TEST, binding, __FILE__, __LINE__ + 1 if RUBY_VERSION.to_f > 2.5
+    it 'supports endless ranges' do
+      expect(result[2..].map(&:text)).to eq %w[Gamma Delta]
+    end
+  TEST
+
+  eval <<~TEST, binding, __FILE__, __LINE__ + 1 if RUBY_VERSION.to_f > 2.6
+    it 'supports inclusive positive beginless ranges' do
+      expect(result[..2].map(&:text)).to eq %w[Alpha Beta Gamma]
+    end
+
+    it 'supports inclusive negative beginless ranges' do
+      expect(result[..-2].map(&:text)).to eq %w[Alpha Beta Gamma]
+      expect(result[..-1].map(&:text)).to eq %w[Alpha Beta Gamma Delta]
+    end
+
+    it 'supports exclusive positive beginless ranges' do
+      expect(result[...2].map(&:text)).to eq %w[Alpha Beta]
+    end
+
+    it 'supports exclusive negative beginless ranges' do
+      expect(result[...-2].map(&:text)).to eq %w[Alpha Beta]
+      expect(result[...-1].map(&:text)).to eq %w[Alpha Beta Gamma]
+    end
+  TEST
+
+  it 'works with filter blocks' do
+    result = string.all('//li') { |node| node.text == 'Alpha' }
+    expect(result.size).to eq 1
+  end
+
+  # Not a great test but it indirectly tests what is needed
+  it 'should evaluate filters lazily for idx' do
+    skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+    # Not processed until accessed
+    expect(result.instance_variable_get('@result_cache').size).to be 0
+
+    # Only one retrieved when needed
+    result.first
+    expect(result.instance_variable_get('@result_cache').size).to be 1
+
+    # works for indexed access
+    result[0]
+    expect(result.instance_variable_get('@result_cache').size).to be 1
+
+    result[2]
+    expect(result.instance_variable_get('@result_cache').size).to be 3
+
+    # All cached when converted to array
+    result.to_a
+    expect(result.instance_variable_get('@result_cache').size).to eq 4
+  end
+
+  it 'should evaluate filters lazily for range' do
+    skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+    result[0..1]
+    expect(result.instance_variable_get('@result_cache').size).to be 2
+
+    expect(result[0..7].size).to eq 4
+    expect(result.instance_variable_get('@result_cache').size).to be 4
+  end
+
+  it 'should evaluate filters lazily for idx and length' do
+    skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+    result[1, 2]
+    expect(result.instance_variable_get('@result_cache').size).to be 3
+
+    expect(result[2, 5].size).to eq 2
+    expect(result.instance_variable_get('@result_cache').size).to be 4
+  end
+
+  it 'should only need to evaluate one result for any?' do
+    skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+    result.any?
+    expect(result.instance_variable_get('@result_cache').size).to be 1
+  end
+
+  it 'should evaluate all elements when #to_a called' do
+    # All cached when converted to array
+    result.to_a
+    expect(result.instance_variable_get('@result_cache').size).to eq 4
+  end
+
+  describe '#each' do
+    it 'lazily evaluates' do
+      skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+      results = []
+      result.each do |el|
+        results << el
+        expect(result.instance_variable_get('@result_cache').size).to eq results.size
+      end
+
+      expect(results.size).to eq 4
+    end
+
+    context 'without a block' do
+      it 'returns an iterator' do
+        expect(result.each).to be_a(Enumerator)
+      end
+
+      it 'lazily evaluates' do
+        skip 'JRuby has an issue with lazy enumerator evaluation' if jruby_lazy_enumerator_workaround?
+        result.each.with_index do |_el, idx|
+          expect(result.instance_variable_get('@result_cache').size).to eq(idx + 1) # 0 indexing
+        end
+      end
+    end
+  end
+
+  def jruby_lazy_enumerator_workaround?
+    RUBY_PLATFORM == 'java'
+  end
+end

data/spec/rspec/features_spec.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'capybara/rspec'
+
+# rubocop:disable RSpec/InstanceVariable
+RSpec.configuration.before(:each, file_path: './spec/rspec/features_spec.rb') do
+  @in_filtered_hook = true
+end
+
+feature "Capybara's feature DSL" do
+  background do
+    @in_background = true
+  end
+
+  scenario 'includes Capybara' do
+    visit('/')
+    expect(page).to have_content('Hello world!')
+  end
+
+  scenario 'preserves description' do |ex|
+    expect(ex.metadata[:full_description])
+      .to eq("Capybara's feature DSL preserves description")
+  end
+
+  scenario 'allows driver switching', driver: :selenium do
+    expect(Capybara.current_driver).to eq(:selenium)
+  end
+
+  scenario 'runs background' do
+    expect(@in_background).to be_truthy
+  end
+
+  scenario 'runs hooks filtered by file path' do
+    expect(@in_filtered_hook).to be_truthy
+  end
+
+  scenario "doesn't pollute the Object namespace" do
+    expect(Object.new).not_to respond_to(:feature)
+  end
+
+  feature 'nested features' do
+    scenario 'work as expected' do
+      visit '/'
+      expect(page).to have_content 'Hello world!'
+    end
+
+    scenario 'are marked in the metadata as capybara_feature' do |ex|
+      expect(ex.metadata[:capybara_feature]).to be_truthy
+    end
+
+    scenario 'have a type of :feature' do |ex|
+      expect(ex.metadata[:type]).to eq :feature
+    end
+  end
+end
+# rubocop:enable RSpec/InstanceVariable
+
+feature 'given and given! aliases to let and let!' do
+  given(:value) { :available }
+  given!(:value_in_background) { :available }
+
+  background do
+    expect(value_in_background).to be(:available)
+  end
+
+  scenario 'given and given! work as intended' do
+    expect(value).to be(:available)
+    expect(value_in_background).to be(:available)
+  end
+end
+
+feature "Capybara's feature DSL with driver", driver: :culerity do
+  scenario 'switches driver' do
+    expect(Capybara.current_driver).to eq(:culerity)
+  end
+end
+
+# rubocop:disable RSpec/RepeatedExample
+xfeature 'if xfeature aliases to pending then' do
+  scenario "this should be 'temporarily disabled with xfeature'" do
+    # dummy
+  end
+
+  scenario "this also should be 'temporarily disabled with xfeature'" do
+    # dummy
+  end
+end
+
+ffeature 'if ffeature aliases focused tag then' do # rubocop:disable RSpec/Focus
+  scenario 'scenario inside this feature has metatag focus tag' do |example|
+    expect(example.metadata[:focus]).to eq true
+  end
+
+  scenario 'other scenarios also has metatag focus tag ' do |example|
+    expect(example.metadata[:focus]).to eq true
+  end
+end
+# rubocop:enable RSpec/RepeatedExample

data/spec/rspec/scenarios_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'capybara/rspec'
+
+RSpec.configuration.before(:each, file_path: './spec/rspec/scenarios_spec.rb') do
+  @in_filtered_hook = true
+end
+
+feature 'if fscenario aliases focused tag then' do
+  fscenario 'scenario should have focused meta tag' do |example| # rubocop:disable RSpec/Focus
+    expect(example.metadata[:focus]).to eq true
+  end
+end
+
+feature 'if xscenario aliases to pending then' do
+  xscenario "this test should be 'temporarily disabled with xscenario'" do
+  end
+end

data/spec/rspec/shared_spec_matchers.rb

@@ -0,0 +1,947 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'capybara/dsl'
+require 'capybara/rspec/matchers'
+require 'benchmark'
+
+# rubocop:disable RSpec/ExpectActual
+
+RSpec.shared_examples Capybara::RSpecMatchers do |session, _mode|
+  include Capybara::DSL
+  include Capybara::RSpecMatchers
+
+  describe 'have_css matcher' do
+    it 'gives proper description' do
+      expect(have_css('h1').description).to eq('have visible css "h1"')
+    end
+
+    context 'on a string' do
+      context 'with should' do
+        it 'passes if has_css? returns true' do
+          expect('<h1>Text</h1>').to have_css('h1')
+        end
+
+        it 'fails if has_css? returns false' do
+          expect do
+            expect('<h1>Text</h1>').to have_css('h2')
+          end.to raise_error(/expected to find css "h2" but there were no matches/)
+        end
+
+        it 'passes if matched node count equals expected count' do
+          expect('<h1>Text</h1>').to have_css('h1', count: 1)
+        end
+
+        it 'fails if matched node count does not equal expected count' do
+          expect do
+            expect('<h1>Text</h1>').to have_css('h1', count: 2)
+          end.to raise_error('expected to find visible css "h1" 2 times, found 1 match: "Text"')
+        end
+
+        it 'fails if matched node count is less than expected minimum count' do
+          expect do
+            expect('<h1>Text</h1>').to have_css('p', minimum: 1)
+          end.to raise_error('expected to find css "p" at least 1 time but there were no matches')
+        end
+
+        it 'fails if matched node count is more than expected maximum count' do
+          expect do
+            expect('<h1>Text</h1><h1>Text</h1><h1>Text</h1>').to have_css('h1', maximum: 2)
+          end.to raise_error('expected to find visible css "h1" at most 2 times, found 3 matches: "Text", "Text", "Text"')
+        end
+
+        it 'fails if matched node count does not belong to expected range' do
+          expect do
+            expect('<h1>Text</h1>').to have_css('h1', between: 2..3)
+          end.to raise_error('expected to find visible css "h1" between 2 and 3 times, found 1 match: "Text"')
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_css? returns true' do
+          expect('<h1>Text</h1>').not_to have_css('h2')
+        end
+
+        it 'fails if has_no_css? returns false' do
+          expect do
+            expect('<h1>Text</h1>').not_to have_css('h1')
+          end.to raise_error(/expected not to find visible css "h1"/)
+        end
+
+        it 'passes if matched node count does not equal expected count' do
+          expect('<h1>Text</h1>').not_to have_css('h1', count: 2)
+        end
+
+        it 'fails if matched node count equals expected count' do
+          expect do
+            expect('<h1>Text</h1>').not_to have_css('h1', count: 1)
+          end.to raise_error(/expected not to find visible css "h1"/)
+        end
+      end
+
+      it 'supports compounding' do
+        expect('<h1>Text</h1><h2>Text</h2>').to have_css('h1').and have_css('h2')
+        expect('<h1>Text</h1><h2>Text</h2>').to have_css('h3').or have_css('h1')
+        expect('<h1>Text</h1><h2>Text</h2>').to have_no_css('h4').and have_css('h2')
+        expect('<h1>Text</h1><h2>Text</h2>').to have_no_css('h2').or have_css('h1')
+      end
+    end
+
+    context 'on a page or node' do
+      before do
+        visit('/with_html')
+      end
+
+      context 'with should' do
+        it 'passes if has_css? returns true' do
+          expect(page).to have_css('h1')
+        end
+
+        it 'fails if has_css? returns false' do
+          expect do
+            expect(page).to have_css('h1#doesnotexist')
+          end.to raise_error(/expected to find css "h1#doesnotexist" but there were no matches/)
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_css? returns true' do
+          expect(page).not_to have_css('h1#doesnotexist')
+        end
+
+        it 'fails if has_no_css? returns false' do
+          expect do
+            expect(page).not_to have_css('h1')
+          end.to raise_error(/expected not to find visible css "h1"/)
+        end
+      end
+    end
+  end
+
+  describe 'have_xpath matcher' do
+    it 'gives proper description' do
+      expect(have_xpath('//h1').description).to eq("have visible xpath \"\/\/h1\"")
+    end
+
+    context 'on a string' do
+      context 'with should' do
+        it 'passes if has_xpath? returns true' do
+          expect('<h1>Text</h1>').to have_xpath('//h1')
+        end
+
+        it 'fails if has_xpath? returns false' do
+          expect do
+            expect('<h1>Text</h1>').to have_xpath('//h2')
+          end.to raise_error(%r{expected to find xpath "//h2" but there were no matches})
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_xpath? returns true' do
+          expect('<h1>Text</h1>').not_to have_xpath('//h2')
+        end
+
+        it 'fails if has_no_xpath? returns false' do
+          expect do
+            expect('<h1>Text</h1>').not_to have_xpath('//h1')
+          end.to raise_error(%r{expected not to find visible xpath "//h1"})
+        end
+      end
+
+      it 'supports compounding' do
+        expect('<h1>Text</h1><h2>Text</h2>').to have_xpath('//h1').and have_xpath('//h2')
+        expect('<h1>Text</h1><h2>Text</h2>').to have_xpath('//h3').or have_xpath('//h1')
+        expect('<h1>Text</h1><h2>Text</h2>').to have_no_xpath('//h4').and have_xpath('//h1')
+        expect('<h1>Text</h1><h2>Text</h2>').to have_no_xpath('//h4').or have_xpath('//h4')
+      end
+    end
+
+    context 'on a page or node' do
+      before do
+        visit('/with_html')
+      end
+
+      context 'with should' do
+        it 'passes if has_xpath? returns true' do
+          expect(page).to have_xpath('//h1')
+        end
+
+        it 'fails if has_xpath? returns false' do
+          expect do
+            expect(page).to have_xpath("//h1[@id='doesnotexist']")
+          end.to raise_error(%r{expected to find xpath "//h1\[@id='doesnotexist'\]" but there were no matches})
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_xpath? returns true' do
+          expect(page).not_to have_xpath('//h1[@id="doesnotexist"]')
+        end
+
+        it 'fails if has_no_xpath? returns false' do
+          expect do
+            expect(page).not_to have_xpath('//h1')
+          end.to raise_error(%r{expected not to find visible xpath "//h1"})
+        end
+      end
+    end
+  end
+
+  describe 'have_selector matcher' do
+    it 'gives proper description' do
+      matcher = have_selector('//h1')
+      expect('<h1>Text</h1>').to matcher
+      expect(matcher.description).to eq('have visible xpath "//h1"')
+    end
+
+    context 'on a string' do
+      context 'with should' do
+        it 'passes if has_selector? returns true' do
+          expect('<h1>Text</h1>').to have_selector('//h1')
+        end
+
+        it 'fails if has_selector? returns false' do
+          expect do
+            expect('<h1>Text</h1>').to have_selector('//h2')
+          end.to raise_error(%r{expected to find xpath "//h2" but there were no matches})
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_selector? returns true' do
+          expect('<h1>Text</h1>').not_to have_selector(:css, 'h2')
+        end
+
+        it 'fails if has_no_selector? returns false' do
+          expect do
+            expect('<h1>Text</h1>').not_to have_selector(:css, 'h1')
+          end.to raise_error(/expected not to find visible css "h1"/)
+        end
+      end
+    end
+
+    context 'on a page or node' do
+      before do
+        visit('/with_html')
+      end
+
+      context 'with should' do
+        it 'passes if has_selector? returns true' do
+          expect(page).to have_selector('//h1', text: 'test')
+        end
+
+        it 'fails if has_selector? returns false' do
+          expect do
+            expect(page).to have_selector("//h1[@id='doesnotexist']")
+          end.to raise_error(%r{expected to find xpath "//h1\[@id='doesnotexist'\]" but there were no matches})
+        end
+
+        it 'includes text in error message' do
+          expect do
+            expect(page).to have_selector('//h1', text: 'wrong text')
+          end.to raise_error(%r{expected to find visible xpath "//h1" with text "wrong text" but there were no matches})
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_css? returns true' do
+          expect(page).not_to have_selector(:css, 'h1#doesnotexist')
+        end
+
+        it 'fails if has_no_selector? returns false' do
+          expect do
+            expect(page).not_to have_selector(:css, 'h1', text: 'test')
+          end.to raise_error(/expected not to find visible css "h1" with text "test"/)
+        end
+      end
+    end
+
+    it 'supports compounding' do
+      expect('<h1>Text</h1><h2>Text</h2>').to have_selector('//h1').and have_selector('//h2')
+      expect('<h1>Text</h1><h2>Text</h2>').to have_selector('//h3').or have_selector('//h1')
+      expect('<h1>Text</h1><h2>Text</h2>').to have_no_selector('//h3').and have_selector('//h1')
+    end
+  end
+
+  describe 'have_content matcher' do
+    it 'gives proper description' do
+      expect(have_content('Text').description).to eq('have text "Text"')
+    end
+
+    context 'on a string' do
+      context 'with should' do
+        it 'passes if has_content? returns true' do
+          expect('<h1>Text</h1>').to have_content('Text')
+        end
+
+        it 'passes if has_content? returns true using regexp' do
+          expect('<h1>Text</h1>').to have_content(/ext/)
+        end
+
+        it 'fails if has_content? returns false' do
+          expect do
+            expect('<h1>Text</h1>').to have_content('No such Text')
+          end.to raise_error(/expected to find text "No such Text" in "Text"/)
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_content? returns true' do
+          expect('<h1>Text</h1>').not_to have_content('No such Text')
+        end
+
+        it 'passes because escapes any characters that would have special meaning in a regexp' do
+          expect('<h1>Text</h1>').not_to have_content('.')
+        end
+
+        it 'fails if has_no_content? returns false' do
+          expect do
+            expect('<h1>Text</h1>').not_to have_content('Text')
+          end.to raise_error(/expected not to find text "Text" in "Text"/)
+        end
+      end
+    end
+
+    context 'on a page or node' do
+      before do
+        visit('/with_html')
+      end
+
+      context 'with should' do
+        it 'passes if has_content? returns true' do
+          expect(page).to have_content('This is a test')
+        end
+
+        it 'passes if has_content? returns true using regexp' do
+          expect(page).to have_content(/test/)
+        end
+
+        it 'fails if has_content? returns false' do
+          expect do
+            expect(page).to have_content('No such Text')
+          end.to raise_error(/expected to find text "No such Text" in "(.*)This is a test(.*)"/)
+        end
+
+        context 'with default selector CSS' do
+          before { Capybara.default_selector = :css }
+
+          after { Capybara.default_selector = :xpath }
+
+          it 'fails if has_content? returns false' do
+            expect do
+              expect(page).to have_content('No such Text')
+            end.to raise_error(/expected to find text "No such Text" in "(.*)This is a test(.*)"/)
+          end
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_content? returns true' do
+          expect(page).not_to have_content('No such Text')
+        end
+
+        it 'fails if has_no_content? returns false' do
+          expect do
+            expect(page).not_to have_content('This is a test')
+          end.to raise_error(/expected not to find text "This is a test"/)
+        end
+      end
+    end
+
+    it 'supports compounding' do
+      expect('<h1>Text</h1><h2>And</h2>').to have_content('Text').and have_content('And')
+      expect('<h1>Text</h1><h2>Or</h2>').to have_content('XYZ').or have_content('Or')
+      expect('<h1>Text</h1><h2>Or</h2>').to have_no_content('XYZ').and have_content('Or')
+    end
+  end
+
+  describe 'have_text matcher' do
+    it 'gives proper description' do
+      expect(have_text('Text').description).to eq('have text "Text"')
+    end
+
+    context 'on a string' do
+      context 'with should' do
+        it 'passes if text contains given string' do
+          expect('<h1>Text</h1>').to have_text('Text')
+        end
+
+        it 'passes if text matches given regexp' do
+          expect('<h1>Text</h1>').to have_text(/ext/)
+        end
+
+        it "fails if text doesn't contain given string" do
+          expect do
+            expect('<h1>Text</h1>').to have_text('No such Text')
+          end.to raise_error(/expected to find text "No such Text" in "Text"/)
+        end
+
+        it "fails if text doesn't match given regexp" do
+          expect do
+            expect('<h1>Text</h1>').to have_text(/No such Text/)
+          end.to raise_error('expected to find text matching /No such Text/ in "Text"')
+        end
+
+        it 'casts Integer to string' do
+          expect do
+            expect('<h1>Text</h1>').to have_text(3)
+          end.to raise_error(/expected to find text "3" in "Text"/)
+        end
+
+        it 'fails if matched text count does not equal to expected count' do
+          expect do
+            expect('<h1>Text</h1>').to have_text('Text', count: 2)
+          end.to raise_error('expected to find text "Text" 2 times but found 1 time in "Text"')
+        end
+
+        it 'fails if matched text count is less than expected minimum count' do
+          expect do
+            expect('<h1>Text</h1>').to have_text('Lorem', minimum: 1)
+          end.to raise_error('expected to find text "Lorem" at least 1 time but found 0 times in "Text"')
+        end
+
+        it 'fails if matched text count is more than expected maximum count' do
+          expect do
+            expect('<h1>Text TextText</h1>').to have_text('Text', maximum: 2)
+          end.to raise_error('expected to find text "Text" at most 2 times but found 3 times in "Text TextText"')
+        end
+
+        it 'fails if matched text count does not belong to expected range' do
+          expect do
+            expect('<h1>Text</h1>').to have_text('Text', between: 2..3)
+          end.to raise_error('expected to find text "Text" between 2 and 3 times but found 1 time in "Text"')
+        end
+      end
+
+      context 'with should_not' do
+        it "passes if text doesn't contain a string" do
+          expect('<h1>Text</h1>').not_to have_text('No such Text')
+        end
+
+        it 'passes because escapes any characters that would have special meaning in a regexp' do
+          expect('<h1>Text</h1>').not_to have_text('.')
+        end
+
+        it 'fails if text contains a string' do
+          expect do
+            expect('<h1>Text</h1>').not_to have_text('Text')
+          end.to raise_error(/expected not to find text "Text" in "Text"/)
+        end
+      end
+    end
+
+    context 'on a page or node' do
+      before do
+        visit('/with_html')
+      end
+
+      context 'with should' do
+        it 'passes if has_text? returns true' do
+          expect(page).to have_text('This is a test')
+        end
+
+        it 'passes if has_text? returns true using regexp' do
+          expect(page).to have_text(/test/)
+        end
+
+        it 'can check for all text' do
+          expect(page).to have_text(:all, 'Some of this text is hidden!')
+        end
+
+        it 'can check for visible text' do
+          expect(page).to have_text(:visible, 'Some of this text is')
+          expect(page).not_to have_text(:visible, 'Some of this text is hidden!')
+        end
+
+        it 'fails if has_text? returns false' do
+          expect do
+            expect(page).to have_text('No such Text')
+          end.to raise_error(/expected to find text "No such Text" in "(.*)This is a test(.*)"/)
+        end
+
+        context 'with default selector CSS' do
+          before { Capybara.default_selector = :css }
+
+          after { Capybara.default_selector = :xpath }
+
+          it 'fails if has_text? returns false' do
+            expect do
+              expect(page).to have_text('No such Text')
+            end.to raise_error(/expected to find text "No such Text" in "(.*)This is a test(.*)"/)
+          end
+        end
+      end
+
+      context 'with should_not' do
+        it 'passes if has_no_text? returns true' do
+          expect(page).not_to have_text('No such Text')
+        end
+
+        it 'fails if has_no_text? returns false' do
+          expect do
+            expect(page).not_to have_text('This is a test')
+          end.to raise_error(/expected not to find text "This is a test"/)
+        end
+      end
+    end
+
+    it 'supports compounding' do
+      expect('<h1>Text</h1><h2>And</h2>').to have_text('Text').and have_text('And')
+      expect('<h1>Text</h1><h2>Or</h2>').to have_text('Not here').or have_text('Or')
+    end
+  end
+
+  describe 'have_link matcher' do
+    let(:html) { '<a href="#">Just a link</a><a href="#">Another link</a>' }
+
+    it 'gives proper description' do
+      expect(have_link('Just a link').description).to eq('have visible link "Just a link"')
+    end
+
+    it 'passes if there is such a link' do
+      expect(html).to have_link('Just a link')
+    end
+
+    it 'fails if there is no such link' do
+      expect do
+        expect(html).to have_link('No such Link')
+      end.to raise_error(/expected to find link "No such Link"/)
+    end
+
+    it 'supports compounding' do
+      expect(html).to have_link('Just a link').and have_link('Another link')
+      expect(html).to have_link('Not a link').or have_link('Another link')
+      expect(html).to have_no_link('Not a link').and have_link('Another link')
+    end
+  end
+
+  describe 'have_title matcher' do
+    it 'gives proper description' do
+      expect(have_title('Just a title').description).to eq('have title "Just a title"')
+    end
+
+    context 'on a string' do
+      let(:html) { '<title>Just a title</title>' }
+
+      it 'passes if there is such a title' do
+        expect(html).to have_title('Just a title')
+      end
+
+      it 'fails if there is no such title' do
+        expect do
+          expect(html).to have_title('No such title')
+        end.to raise_error('expected "Just a title" to include "No such title"')
+      end
+
+      it "fails if title doesn't match regexp" do
+        expect do
+          expect(html).to have_title(/[[:upper:]]+[[:lower:]]+l{2}o/)
+        end.to raise_error('expected "Just a title" to match /[[:upper:]]+[[:lower:]]+l{2}o/')
+      end
+    end
+
+    context 'on a page or node' do
+      it 'passes if there is such a title' do
+        visit('/with_js')
+        expect(page).to have_title('with_js')
+      end
+
+      it 'fails if there is no such title' do
+        visit('/with_js')
+        expect do
+          expect(page).to have_title('No such title')
+        end.to raise_error('expected "with_js" to include "No such title"')
+      end
+
+      context 'with wait' do
+        before do
+          session.visit('/with_js')
+        end
+
+        it 'waits if wait time is more than timeout' do
+          session.click_link('Change title')
+          using_wait_time 0 do
+            expect(session).to have_title('changed title', wait: 2)
+          end
+        end
+
+        it "doesn't wait if wait time is less than timeout" do
+          session.click_link('Change title')
+          using_wait_time 3 do
+            expect(session).not_to have_title('changed title', wait: 0)
+          end
+        end
+      end
+    end
+
+    it 'supports compounding' do
+      expect('<title>I compound</title>').to have_title('I dont compound').or have_title('I compound')
+    end
+  end
+
+  describe 'have_current_path matcher' do
+    it 'gives proper description' do
+      expect(have_current_path('http://www.example.com').description).to eq('have current path "http://www.example.com"')
+    end
+
+    context 'on a page or node' do
+      it 'passes if there is such a current path' do
+        visit('/with_js')
+        expect(page).to have_current_path('/with_js')
+      end
+
+      it 'fails if there is no such current_path' do
+        visit('/with_js')
+        expect do
+          expect(page).to have_current_path('/not_with_js')
+        end.to raise_error('expected "/with_js" to equal "/not_with_js"')
+      end
+
+      context 'with wait' do
+        before do
+          session.visit('/with_js')
+        end
+
+        it 'waits if wait time is more than timeout' do
+          session.click_link('Change page')
+          using_wait_time 0 do
+            expect(session).to have_current_path('/with_html', wait: 2)
+          end
+        end
+
+        it "doesn't wait if wait time is less than timeout" do
+          session.click_link('Change page')
+          using_wait_time 0 do
+            expect(session).not_to have_current_path('/with_html')
+          end
+        end
+      end
+    end
+
+    it 'supports compounding' do
+      visit('/with_html')
+      expect(page).to have_current_path('/not_with_html').or have_current_path('/with_html')
+    end
+  end
+
+  describe 'have_button matcher' do
+    let(:html) { '<button>A button</button><input type="submit" value="Another button"/>' }
+
+    it 'gives proper description with no options' do
+      expect(have_button('A button').description).to eq('have visible button "A button" that is not disabled')
+    end
+
+    it 'gives proper description with disabled :any option' do
+      expect(have_button('A button', disabled: :all).description).to eq('have visible button "A button"')
+    end
+
+    it 'passes if there is such a button' do
+      expect(html).to have_button('A button')
+    end
+
+    it 'fails if there is no such button' do
+      expect do
+        expect(html).to have_button('No such Button')
+      end.to raise_error(/expected to find button "No such Button"/)
+    end
+
+    it 'supports compounding' do
+      expect(html).to have_button('Not this button').or have_button('A button')
+    end
+  end
+
+  describe 'have_field matcher' do
+    let(:html) { '<p><label>Text field<input type="text" value="some value"/></label></p>' }
+
+    it 'gives proper description' do
+      expect(have_field('Text field').description).to eq('have visible field "Text field" that is not disabled')
+    end
+
+    it 'gives proper description for a given value' do
+      expect(have_field('Text field', with: 'some value').description).to eq('have visible field "Text field" that is not disabled with value "some value"')
+    end
+
+    it 'passes if there is such a field' do
+      expect(html).to have_field('Text field')
+    end
+
+    it 'passes if there is such a field with value' do
+      expect(html).to have_field('Text field', with: 'some value')
+    end
+
+    it 'fails if there is no such field' do
+      expect do
+        expect(html).to have_field('No such Field')
+      end.to raise_error(/expected to find field "No such Field"/)
+    end
+
+    it 'fails if there is such field but with false value' do
+      expect do
+        expect(html).to have_field('Text field', with: 'false value')
+      end.to raise_error(/expected to find visible field "Text field"/)
+    end
+
+    it 'treats a given value as a string' do
+      foo = Class.new do
+        def to_s
+          'some value'
+        end
+      end
+      expect(html).to have_field('Text field', with: foo.new)
+    end
+
+    it 'supports compounding' do
+      expect(html).to have_field('Not this one').or have_field('Text field')
+    end
+  end
+
+  describe 'have_checked_field matcher' do
+    let(:html) do
+      '<label>it is checked<input type="checkbox" checked="checked"/></label>
+      <label>unchecked field<input type="checkbox"/></label>'
+    end
+
+    it 'gives proper description' do
+      expect(have_checked_field('it is checked').description).to eq('have visible field "it is checked" that is not disabled that is checked')
+    end
+
+    context 'with should' do
+      it 'passes if there is such a field and it is checked' do
+        expect(html).to have_checked_field('it is checked')
+      end
+
+      it 'fails if there is such a field but it is not checked' do
+        expect do
+          expect(html).to have_checked_field('unchecked field')
+        end.to raise_error(/expected to find visible field "unchecked field"/)
+      end
+
+      it 'fails if there is no such field' do
+        expect do
+          expect(html).to have_checked_field('no such field')
+        end.to raise_error(/expected to find field "no such field"/)
+      end
+    end
+
+    context 'with should not' do
+      it 'fails if there is such a field and it is checked' do
+        expect do
+          expect(html).not_to have_checked_field('it is checked')
+        end.to raise_error(/expected not to find visible field "it is checked"/)
+      end
+
+      it 'passes if there is such a field but it is not checked' do
+        expect(html).not_to have_checked_field('unchecked field')
+      end
+
+      it 'passes if there is no such field' do
+        expect(html).not_to have_checked_field('no such field')
+      end
+    end
+
+    it 'supports compounding' do
+      expect(html).to have_checked_field('not this one').or have_checked_field('it is checked')
+    end
+  end
+
+  describe 'have_unchecked_field matcher' do
+    let(:html) do
+      '<label>it is checked<input type="checkbox" checked="checked"/></label>
+      <label>unchecked field<input type="checkbox"/></label>'
+    end
+
+    it 'gives proper description' do
+      expect(have_unchecked_field('unchecked field').description).to eq('have visible field "unchecked field" that is not disabled that is not checked')
+    end
+
+    context 'with should' do
+      it 'passes if there is such a field and it is not checked' do
+        expect(html).to have_unchecked_field('unchecked field')
+      end
+
+      it 'fails if there is such a field but it is checked' do
+        expect do
+          expect(html).to have_unchecked_field('it is checked')
+        end.to raise_error(/expected to find visible field "it is checked"/)
+      end
+
+      it 'fails if there is no such field' do
+        expect do
+          expect(html).to have_unchecked_field('no such field')
+        end.to raise_error(/expected to find field "no such field"/)
+      end
+    end
+
+    context 'with should not' do
+      it 'fails if there is such a field and it is not checked' do
+        expect do
+          expect(html).not_to have_unchecked_field('unchecked field')
+        end.to raise_error(/expected not to find visible field "unchecked field"/)
+      end
+
+      it 'passes if there is such a field but it is checked' do
+        expect(html).not_to have_unchecked_field('it is checked')
+      end
+
+      it 'passes if there is no such field' do
+        expect(html).not_to have_unchecked_field('no such field')
+      end
+    end
+
+    it 'supports compounding' do
+      expect(html).to have_unchecked_field('it is checked').or have_unchecked_field('unchecked field')
+    end
+  end
+
+  describe 'have_select matcher' do
+    let(:html) { '<label>Select Box<select></select></label>' }
+
+    it 'gives proper description' do
+      expect(have_select('Select Box').description).to eq('have visible select box "Select Box" that is not disabled')
+    end
+
+    it 'gives proper description for a given selected value' do
+      expect(have_select('Select Box', selected: 'some value').description).to eq('have visible select box "Select Box" that is not disabled with "some value" selected')
+    end
+
+    it 'passes if there is such a select' do
+      expect(html).to have_select('Select Box')
+    end
+
+    it 'fails if there is no such select' do
+      expect do
+        expect(html).to have_select('No such Select box')
+      end.to raise_error(/expected to find select box "No such Select box"/)
+    end
+
+    it 'supports compounding' do
+      expect(html).to have_select('Not this one').or have_select('Select Box')
+    end
+  end
+
+  describe 'have_table matcher' do
+    let(:html) { '<table><caption>Lovely table</caption></table>' }
+
+    it 'gives proper description' do
+      expect(have_table('Lovely table').description).to eq('have visible table "Lovely table"')
+      expect(have_table('Lovely table', caption: 'my caption').description).to eq('have visible table "Lovely table" with caption "my caption"')
+    end
+
+    it 'gives proper description when :visible option passed' do
+      expect(have_table('Lovely table', visible: true).description).to eq('have visible table "Lovely table"')
+      expect(have_table('Lovely table', visible: :hidden).description).to eq('have non-visible table "Lovely table"')
+      expect(have_table('Lovely table', visible: :all).description).to eq('have table "Lovely table"')
+      expect(have_table('Lovely table', visible: false).description).to eq('have table "Lovely table"')
+    end
+
+    it 'passes if there is such a table' do
+      expect(html).to have_table('Lovely table')
+    end
+
+    it 'fails if there is no such table' do
+      expect do
+        expect(html).to have_table('No such Table')
+      end.to raise_error(/expected to find table "No such Table"/)
+    end
+
+    it 'supports compounding' do
+      expect(html).to have_table('nope').or have_table('Lovely table')
+    end
+  end
+
+  context 'compounding timing' do
+    let(:session) { session }
+    let(:el) { session.find(:css, '#reload-me') }
+
+    before do
+      session.visit('/with_js')
+    end
+
+    describe '#and' do
+      it "should run 'concurrently'" do
+        Capybara.using_wait_time(2) do
+          matcher = have_text('this is not there').and have_text('neither is this')
+          expect(Benchmark.realtime do
+            expect do
+              expect(el).to matcher
+            end.to raise_error RSpec::Expectations::ExpectationNotMetError
+          end).to be_between(2, 3)
+        end
+      end
+
+      it "should run 'concurrently' and retry" do
+        session.click_link('reload-link')
+        session.using_wait_time(2) do
+          expect(Benchmark.realtime do
+            expect do
+              expect(el).to have_text('waiting to be reloaded').and(have_text('has been reloaded'))
+            end.to raise_error RSpec::Expectations::ExpectationNotMetError, /expected to find text "waiting to be reloaded" in "has been reloaded"/
+          end).to be_between(2, 3)
+        end
+      end
+
+      it 'should ignore :wait options' do
+        session.using_wait_time(2) do
+          matcher = have_text('this is not there', wait: 5).and have_text('neither is this', wait: 6)
+          expect(Benchmark.realtime do
+            expect do
+              expect(el).to matcher
+            end.to raise_error RSpec::Expectations::ExpectationNotMetError
+          end).to be_between(2, 3)
+        end
+      end
+
+      it 'should work on the session' do
+        session.using_wait_time(2) do
+          session.click_link('reload-link')
+          expect(session).to have_selector(:css, 'h1', text: 'FooBar').and have_text('has been reloaded')
+        end
+      end
+    end
+
+    describe '#and_then' do
+      it 'should run sequentially' do
+        session.click_link('reload-link')
+        expect(el).to have_text('waiting to be reloaded').and_then have_text('has been reloaded')
+      end
+    end
+
+    describe '#or' do
+      it "should run 'concurrently'" do
+        session.using_wait_time(3) do
+          expect(Benchmark.realtime do
+            expect(el).to have_text('has been reloaded').or have_text('waiting to be reloaded')
+          end).to be < 1
+        end
+      end
+
+      it 'should retry' do
+        session.using_wait_time(3) do
+          expect(Benchmark.realtime do
+            expect do
+              expect(el).to have_text('has been reloaded').or have_text('random stuff')
+            end.to raise_error RSpec::Expectations::ExpectationNotMetError
+          end).to be > 3
+        end
+      end
+
+      it 'should ignore :wait options' do
+        session.using_wait_time(2) do
+          expect(Benchmark.realtime do
+            expect do
+              expect(el).to have_text('this is not there', wait: 10).or have_text('neither is this', wait: 15)
+            end.to raise_error RSpec::Expectations::ExpectationNotMetError
+          end).to be_between(2, 3)
+        end
+      end
+
+      it 'should work on the session' do
+        session.using_wait_time(2) do
+          session.click_link('reload-link')
+          expect(session).to have_selector(:css, 'h1', text: 'Not on the page').or have_text('has been reloaded')
+        end
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/ExpectActual