capybara 3.23.0 → 3.35.3

data/lib/capybara/selenium/driver_specializations/edge_driver.rb

@@ -3,25 +3,29 @@
 require 'capybara/selenium/nodes/edge_node'
 
 module Capybara::Selenium::Driver::EdgeDriver
+  def self.extended(base)
+    bridge = base.send(:bridge)
+    bridge.extend Capybara::Selenium::IsDisplayed unless bridge.send(:commands, :is_element_displayed)
+    base.options[:native_displayed] = false if base.options[:native_displayed].nil?
+  end
+
   def fullscreen_window(handle)
     return super if edgedriver_version < 75
 
     within_given_window(handle) do
-      begin
-        super
-      rescue NoMethodError => e
-        raise unless e.message.match?(/full_screen_window/)
-
-        result = bridge.http.call(:post, "session/#{bridge.session_id}/window/fullscreen", {})
-        result['value']
-      end
+      super
+    rescue NoMethodError => e
+      raise unless e.message.include?('full_screen_window')
+
+      result = bridge.http.call(:post, "session/#{bridge.session_id}/window/fullscreen", {})
+      result['value']
     end
   end
 
   def resize_window_to(handle, width, height)
     super
   rescue Selenium::WebDriver::Error::UnknownError => e
-    raise unless e.message.match?(/failed to change window state/)
+    raise unless e.message.include?('failed to change window state')
 
     # Chromedriver doesn't wait long enough for state to change when coming out of fullscreen
     # and raises unnecessary error. Wait a bit and try again.
@@ -39,8 +43,8 @@ module Capybara::Selenium::Driver::EdgeDriver
 
     timer = Capybara::Helpers.timer(expire_in: 10)
     begin
-      @browser.navigate.to('about:blank')
       clear_storage unless uniform_storage_clear?
+      @browser.navigate.to('about:blank')
       wait_for_empty_page(timer)
     rescue *unhandled_alert_errors
       accept_unhandled_reset_alert
@@ -68,17 +72,19 @@ private
   end
 
   def clear_all_storage?
-    options.values_at(:clear_session_storage, :clear_local_storage).none? { |s| s == false }
+    storage_clears.none? false
   end
 
   def uniform_storage_clear?
-    clear = options.values_at(:clear_session_storage, :clear_local_storage)
-    clear.all? { |s| s == false } || clear.none? { |s| s == false }
+    storage_clears.uniq { |s| s == false }.length <= 1
+  end
+
+  def storage_clears
+    options.values_at(:clear_session_storage, :clear_local_storage)
   end
 
   def clear_storage
-    # Chrome errors if attempt to clear storage on about:blank
-    # In W3C mode it crashes chromedriver
+    # Edgedriver crashes if attempt to clear storage on about:blank
     url = current_url
     super unless url.nil? || url.start_with?('about:')
   end
@@ -106,10 +112,6 @@ private
     ::Capybara::Selenium::EdgeNode.new(self, native_node, initial_cache)
   end
 
-  def bridge
-    browser.send(:bridge)
-  end
-
   def edgedriver_version
     @edgedriver_version ||= begin
       caps = browser.capabilities

data/lib/capybara/selenium/driver_specializations/firefox_driver.rb

@@ -5,6 +5,8 @@ require 'capybara/selenium/nodes/firefox_node'
 module Capybara::Selenium::Driver::FirefoxDriver
   def self.extended(driver)
     driver.extend Capybara::Selenium::Driver::W3CFirefoxDriver if w3c?(driver)
+    bridge = driver.send(:bridge)
+    bridge.extend Capybara::Selenium::IsDisplayed unless bridge.send(:commands, :is_element_displayed)
   end
 
   def self.w3c?(driver)
@@ -17,6 +19,7 @@ module Capybara::Selenium::Driver::W3CFirefoxDriver
   class << self
     def extended(driver)
       require 'capybara/selenium/patches/pause_duration_fix' if pause_broken?(driver.browser)
+      driver.options[:native_displayed] = false if driver.options[:native_displayed].nil?
     end
 
     def pause_broken?(sel_driver)
@@ -39,6 +42,15 @@ module Capybara::Selenium::Driver::W3CFirefoxDriver
     # Use instance variable directly so we avoid starting the browser just to reset the session
     return unless @browser
 
