cuprite 0.18 → 0.20

data/lib/capybara/cuprite/node/deprecations.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "capybara/cuprite/deprecation"
+
+module Capybara
+  module Cuprite
+    class Node < Capybara::Driver::Node
+      module Deprecations
+        def browser
+          Cuprite.deprecation_warning("#{self.class}#browser", "use page.driver.browser")
+          driver.browser
+        end
+
+        def parents
+          Cuprite.deprecation_warning("#{self.class}#parents", "use Capybara's ancestor")
+          command { driver.browser.evaluate("_cuprite.parents(node)", node: node) }.map do |parent|
+            self.class.new(driver, parent)
+          end
+        end
+
+        def property(name)
+          Cuprite.deprecation_warning("#{self.class}#property", "use node.native.node.property")
+          command { node.property(name) }
+        end
+
+        def attributes
+          Cuprite.deprecation_warning("#{self.class}#attributes")
+          JSON.parse(command(:getAttributes))
+        end
+
+        def description
+          Cuprite.deprecation_warning("#{self.class}#description", "use node.native.node.description")
+          node.description
+        end
+
+        def send_key(*keys)
+          Cuprite.deprecation_warning("#{self.class}#send_key", "use #send_keys")
+          send_keys(*keys)
+        end
+      end
+    end
+  end
+end

data/lib/capybara/cuprite/node/extensions.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Cuprite
+    class Node < Capybara::Driver::Node
+      module Extensions
+        def drag_by(x, y, steps: 1, delay: nil, scroll: true)
+          mouse = driver.browser.mouse
+
+          command do
+            x1, y1 = node.find_position
+            mouse.move(x: x1, y: y1)
+            mouse.down
+
+            sleep delay if delay
+
+            mouse.scroll_by(x, y) if scroll
+
+            x2, y2 = node.find_position
+            mouse.move(x: x2 + x, y: y2 + y, steps: steps)
+            mouse.up
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/cuprite/node.rb

@@ -1,45 +1,26 @@
 # frozen_string_literal: true
 
-require "forwardable"
+require "capybara/cuprite/finder"
+require "capybara/cuprite/node/deprecations"
+require "capybara/cuprite/node/extensions"
 
 module Capybara
   module Cuprite
     class Node < Capybara::Driver::Node
       attr_reader :node
 
-      extend Forwardable
-
-      delegate %i[description] => :node
-      delegate %i[browser] => :driver
+      include Deprecations
+      include Extensions
 
       DRAG_MODIFIER_ALIASES = { control: :ctrl, command: :meta, cmd: :meta }.freeze
+      DRAG_HTML5_JS = File.read(File.expand_path("javascripts/drag.js", __dir__))
+      TRIGGER_CLICK_WAIT = ENV.fetch("CUPRITE_TRIGGER_CLICK_WAIT", 0.1).to_f
 
       def initialize(driver, node)
         super(driver, self)
         @node = node
       end
 
-      def command(name, *args)
-        raise ObsoleteNode.new(self, nil) unless node.evaluate("this.isConnected")
-
-        browser.send(name, node, *args)
-      rescue Ferrum::NodeNotFoundError => e
-        raise ObsoleteNode.new(self, e.response)
-      rescue Ferrum::BrowserError => e
-        case e.message
-        when "Cuprite.MouseEventFailed"
-          raise MouseEventFailed.new(self, e.response)
-        else
-          raise
-        end
-      end
-
-      def parents
-        command(:parents).map do |parent|
-          self.class.new(driver, parent)
-        end
-      end
-
       def find_xpath(selector)
         find(:xpath, selector)
       end
@@ -48,26 +29,16 @@ module Capybara
         find(:css, selector)
       end
 
-      def find(method, selector)
-        command(:find_within, method, selector).map do |node|
-          self.class.new(driver, node)
-        end
-      end
-
       def all_text
-        filter_text(command(:all_text))
+        filter_text(command { node.text })
       end
 
       def visible_text
