capybara 3.29.0 → 3.37.1

data/spec/minitest_spec_spec.rb

@@ -17,125 +17,125 @@ class MinitestSpecTest < Minitest::Spec
   end
 
   it 'supports text expectations' do
-    page.must_have_text('Form', minimum: 1)
-    page.wont_have_text('Not a form')
+    _(page).must_have_text('Form', minimum: 1)
+    _(page).wont_have_text('Not a form')
     form = find(:css, 'form', text: 'Title')
-    form.must_have_text('Customer Email')
-    form.wont_have_text('Some other email')
+    _(form).must_have_text('Customer Email')
+    _(form).wont_have_text('Some other email')
   end
 
   it 'supports current_path expectations' do
-    page.must_have_current_path('/form')
-    page.wont_have_current_path('/form2')
+    _(page).must_have_current_path('/form')
+    _(page).wont_have_current_path('/form2')
   end
 
   it 'supports title expectations' do
     visit('/with_title')
-    page.must_have_title('Test Title')
-    page.wont_have_title('Not the title')
+    _(page).must_have_title('Test Title')
+    _(page).wont_have_title('Not the title')
   end
 
   it 'supports xpath expectations' do
-    page.must_have_xpath('.//input[@id="customer_email"]')
-    page.wont_have_xpath('.//select[@id="not_form_title"]')
-    page.wont_have_xpath('.//input[@id="customer_email"]') { |el| el[:id] == 'not_customer_email' }
+    _(page).must_have_xpath('.//input[@id="customer_email"]')
+    _(page).wont_have_xpath('.//select[@id="not_form_title"]')
+    _(page).wont_have_xpath('.//input[@id="customer_email"]') { |el| el[:id] == 'not_customer_email' }
     select = find(:select, 'form_title')
-    select.must_have_xpath('.//option[@class="title"]')
-    select.must_have_xpath('.//option', count: 1) { |option| option[:class] != 'title' && !option.disabled? }
-    select.wont_have_xpath('.//input[@id="customer_email"]')
+    _(select).must_have_xpath('.//option[@class="title"]')
+    _(select).must_have_xpath('.//option', count: 1) { |option| option[:class] != 'title' && !option.disabled? }
+    _(select).wont_have_xpath('.//input[@id="customer_email"]')
   end
 
   it 'support css expectations' do
-    page.must_have_css('input#customer_email')
-    page.wont_have_css('select#not_form_title')
+    _(page).must_have_css('input#customer_email')
+    _(page).wont_have_css('select#not_form_title')
     el = find(:select, 'form_title')
-    el.must_have_css('option.title')
-    el.wont_have_css('input#customer_email')
+    _(el).must_have_css('option.title')
+    _(el).wont_have_css('input#customer_email')
   end
 
   it 'supports link expectations' do
     visit('/with_html')
-    page.must_have_link('A link')
-    page.wont_have_link('Not on page')
+    _(page).must_have_link('A link')
+    _(page).wont_have_link('Not on page')
   end
 
   it 'supports button expectations' do
-    page.must_have_button('fresh_btn')
-    page.wont_have_button('not_btn')
+    _(page).must_have_button('fresh_btn')
+    _(page).wont_have_button('not_btn')
   end
 
   it 'supports field expectations' do
-    page.must_have_field('customer_email')
-    page.wont_have_field('not_on_the_form')
+    _(page).must_have_field('customer_email')
+    _(page).wont_have_field('not_on_the_form')
   end
 
   it 'supports select expectations' do
-    page.must_have_select('form_title')
-    page.wont_have_select('not_form_title')
+    _(page).must_have_select('form_title')
+    _(page).wont_have_select('not_form_title')
   end
 
   it 'supports checked_field expectations' do
-    page.must_have_checked_field('form_pets_dog')
-    page.wont_have_checked_field('form_pets_cat')
+    _(page).must_have_checked_field('form_pets_dog')
+    _(page).wont_have_checked_field('form_pets_cat')
   end
 
   it 'supports unchecked_field expectations' do
-    page.must_have_unchecked_field('form_pets_cat')
-    page.wont_have_unchecked_field('form_pets_dog')
+    _(page).must_have_unchecked_field('form_pets_cat')
+    _(page).wont_have_unchecked_field('form_pets_dog')
   end
 
   it 'supports table expectations' do
     visit('/tables')
-    page.must_have_table('agent_table')
-    page.wont_have_table('not_on_form')
+    _(page).must_have_table('agent_table')
+    _(page).wont_have_table('not_on_form')
   end
 
   it 'supports all_of_selectors expectations' do
-    page.must_have_all_of_selectors(:css, 'select#form_other_title', 'input#form_last_name')
+    _(page).must_have_all_of_selectors(:css, 'select#form_other_title', 'input#form_last_name')
   end
 
   it 'supports none_of_selectors expectations' do
