capybara 3.8.1 → 3.33.0

data/lib/capybara/selenium/extensions/scroll.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Selenium
+    module Scroll
+      def scroll_by(x, y)
+        driver.execute_script <<~JS, self, x, y
+          var el = arguments[0];
+          if (el.scrollBy){
+            el.scrollBy(arguments[1], arguments[2]);
+          } else {
+            el.scrollTop = el.scrollTop + arguments[2];
+            el.scrollLeft = el.scrollLeft + arguments[1];
+          }
+        JS
+      end
+
+      def scroll_to(element, location, position = nil)
+        # location, element = element, nil if element.is_a? Symbol
+        if element.is_a? Capybara::Selenium::Node
+          scroll_element_to_location(element, location)
+        elsif location.is_a? Symbol
+          scroll_to_location(location)
+        else
+          scroll_to_coords(*position)
+        end
+        self
+      end
+
+    private
+
+      def scroll_element_to_location(element, location)
+        scroll_opts = case location
+        when :top
+          'true'
+        when :bottom
+          'false'
+        when :center
+          "{behavior: 'instant', block: 'center'}"
+        else
+          raise ArgumentError, "Invalid scroll_to location: #{location}"
+        end
+        driver.execute_script <<~JS, element
+          arguments[0].scrollIntoView(#{scroll_opts})
+        JS
+      end
+
+      def scroll_to_location(location)
+        scroll_y = case location
+        when :top
+          '0'
+        when :bottom
+          'arguments[0].scrollHeight'
+        when :center
+          '(arguments[0].scrollHeight - arguments[0].clientHeight)/2'
+        end
+        driver.execute_script <<~JS, self
+          if (arguments[0].scrollTo){
+            arguments[0].scrollTo(0, #{scroll_y});
+          } else {
+            arguments[0].scrollTop = #{scroll_y};
+          }
+        JS
+      end
+
+      def scroll_to_coords(x, y)
+        driver.execute_script <<~JS, self, x, y
+          if (arguments[0].scrollTo){
+            arguments[0].scrollTo(arguments[1], arguments[2]);
+          } else {
+            arguments[0].scrollTop = arguments[2];
+            arguments[0].scrollLeft = arguments[1];
+          }
+        JS
+      end
+    end
+  end
+end

data/lib/capybara/selenium/logger_suppressor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Selenium
+    module DeprecationSuppressor
+      def initialize(*)
+        @suppress_for_capybara = false
+        super
+      end
+
+      def deprecate(*)
+        super unless @suppress_for_capybara
+      end
+
+      def suppress_deprecations
+        prev_suppress_for_capybara, @suppress_for_capybara = @suppress_for_capybara, true
+        yield
+      ensure
+        @suppress_for_capybara = prev_suppress_for_capybara
+      end
+    end
+
+    module ErrorSuppressor
+      def for_code(*)
+        ::Selenium::WebDriver.logger.suppress_deprecations do
+          super
+        end
+      end
+    end
+  end
+end
+
+Selenium::WebDriver::Logger.prepend Capybara::Selenium::DeprecationSuppressor
+Selenium::WebDriver::Error.singleton_class.prepend Capybara::Selenium::ErrorSuppressor

data/lib/capybara/selenium/node.rb

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
 
 # Selenium specific implementation of the Capybara::Driver::Node API
+
+require 'capybara/selenium/extensions/find'
+require 'capybara/selenium/extensions/scroll'
+
 class Capybara::Selenium::Node < Capybara::Driver::Node
+  include Capybara::Selenium::Find
+  include Capybara::Selenium::Scroll
+
   def visible_text
     native.text
   end
 
   def all_text
-    text = driver.execute_script('return arguments[0].textContent', self)
+    text = driver.evaluate_script('arguments[0].textContent', self)
     text.gsub(/[\u200b\u200e\u200f]/, '')
         .gsub(/[\ \n\f\t\v\u2028\u2029]+/, ' ')
         .gsub(/\A[[:space:]&&[^\u00a0]]+/, '')
@@ -47,10 +54,16 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   #   :backspace => send backspace keystrokes to clear the field <br/>
   #   Array => an array of keys to send before the value being set, e.g. [[:command, 'a'], :backspace]
   def set(value, **options)
-    raise ArgumentError, "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}" if value.is_a?(Array) && !multiple?
+    if value.is_a?(Array) && !multiple?
+      raise ArgumentError, "Value cannot be an Array when 'multiple' attribute is not present. Not a #{value.class}"
+    end
+
+    tag_name, type = attrs(:tagName, :type).map { |val| val&.downcase }
+    @tag_name ||= tag_name
+
     case tag_name
     when 'input'
-      case self[:type]
+      case type
       when 'radio'
         click
       when 'checkbox'
@@ -63,13 +76,17 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
         set_time(value)
       when 'datetime-local'
         set_datetime_local(value)
+      when 'color'
+        set_color(value)
+      when 'range'
+        set_range(value)
       else
-        set_text(value, options)
+        set_text(value, **options)
       end
     when 'textarea'
-      set_text(value, options)
+      set_text(value, **options)
     else
-      set_content_editable(value) if content_editable?
+      set_content_editable(value)
     end
   end
 
@@ -79,32 +96,59 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
 
   def unselect_option
     raise Capybara::UnselectNotAllowed, 'Cannot unselect option from single select box.' unless select_node.multiple?
+
     click if selected?
   end
 
   def click(keys = [], **options)
     click_options = ClickOptions.new(keys, options)
     return native.click if click_options.empty?
-    click_with_options(click_options)
-  rescue StandardError => err
-    if err.is_a?(::Selenium::WebDriver::Error::ElementClickInterceptedError) ||
-       err.message =~ /Other element would receive the click/
+
+    perform_with_options(click_options) do |action|
+      target = click_options.coords? ? nil : native
+      if click_options.delay.zero?
+        action.click(target)
+      else
+        action.click_and_hold(target)
+        if w3c?
+          action.pause(action.pointer_inputs.first, click_options.delay)
+        else
+          action.pause(click_options.delay)
+        end
+        action.release
+      end
+    end
+  rescue StandardError => e
+    if e.is_a?(::Selenium::WebDriver::Error::ElementClickInterceptedError) ||
+       e.message.match?(/Other element would receive the click/)
       scroll_to_center
     end
 
-    raise err
+    raise e
   end
 
   def right_click(keys = [], **options)
     click_options = ClickOptions.new(keys, options)
-    click_with_options(click_options) do |action|
-      click_options.coords? ? action.context_click : action.context_click(native)
+    perform_with_options(click_options) do |action|
+      target = click_options.coords? ? nil : native
+      if click_options.delay.zero?
+        action.context_click(target)
+      elsif w3c?
+        action.move_to(target) if target
+        action.pointer_down(:right)
+              .pause(action.pointer_inputs.first, click_options.delay)
+              .pointer_up(:right)
+      else
+        raise ArgumentError, 'Delay is not supported when right clicking with legacy (non-w3c) selenium driver'
+      end
     end
   end
 
   def double_click(keys = [], **options)
     click_options = ClickOptions.new(keys, options)
-    click_with_options(click_options) do |action|
+    raise ArgumentError, "double_click doesn't support a delay option" unless click_options.delay.zero?
+
+    perform_with_options(click_options) do |action|
       click_options.coords? ? action.double_click : action.double_click(native)
     end
   end
@@ -117,15 +161,25 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
     scroll_if_needed { browser_action.move_to(native).perform }
   end
 
-  def drag_to(element)
+  def drag_to(element, drop_modifiers: [], **)
+    drop_modifiers = Array(drop_modifiers)
     # Due to W3C spec compliance - The Actions API no longer scrolls to elements when necessary
     # which means Seleniums `drag_and_drop` is now broken - do it manually
     scroll_if_needed { browser_action.click_and_hold(native).perform }
-    element.scroll_if_needed { browser_action.move_to(element.native).release.perform }
+    # element.scroll_if_needed { browser_action.move_to(element.native).release.perform }
+    element.scroll_if_needed do
+      keys_down = modifiers_down(browser_action, drop_modifiers)
+      keys_up = modifiers_up(keys_down.move_to(element.native).release, drop_modifiers)
+      keys_up.perform
+    end
+  end
+
+  def drop(*_)
+    raise NotImplementedError, 'Out of browser drop emulation is not implemented for the current browser'
   end
 
   def tag_name
-    native.tag_name.downcase
+    @tag_name ||= native.tag_name.downcase
   end
 
   def visible?; boolean_attr(native.displayed?); end
@@ -136,20 +190,13 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
 
   def disabled?
     return true unless native.enabled?
+
     # WebDriver only defines `disabled?` for form controls but fieldset makes sense too
-    tag_name == 'fieldset' && find_xpath('ancestor-or-self::fieldset[@disabled]').any?
+    find_xpath('self::fieldset/ancestor-or-self::fieldset[@disabled]').any?
   end
 
   def content_editable?
-    native.attribute('isContentEditable')
-  end
-
-  def find_xpath(locator)
-    native.find_elements(:xpath, locator).map { |el| self.class.new(driver, el) }
-  end
-
-  def find_css(locator)
-    native.find_elements(:css, locator).map { |el| self.class.new(driver, el) }
+    native.attribute('isContentEditable') == 'true'
   end
 
   def ==(other)
@@ -157,33 +204,18 @@ class Capybara::Selenium::Node < Capybara::Driver::Node
   end
 
   def path
-    path = find_xpath(XPath.ancestor_or_self).reverse
-
-    result = []
-    default_ns = path.last[:namespaceURI]
-    while (node = path.shift)
-      parent = path.first
-      selector = node[:tagName]
-      if node[:namespaceURI] != default_ns
-        selector = XPath.child.where((XPath.local_name == selector) & (XPath.namespace_uri == node[:namespaceURI])).to_s
-        selector
-      end
+    driver.evaluate_script GET_XPATH_SCRIPT, self
+  end
 
-      if parent
-        siblings = parent.find_xpath(selector)
-        selector += case siblings.size
-        when 0
-          '[ERROR]' # IE doesn't support full XPath (namespace-uri, etc)
-        when 1
-          '' # index not necessary when only one matching element
-        else
-          "[#{siblings.index(node) + 1}]"
-        end
-      end
-      result.push selector
-    end
+  def obscured?(x: nil, y: nil)
+    res = driver.evaluate_script(OBSCURED_OR_OFFSET_SCRIPT, self, x, y)
+    return true if res == true
+
+    driver.frame_obscured_at?(x: res['x'], y: res['y'])
+  end
 
-    '/' + result.reverse.join('/')
+  def rect
+    native.rect
   end
 
 protected
@@ -195,8 +227,37 @@ protected
     yield
   end
 
+  def scroll_to_center
+    script = <<-'JS'
+      try {
+        arguments[0].scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
+      } catch(e) {
+        arguments[0].scrollIntoView(true);
+      }
+    JS
+    begin
+      driver.execute_script(script, self)
+    rescue StandardError
+      # Swallow error if scrollIntoView with options isn't supported
+    end
+  end
+
 private
 
+  def sibling_index(parent, node, selector)
+    siblings = parent.find_xpath(selector)
+    case siblings.size
+    when 0
+      '[ERROR]' # IE doesn't support full XPath (namespace-uri, etc)
+    when 1
+      '' # index not necessary when only one matching element
+    else
+      idx = siblings.index(node)
+      # Element may not be found in the siblings if it has gone away
+      idx.nil? ? '[ERROR]' : "[#{idx + 1}]"
+    end
+  end
+
   def boolean_attr(val)
     val && (val != 'false')
   end
@@ -206,7 +267,7 @@ private
     find_xpath(XPath.ancestor(:select)[1]).first
   end
 
-  def set_text(value, clear: nil, **_unused)
+  def set_text(value, clear: nil, rapid: nil, **_unused)
     value = value.to_s
     if value.empty? && clear.nil?
       native.clear
@@ -217,15 +278,24 @@ private
     elsif clear.is_a? Array
       send_keys(*clear, value)
     else
-      # Clear field by JavaScript assignment of the value property.
-      # Script can change a readonly element which user input cannot, so
-      # don't execute if readonly.
-      driver.execute_script "arguments[0].value = ''", self unless clear == :none
-      send_keys(value)
+      driver.execute_script 'arguments[0].select()', self unless clear == :none
+      if rapid == true || ((value.length > auto_rapid_set_length) && rapid != false)
+        send_keys(value[0..3])
+        driver.execute_script RAPID_APPEND_TEXT, self, value[4...-3]
+        send_keys(value[-3..-1])
+      else
+        send_keys(value)
+      end
     end
   end
 
-  def click_with_options(click_options)
+  def auto_rapid_set_length
+    30
+  end
+
+  def perform_with_options(click_options, &block)
+    raise ArgumentError, 'A block must be provided' unless block
+
     scroll_if_needed do
       action_with_modifiers(click_options) do |action|
         if block_given?
@@ -237,24 +307,10 @@ private
     end
   end
 
-  def scroll_to_center
-    script = <<-'JS'
-      try {
-        arguments[0].scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
-      } catch(e) {
-        arguments[0].scrollIntoView(true);
-      }
-    JS
-    begin
-      driver.execute_script(script, self)
-    rescue StandardError # rubocop:disable Lint/HandleExceptions
-      # Swallow error if scrollIntoView with options isn't supported
-    end
-  end
-
   def set_date(value) # rubocop:disable Naming/AccessorMethodName
     value = SettableValue.new(value)
     return set_text(value) unless value.dateable?
+
     # TODO: this would be better if locale can be detected and correct keystrokes sent
     update_value_js(value.to_date_str)
   end
@@ -262,6 +318,7 @@ private
   def set_time(value) # rubocop:disable Naming/AccessorMethodName
     value = SettableValue.new(value)
     return set_text(value) unless value.timeable?
+
     # TODO: this would be better if locale can be detected and correct keystrokes sent
     update_value_js(value.to_time_str)
   end
@@ -269,12 +326,22 @@ private
   def set_datetime_local(value) # rubocop:disable Naming/AccessorMethodName
     value = SettableValue.new(value)
     return set_text(value) unless value.timeable?
+
     # TODO: this would be better if locale can be detected and correct keystrokes sent
     update_value_js(value.to_datetime_str)
   end
 
+  def set_color(value) # rubocop:disable Naming/AccessorMethodName
+    update_value_js(value)
+  end
+
+  def set_range(value) # rubocop:disable Naming/AccessorMethodName
+    update_value_js(value)
+  end
+
   def update_value_js(value)
     driver.execute_script(<<-JS, self, value)
+      if (arguments[0].readOnly) { return };
       if (document.activeElement !== arguments[0]){
         arguments[0].focus();
       }
@@ -287,33 +354,65 @@ private
   end
 
   def set_file(value) # rubocop:disable Naming/AccessorMethodName
-    path_names = value.to_s.empty? ? [] : value
-    native.send_keys(Array(path_names).join("\n"))
+    with_file_detector do
+      path_names = value.to_s.empty? ? [] : value
+      file_names = Array(path_names).map do |pn|
+        Pathname.new(pn).absolute? ? pn : File.expand_path(pn)
+      end.join("\n")
+      native.send_keys(file_names)
+    end
+  end
+
+  def with_file_detector
+    if driver.options[:browser] == :remote &&
+       bridge.respond_to?(:file_detector) &&
+       bridge.file_detector.nil?
+      begin
+        bridge.file_detector = lambda do |(fn, *)|
+          str = fn.to_s
+          str if File.exist?(str)
+        end
+        yield
+      ensure
+        bridge.file_detector = nil
+      end
+    else
+      yield
+    end
   end
 
   def set_content_editable(value) # rubocop:disable Naming/AccessorMethodName
     # Ensure we are focused on the element
     click
 
-    script = <<-JS
-      var range = document.createRange();
-      var sel = window.getSelection();
-      arguments[0].focus();
-      range.selectNodeContents(arguments[0]);
-      sel.removeAllRanges();
-      sel.addRange(range);
+    editable = driver.execute_script <<-JS, self
+      if (arguments[0].isContentEditable) {
+        var range = document.createRange();
+        var sel = window.getSelection();
+        arguments[0].focus();
+        range.selectNodeContents(arguments[0]);
+        sel.removeAllRanges();
+        sel.addRange(range);
+        return true;
+      }
+      return false;
     JS
-    driver.execute_script script, self
 
     # The action api has a speed problem but both chrome and firefox 58 raise errors
     # if we use the faster direct send_keys.  For now just send_keys to the element
     # we've already focused.
     # native.send_keys(value.to_s)
-    browser_action.send_keys(value.to_s).perform
+    browser_action.send_keys(value.to_s).perform if editable
   end
 
   def action_with_modifiers(click_options)
-    actions = browser_action.move_to(native, *click_options.coords)
+    actions = browser_action.tap do |acts|
+      if click_options.center_offset? && click_options.coords?
+        acts.move_to(native).move_by(*click_options.coords)
+      else
+        acts.move_to(native, *click_options.coords)
+      end
+    end
     modifiers_down(actions, click_options.keys)
     yield actions
     modifiers_up(actions, click_options.keys)
@@ -325,28 +424,126 @@ private
 
   def modifiers_down(actions, keys)
     each_key(keys) { |key| actions.key_down(key) }
+    actions
   end
 
   def modifiers_up(actions, keys)
     each_key(keys) { |key| actions.key_up(key) }
+    actions
+  end
+
+  def browser
+    driver.browser
+  end
+
+  def bridge
+    browser.send(:bridge)
   end
 
   def browser_action
-    driver.browser.action
+    browser.action
   end
 
-  def each_key(keys)
-    keys.each do |key|
-      key = case key
+  def capabilities
+    browser.capabilities
+  end
+
+  def w3c?
+    (defined?(Selenium::WebDriver::VERSION) && (Selenium::WebDriver::VERSION.to_f >= 4)) ||
+      capabilities.is_a?(::Selenium::WebDriver::Remote::W3C::Capabilities)
+  end
+
+  def normalize_keys(keys)
+    keys.map do |key|
+      case key
       when :ctrl then :control
       when :command, :cmd then :meta
       else
         key
       end
-      yield key
     end
   end
 
+  def each_key(keys)
+    normalize_keys(keys).each { |key| yield(key) }
+  end
+
+  def find_context
+    native
+  end
+
+  def build_node(native_node, initial_cache = {})
+    self.class.new(driver, native_node, initial_cache)
+  end
+
+  def attrs(*attr_names)
+    return attr_names.map { |name| self[name.to_s] } if ENV['CAPYBARA_THOROUGH']
+
+    driver.evaluate_script <<~'JS', self, attr_names.map(&:to_s)
+      (function(el, names){
+        return names.map(function(name){
+          return el[name]
+        });
+      })(arguments[0], arguments[1]);
+    JS
+  end
+
+  GET_XPATH_SCRIPT = <<~'JS'
+    (function(el, xml){
+      var xpath = '';
+    	var pos, tempitem2;
+
+      while(el !== xml.documentElement) {
+        pos = 0;
+        tempitem2 = el;
+        while(tempitem2) {
+          if (tempitem2.nodeType === 1 && tempitem2.nodeName === el.nodeName) { // If it is ELEMENT_NODE of the same name
+            pos += 1;
+          }
+          tempitem2 = tempitem2.previousSibling;
+        }
+
+        if (el.namespaceURI != xml.documentElement.namespaceURI) {
+          xpath = "*[local-name()='"+el.nodeName+"' and namespace-uri()='"+(el.namespaceURI===null?'':el.namespaceURI)+"']["+pos+']'+'/'+xpath;
+        } else {
+          xpath = el.nodeName.toUpperCase()+"["+pos+"]/"+xpath;
+        }
+
+        el = el.parentNode;
+      }
+      xpath = '/'+xml.documentElement.nodeName.toUpperCase()+'/'+xpath;
+      xpath = xpath.replace(/\/$/, '');
+      return xpath;
+    })(arguments[0], document)
+  JS
+
+  OBSCURED_OR_OFFSET_SCRIPT = <<~'JS'
+    (function(el, x, y) {
+      var box = el.getBoundingClientRect();
+      if (x == null) x = box.width/2;
+      if (y == null) y = box.height/2 ;
+
+      var px = box.left + x,
+          py = box.top + y,
+          e = document.elementFromPoint(px, py);
+
+      if (!el.contains(e))
+        return true;
+
+      return { x: px, y: py };
+    })(arguments[0], arguments[1], arguments[2])
+  JS
+
+  RAPID_APPEND_TEXT = <<~'JS'
+    (function(el, value) {
+      value = el.value + value;
+      if (el.maxLength && el.maxLength != -1){
+        value = value.slice(0, el.maxLength);
+      }
+      el.value = value;
+    })(arguments[0], arguments[1])
+  JS
+
   # SettableValue encapsulates time/date field formatting
   class SettableValue
     attr_reader :value
@@ -364,7 +561,7 @@ private
     end
 
     def to_date_str
-      value.to_date.strftime('%Y-%m-%d')
+      value.to_date.iso8601
     end
 
     def timeable?
@@ -398,8 +595,16 @@ private
       [options[:x], options[:y]]
     end
 
+    def center_offset?
+      options[:offset] == :center
+    end
+
     def empty?
-      keys.empty? && !coords?
+      keys.empty? && !coords? && delay.zero?
+    end
+
+    def delay
+      options[:delay] || 0
     end
   end
   private_constant :ClickOptions