-        command(:visible_text).to_s
-                              .gsub(/\A[[:space:]&&[^\u00a0]]+/, "")
-                              .gsub(/[[:space:]&&[^\u00a0]]+\z/, "")
-                              .gsub(/\n+/, "\n")
-                              .tr("\u00a0", " ")
-      end
-
-      def property(name)
-        command(:property, name)
+        command(:visibleText).to_s
+                             .gsub(/\A[[:space:]&&[^\u00a0]]+/, "")
+                             .gsub(/[[:space:]&&[^\u00a0]]+\z/, "")
+                             .gsub(/\n+/, "\n")
+                             .tr("\u00a0", " ")
       end
 
       def [](name)
@@ -76,17 +47,13 @@ module Capybara
         if (tag_name == "img" && name == "src") ||
            (tag_name == "a" && name == "href")
           # if attribute exists get the property
-          return command(:attribute, name) && command(:property, name)
+          return command(:getAttribute, name) && command { node.property(name) }
         end
 
-        value = property(name)
-        value = command(:attribute, name) if value.nil? || value.is_a?(Hash)
-
-        value
-      end
-
-      def attributes
-        command(:attributes)
+        case (value = command { node.property(name) })
+        when String, Numeric, true, false then value
+        else command(:getAttribute, name)
+        end
       end
 
       def value
@@ -104,9 +71,9 @@ module Capybara
             click if value != checked?
           when "file"
             files = value.respond_to?(:to_ary) ? value.to_ary.map(&:to_s) : value.to_s
-            command(:select_file, files)
+            command { node.select_file(files) }
           when "color"
-            node.evaluate("this.setAttribute('value', '#{value}')")
+            node.evaluate("this.setAttribute('value', value)", value: value)
             node.evaluate("this.dispatchEvent(new InputEvent('input'))")
             node.evaluate("this.dispatchEvent(new Event('change', { bubbles: true }))")
           when "date"
@@ -130,7 +97,7 @@ module Capybara
         elsif tag_name == "textarea"
           command(:set, value.to_s)
         elsif self[:isContentEditable]
-          command(:delete_text)
+          command(:deleteText)
           click.type(value.to_s)
         end
       end
@@ -145,11 +112,11 @@ module Capybara
       end
 
       def tag_name
-        @tag_name ||= description["shadowRootType"] ? "ShadowRoot" : description["nodeName"].downcase
+        @tag_name ||= node.description["shadowRootType"] ? "ShadowRoot" : node.description["nodeName"].downcase
       end
 
       def visible?
-        command(:visible?)
+        command(:isVisible)
       end
 
       def checked?
@@ -161,7 +128,7 @@ module Capybara
       end
 
       def disabled?
-        command(:disabled?)
+        command(:isDisabled)
       end
 
       def click(keys = [], **options)
@@ -177,28 +144,43 @@ module Capybara
       end
 
       def hover
-        command(:hover)
+        command do
+          js(:scrollIntoViewport)
+          x, y = find_position
+          driver.browser.page.command("Input.dispatchMouseEvent", type: "mouseMoved", x: x, y: y)
+        end
       end
 
       def drag_to(other, **options)
+        raise ArgumentError, "You must specify both x: and y: for a drop offset" if options[:x].nil? ^ options[:y].nil?
+
         options[:steps] ||= 1
         options[:scroll] = true unless options.key?(:scroll)
+        options[:drop_offset] = drop_offset(*options.values_at(:x, :y, :offset))
         modifiers = Array(options[:drop_modifiers]).map { |m| DRAG_MODIFIER_ALIASES.fetch(m.to_sym, m.to_sym) }
 
-        command(:drag, other.node, modifiers, options.slice(:steps, :delay, :scroll, :html5))
+        command { drag(other.node, modifiers, options) }
       end
 
-      def drag_by(x, y, **options)
-        options[:steps] ||= 1
-        options[:scroll] = true unless options.key?(:scroll)
-
-        command(:drag_by, x, y, options[:steps], options[:delay], options[:scroll])
+      def drop(*args)
+        command do
+          if args[0].is_a?(String)
+            driver.browser.execute("_cuprite.attachDropInput()")
+            driver.browser.at_css("#_cuprite_drop_file").select_file(args)
+            js(:dropFile)
+          else
+            strings = args.flat_map { |arg| arg.map { |type, data| { "type" => type, "data" => data } } }
+            node.evaluate("_cuprite.dropString(strings, this)", strings: strings)
+          end
+        end
       end
 