-    page.must_have_none_of_selectors(:css, 'input#not_on_page', 'input#also_not_on_page')
+    _(page).must_have_none_of_selectors(:css, 'input#not_on_page', 'input#also_not_on_page')
   end
 
   it 'supports any_of_selectors expectations' do
-    page.must_have_any_of_selectors(:css, 'select#form_other_title', 'input#not_on_page')
+    _(page).must_have_any_of_selectors(:css, 'select#form_other_title', 'input#not_on_page')
   end
 
   it 'supports match_selector expectations' do
-    find(:field, 'customer_email').must_match_selector(:field, 'customer_email')
-    find(:select, 'form_title').wont_match_selector(:field, 'customer_email')
+    _(find(:field, 'customer_email')).must_match_selector(:field, 'customer_email')
+    _(find(:select, 'form_title')).wont_match_selector(:field, 'customer_email')
   end
 
   it 'supports match_css expectations' do
-    find(:select, 'form_title').must_match_css('select#form_title')
-    find(:select, 'form_title').wont_match_css('select#form_other_title')
+    _(find(:select, 'form_title')).must_match_css('select#form_title')
+    _(find(:select, 'form_title')).wont_match_css('select#form_other_title')
   end
 
   it 'supports match_xpath expectations' do
-    find(:select, 'form_title').must_match_xpath('.//select[@id="form_title"]')
-    find(:select, 'form_title').wont_match_xpath('.//select[@id="not_on_page"]')
+    _(find(:select, 'form_title')).must_match_xpath('.//select[@id="form_title"]')
+    _(find(:select, 'form_title')).wont_match_xpath('.//select[@id="not_on_page"]')
   end
 
   it 'handles failures' do
-    page.must_have_select('non_existing_form_title')
+    _(page).must_have_select('non_existing_form_title')
   end
 
   it 'supports style expectations' do
     skip "Rack test doesn't support style" if Capybara.current_driver == :rack_test
     visit('/with_html')
-    find(:css, '#second').must_have_style('display' => 'inline') # deprecated
-    find(:css, '#second').must_match_style('display' => 'inline')
+    _(find(:css, '#second')).must_have_style('display' => 'inline') # deprecated
+    _(find(:css, '#second')).must_match_style('display' => 'inline')
   end
 
   it 'supports ancestor expectations' do
     option = find(:option, 'Finnish')
-    option.must_have_ancestor(:css, '#form_locale')
+    _(option).must_have_ancestor(:css, '#form_locale')
   end
 
   it 'supports sibling expectations' do
     option = find(:css, '#form_title').find(:option, 'Mrs')
-    option.must_have_sibling(:option, 'Mr')
+    _(option).must_have_sibling(:option, 'Mr')
   end
 end
 

data/spec/rack_test_spec.rb

@@ -1,12 +1,6 @@
 # frozen_string_literal: true
 
 require 'spec_helper'
-nokogumbo_required = begin
-                       require 'nokogumbo'
-                       true
-                     rescue LoadError
-                       false
-                     end
 
 module TestSessions
   RackTest = Capybara::Session.new(:rack_test, TestApp)
@@ -26,6 +20,9 @@ skipped_tests = %i[
   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]
@@ -37,6 +34,7 @@ Capybara::SpecHelper.run_specs TestSessions::RackTest, 'RackTest', capybara_skip
 end
 
 RSpec.describe Capybara::Session do # rubocop:disable RSpec/MultipleDescribes
+  include Capybara::RSpecMatchers
   context 'with rack test driver' do
     let(:session) { TestSessions::RackTest }
 
@@ -82,7 +80,6 @@ RSpec.describe Capybara::Session do # rubocop:disable RSpec/MultipleDescribes
     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')
@@ -128,6 +125,34 @@ RSpec.describe Capybara::Session do # rubocop:disable RSpec/MultipleDescribes
           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
 
@@ -191,6 +216,12 @@ RSpec.describe Capybara::RackTest::Driver do
       expect(driver.current_url).to match %r{/landed$}
     end
 
+    it 'should not include fragments in the referer header' do
+      driver.visit('/header_links#an-anchor')
+      driver.find_xpath('.//input').first.click
+      expect(driver.request.get_header('HTTP_REFERER')).to eq('http://www.example.com/header_links')
+    end
+
     it 'is possible to not follow redirects' do
       driver = described_class.new(TestApp, follow_redirects: false)
 
@@ -234,11 +265,12 @@ RSpec.describe Capybara::RackTest::Driver do
 end
 
 RSpec.describe 'Capybara::String' do
-  it 'should use gumbo' do
-    skip 'Only  valid if gumbo is included' unless nokogumbo_required
-    allow(Nokogiri).to receive(:HTML5).and_call_original
+  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).to have_received(:HTML5)
+    expect(Nokogiri::HTML5).to have_received(:parse)
   end
 end
 

data/spec/regexp_dissassembler_spec.rb

