capybara 3.16.1 → 3.33.0

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

@@ -3,6 +3,30 @@
 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.commands(:is_element_displayed)
+  end
+
+  def self.w3c?(driver)
+    (defined?(Selenium::WebDriver::VERSION) && (Selenium::WebDriver::VERSION.to_f >= 4)) ||
+      driver.browser.capabilities.is_a?(::Selenium::WebDriver::Remote::W3C::Capabilities)
+  end
+end
+
+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)
+      sel_driver.capabilities['moz:geckodriverVersion']&.start_with?('0.22.')
+    end
+  end
+
   def resize_window_to(handle, width, height)
     within_given_window(handle) do
       # Don't set the size if already set - See https://github.com/mozilla/geckodriver/issues/643
@@ -18,6 +42,15 @@ module Capybara::Selenium::Driver::FirefoxDriver
     # 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
@@ -28,7 +61,7 @@ module Capybara::Selenium::Driver::FirefoxDriver
     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
 
@@ -39,7 +72,7 @@ module Capybara::Selenium::Driver::FirefoxDriver
     # so we have to move to the default_content and iterate back through the frames
     handles = @frame_handles[current_window_handle]
     browser.switch_to.default_content
-    handles.tap(&:pop).each { |fh| browser.switch_to.frame(fh) }
+    handles.tap(&:pop).each { |fh| browser.switch_to.frame(fh.native) }
   end
 
 private
@@ -47,4 +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/internet_explorer_driver.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'capybara/selenium/nodes/ie_node'
+
 module Capybara::Selenium::Driver::InternetExplorerDriver
   def switch_to_frame(frame)
     return super unless frame == :parent
@@ -8,6 +10,17 @@ module Capybara::Selenium::Driver::InternetExplorerDriver
     # so we have to move to the default_content and iterate back through the frames
     handles = @frame_handles[current_window_handle]
     browser.switch_to.default_content
-    handles.tap(&:pop).each { |fh| browser.switch_to.frame(fh) }
+    handles.tap(&:pop).each { |fh| browser.switch_to.frame(fh.native) }
+  end
+
+private
+
+  def build_node(native_node, initial_cache = {})
+    ::Capybara::Selenium::IENode.new(self, native_node, initial_cache)
   end
 end
+
+module Capybara::Selenium
+  Driver.register_specialization :ie, Driver::InternetExplorerDriver
+  Driver.register_specialization :internet_explorer, Driver::InternetExplorerDriver
+end

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

@@ -3,13 +3,22 @@
 require 'capybara/selenium/nodes/safari_node'
 
 module Capybara::Selenium::Driver::SafariDriver
-private # rubocop:disable Layout/IndentationWidth
+  def switch_to_frame(frame)
+    return super unless frame == :parent
 
-  def build_node(native_node, initial_cache = {})
-    ::Capybara::Selenium::SafariNode.new(self, native_node, initial_cache)
+    # safaridriver/safari has an issue where switch_to_frame(:parent)
+    # behaves like switch_to_frame(:top)
+    handles = @frame_handles[current_window_handle]
+    browser.switch_to.default_content
+    handles.tap(&:pop).each { |fh| browser.switch_to.frame(fh.native) }
   end
 
-  def bridge
-    browser.send(:bridge)
+private
+
+  def build_node(native_node, initial_cache = {})
+    ::Capybara::Selenium::SafariNode.new(self, native_node, initial_cache)
   end
 end
+
+Capybara::Selenium::Driver.register_specialization(/^(safari|Safari_Technology_Preview)$/,
+                                                   Capybara::Selenium::Driver::SafariDriver)

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,67 +3,47 @@
 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']
           els = filter_by_text(els, texts) unless texts.empty?
