capybara 3.3.0 → 3.40.0

data/spec/spec_helper.rb

@@ -1,11 +1,133 @@
 # frozen_string_literal: true
 
 require 'rspec/expectations'
-require "capybara/spec/spec_helper"
-require 'webdrivers' if ENV['CI']
+require 'webdrivers' if ENV.fetch('WEBDRIVERS', nil)
+require 'selenium_statistics'
+if ENV['TRAVIS']
+  require 'coveralls'
+  Coveralls.wear! do
+    add_filter '/lib/capybara/driver/'
+    add_filter '/lib/capybara/registrations/'
+  end
+end
+require 'capybara/spec/spec_helper'
+
+module Capybara
+  module SpecHelper
+    def firefox?(session)
+      browser_name(session) == :firefox &&
+        ((defined?(::Selenium::WebDriver::VERSION) && (Gem::Version.new(::Selenium::WebDriver::VERSION) >= Gem::Version.new('4'))) ||
+         session.driver.browser.capabilities.is_a?(::Selenium::WebDriver::Remote::W3C::Capabilities))
+    end
+
+    def firefox_lt?(version, session)
+      firefox?(session) && (session.driver.browser.capabilities[:browser_version].to_f < version)
+    end
+
+    def firefox_gte?(version, session)
+      firefox?(session) && (session.driver.browser.capabilities[:browser_version].to_f >= version)
+    end
+
+    def geckodriver_version(session)
+      Gem::Version.new(session.driver.browser.capabilities['moz:geckodriverVersion'])
+    end
+
+    def geckodriver_gte?(version, session)
+      firefox?(session) && geckodriver_version(session) >= Gem::Version.new(version)
+    end
+
+    def geckodriver_lt?(version, session)
+      firefox?(session) && geckodriver_version(session) < Gem::Version.new(version)
+    end
+
+    def chrome?(session)
+      browser_name(session) == :chrome
+    end
+
+    def chrome_version(session)
+      (session.driver.browser.capabilities[:browser_version] ||
+        session.driver.browser.capabilities[:version]).to_f
+    end
+
+    def chrome_lt?(version, session)
+      chrome?(session) && (chrome_version(session) < version)
+    end
+
+    def chrome_gte?(version, session)
+      chrome?(session) && (chrome_version(session) >= version)
+    end
+
+    def chromedriver_version(session)
+      Gem::Version.new(session.driver.browser.capabilities['chrome']['chromedriverVersion'].split[0])
+    end
+
+    def chromedriver_gte?(version, session)
+      chrome?(session) && chromedriver_version(session) >= Gem::Version.new(version)
+    end
+
+    def chromedriver_lt?(version, session)
+      chrome?(session) && chromedriver_version(session) < Gem::Version.new(version)
+    end
+
+    def selenium?(session)
+      session.driver.is_a? Capybara::Selenium::Driver
+    end
+
+    def selenium_lt?(version, session)
+      selenium?(session) &&
+        Gem::Version.new(::Selenium::WebDriver::VERSION) < Gem::Version.new(version)
+    end
+
+    def edge?(session)
+      browser_name(session).to_s.start_with?('edge')
+    end
+
+    def legacy_edge?(session)
+      browser_name(session) == :edge
+    end
+
+    def edge_lt?(version, session)
+      edge?(session) && (chrome_version(session) < version)
+    end
+
+    def edge_gte?(version, session)
+      edge?(session) && (chrome_version(session) >= version)
+    end
+
+    def ie?(session)
+      %i[internet_explorer ie].include?(browser_name(session))
+    end
+
+    def safari?(session)
+      %i[safari Safari Safari_Technology_Preview].include?(browser_name(session))
+    end
+
+    def browser_name(session)
+      session.driver.browser.browser if session.respond_to?(:driver)
+    end
+
+    def remote?(session)
+      session.driver.browser.is_a? ::Selenium::WebDriver::Remote::Driver
+    end
+
+    def self.log_selenium_driver_version(mod)
+      mod = mod::Service if ::Selenium::WebDriver::Service.respond_to? :driver_path
+      path = mod.driver_path
+      path = path.call if path.respond_to? :call
+      $stdout.puts `#{path.gsub(' ', '\ ')} --version` if path
+    end
+  end
+end
 
 RSpec.configure do |config|
   Capybara::SpecHelper.configure(config)
+  config.expect_with :rspec do |expectations|
+    expectations.syntax = :expect
+  end
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
   config.filter_run_including focus_: true unless ENV['CI']
   config.run_all_when_everything_filtered = true
+  config.after(:suite) { SeleniumStatistics.print_results }
 end