@@ -50,14 +50,16 @@ RSpec.describe Capybara::Selector::RegexpDisassembler, :aggregate_failures do
 
   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?/ => []
+      {
+        /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
 
@@ -137,34 +139,36 @@ RSpec.describe Capybara::Selector::RegexpDisassembler, :aggregate_failures do
 
   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]]
+      {
+        /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
 

data/spec/result_spec.rb

@@ -44,9 +44,9 @@ RSpec.describe Capybara::Result do
   end
 
   it 'can be selected' do
-    expect(result.select do |element|
+    expect(result.count do |element|
       element.text.include? 't'
-    end.length).to eq(2)
+    end).to eq(2)
   end
 
   it 'can be reduced' do
@@ -65,19 +65,43 @@ RSpec.describe Capybara::Result do
     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(result[1].text).to eq 'Beta'
-    expect(result[0, 2].map(&:text)).to eq %w[Alpha Beta]
-    expect(result[1..3].map(&:text)).to eq %w[Beta Gamma Delta]
-    expect(result[-1].text).to eq 'Delta'
-    expect(result[-2, 3].map(&:text)).to eq %w[Gamma Delta]
-    expect(result[1..7].map(&:text)).to eq %w[Beta Gamma Delta]
-    expect(result[1...3].map(&:text)).to eq %w[Beta Gamma]
-    expect(result[2..-1].map(&:text)).to eq %w[Gamma Delta]
-    expect(result[2...-1].map(&:text)).to eq %w[Gamma]
-    eval <<~TEST, binding, __FILE__, __LINE__ + 1 if RUBY_VERSION.to_f > 2.5
-      expect(result[2..].map(&:text)).to eq %w[Gamma Delta]
-    TEST
+    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] # rubocop:disable Style/SlicingWithRange
+    expect(recalc_result[2..].map(&:text)).to eq %w[Gamma Delta]
+  end
+
+  it 'supports endless ranges' do
+    expect(result[2..].map(&:text)).to eq %w[Gamma Delta]
+  end
+
+  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
 
   it 'works with filter blocks' do
@@ -89,61 +113,61 @@ RSpec.describe Capybara::Result do
   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
+    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
+    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
+    expect(result.instance_variable_get(:@result_cache).size).to be 1
 
     result[2]
-    expect(result.instance_variable_get('@result_cache').size).to be 3
+    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
+    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.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
+    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.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
+    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
+    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
+    expect(result.instance_variable_get(:@result_cache).size).to eq 4
   end
 
-  context '#each' do
+  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
+        expect(result.instance_variable_get(:@result_cache).size).to eq results.size
       end
 
       expect(results.size).to eq 4
@@ -157,29 +181,13 @@ RSpec.describe Capybara::Result do
       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
+          expect(result.instance_variable_get(:@result_cache).size).to eq(idx + 1) # 0 indexing
         end
       end
     end
   end
 
-  context 'lazy select' do
-    it 'is compatible' do
-      # This test will let us know when JRuby fixes lazy select so we can re-enable it in Result
-      pending 'JRuby < 9.2.8.0 has an issue with lazy enumberator evaluation' if jruby_lazy_enumerator_workaround?
-      eval_count = 0
-      enum = %w[Text1 Text2 Text3].lazy.select do
-        eval_count += 1
-        true
-      end
-      expect(eval_count).to eq 0
-      enum.next
-      sleep 1
-      expect(eval_count).to eq 1
-    end
-  end
-
   def jruby_lazy_enumerator_workaround?
-    (RUBY_PLATFORM == 'java') && (Gem::Version.new(JRUBY_VERSION) < Gem::Version.new('9.2.8.0'))
+    RUBY_PLATFORM == 'java'
   end
 end

data/spec/rspec/features_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable RSpec/MultipleDescribes
+
 require 'spec_helper'
 require 'capybara/rspec'
 
@@ -81,6 +83,7 @@ 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
@@ -88,11 +91,11 @@ 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
+    expect(example.metadata[:focus]).to be true
   end
 
-  scenario 'other scenarios also has metatag focus tag ' do |example|
-    expect(example.metadata[:focus]).to eq true
+  scenario 'other scenarios also has metatag focus tag' do |example|
+    expect(example.metadata[:focus]).to be true
   end
 end
-# rubocop:enable RSpec/RepeatedExample
+# rubocop:enable RSpec/RepeatedExample, RSpec/MultipleDescribes

data/spec/rspec/scenarios_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable RSpec/MultipleDescribes
+
 require 'spec_helper'
 require 'capybara/rspec'
 
@@ -9,7 +11,7 @@ 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
+    expect(example.metadata[:focus]).to be true
   end
 end
 
@@ -17,3 +19,5 @@ feature 'if xscenario aliases to pending then' do
   xscenario "this test should be 'temporarily disabled with xscenario'" do
   end
 end
+
+# rubocop:enable RSpec/MultipleDescribes