-      def drop(...) = command(:drop, ...)
-
       def trigger(event)
-        command(:trigger, event)
+        command do
+          next js(:trigger, event.to_s) unless event.to_s == "click" && TRIGGER_CLICK_WAIT.positive?
+
+          driver.browser.wait_for_navigation!(TRIGGER_CLICK_WAIT) { js(:trigger, "click") }
+        end
       end
 
       def scroll_to(element, location, position = nil)
@@ -213,15 +195,7 @@ module Capybara
       end
 
       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
+        node.evaluate("this.scrollBy(x, y)", x: x, y: y)
       end
 
       def ==(other)
@@ -232,56 +206,121 @@ module Capybara
         keys = keys.reject { |key| key.nil? || key == "" }
         return if keys.empty?
 
-        command(:send_keys, keys)
+        command do
+          unless node.evaluate("_cuprite.containsSelection(this) || _cuprite.hasFocus(this)")
+            before_click("click")
+            node.click(mode: :left, keys: keys)
+          end
+
+          driver.browser.keyboard.type(keys)
+        end
       end
-      alias send_key send_keys
 
       def path
         command(:path)
       end
 
       def obscured?
-        command(:obscured?)
+        command(:isObscured)
       end
 
       def shadow_root
-        root = driver.evaluate_script <<~JS, self
-          arguments[0].shadowRoot
-        JS
-        root && self.class.new(driver, root.node)
+        root = driver.browser.evaluate("node.shadowRoot", node: node)
+        root && self.class.new(driver, root)
       end
 
       def rect
