ferrum 0.7 → 0.10.2

data/lib/ferrum/keyboard.rb

@@ -33,13 +33,13 @@ module Ferrum
     def down(key)
       key = normalize_keys(Array(key))
       type = key[:text] ? "keyDown" : "rawKeyDown"
-      @page.command("Input.dispatchKeyEvent", type: type, **key)
+      @page.command("Input.dispatchKeyEvent", slowmoable: true, type: type, **key)
       self
     end
 
     def up(key)
       key = normalize_keys(Array(key))
-      @page.command("Input.dispatchKeyEvent", type: "keyUp", **key)
+      @page.command("Input.dispatchKeyEvent", slowmoable: true, type: "keyUp", **key)
       self
     end
 
@@ -49,7 +49,7 @@ module Ferrum
       keys.each do |key|
         type = key[:text] ? "keyDown" : "rawKeyDown"
         @page.command("Input.dispatchKeyEvent", type: type, **key)
-        @page.command("Input.dispatchKeyEvent", type: "keyUp", **key)
+        @page.command("Input.dispatchKeyEvent", slowmoable: true, type: "keyUp", **key)
       end
 
       self

data/lib/ferrum/mouse.rb

@@ -32,10 +32,21 @@ module Ferrum
       tap { mouse_event(type: "mouseReleased", **options) }
     end
 
-    # FIXME: steps
     def move(x:, y:, steps: 1)
+      from_x, from_y = @x, @y
       @x, @y = x, y
-      @page.command("Input.dispatchMouseEvent", type: "mouseMoved", x: @x, y: @y)
+
+      steps.times do |i|
+        new_x = from_x + (@x - from_x) * ((i + 1) / steps.to_f)
+        new_y = from_y + (@y - from_y) * ((i + 1) / steps.to_f)
+
+        @page.command("Input.dispatchMouseEvent",
+                      slowmoable: true,
+                      type: "mouseMoved",
+                      x: new_x.to_i,
+                      y: new_y.to_i)
+      end
+
       self
     end
 
@@ -45,7 +56,7 @@ module Ferrum
       button = validate_button(button)
       options = { x: @x, y: @y, type: type, button: button, clickCount: count }
       options.merge!(modifiers: modifiers) if modifiers
-      @page.command("Input.dispatchMouseEvent", wait: wait, **options)
+      @page.command("Input.dispatchMouseEvent", wait: wait, slowmoable: true, **options)
     end
 
     def validate_button(button)

data/lib/ferrum/network.rb

@@ -83,19 +83,21 @@ module Ferrum
       @page.command("Fetch.enable", handleAuthRequests: true, patterns: [pattern])
     end
 
-    def authorize(user:, password:, type: :server)
+    def authorize(user:, password:, type: :server, &block)
       unless AUTHORIZE_TYPE.include?(type)
         raise ArgumentError, ":type should be in #{AUTHORIZE_TYPE}"
       end
 
+      if !block_given? && !@page.subscribed?("Fetch.requestPaused")
+        raise ArgumentError, "Block is missing, call `authorize(...) { |r| r.continue } or subscribe to `on(:request)` events before calling it"
+      end
+
       @authorized_ids ||= {}
       @authorized_ids[type] ||= []
 
       intercept
 
-      @page.on(:request) do |request|
-        request.continue
-      end
+      @page.on(:request, &block)
 
       @page.on(:auth) do |request, index, total|
         if request.auth_challenge?(type)
@@ -157,12 +159,27 @@ module Ferrum
         end
       end
 
+      @page.on("Network.loadingFailed") do |params|
+        exchange = select(params["requestId"]).last
+        exchange.error ||= Network::Error.new
+
+        exchange.error.id = params["requestId"]
+        exchange.error.type = params["type"]
+        exchange.error.error_text = params["errorText"]
+        exchange.error.monotonic_time = params["timestamp"]
+        exchange.error.canceled = params["canceled"]
+      end
+
       @page.on("Log.entryAdded") do |params|
         entry = params["entry"] || {}
         if entry["source"] == "network" && entry["level"] == "error"
           exchange = select(entry["networkRequestId"]).last
