capybara 3.0.0 → 3.36.0

data/spec/spec_helper.rb

@@ -1,11 +1,100 @@
 # frozen_string_literal: true
 
 require 'rspec/expectations'
-require "capybara/spec/spec_helper"
-require 'webdrivers' if ENV['CI']
+require 'webdrivers' if ENV['CI'] || ENV['WEBDRIVERS']
+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) && (::Selenium::WebDriver::VERSION.to_f >= 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 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 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`
+    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/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
+    ::Capybara::Selector::XPathBuilder.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