data/spec/whitespace_normalizer_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'capybara/node/whitespace_normalizer'
+
+RSpec.describe Capybara::Node::WhitespaceNormalizer do
+  subject(:normalizer) do
+    klass = Class.new do
+      include Capybara::Node::WhitespaceNormalizer
+    end
+
+    klass.new
+  end
+
+  let(:text_needing_correction) do
+    <<~TEXT
+      Some     #{described_class::NON_BREAKING_SPACE}text
+      #{described_class::RIGHT_TO_LEFT_MARK}
+      #{described_class::ZERO_WIDTH_SPACE * 30}
+      #{described_class::LEFT_TO_RIGHT_MARK}
+      Here
+    TEXT
+  end
+
+  describe '#normalize_spacing' do
+    it 'does nothing to text not containing special characters' do
+      expect(normalizer.normalize_spacing('text')).to eq('text')
+    end
+
+    it 'compresses excess breaking spacing' do
+      expect(
+        normalizer.normalize_spacing(text_needing_correction)
+      ).to eq('Some  text Here')
+    end
+  end
+
+  describe '#normalize_visible_spacing' do
+    it 'does nothing to text not containing special characters' do
+      expect(normalizer.normalize_visible_spacing('text')).to eq('text')
+    end
+
+    it 'compresses excess breaking visible spacing' do
+      expect(
+        normalizer.normalize_visible_spacing(text_needing_correction)
+      ).to eq <<~TEXT.chomp
+        Some  text
+        #{described_class::RIGHT_TO_LEFT_MARK}
+        #{described_class::ZERO_WIDTH_SPACE * 30}
+        #{described_class::LEFT_TO_RIGHT_MARK}
+        Here
+      TEXT
+    end
+  end
+end

data/spec/xpath_builder_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+# rubocop:disable RSpec/InstanceVariable
+RSpec.describe Capybara::Selector::XPathBuilder do
+  let :builder do
+    described_class.new(@xpath)
+  end
+
+  context 'add_attribute_conditions' do
+    it 'adds a single string condition to a single selector' do
+      @xpath = './/div'
+      selector = builder.add_attribute_conditions(random: 'abc')
+      expect(selector).to eq %((.//div)[(./@random = 'abc')])
+    end
+
+    it 'adds multiple string conditions to a single selector' do
+      @xpath = './/div'
+      selector = builder.add_attribute_conditions(random: 'abc', other: 'def')
+      expect(selector).to eq %(((.//div)[(./@random = 'abc')])[(./@other = 'def')])
+    end
+
+    it 'adds a single string condition to a multiple selector' do
+      @xpath = XPath.descendant(:div, :ul)
+      selector = builder.add_attribute_conditions(random: 'abc')
+      expect(selector.to_s).to eq @xpath[XPath.attr(:random) == 'abc'].to_s
+    end
+
+    it 'adds multiple string conditions to a multiple selector' do
+      @xpath = XPath.descendant(:div, :ul)
+      selector = builder.add_attribute_conditions(random: 'abc', other: 'def')
+      expect(selector.to_s).to eq %(.//*[self::div | self::ul][(./@random = 'abc')][(./@other = 'def')])
+    end
+
+    it 'adds simple regexp conditions to a single selector' do
+      @xpath = XPath.descendant(:div)
+      selector = builder.add_attribute_conditions(random: /abc/, other: /def/)
+      expect(selector.to_s).to eq %(.//div[./@random[contains(., 'abc')]][./@other[contains(., 'def')]])
+    end
+
+    it 'adds wildcard regexp conditions to a single selector' do
+      @xpath = './/div'
+      selector = builder.add_attribute_conditions(random: /abc.*def/, other: /def.*ghi/)
+      expect(selector).to eq %(((.//div)[./@random[(contains(., 'abc') and contains(., 'def'))]])[./@other[(contains(., 'def') and contains(., 'ghi'))]])
+    end
+
+    it 'adds alternated regexp conditions to a single selector' do
+      @xpath = XPath.descendant(:div)
+      selector = builder.add_attribute_conditions(random: /abc|def/, other: /def|ghi/)
+      expect(selector.to_s).to eq %(.//div[./@random[(contains(., 'abc') or contains(., 'def'))]][./@other[(contains(., 'def') or contains(., 'ghi'))]])
+    end
+
+    it 'adds alternated regexp conditions to a multiple selector' do
+      @xpath = XPath.descendant(:div, :ul)
+      selector = builder.add_attribute_conditions(other: /def.*ghi|jkl/)
+      expect(selector.to_s).to eq %(.//*[self::div | self::ul][./@other[((contains(., 'def') and contains(., 'ghi')) or contains(., 'jkl'))]])
+    end
+
+    it "returns original selector when regexp can't be substringed" do
+      @xpath = './/div'
+      selector = builder.add_attribute_conditions(other: /.+/)
+      expect(selector).to eq '(.//div)[./@other]'
+    end
+
+    context ':class' do
+      it 'handles string' do
+        @xpath = './/a'
+        selector = builder.add_attribute_conditions(class: 'my_class')
+        expect(selector).to eq %((.//a)[contains(concat(' ', normalize-space(./@class), ' '), ' my_class ')])
+      end
+
+      it 'handles negated strings' do
+        @xpath = XPath.descendant(:a)
+        selector = builder.add_attribute_conditions(class: '!my_class')
+        expect(selector.to_s).to eq @xpath[!XPath.attr(:class).contains_word('my_class')].to_s
+      end
+
+      it 'handles array of strings' do
+        @xpath = './/a'
+        selector = builder.add_attribute_conditions(class: %w[my_class my_other_class])
+        expect(selector).to eq %((.//a)[(contains(concat(' ', normalize-space(./@class), ' '), ' my_class ') and contains(concat(' ', normalize-space(./@class), ' '), ' my_other_class '))])
+      end
+
+      it 'handles array of string when negated included' do
+        @xpath = XPath.descendant(:a)
+        selector = builder.add_attribute_conditions(class: %w[my_class !my_other_class])
+        expect(selector.to_s).to eq @xpath[XPath.attr(:class).contains_word('my_class') & !XPath.attr(:class).contains_word('my_other_class')].to_s
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/InstanceVariable