-          error = Network::Error.new(entry)
-          exchange.error = error
+          exchange.error ||= Network::Error.new
+
+          exchange.error.id = entry["networkRequestId"]
+          exchange.error.url = entry["url"]
+          exchange.error.description = entry["text"]
+          exchange.error.timestamp = entry["timestamp"]
         end
       end
     end

data/lib/ferrum/network/error.rb

@@ -3,24 +3,17 @@
 module Ferrum
   class Network
     class Error
-      def initialize(data)
-        @data = data
-      end
-
-      def id
-        @data["networkRequestId"]
-      end
-
-      def url
-        @data["url"]
-      end
+      attr_writer :canceled
+      attr_reader :time, :timestamp
+      attr_accessor :id, :url, :type, :error_text, :monotonic_time, :description
 
-      def description
-        @data["text"]
+      def canceled?
+        @canceled
       end
 
-      def time
-        @time ||= Time.strptime(@data["timestamp"].to_s, "%s")
+      def timestamp=(value)
+        @timestamp = value
+        @time = Time.strptime((value / 1000).to_s, "%s")
       end
     end
   end

data/lib/ferrum/network/intercepted_request.rb

@@ -39,7 +39,7 @@ module Ferrum
           requestId: request_id,
           responseHeaders: header_array(headers),
         })
-        options = options.merge(body: Base64.encode64(options.fetch(:body, "")).strip) if has_body
+        options = options.merge(body: Base64.strict_encode64(options.fetch(:body, ""))) if has_body
 
         @status = :responded
         @page.command("Fetch.fulfillRequest", **options)

data/lib/ferrum/node.rb

@@ -2,6 +2,9 @@
 
 module Ferrum
   class Node
+    MOVING_WAIT = ENV.fetch("FERRUM_NODE_MOVING_WAIT", 0.01).to_f
+    MOVING_ATTEMPTS = ENV.fetch("FERRUM_NODE_MOVING_ATTEMPTS", 50).to_i
+
     attr_reader :page, :target_id, :node_id, :description, :tag_name
 
     def initialize(frame, target_id, node_id, description)
@@ -24,7 +27,7 @@ module Ferrum
     end
 
     def focus
-      tap { page.command("DOM.focus", nodeId: node_id) }
+      tap { page.command("DOM.focus", slowmoable: true, nodeId: node_id) }
     end
 
     def blur
@@ -37,22 +40,23 @@ module Ferrum
 
     # mode: (:left | :right | :double)
     # keys: (:alt, (:ctrl | :control), (:meta | :command), :shift)
-    # offset: { :x, :y }
-    def click(mode: :left, keys: [], offset: {})
-      x, y = find_position(offset[:x], offset[:y])
+    # offset: { :x, :y, :position (:top | :center) }
+    def click(mode: :left, keys: [], offset: {}, delay: 0)
+      x, y = find_position(**offset)
       modifiers = page.keyboard.modifiers(keys)
 
       case mode
       when :right
         page.mouse.move(x: x, y: y)
         page.mouse.down(button: :right, modifiers: modifiers)
+        sleep(delay)
         page.mouse.up(button: :right, modifiers: modifiers)
       when :double
         page.mouse.move(x: x, y: y)
         page.mouse.down(modifiers: modifiers, count: 2)
         page.mouse.up(modifiers: modifiers, count: 2)
       when :left
-        page.mouse.click(x: x, y: y, modifiers: modifiers)
+        page.mouse.click(x: x, y: y, modifiers: modifiers, delay: delay)
       end
 
       self
@@ -63,7 +67,7 @@ module Ferrum
     end
 
     def select_file(value)
-      page.command("DOM.setFileInputFiles", nodeId: node_id, files: Array(value))
+      page.command("DOM.setFileInputFiles", slowmoable: true, nodeId: node_id, files: Array(value))
     end
 
     def at_xpath(selector)