+    if browser_version >= 68
+      begin
+        # Firefox 68 hangs if we try to switch windows while a modal is visible
+        browser.switch_to.alert&.dismiss
+      rescue Selenium::WebDriver::Error::NoSuchAlertError
+        # Swallow
+      end
+    end
+
     switch_to_window(window_handles.first)
     window_handles.slice(1..-1).each { |win| close_window(win) }
     super
@@ -49,7 +61,7 @@ module Capybara::Selenium::Driver::W3CFirefoxDriver
     accept_modal :confirm, wait: 0.1 do
       super
     end
-  rescue Capybara::ModalNotFound # rubocop:disable Lint/HandleExceptions
+  rescue Capybara::ModalNotFound
     # No modal was opened - page has refreshed - ignore
   end
 
@@ -68,6 +80,10 @@ private
   def build_node(native_node, initial_cache = {})
     ::Capybara::Selenium::FirefoxNode.new(self, native_node, initial_cache)
   end
+
+  def browser_version
+    browser.capabilities[:browser_version].to_f
+  end
 end
 
 Capybara::Selenium::Driver.register_specialization :firefox, Capybara::Selenium::Driver::FirefoxDriver

data/lib/capybara/selenium/driver_specializations/safari_driver.rb

@@ -18,10 +18,6 @@ private
   def build_node(native_node, initial_cache = {})
     ::Capybara::Selenium::SafariNode.new(self, native_node, initial_cache)
   end
