capybara 3.3.0 → 3.40.0

data/spec/result_spec.rb

@@ -18,38 +18,47 @@ RSpec.describe Capybara::Result do
     string.all '//li', minimum: 0 # pass minimum: 0 so lazy evaluation doesn't get triggered yet
   end
 
-  it "has a length" do
+  it 'has a length' do
     expect(result.length).to eq(4)
   end
 
-  it "has a first element" do
+  it 'has a first element' do
     result.first.text == 'Alpha'
   end
 
-  it "has a last element" do
+  it 'has a last element' do
     result.last.text == 'Delta'
   end
 
+  it 'splats into multiple assignment' do
+    first, *rest, last = result
+
+    expect(first).to have_text 'Alpha'
+    expect(rest.first).to have_text 'Beta'
+    expect(rest.last).to have_text 'Gamma'
+    expect(last).to have_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
+  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
+  it 'can be mapped' do
     expect(result.map(&:text)).to eq(%w[Alpha Beta Gamma Delta])
   end
 
-  it "can be selected" do
-    expect(result.select do |element|
+  it 'can be selected' do
+    expect(result.count do |element|
       element.text.include? 't'
-    end.length).to eq(2)
+    end).to eq(2)
   end
 
-  it "can be reduced" do
+  it 'can be reduced' do
     expect(result.reduce('') do |memo, element|
       memo + element.text[0]
     end).to eq('ABGD')
@@ -65,98 +74,109 @@ 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(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 'works with filter blocks' do
-    result = string.all('//li') { |node| node.text == 'Alpha' }
-    expect(result.size).to eq 1
+  it 'supports endless ranges' do
+    expect(result[2..].map(&:text)).to eq %w[Gamma Delta]
   end
 
-  it 'should catch invalid element errors during filtering' do
-    allow_any_instance_of(Capybara::Node::Simple).to receive(:text).and_raise(StandardError)
-    allow_any_instance_of(Capybara::Node::Simple).to receive(:session).and_return(
-      instance_double("Capybara::Session", driver: instance_double("Capybara::Driver::Base", invalid_element_errors: [StandardError]))
-    )
-    result = string.all('//li', text: 'Alpha')
-    expect(result.size).to eq 0
+  it 'supports inclusive positive beginless ranges' do
+    expect(result[..2].map(&:text)).to eq %w[Alpha Beta Gamma]
   end
 
-  it 'should return non-invalid element errors during filtering' do
-    allow_any_instance_of(Capybara::Node::Simple).to receive(:text).and_raise(StandardError)
-    allow_any_instance_of(Capybara::Node::Simple).to receive(:session).and_return(
-      instance_double("Capybara::Session", driver: instance_double("Capybara::Driver::Base", invalid_element_errors: [ArgumentError]))
-    )
-    expect do
-      string.all('//li', text: 'Alpha').to_a
-    end.to raise_error(StandardError)
+  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
+    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 RUBY_PLATFORM == 'java'
+  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 RUBY_PLATFORM == 'java'
+  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 RUBY_PLATFORM == 'java'
+  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 RUBY_PLATFORM == 'java'
+  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
+  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 RUBY_PLATFORM == 'java'
+      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
@@ -168,27 +188,15 @@ RSpec.describe Capybara::Result do
       end
 
       it 'lazily evaluates' do
-        skip 'JRuby has an issue with lazy enumerator evaluation' if RUBY_PLATFORM == 'java'
+        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 has an issue with lazy enumberator evaluation' if RUBY_PLATFORM == 'java'
-      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
+  def jruby_lazy_enumerator_workaround?
+    RUBY_PLATFORM == 'java'
   end
 end

data/spec/rspec/features_spec.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
+# rubocop:disable RSpec/MultipleDescribes
+
 require 'spec_helper'
 require 'capybara/rspec'
 
-RSpec.configuration.before(:each, file_path: "./spec/rspec/features_spec.rb") do
+# rubocop:disable RSpec/InstanceVariable
+RSpec.configuration.before(:each, file_path: './spec/rspec/features_spec.rb') do
   @in_filtered_hook = true
 end
 
@@ -12,25 +15,25 @@ feature "Capybara's feature DSL" do
     @in_background = true
   end
 
-  scenario "includes Capybara" do
+  scenario 'includes Capybara' do
     visit('/')
     expect(page).to have_content('Hello world!')
   end
 
-  scenario "preserves description" do |ex|
+  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
+  scenario 'allows driver switching', driver: :selenium do
     expect(Capybara.current_driver).to eq(:selenium)
   end
 
-  scenario "runs background" do
+  scenario 'runs background' do
     expect(@in_background).to be_truthy
   end
 
-  scenario "runs hooks filtered by file path" do
+  scenario 'runs hooks filtered by file path' do
     expect(@in_filtered_hook).to be_truthy
   end
 
@@ -53,8 +56,9 @@ feature "Capybara's feature DSL" do
     end
   end
 end
+# rubocop:enable RSpec/InstanceVariable
 
-feature "given and given! aliases to let and let!" do
+feature 'given and given! aliases to let and let!' do
   given(:value) { :available }
   given!(:value_in_background) { :available }
 
@@ -62,35 +66,36 @@ feature "given and given! aliases to let and let!" do
     expect(value_in_background).to be(:available)
   end
 
-  scenario "given and given! work as intended" do
+  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
+  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
+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
+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 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,19 +1,23 @@
 # frozen_string_literal: true
 
+# rubocop:disable RSpec/MultipleDescribes
+
 require 'spec_helper'
 require 'capybara/rspec'
 
-RSpec.configuration.before(:each, file_path: "./spec/rspec/scenarios_spec.rb") do
+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
+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 be true
   end
 end
 
-feature "if xscenario aliases to pending then" do
-  xscenario "this test should be 'temporarily disabled with xscenario'" do
+feature 'if xscenario aliases to pending then' do
+  xscenario "this test should be 'temporarily disabled with xscenario'" do # rubocop:disable RSpec/PendingWithoutReason
   end
 end
+
+# rubocop:enable RSpec/MultipleDescribes