-
-          hints_js = +''
-          functions = []
-          if uses_visibility && !is_displayed_atom.empty?
-            hints_js << <<~VISIBILITY_JS
-              var vis_func = #{is_displayed_atom};
-            VISIBILITY_JS
-            functions << 'vis_func'
-          end
-
-          if styles.is_a? Hash
-            hints_js << <<~STYLE_JS
-              var style_func = function(el){
-                var el_styles = window.getComputedStyle(el);
-                return #{styles.keys.map(&:to_s)}.reduce(function(res, style){
-                  res[style] = el_styles[style];
-                  return res;
-                }, {});
-              };
-            STYLE_JS
-            functions << 'style_func'
-          end
-
-          unless functions.empty?
-            hints_js << <<~EACH_JS
-              return arguments[0].map(function(el){
-                return [#{functions.join(',')}].map(function(fn){ return fn.call(null, el) });
-              });
-            EACH_JS
-
-            hints = es_context.execute_script hints_js, els
-            hints.map! do |results|
-              result = {}
-              result[:style] = results.pop if styles.is_a? Hash
-              result[:visible] = results.pop if uses_visibility
-              result
-            end
-          end
+          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]
+          var texts = arguments[1];
           return arguments[0].filter(function(el){
             var content = el.textContent.toLowerCase();
             return texts.every(function(txt){ return content.indexOf(txt.toLowerCase()) != -1 });
@@ -71,12 +51,54 @@ module Capybara
         JS
       end
 
+      def build_hints_js(uses_visibility, styles, position)
+        functions = []
+        hints_js = +''
+
+        if uses_visibility && !is_displayed_atom.empty?
+          hints_js << <<~VISIBILITY_JS
+            var vis_func = #{is_displayed_atom};
+          VISIBILITY_JS
+          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){
+              var el_styles = window.getComputedStyle(el);
+              return #{styles.keys.map(&:to_s)}.reduce(function(res, style){
+                res[style] = el_styles[style];
+                return res;
+              }, {});
+            };
+          STYLE_JS
+          functions << :style_func
+        end
+
+        hints_js << <<~EACH_JS
+          return arguments[0].map(function(el){
+            return [#{functions.join(',')}].map(function(fn){ return fn.call(null, el) });
+          });
+        EACH_JS
+
+        [hints_js, functions]
+      end
+
       def es_context
         respond_to?(:execute_script) ? self : driver
       end
 
       def is_displayed_atom # rubocop:disable Naming/PredicateName
-        @@is_displayed_atom ||= begin
+        @@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

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

@@ -2,36 +2,121 @@
 
 class Capybara::Selenium::Node
   module Html5Drag
-  # Implement methods to emulate HTML5 drag and drop
+    # Implement methods to emulate HTML5 drag and drop
 
-  private # rubocop:disable Layout/IndentationWidth
+    def drag_to(element, html5: nil, delay: 0.05, drop_modifiers: [])
+      drop_modifiers = Array(drop_modifiers)
 
-    def html5_drag_to(element)
       driver.execute_script MOUSEDOWN_TRACKER
       scroll_if_needed { browser_action.click_and_hold(native).perform }
-      if driver.evaluate_script('window.capybara_mousedown_prevented')
-        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.execute_script HTML5_DRAG_DROP_SCRIPT, self, element
-        browser_action.release.perform
+        perform_legacy_drag(element, drop_modifiers)
       end
     end
 
-    def html5_draggable?
-      # Workaround https://github.com/SeleniumHQ/selenium/issues/6396
-      native.property('draggable')
+  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
+        input.set_file(args)
+        driver.execute_script DROP_FILE, self, input
+      else
+        items = args.each_with_object([]) do |arg, arr|
+          arg.each_with_object(arr) do |(type, data), arr_|
+            arr_ << { type: type, data: data }
+          end
+        end
+        driver.execute_script DROP_STRING, items, self
+      end
     end
 
+    DROP_STRING = <<~JS
+      var strings = arguments[0],
+          el = arguments[1],
+          dt = new DataTransfer(),
+          opts = { cancelable: true, bubbles: true, dataTransfer: dt };
+      for (var i=0; i < strings.length; i++){
+        if (dt.items) {
+          dt.items.add(strings[i]['data'], strings[i]['type']);
+        } else {
+          dt.setData(strings[i]['type'], strings[i]['data']);
+        }
+      }
+      var dropEvent = new DragEvent('drop', opts);
+      el.dispatchEvent(dropEvent);
+    JS
+
+    DROP_FILE = <<~JS
+      var el = arguments[0],
+          input = arguments[1],
+          files = input.files,
+          dt = new DataTransfer(),
+          opts = { cancelable: true, bubbles: true, dataTransfer: dt };
+      input.parentElement.removeChild(input);
+      if (dt.items){
+        for (var i=0; i<files.length; i++){
+          dt.items.add(files[i]);
+        }
+      } else {
+        Object.defineProperty(dt, "files", {
+          value: files,
+          writable: false
+        });
+      }
+      var dropEvent = new DragEvent('drop', opts);
+      el.dispatchEvent(dropEvent);
+    JS
+
+    ATTACH_FILE = <<~JS
+      (function(){
+        var input = document.createElement('INPUT');
+        input.type = "file";
+        input.id = "_capybara_drop_file";
+        input.multiple = true;
+        document.body.appendChild(input);
+        return input;
+      })()
+    JS
+
     MOUSEDOWN_TRACKER = <<~JS
+      window.capybara_mousedown_prevented = null;
       document.addEventListener('mousedown', ev => {
         window.capybara_mousedown_prevented = ev.defaultPrevented;
       }, { once: true, passive: true })
     JS
 
-    HTML5_DRAG_DROP_SCRIPT = <<~JS
-      var source = arguments[0];
-      var target = arguments[1];
+    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(
           (rect.left + rect.right)/2,
@@ -70,9 +155,61 @@ class Capybara::Selenium::Node
         return new DOMPoint(pt.x,pt.y);
       }
 
+      function dragEnterTarget() {
+        target.scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
+        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);
+        var dragOverEvent = new DragEvent('dragover', dragOverOpts);
+        target.dispatchEvent(dragOverEvent);
+        window.setTimeout(dragOnTarget, step_delay);
+      }
+
+      function dragOnTarget() {
+        var targetCenter = rectCenter(target.getBoundingClientRect());
+        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, dragOverOpts);
+      }
+
+      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', dragLeaveOptions);
+          target.dispatchEvent(dropEvent);
+        }
+        var dragEndEvent = new DragEvent('dragend', dragLeaveOptions);
+        source.dispatchEvent(dragEndEvent);
+        callback.call(true);
+      }
+
+      var source = arguments[0],
+          target = arguments[1],
+          step_delay = arguments[2],
+          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);
@@ -84,29 +221,8 @@ class Capybara::Selenium::Node
 
       var dragEvent = new DragEvent('dragstart', opts);
       source.dispatchEvent(dragEvent);
-      target.scrollIntoView({behavior: 'instant', block: 'center', inline: 'center'});
-      var targetRect = target.getBoundingClientRect();
-      var sourceCenter = rectCenter(source.getBoundingClientRect());
-
-      // 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);
-      var dragOverEvent = new DragEvent('dragover', dragOverOpts);
-      target.dispatchEvent(dragOverEvent);
-
-      var targetCenter = rectCenter(targetRect);
-      dragOverOpts = Object.assign({clientX: targetCenter.x, clientY: targetCenter.y}, opts);
-      dragOverEvent = new DragEvent('dragover', dragOverOpts);
-      target.dispatchEvent(dragOverEvent);
-
-      var dragLeaveEvent = new DragEvent('dragleave', opts);
-      target.dispatchEvent(dragLeaveEvent);
-      if (dragOverEvent.defaultPrevented) {
-        var dropEvent = new DragEvent('drop', opts);
-        target.dispatchEvent(dropEvent);
-      }
-      var dragEndEvent = new DragEvent('dragend', opts);
-      source.dispatchEvent(dragEndEvent);
+
+      window.setTimeout(dragEnterTarget, step_delay);
     JS
   end
 end