-        driver.evaluate_script <<~JS, self
-          arguments[0].getBoundingClientRect().toJSON()
-        JS
+        node.evaluate("this.getBoundingClientRect().toJSON()")
       end
 
       def inspect
         %(#<#{self.class} @node=#{@node.inspect}>)
       end
 
-      # @api private
-      def to_json(*)
-        JSON.generate(as_json)
-      end
+      private
 
-      # @api private
-      def as_json(*)
-        # FIXME: Where is this method used and why attr is called id?
-        { ELEMENT: { node: node, id: node.node_id } }
+      def find(method, selector)
+        command { Finder.find(driver.browser, method, selector, node) }.map do |node|
+          self.class.new(driver, node)
+        end
       end
 
-      private
+      def command(function = nil, *args)
+        raise ObsoleteNode.new(self, nil) unless node.evaluate("this.isConnected")
+
+        block_given? ? yield : js(function, *args)
+      rescue Ferrum::NodeNotFoundError => e
+        raise ObsoleteNode.new(self, e.response)
+      end
 
       def prepare_and_click(mode, name, keys, options)
         delay = options[:delay].to_i
         x, y = options.values_at(:x, :y)
         offset = { x: x, y: y, position: options[:offset] || :top }
-        command(:before_click, name, keys, offset)
+        command { before_click(name, offset) }
         node.click(mode: mode, keys: keys, offset: offset, delay: delay)
       end
 
+      def js(function, *args)
+        node.evaluate("_cuprite.#{function}(this, ...arguments)", *args)
+      end
+
+      def before_click(name, offset = {})
+        js(:scrollIntoViewport)
+
+        # If offset is given it may go outside of the element and likely error
+        # will be raised that we detected another element at this position.
+        return if offset[:x] || offset[:y]
+
+        x, y = find_position(**offset)
+        js(:mouseEventTest, name.to_s, x, y)
+      rescue Ferrum::JavaScriptError => e
+        raise MouseEventFailed, e.message if e.class_name == "MouseEventFailed"
+
+        raise
+      end
+
+      def find_position(**options)
+        node.find_position(**options)
+      rescue Ferrum::BrowserError => e
+        raise MouseEventFailed, "MouseEventFailed: click, none, 0, 0" if e.message == "Could not compute content quads."
+
+        raise
+      end
+
+      def drag(other, modifiers, options)
+        browser = driver.browser
+        delay, scroll, html5, drop_offset = options.values_at(:delay, :scroll, :html5, :drop_offset)
+        browser.execute("_cuprite.dragMousedownTracker()")
+
+        node.scroll_into_view if scroll
+        x1, y1 = node.find_position
+
+        browser.mouse.move(x: x1, y: y1)
+        browser.mouse.down
+        sleep delay if delay
+
+        html5 = !js(:legacyDragCheck) if html5.nil?
+
+        if html5
+          keys = modifiers.map(&:to_s)
+          driver.evaluate_async_script(DRAG_HTML5_JS, node, other, (delay || 0.05) * 1000, keys, drop_offset)
+          browser.mouse.up
+        else
+          other.scroll_into_view if scroll
+          x2, y2 = other.find_position(**drop_offset.to_h)
+
+          browser.keyboard.hold(*modifiers) { browser.mouse.move(x: x2, y: y2, steps: options[:steps]).up }
+        end
+      end
+
+      def drop_offset(x, y, position)
+        return unless x
+
+        position ||= driver.session_options.w3c_click_offset ? :center : :top
+        { x: x, y: y, position: position.to_sym }
+      end
+
       def filter_text(text)
         text.gsub(/[\u200b\u200e\u200f]/, "")
             .gsub(/[\ \n\f\t\v\u2028\u2029]+/, " ")
@@ -301,34 +340,19 @@ module Capybara
                       else
                         raise ArgumentError, "Invalid scroll_to location: #{location}"
                       end
-        driver.execute_script <<~JS, element
-          arguments[0].scrollIntoView(#{scroll_opts})
-        JS
+        element.node.evaluate("this.scrollIntoView(#{scroll_opts})")
       end
 
       def scroll_to_location(location)
         height = { top: "0",
-                   bottom: "arguments[0].scrollHeight",
-                   center: "(arguments[0].scrollHeight - arguments[0].clientHeight)/2" }
+                   bottom: "this.scrollHeight",
+                   center: "(this.scrollHeight - this.clientHeight) / 2" }
 
-        driver.execute_script <<~JS, self
-          if (arguments[0].scrollTo){
-            arguments[0].scrollTo(0, #{height[location]});
-          } else {
-            arguments[0].scrollTop = #{height[location]};
-          }
-        JS
+        node.evaluate("this.scrollTo(0, #{height[location]})")
       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
+        node.evaluate("this.scrollTo(x, y)", x: x, y: y)
       end
     end
   end

data/lib/capybara/cuprite/options.rb

@@ -6,6 +6,25 @@ module Ferrum
       attr_writer :window_size
       attr_accessor :url_blacklist, :url_whitelist, :raise_on_unhandled_modal
 
+      def mobile
+        @options.fetch(:mobile, nil)
+      end
+
+      def scale_factor
+        @options.fetch(:scale_factor, 0)
+      end
+
+      def device_user_agent
+        Capybara::Cuprite::Devices.fetch(@options[:emulate])[:user_agent] if @options[:emulate]
+      end
+
+      def default_user_agent
+        return @default_user_agent unless device_user_agent
+
+        chrome_version = @default_user_agent.to_s[%r{Chrome/(\S+)}, 1].to_s
+        format(device_user_agent, version: chrome_version)
+      end
+
       def reset_window_size
         @window_size = @options[:window_size]
       end

data/lib/capybara/cuprite/page/frames.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Capybara
+  module Cuprite
+    class Page < Ferrum::Page
+      module Frames
+        extend Forwardable
+
+        delegate %i[at_css at_xpath css xpath
+                    current_url current_title body execution_id execution_id!
+                    evaluate execute] => :active_frame
+
+        def initialize(...)
+          @frame_stack = []
+          super
+        end
+
+        def switch_to_frame(handle)
+          case handle
+          when :parent
+            @frame_stack.pop
+          when :top
+            @frame_stack = []
+          else
+            @frame_stack << handle
+          end
+        end
+
+        def title
+          active_frame.current_title
+        end
+
+        private
+
+        def active_frame
+          if @frame_stack.empty?
+            main_frame
+          else
+            @frames[@frame_stack.last]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capybara/cuprite/page/modals.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Cuprite
+    class Page < Ferrum::Page
+      module Modals
+        MODAL_WAIT = ENV.fetch("CUPRITE_MODAL_WAIT", 0.05).to_f
+
+        def initialize(...)
+          @accept_modal = []
+          @modal_messages = []
+          @modal_response = nil
+          @unhandled_modal_error = nil
+          super
+        end
+
+        # The `Page.javascriptDialogOpening` event is handled on Ferrum's
+        # background CDP dispatcher thread, so raising there wouldn't reach
+        # the caller and would permanently kill that thread instead. The
+        # dialog is always accepted immediately from that thread, and the
+        # error (if any) is stashed here to be raised from the main thread
+        # the next time it makes a command round trip.
+        def command(...)
+          raise_pending_unhandled_modal_error! { super }
+        end
+
+        def accept_confirm
+          @accept_modal << true
+        end
+
+        def dismiss_confirm
+          @accept_modal << false
+        end
+
+        def accept_prompt(modal_response)
+          @accept_modal << true
+          @modal_response = modal_response
+        end
+
+        def dismiss_prompt
+          @accept_modal << false
+        end
+
+        def find_modal(options)
+          start = Ferrum::Utils::ElapsedTime.monotonic_time
+          expect_text = options[:text]
+          expect_regexp = expect_text.is_a?(Regexp) ? expect_text : Regexp.escape(expect_text.to_s)
+          not_found_msg = "Unable to find modal dialog"
+          not_found_msg += " with #{expect_text}" if expect_text
+          wait = options.fetch(:wait, timeout)
+
+          begin
+            modal_text = @modal_messages.shift
+            raise Capybara::ModalNotFound if modal_text.nil? || (expect_text && !modal_text.match(expect_regexp))
+          rescue Capybara::ModalNotFound => e
+            raise e, not_found_msg if Ferrum::Utils::ElapsedTime.timeout?(start, wait)
+
+            sleep(MODAL_WAIT)
+            retry
+          end
+
+          modal_text
+        end
+
+        private
+
+        def raise_pending_unhandled_modal_error!
+          error = @unhandled_modal_error
+          @unhandled_modal_error = nil
+          raise error if error
+
+          yield
+        ensure
+          error = @unhandled_modal_error
+          @unhandled_modal_error = nil
+          raise error if error
+        end
+
+        def prepare_page
+          super
+          on("Page.javascriptDialogOpening") { |params| handle_javascript_dialog(params) }
+        end
+
+        def handle_javascript_dialog(params)
+          accept_modal = @accept_modal.last
+          unhandled_modal_error = nil
+
+          if [true, false].include?(accept_modal)
+            @accept_modal.pop
+            @modal_messages << params["message"]
+            options = { accept: accept_modal }
+            response = @modal_response || params["defaultPrompt"]
+          else
+            with_text = params["message"] ? "with text `#{params['message']}` " : ""
+            message = "Modal window #{with_text}has been opened, but you didn't wrap " \
+                      "your code into (`accept_prompt` | `dismiss_prompt` | " \
+                      "`accept_confirm` | `dismiss_confirm` | `accept_alert`), " \
+                      "accepting by default"
+
+            if @options.raise_on_unhandled_modal
+              unhandled_modal_error = UnhandledModalError.new(message)
+            else
+              warn message
+            end
+
+            options = { accept: true }
+            response = params["defaultPrompt"]
+          end
+          options.merge!(promptText: response) if response
+          # Skips #command so a pending error isn't raised on the dispatcher thread.
+          client.command("Page.handleJavaScriptDialog", timeout: timeout, **options)
+
+          @unhandled_modal_error = unhandled_modal_error if unhandled_modal_error
+        end
+      end
+    end
+  end
+end