capybara 2.15.1 → 3.36.0

data/spec/rack_test_spec.rb

@@ -1,228 +1,283 @@
 # frozen_string_literal: true
+
 require 'spec_helper'
 
 module TestSessions
   RackTest = Capybara::Session.new(:rack_test, TestApp)
 end
 
-Capybara::SpecHelper.run_specs TestSessions::RackTest, "RackTest", capybara_skip: [
-  :js,
-  :modals,
-  :screenshot,
-  :frames,
-  :windows,
-  :send_keys,
-  :server,
-  :hover,
-  :about_scheme,
+skipped_tests = %i[
+  js
+  modals
+  screenshot
+  frames
+  windows
+  send_keys
+  server
+  hover
+  about_scheme
+  download
+  css
+  scroll
+  spatial
+  html_validation
+  shadow_dom
+  active_element
 ]
+Capybara::SpecHelper.run_specs TestSessions::RackTest, 'RackTest', capybara_skip: skipped_tests do |example|
+  case example.metadata[:full_description]
+  when /has_css\? should support case insensitive :class and :id options/
+    skip "Nokogiri doesn't support case insensitive CSS attribute matchers"
+  when /#click_button should follow permanent redirects that maintain method/
+    skip "Rack < 2 doesn't support 308" if Gem.loaded_specs['rack'].version < Gem::Version.new('2.0.0')
+  end
+end
 
-RSpec.describe Capybara::Session do
+RSpec.describe Capybara::Session do # rubocop:disable RSpec/MultipleDescribes
+  include Capybara::RSpecMatchers
   context 'with rack test driver' do
-    before do
-      @session = TestSessions::RackTest
-    end
+    let(:session) { TestSessions::RackTest }
 
     describe '#driver' do
-      it "should be a rack test driver" do
-        expect(@session.driver).to be_an_instance_of(Capybara::RackTest::Driver)
+      it 'should be a rack test driver' do
+        expect(session.driver).to be_an_instance_of(Capybara::RackTest::Driver)
       end
     end
 
     describe '#mode' do
-      it "should remember the mode" do
-        expect(@session.mode).to eq(:rack_test)
+      it 'should remember the mode' do
+        expect(session.mode).to eq(:rack_test)
       end
     end
 
     describe '#click_link' do
-      it "should use data-method if option is true" do
-        @session.driver.options[:respect_data_method] = true
-        @session.visit "/with_html"
-        @session.click_link "A link with data-method"
-        expect(@session.html).to include('The requested object was deleted')
+      after do
+        session.driver.options[:respect_data_method] = false
       end
 
-      it "should not use data-method if option is false" do
-        @session.driver.options[:respect_data_method] = false
-        @session.visit "/with_html"
-        @session.click_link "A link with data-method"
-        expect(@session.html).to include('Not deleted')
+      it 'should use data-method if option is true' do
+        session.driver.options[:respect_data_method] = true
+        session.visit '/with_html'
+        session.click_link 'A link with data-method'
+        expect(session.html).to include('The requested object was deleted')
       end
 
-      it "should use data-method if available even if it's capitalized" do
-        @session.driver.options[:respect_data_method] = true
-        @session.visit "/with_html"
-        @session.click_link "A link with capitalized data-method"
-        expect(@session.html).to include('The requested object was deleted')
+      it 'should not use data-method if option is false' do
+        session.driver.options[:respect_data_method] = false
+        session.visit '/with_html'
+        session.click_link 'A link with data-method'
+        expect(session.html).to include('Not deleted')
       end
 
-      after do
-        @session.driver.options[:respect_data_method] = false
+      it "should use data-method if available even if it's capitalized" do
+        session.driver.options[:respect_data_method] = true
+        session.visit '/with_html'
+        session.click_link 'A link with capitalized data-method'
+        expect(session.html).to include('The requested object was deleted')
       end
     end
 
-    describe "#fill_in" do
-      it "should warn that :fill_options are not supported" do
-        expect_any_instance_of(Capybara::Node::Element).to receive(:warn)
-          .with("Options passed to Capybara::Node#set but the driver doesn't support them")
-        @session.visit "/with_html"
-        @session.fill_in 'test_field', with: 'not_moneky', fill_options: { random: true }
+    describe '#fill_in' do
+      it 'should warn that :fill_options are not supported' do
+        session.visit '/with_html'
+        expect { session.fill_in 'test_field', with: 'not_monkey', fill_options: { random: true } }.to \
+          output(/^Options passed to Node#set but the RackTest driver doesn't support any - ignoring/).to_stderr
+        expect(session).to have_field('test_field', with: 'not_monkey')
       end
     end
 
-    describe "#attach_file" do
-      context "with multipart form" do
-        it "should submit an empty form-data section if no file is submitted" do
-          @session.visit("/form")
-          @session.click_button("Upload Empty")
-          expect(@session.html).to include('Successfully ignored empty file field.')
+    describe '#attach_file' do
+      context 'with multipart form' do
+        it 'should submit an empty form-data section if no file is submitted' do
+          session.visit('/form')
+          session.click_button('Upload Empty')
+          expect(session.html).to include('Successfully ignored empty file field.')
         end
       end
 
-      it "should not submit an obsolete mime type" do
-        @test_jpg_file_path = File.expand_path('fixtures/capybara.csv', File.dirname(__FILE__))
-        @session.visit("/form")
-        @session.attach_file "form_document", @test_jpg_file_path
-        @session.click_button('Upload Single')
-        expect(@session).to have_content("Content-type: text/csv")
+      it 'should not submit an obsolete mime type' do
+        test_jpg_file_path = File.expand_path('fixtures/capybara.csv', File.dirname(__FILE__))
+        session.visit('/form')
+        session.attach_file 'form_document', test_jpg_file_path
+        session.click_button('Upload Single')
+        expect(session).to have_content('Content-type: text/csv')
       end
     end
 
-    describe "#click" do
-      context "on a label" do
-        it "should toggle the associated checkbox" do
-          @session.visit("/form")
-          expect(@session).to have_unchecked_field('form_pets_cat')
-          @session.find(:label, 'Cat').click
-          expect(@session).to have_checked_field('form_pets_cat')
-          @session.find(:label, 'Cat').click
-          expect(@session).to have_unchecked_field('form_pets_cat')
-          @session.find(:label, 'McLaren').click
-          expect(@session).to have_checked_field('form_cars_mclaren', visible: :hidden)
+    describe '#click' do
+      context 'on a label' do
+        it 'should toggle the associated checkbox' do
+          session.visit('/form')
+          expect(session).to have_unchecked_field('form_pets_cat')
+          session.find(:label, 'Cat').click
+          expect(session).to have_checked_field('form_pets_cat')
+          session.find(:label, 'Cat').click
+          expect(session).to have_unchecked_field('form_pets_cat')
+          session.find(:label, 'McLaren').click
+          expect(session).to have_checked_field('form_cars_mclaren', visible: :hidden)
         end
 
-        it "should toggle the associated radio" do
-          @session.visit("/form")
-          expect(@session).to have_unchecked_field('gender_male')
-          @session.find(:label, 'Male').click
-          expect(@session).to have_checked_field('gender_male')
-          @session.find(:label, 'Female').click
-          expect(@session).to have_unchecked_field('gender_male')
+        it 'should toggle the associated radio' do
+          session.visit('/form')
+          expect(session).to have_unchecked_field('gender_male')
+          session.find(:label, 'Male').click
+          expect(session).to have_checked_field('gender_male')
+          session.find(:label, 'Female').click
+          expect(session).to have_unchecked_field('gender_male')
         end
+
+        it 'should rewrite the forms action query for get submission' do
+          session.visit('/form')
+          session.click_button('mediocre')
+          expect(session).not_to have_current_path(/foo|bar/)
+        end
+
+        it 'should rewrite the submit buttons formaction query for get submission' do
+          session.visit('/form')
+          session.click_button('mediocre2')
+          expect(session).not_to have_current_path(/foo|bar/)
+        end
+      end
+    end
+
+    describe '#send_keys' do
+      it 'raises an UnsupportedMethodError' do
+        session.visit('/form')
+
+        expect { session.send_keys(:tab) }.to raise_error(Capybara::NotSupportedByDriverError)
+      end
+    end
+
+    describe '#active_element' do
+      it 'raises an UnsupportedMethodError' do
+        session.visit('/form')
+
+        expect { session.active_element }.to raise_error(Capybara::NotSupportedByDriverError)
       end
     end
 
     describe '#text' do
-      it "should return original text content for textareas" do
-        @session.visit('/with_html')
-        @session.find_field('normal', type: 'textarea', with: 'banana').set('hello')
-        normal = @session.find(:css, '#normal')
+      it 'should return original text content for textareas' do
+        session.visit('/with_html')
+        session.find_field('normal', type: 'textarea', with: 'banana').set('hello')
+        normal = session.find(:css, '#normal')
         expect(normal.value).to eq 'hello'
         expect(normal.text).to eq 'banana'
       end
     end
+
+    describe '#style' do
+      it 'should raise an error' do
+        session.visit('/with_html')
+        el = session.find(:css, '#first')
+        expect { el.style('display') }.to raise_error NotImplementedError, /not process CSS/
+      end
+    end
   end
 end
 
 RSpec.describe Capybara::RackTest::Driver do
-  before do
-    @driver = TestSessions::RackTest.driver
-  end
+  let(:driver) { TestSessions::RackTest.driver }
 
   describe ':headers option' do
     it 'should always set headers' do
-      @driver = Capybara::RackTest::Driver.new(TestApp, headers: {'HTTP_FOO' => 'foobar'})
-      @driver.visit('/get_header')
-      expect(@driver.html).to include('foobar')
+      driver = described_class.new(TestApp, headers: { 'HTTP_FOO' => 'foobar' })
+      driver.visit('/get_header')
+      expect(driver.html).to include('foobar')
     end
 
     it 'should keep headers on link clicks' do
-      @driver = Capybara::RackTest::Driver.new(TestApp, headers: {'HTTP_FOO' => 'foobar'})
-      @driver.visit('/header_links')
-      @driver.find_xpath('.//a').first.click
-      expect(@driver.html).to include('foobar')
+      driver = described_class.new(TestApp, headers: { 'HTTP_FOO' => 'foobar' })
+      driver.visit('/header_links')
+      driver.find_xpath('.//a').first.click
+      expect(driver.html).to include('foobar')
     end
 
     it 'should keep headers on form submit' do
-      @driver = Capybara::RackTest::Driver.new(TestApp, headers: {'HTTP_FOO' => 'foobar'})
-      @driver.visit('/header_links')
-      @driver.find_xpath('.//input').first.click
-      expect(@driver.html).to include('foobar')
+      driver = described_class.new(TestApp, headers: { 'HTTP_FOO' => 'foobar' })
+      driver.visit('/header_links')
+      driver.find_xpath('.//input').first.click
+      expect(driver.html).to include('foobar')
     end
 
     it 'should keep headers on redirects' do
-      @driver = Capybara::RackTest::Driver.new(TestApp, headers: {'HTTP_FOO' => 'foobar'})
-      @driver.visit('/get_header_via_redirect')
-      expect(@driver.html).to include('foobar')
+      driver = described_class.new(TestApp, headers: { 'HTTP_FOO' => 'foobar' })
+      driver.visit('/get_header_via_redirect')
+      expect(driver.html).to include('foobar')
     end
   end
 
   describe ':follow_redirects option' do
-    it "defaults to following redirects" do
-      @driver = Capybara::RackTest::Driver.new(TestApp)
+    it 'defaults to following redirects' do
+      driver = described_class.new(TestApp)
 
-      @driver.visit('/redirect')
-      expect(@driver.response.header['Location']).to be_nil
-      expect(@driver.current_url).to match %r{/landed$}
+      driver.visit('/redirect')
+      expect(driver.response.header['Location']).to be_nil
+      expect(driver.current_url).to match %r{/landed$}
     end
 
-    it "is possible to not follow redirects" do
-      @driver = Capybara::RackTest::Driver.new(TestApp, follow_redirects: false)
+    it 'is possible to not follow redirects' do
+      driver = described_class.new(TestApp, follow_redirects: false)
 
-      @driver.visit('/redirect')
-      expect(@driver.response.header['Location']).to match %r{/redirect_again$}
-      expect(@driver.current_url).to match %r{/redirect$}
+      driver.visit('/redirect')
+      expect(driver.response.header['Location']).to match %r{/redirect_again$}
+      expect(driver.current_url).to match %r{/redirect$}
     end
   end
 
   describe ':redirect_limit option' do
-    context "with default redirect limit" do
-      before do
-        @driver = Capybara::RackTest::Driver.new(TestApp)
-      end
+    context 'with default redirect limit' do
+      let(:driver) { described_class.new(TestApp) }
 
-      it "should follow 5 redirects" do
-        @driver.visit("/redirect/5/times")
-        expect(@driver.html).to include('redirection complete')
+      it 'should follow 5 redirects' do
+        driver.visit('/redirect/5/times')
+        expect(driver.html).to include('redirection complete')
       end
 
-      it "should not follow more than 6 redirects" do
+      it 'should not follow more than 6 redirects' do
         expect do
-          @driver.visit("/redirect/6/times")
+          driver.visit('/redirect/6/times')
         end.to raise_error(Capybara::InfiniteRedirectError)
       end
     end
 
-    context "with 21 redirect limit" do
-      before do
-        @driver = Capybara::RackTest::Driver.new(TestApp, redirect_limit: 21)
-      end
+    context 'with 21 redirect limit' do
+      let(:driver) { described_class.new(TestApp, redirect_limit: 21) }
 
-      it "should follow 21 redirects" do
-        @driver.visit("/redirect/21/times")
-        expect(@driver.html).to include('redirection complete')
+      it 'should follow 21 redirects' do
+        driver.visit('/redirect/21/times')
+        expect(driver.html).to include('redirection complete')
       end
 
-      it "should not follow more than 21 redirects" do
+      it 'should not follow more than 21 redirects' do
         expect do
-          @driver.visit("/redirect/22/times")
+          driver.visit('/redirect/22/times')
         end.to raise_error(Capybara::InfiniteRedirectError)
       end
     end
   end
 end
 
+RSpec.describe 'Capybara::String' do
+  it 'should use HTML5 parsing' do
+    skip 'Only valid if Nokogiri >= 1.12.0 or gumbo is included' unless defined? Nokogiri::HTML5
+    Capybara.use_html5_parsing = true
+    allow(Nokogiri::HTML5).to receive(:parse).and_call_original
+    Capybara.string('<div id=test_div></div>')
+    expect(Nokogiri::HTML5).to have_received(:parse)
+  end
+end
+
 module CSSHandlerIncludeTester
   def dont_extend_css_handler
     raise 'should never be called'
   end
 end
-include CSSHandlerIncludeTester
 
-RSpec.describe  Capybara::RackTest::CSSHandlers do
-  it "should not be extended by global includes" do
-    expect(Capybara::RackTest::CSSHandlers.new).not_to respond_to(:dont_extend_css_handler)
+RSpec.describe Capybara::RackTest::CSSHandlers do
+  include CSSHandlerIncludeTester
+
+  it 'should not be extended by global includes' do
+    expect(described_class.new).not_to respond_to(:dont_extend_css_handler)
   end
 end
-

data/spec/regexp_dissassembler_spec.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Capybara::Selector::RegexpDisassembler, :aggregate_failures do
+  it 'handles strings' do
+    verify_strings(
+      /abcdef/ => %w[abcdef],
+      /abc def/ => ['abc def']
+    )
+  end
+
+  it 'handles escaped characters' do
+    verify_strings(
+      /abc\\def/ => %w[abc\def],
+      /abc\.def/ => %w[abc.def],
+      /\nabc/ => ["\nabc"],
+      %r{abc/} => %w[abc/],
+      /ab\++cd/ => %w[ab+ cd]
+    )
+  end
+
+  it 'handles wildcards' do
+    verify_strings(
+      /abc.*def/ => %w[abc def],
+      /.*def/ => %w[def],
+      /abc./ => %w[abc],
+      /abc.*/ => %w[abc],
+      /abc.def/ => %w[abc def],
+      /abc.def.ghi/ => %w[abc def ghi],
+      /abc.abcd.abcde/ => %w[abcde],
+      /.*/ => []
+    )
+  end
+
+  it 'ignores optional characters for substrings' do
+    {
+      /abc*def/ => %w[ab def],
+      /abc*/ => %w[ab],
+      /c*/ => [],
+      /abc?def/ => %w[ab def],
+      /abc?/ => %w[ab],
+      /abc?def?/ => %w[ab de],
+      /abc?def?g/ => %w[ab de g],
+      /d?/ => []
+    }.each do |regexp, expected|
+      expect(described_class.new(regexp).substrings).to eq expected
+    end
+  end
+
+  it 'handles optional characters for #alternated_substrings' do
+    verify_alternated_strings(
+      {
+        /abc*def/ => [%w[ab def]],
+        /abc*/ => [%w[ab]],
+        /c*/ => [],
+        /abc?def/ => [%w[abdef], %w[abcdef]],
+        /abc?/ => [%w[ab]],
+        /abc?def?/ => [%w[abde], %w[abcde]],
+        /abc?def?g/ => [%w[abdeg], %w[abdefg], %w[abcdeg], %w[abcdefg]],
+        /d?/ => []
+      }
+    )
+  end
+
+  it 'handles character classes' do
+    verify_strings(
+      /abc[a-z]/ => %w[abc],
+      /abc[a-z]def[0-9]g/ => %w[abc def g],
+      /[0-9]abc/ => %w[abc],
+      /[0-9]+/ => [],
+      /abc[0-9&&[^7]]/ => %w[abc]
+    )
+  end
+
+  it 'handles posix bracket expressions' do
+    verify_strings(
+      /abc[[:alpha:]]/ => %w[abc],
+      /[[:digit:]]abc/ => %w[abc],
+      /abc[[:print:]]def/ => %w[abc def]
+    )
+  end
+
+  it 'handles repitition' do
+    verify_strings(
+      /abc{3}/ => %w[abccc],
+      /abc{3}d/ => %w[abcccd],
+      /abc{0}/ => %w[ab],
+      /abc{,2}/ => %w[ab],
+      /abc{2,}/ => %w[abcc],
+      /def{1,5}/ => %w[def],
+      /abc+def/ => %w[abc def],
+      /ab(cde){,4}/ => %w[ab],
+      /(ab){,2}cd/ => %w[cd],
+      /(abc){2,3}/ => %w[abcabc],
+      /(abc){3}/ => %w[abcabcabc],
+      /ab{2,3}cd/ => %w[abb cd],
+      /(ab){2,3}cd/ => %w[abab cd]
+    )
+  end
+
+  it 'handles non-greedy repetition' do
+    verify_strings(
+      /abc.*?/ => %w[abc],
+      /abc+?/ => %w[abc],
+      /abc*?cde/ => %w[ab cde],
+      /(abc)+?def/ => %w[abc def],
+      /ab(cde)*?fg/ => %w[ab fg]
+    )
+  end
+
+  it 'ignores alternation for #substrings' do
+    {
+      /abc|def/ => [],
+      /ab(?:c|d)/ => %w[ab],
+      /ab(c|d|e)fg/ => %w[ab fg],
+      /ab?(c|d)fg/ => %w[a fg],
+      /ab(c|d)ef/ => %w[ab ef],
+      /ab(cd?|ef)g/ => %w[ab g],
+      /ab(cd|ef*)g/ => %w[ab g],
+      /ab|cd*/ => [],
+      /cd(?:ef|gh)|xyz/ => [],
+      /(cd(?:ef|gh)|xyz)/ => [],
+      /cd(ef|gh)+/ => %w[cd],
+      /cd(ef|gh)?/ => %w[cd],
+      /cd(ef|gh)?ij/ => %w[cd ij],
+      /cd(ef|gh)+ij/ => %w[cd ij],
+      /cd(ef|gh){2}ij/ => %w[cd ij],
+      /(cd(ef|g*))/ => %w[cd],
+      /ab(cd){0,2}ef/ => %w[ab ef],
+      /ab(cd){0,1}ef/ => %w[ab ef],
+      /ab(cd|cd)ef/ => %w[ab ef],
+      /ab(cd|cd)?ef/ => %w[ab ef],
+      /ab\\?cd/ => %w[ab cd]
+    }.each do |regexp, expected|
+      expect(described_class.new(regexp).substrings).to eq expected
+    end
+  end
+
+  it 'handles alternation for #alternated_substrings' do
+    verify_alternated_strings(
+      {
+        /abc|def/ => [%w[abc], %w[def]],
+        /ab(?:c|d)/ => [%w[abc], %w[abd]],
+        /ab(c|d|e)fg/ => [%w[abcfg], %w[abdfg], %w[abefg]],
+        /ab?(c|d)fg/ => [%w[acfg], %w[adfg], %w[abcfg], %w[abdfg]],
+        /ab(c|d)ef/ => [%w[abcef], %w[abdef]],
+        /ab(cd?|ef)g/ => [%w[abcg], %w[abcdg], %w[abefg]],
+        /ab(cd|ef*)g/ => [%w[abcdg], %w[abe g]],
+        /ab|cd*/ => [%w[ab], %w[c]],
+        /cd(?:ef|gh)|xyz/ => [%w[cdef], %w[cdgh], %w[xyz]],
+        /(cd(?:ef|gh)|xyz)/ => [%w[cdef], %w[cdgh], %w[xyz]],
+        /cd(ef|gh)+/ => [%w[cdef], %w[cdgh]],
+        /cd(ef|gh)?/ => [%w[cd]],
+        /cd(ef|gh)?ij/ => [%w[cdij], %w[cdefij], %w[cdghij]],
+        /cd(ef|gh)+ij/ => [%w[cdef ij], %w[cdgh ij]],
+        /cd(ef|gh){2}ij/ => [%w[cdefefij], %w[cdefghij], %w[cdghefij], %w[cdghghij]],
+        /(cd(ef|g*))/ => [%w[cd]],
+        /a|b*/ => [],
+        /ab(?:c|d?)/ => [%w[ab]],
+        /ab(c|d)|a*/ => [],
+        /(abc)?(d|e)/ => [%w[d], %w[e]],
+        /(abc*de)?(d|e)/ => [%w[d], %w[e]],
+        /(abc*de)?(d|e?)/ => [],
+        /(abc)?(d|e?)/ => [],
+        /ab(cd){0,2}ef/ => [%w[ab ef]],
+        /ab(cd){0,1}ef/ => [%w[abef], %w[abcdef]],
+        /ab(cd|cd)ef/ => [%w[abcdef]],
+        /ab(cd|cd)?ef/ => [%w[abef], %w[abcdef]],
+        /ab\\?cd/ => [%w[abcd], %w[ab\cd]]
+      }
+    )
+  end
+
+  it 'handles grouping' do
+    verify_strings(
+      /(abc)/ => %w[abc],
+      /(abc)?/ => [],
+      /ab(cde)/ => %w[abcde],
+      /(abc)de/ => %w[abcde],
+      /ab(cde)fg/ => %w[abcdefg],
+      /ab(?<name>cd)ef/ => %w[abcdef],
+      /gh(?>ij)kl/ => %w[ghijkl],
+      /m(n.*p)q/ => %w[mn pq],
+      /(?:ab(cd)*){2,3}/ => %w[ab],
+      /(ab(cd){3})?/ => [],
+      /(ab(cd)+){2}/ => %w[abcd]
+    )
+  end
+
+  it 'handles meta characters' do
+    verify_strings(
+      /abc\d/ => %w[abc],
+      /abc\wdef/ => %w[abc def],
+      /\habc/ => %w[abc]
+    )
+  end
+
+  it 'handles character properties' do
+    verify_strings(
+      /ab\p{Alpha}cd/ => %w[ab cd],
+      /ab\p{Blank}/ => %w[ab],
+      /\p{Digit}cd/ => %w[cd]
+    )
+  end
+
+  it 'handles backreferences' do
+    verify_strings(
+      /a(?<group>abc).\k<group>.+/ => %w[aabc]
+    )
+  end
+
+  it 'handles subexpressions' do
+    verify_strings(
+      /\A(?<paren>a\g<paren>*b)+\z/ => %w[a b]
+    )
+  end
+
+  it 'ignores negative lookaheads' do
+    verify_strings(
+      /^(?!.*\bContributing Editor\b).*$/ => %w[],
+      /abc(?!.*def).*/ => %w[abc],
+      /(?!.*def)abc/ => %w[abc],
+      /abc(?!.*def.*).*ghi/ => %w[abc ghi],
+      /abc(?!.*bcd)def/ => %w[abcdef]
+    )
+  end
+
+  it 'handles anchors' do
+    verify_strings(
+      /^abc/ => %w[abc],
+      /def$/ => %w[def],
+      /^abc$/ => %w[abc]
+    )
+  end
+
+  def verify_strings(hsh)
+    hsh.each do |regexp, expected|
+      expect(Capybara::Selector::RegexpDisassembler.new(regexp).substrings).to eq expected
+    end
+    verify_alternated_strings(hsh, wrap: true)
+  end
+
+  def verify_alternated_strings(hsh, wrap: false)
+    hsh.each do |regexp, expected|
+      expected = [expected] if wrap && (expected != [])
+      expect(Capybara::Selector::RegexpDisassembler.new(regexp).alternated_substrings).to eq expected
+    end
+  end
+end