-
-  def bridge
-    browser.send(:bridge)
-  end
 end
 
 Capybara::Selenium::Driver.register_specialization(/^(safari|Safari_Technology_Preview)$/,

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Capybara::Selenium::Node
+  module FileInputClickEmulation
+    def click(keys = [], **options)
+      super
+    rescue Selenium::WebDriver::Error::InvalidArgumentError
+      return emulate_click if attaching_file? && visible_file_field?
+
+      raise
+    end
+
+  private
+
+    def visible_file_field?
+      (attrs(:tagName, :type).map { |val| val&.downcase } == %w[input file]) && visible?
+    end
+
+    def attaching_file?
+      caller_locations.any? { |cl| cl.base_label == 'attach_file' }
+    end
+
+    def emulate_click
+      driver.execute_script(<<~JS, self)
+        arguments[0].dispatchEvent(
+          new MouseEvent('click', {
+            view: window,
+            bubbles: true,
+            cancelable: true
+          }));
+      JS
+    end
+  end
+end

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

@@ -3,42 +3,44 @@
 module Capybara
   module Selenium
     module Find
-      def find_xpath(selector, uses_visibility: false, styles: nil, **_options)
-        find_by(:xpath, selector, uses_visibility: uses_visibility, texts: [], styles: styles)
+      def find_xpath(selector, uses_visibility: false, styles: nil, position: false, **_options)
+        find_by(:xpath, selector, uses_visibility: uses_visibility, texts: [], styles: styles, position: position)
       end
 
-      def find_css(selector, uses_visibility: false, texts: [], styles: nil, **_options)
-        find_by(:css, selector, uses_visibility: uses_visibility, texts: texts, styles: styles)
+      def find_css(selector, uses_visibility: false, texts: [], styles: nil, position: false, **_options)
+        find_by(:css, selector, uses_visibility: uses_visibility, texts: texts, styles: styles, position: position)
       end
 
     private
 
-      def find_by(format, selector, uses_visibility:, texts:, styles:)
+      def find_by(format, selector, uses_visibility:, texts:, styles:, position:)
         els = find_context.find_elements(format, selector)
         hints = []
 
         if (els.size > 2) && !ENV['DISABLE_CAPYBARA_SELENIUM_OPTIMIZATIONS']
-          begin
-            els = filter_by_text(els, texts) unless texts.empty?
-            hints_js, functions = build_hints_js(uses_visibility, styles)
-
-            unless functions.empty?
-              hints = es_context.execute_script(hints_js, els).map! do |results|
-                hint = {}
-                hint[:style] = results.pop if functions.include?(:style_func)
-                hint[:visible] = results.pop if functions.include?(:vis_func)
-                hint
-              end
-            end
-          rescue ::Selenium::WebDriver::Error::StaleElementReferenceError,
-                 ::Capybara::NotSupportedByDriverError
-            # warn 'Unexpected Stale Element Error - skipping optimization'
-            hints = []
-          end
+          els = filter_by_text(els, texts) unless texts.empty?
+          hints = gather_hints(els, uses_visibility: uses_visibility, styles: styles, position: position)
         end
         els.map.with_index { |el, idx| build_node(el, hints[idx] || {}) }
       end
 
+      def gather_hints(elements, uses_visibility:, styles:, position:)
+        hints_js, functions = build_hints_js(uses_visibility, styles, position)
+        return [] unless functions.any?
+
+        (es_context.execute_script(hints_js, elements) || []).map! do |results|
+          hint = {}
+          hint[:style] = results.pop if functions.include?(:style_func)
+          hint[:position] = results.pop if functions.include?(:position_func)
+          hint[:visible] = results.pop if functions.include?(:vis_func)
+          hint
+        end
+      rescue ::Selenium::WebDriver::Error::StaleElementReferenceError,
+             ::Capybara::NotSupportedByDriverError
+        # warn 'Unexpected Stale Element Error - skipping optimization'
+        []
+      end
+
       def filter_by_text(elements, texts)
         es_context.execute_script <<~JS, elements, texts
           var texts = arguments[1];
@@ -49,7 +51,7 @@ module Capybara
         JS
       end
 
-      def build_hints_js(uses_visibility, styles)
+      def build_hints_js(uses_visibility, styles, position)
         functions = []
         hints_js = +''
 
@@ -60,6 +62,15 @@ module Capybara
           functions << :vis_func
         end
 
+        if position
+          hints_js << <<~POSITION_JS
+            var position_func = function(el){
+              return el.getBoundingClientRect();
+            };
+          POSITION_JS
+          functions << :position_func
+        end
+
         if styles.is_a? Hash
           hints_js << <<~STYLE_JS
             var style_func = function(el){
@@ -89,9 +100,9 @@ module Capybara
       def is_displayed_atom # rubocop:disable Naming/PredicateName
         @@is_displayed_atom ||= begin # rubocop:disable Style/ClassVars
           browser.send(:bridge).send(:read_atom, 'isDisplayed')
-                                rescue StandardError
-                                  # If the atom doesn't exist or other error
-                                  ''
+        rescue StandardError
+          # If the atom doesn't exist or other error
+          ''
         end
       end
     end

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

@@ -4,19 +4,35 @@ class Capybara::Selenium::Node
   module Html5Drag
     # Implement methods to emulate HTML5 drag and drop
 
-    def drag_to(element, delay: 0.05)
+    def drag_to(element, html5: nil, delay: 0.05, drop_modifiers: [])
+      drop_modifiers = Array(drop_modifiers)
+
       driver.execute_script MOUSEDOWN_TRACKER
       scroll_if_needed { browser_action.click_and_hold(native).perform }
-      if driver.evaluate_script('window.capybara_mousedown_prevented || !arguments[0].draggable', self)
-        element.scroll_if_needed { browser_action.move_to(element.native).release.perform }
+      html5 = !driver.evaluate_script(LEGACY_DRAG_CHECK, self) if html5.nil?
+      if html5
+        perform_html5_drag(element, delay, drop_modifiers)
       else
-        driver.evaluate_async_script HTML5_DRAG_DROP_SCRIPT, self, element, delay * 1000
-        browser_action.release.perform
+        perform_legacy_drag(element, drop_modifiers)
       end
     end
 
   private
 
+    def perform_legacy_drag(element, drop_modifiers)
+      element.scroll_if_needed do
+        # browser_action.move_to(element.native).release.perform
+        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 perform_html5_drag(element, delay, drop_modifiers)
+      driver.evaluate_async_script HTML5_DRAG_DROP_SCRIPT, self, element, delay * 1000, normalize_keys(drop_modifiers)
+      browser_action.release.perform
+    end
+
     def html5_drop(*args)
       if args[0].is_a? String
         input = driver.evaluate_script ATTACH_FILE
@@ -81,11 +97,25 @@ class Capybara::Selenium::Node
     JS
 
     MOUSEDOWN_TRACKER = <<~JS
+      window.capybara_mousedown_prevented = null;
       document.addEventListener('mousedown', ev => {
         window.capybara_mousedown_prevented = ev.defaultPrevented;
       }, { once: true, passive: true })
     JS
 
+    LEGACY_DRAG_CHECK = <<~JS
+      (function(el){
+        if ([true, null].indexOf(window.capybara_mousedown_prevented) >= 0){
+          return true;
+        }
+
+        do {
+          if (el.draggable) return false;
+        } while (el = el.parentElement );
+        return true;
+      })(arguments[0])
+    JS
+
     HTML5_DRAG_DROP_SCRIPT = <<~JS
       function rectCenter(rect){
         return new DOMPoint(
@@ -130,6 +160,14 @@ class Capybara::Selenium::Node
         var targetRect = target.getBoundingClientRect();
         var sourceCenter = rectCenter(source.getBoundingClientRect());
 
+        for (var i = 0; i < drop_modifier_keys.length; i++) {
+          key = drop_modifier_keys[i];
+          if (key == "control"){
+            key = "ctrl"
+          }
+          opts[key + 'Key'] = true;
+        }
+
         // fire 2 dragover events to simulate dragging with a direction
         var entryPoint = pointOnRect(sourceCenter, targetRect)
         var dragOverOpts = Object.assign({clientX: entryPoint.x, clientY: entryPoint.y}, opts);
@@ -143,17 +181,18 @@ class Capybara::Selenium::Node
         var dragOverOpts = Object.assign({clientX: targetCenter.x, clientY: targetCenter.y}, opts);
         var dragOverEvent = new DragEvent('dragover', dragOverOpts);
         target.dispatchEvent(dragOverEvent);
-        window.setTimeout(dragLeave, step_delay, dragOverEvent.defaultPrevented);
+        window.setTimeout(dragLeave, step_delay, dragOverEvent.defaultPrevented, dragOverOpts);
       }
 
-      function dragLeave(drop) {
-        var dragLeaveEvent = new DragEvent('dragleave', opts);
+      function dragLeave(drop, dragOverOpts) {
+        var dragLeaveOptions = Object.assign({}, opts, dragOverOpts);
+        var dragLeaveEvent = new DragEvent('dragleave', dragLeaveOptions);
         target.dispatchEvent(dragLeaveEvent);
         if (drop) {
-          var dropEvent = new DragEvent('drop', opts);
+          var dropEvent = new DragEvent('drop', dragLeaveOptions);
           target.dispatchEvent(dropEvent);
         }
-        var dragEndEvent = new DragEvent('dragend', opts);
+        var dragEndEvent = new DragEvent('dragend', dragLeaveOptions);
         source.dispatchEvent(dragEndEvent);
         callback.call(true);
       }
@@ -161,11 +200,16 @@ class Capybara::Selenium::Node
       var source = arguments[0],
           target = arguments[1],
           step_delay = arguments[2],
-          callback = arguments[3];
+          drop_modifier_keys = arguments[3],
+          callback = arguments[4];
 
       var dt = new DataTransfer();
       var opts = { cancelable: true, bubbles: true, dataTransfer: dt };
 
+      while (source && !source.draggable) {
+        source = source.parentElement;
+      }
+
       if (source.tagName == 'A'){
         dt.setData('text/uri-list', source.href);
         dt.setData('text', source.href);

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Capybara::Selenium::Node
+  #
+  # @api private
+  #
+  class ModifierKeysStack
+    def initialize
+      @stack = []
+    end
+
+    def include?(key)
+      @stack.flatten.include?(key)
+    end
+
+    def press(key)
+      @stack.last.push(key)
+    end
+
+    def push
+      @stack.push []
+    end
+
+    def pop
+      @stack.pop
+    end
+  end
+end

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

@@ -45,20 +45,18 @@ module Capybara
         JS
       end
 
+      SCROLL_POSITIONS = {
+        top: '0',
+        bottom: 'arguments[0].scrollHeight',
+        center: '(arguments[0].scrollHeight - arguments[0].clientHeight)/2'
+      }.freeze
+
       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});
+            arguments[0].scrollTo(0, #{SCROLL_POSITIONS[location]});
           } else {
-            arguments[0].scrollTop = #{scroll_y};
+            arguments[0].scrollTop = #{SCROLL_POSITIONS[location]};
           }
         JS
       end