@@ -119,35 +123,75 @@ module Ferrum
       %(#<#{self.class} @target_id=#{@target_id.inspect} @node_id=#{@node_id} @description=#{@description.inspect}>)
     end
 
-    def find_position(offset_x = nil, offset_y = nil)
-      quads = get_content_quads
-      offset_x, offset_y = offset_x.to_i, offset_y.to_i
+    def find_position(x: nil, y: nil, position: :top)
+      prev = get_content_quads
+
+      # FIXME: Case when a few quads returned
+      points = Ferrum.with_attempts(errors: NodeIsMovingError, max: MOVING_ATTEMPTS, wait: 0) do
+        sleep(MOVING_WAIT)
+        current = get_content_quads
+
+        if current != prev
+          error = NodeIsMovingError.new(self, prev, current)
+          prev = current
+          raise(error)
+        end
+
+        current
+      end.map { |q| to_points(q) }.first
+
+      get_position(points, x, y, position)
+    rescue Ferrum::BrowserError => e
+      return raise unless e.message&.include?("Could not compute content quads")
+
+      find_position_via_js
+    end
+
+    private
+
+    def find_position_via_js
+      [
+        evaluate("this.getBoundingClientRect().left + window.pageXOffset + (this.offsetWidth / 2)"), # x
+        evaluate("this.getBoundingClientRect().top + window.pageYOffset + (this.offsetHeight / 2)") # y
+      ]
+    end
 
-      if offset_x > 0 || offset_y > 0
-        point = quads.first
-        [point[:x] + offset_x, point[:y] + offset_y]
+    def get_content_quads
+      quads = page.command("DOM.getContentQuads", nodeId: node_id)["quads"]
+      raise "Node is either not visible or not an HTMLElement" if quads.size == 0
+      quads
+    end
+
+    def get_position(points, offset_x, offset_y, position)
+      x = y = nil
+
+      if offset_x && offset_y && position == :top
+        point = points.first
+        x = point[:x] + offset_x.to_i
+        y = point[:y] + offset_y.to_i
       else
-        x, y = quads.inject([0, 0]) do |memo, point|
+        x, y = points.inject([0, 0]) do |memo, point|
           [memo[0] + point[:x],
            memo[1] + point[:y]]
         end
-        [x / 4, y / 4]
+
+        x = x / 4
+        y = y / 4
       end
-    end
 
-    private
+      if offset_x && offset_y && position == :center
+        x = x + offset_x.to_i
+        y = y + offset_y.to_i
+      end
 
-    def get_content_quads
-      result = page.command("DOM.getContentQuads", nodeId: node_id)
-      raise "Node is either not visible or not an HTMLElement" if result["quads"].size == 0
+      [x, y]
+    end
 
-      # FIXME: Case when a few quads returned
-      result["quads"].map do |quad|
-        [{x: quad[0], y: quad[1]},
-         {x: quad[2], y: quad[3]},
-         {x: quad[4], y: quad[5]},
-         {x: quad[6], y: quad[7]}]
-      end.first
+    def to_points(quad)
+      [{x: quad[0], y: quad[1]},
+       {x: quad[2], y: quad[3]},
+       {x: quad[4], y: quad[5]},
+       {x: quad[6], y: quad[7]}]
     end
   end
 end

data/lib/ferrum/page.rb

@@ -31,8 +31,8 @@ module Ferrum
 
     extend Forwardable
     delegate %i[at_css at_xpath css xpath
-                current_url current_title url title body doctype
-                execution_id evaluate evaluate_on evaluate_async execute
+                current_url current_title url title body doctype set_content
+                execution_id evaluate evaluate_on evaluate_async execute evaluate_func
                 add_script_tag add_style_tag] => :main_frame
 
     include Frames, Screenshot
@@ -44,13 +44,14 @@ module Ferrum
 
     def initialize(target_id, browser)
       @frames = {}
+      @main_frame = Frame.new(nil, self)
       @target_id, @browser = target_id, browser
       @event = Event.new.tap(&:set)
 
       host = @browser.process.host
       port = @browser.process.port
       ws_url = "ws://#{host}:#{port}/devtools/page/#{@target_id}"
-      @client = Browser::Client.new(browser, ws_url, 1000)
+      @client = Browser::Client.new(browser, ws_url, id_starts_with: 1000)
 
       @mouse, @keyboard = Mouse.new(self), Keyboard.new(self)
       @headers, @cookies = Headers.new(self), Cookies.new(self)
@@ -64,7 +65,7 @@ module Ferrum
       @browser.timeout
     end
 
-    def goto(url = nil)
+    def go_to(url = nil)
       options = { url: combine_url!(url) }
       options.merge!(referrer: referrer) if referrer
       response = command("Page.navigate", wait: GOTO_WAIT, **options)
@@ -77,9 +78,12 @@ module Ferrum
       end
       response["frameId"]
     rescue TimeoutError
-      pendings = network.traffic.select(&:pending?).map { |e| e.request.url }
-      raise StatusError.new(options[:url], pendings) unless pendings.empty?
+      if @browser.pending_connection_errors
+        pendings = network.traffic.select(&:pending?).map { |e| e.request.url }
+        raise PendingConnectionsError.new(options[:url], pendings) unless pendings.empty?
+      end
     end
+    alias goto go_to
 
     def close
       @headers.clear
@@ -88,18 +92,16 @@ module Ferrum
     end
 
     def resize(width: nil, height: nil, fullscreen: false)
-      result = @browser.command("Browser.getWindowForTarget", targetId: @target_id)
-      @window_id, @bounds = result.values_at("windowId", "bounds")
-
       if fullscreen
         width, height = document_size
-        @browser.command("Browser.setWindowBounds", windowId: @window_id, bounds: { windowState: "fullscreen" })
+        set_window_bounds(windowState: "fullscreen")
       else
-        @browser.command("Browser.setWindowBounds", windowId: @window_id, bounds: { windowState: "normal" })
-        @browser.command("Browser.setWindowBounds", windowId: @window_id, bounds: { width: width, height: height, windowState: "normal" })
+        set_window_bounds(windowState: "normal")
+        set_window_bounds(width: width, height: height)
       end
 
-      command("Emulation.setDeviceMetricsOverride", width: width,
+      command("Emulation.setDeviceMetricsOverride", slowmoable: true,
+                                                    width: width,
                                                     height: height,
                                                     deviceScaleFactor: 1,
                                                     mobile: false,
@@ -107,10 +109,14 @@ module Ferrum
     end
 
     def refresh
-      command("Page.reload", wait: timeout)
+      command("Page.reload", wait: timeout, slowmoable: true)
     end
     alias_method :reload, :refresh
 
+    def stop
+      command("Page.stopLoading", slowmoable: true)
+    end
+
     def back
       history_navigate(delta: -1)
     end
@@ -119,15 +125,31 @@ module Ferrum
       history_navigate(delta: 1)
     end
 
+    def wait_for_reload(sec = 1)
+      @event.reset if @event.set?
+      @event.wait(sec)
+      @event.set
+    end
+
     def bypass_csp(value = true)
       enabled = !!value
       command("Page.setBypassCSP", enabled: enabled)
       enabled
     end
 
-    def command(method, wait: 0, **params)
+    def window_id
+      @browser.command("Browser.getWindowForTarget", targetId: @target_id)["windowId"]
+    end
+
+    def set_window_bounds(bounds = {})
+      @browser.command("Browser.setWindowBounds", windowId: window_id, bounds: bounds)
+    end
+
+    def command(method, wait: 0, slowmoable: false, **params)
       iteration = @event.reset if wait > 0
+      sleep(@browser.slowmo) if slowmoable && @browser.slowmo > 0
       result = @client.command(method, params)
+
       if wait > 0
         @event.wait(wait) # Wait a bit after command and check if iteration has
                           # changed which means there was some network event for
@@ -165,6 +187,10 @@ module Ferrum
       end
     end
 
+    def subscribed?(event)
+      @client.subscribed?(event)
+    end
+
     private
 
     def subscribe
@@ -236,7 +262,9 @@ module Ferrum
 
       if entry = entries[index + delta]
         # Potential wait because of network event
-        command("Page.navigateToHistoryEntry", wait: Mouse::CLICK_WAIT, entryId: entry["id"])
+        command("Page.navigateToHistoryEntry", wait: Mouse::CLICK_WAIT,
+                                               slowmoable: true,
+                                               entryId: entry["id"])
       end
     end
 
@@ -245,7 +273,7 @@ module Ferrum
       nil_or_relative = url.nil? || url.relative?
 
       if nil_or_relative && !@browser.base_url
-        raise "Set :base_url browser's option or use absolute url in `goto`, you passed: #{url_or_path}"
+        raise "Set :base_url browser's option or use absolute url in `go_to`, you passed: #{url_or_path}"
       end
 
       (nil_or_relative ? @browser.base_url.join(url.to_s) : url).to_s