cuprite 0.6.0 → 0.7.1

data/lib/capybara/cuprite/driver.rb

@@ -1,21 +1,31 @@
 # frozen_string_literal: true
 
 require "uri"
-
 require "forwardable"
 
 module Capybara::Cuprite
   class Driver < Capybara::Driver::Base
+    DEFAULT_MAXIMIZE_SCREEN_SIZE = [1366, 768].freeze
+    EXTENSION = File.expand_path("javascripts/index.js", __dir__)
+
     extend Forwardable
 
     delegate %i(restart quit status_code timeout timeout=) => :browser
 
-    attr_reader :app, :options
+    attr_reader :app, :options, :screen_size
 
     def initialize(app, options = {})
       @app     = app
-      @options = options
+      @options = options.dup
       @started = false
+
+      @options[:extensions] ||= []
+      @options[:extensions] << EXTENSION
+
+      @screen_size = @options.delete(:screen_size)
+      @screen_size ||= DEFAULT_MAXIMIZE_SCREEN_SIZE
+
+      @options[:save_path] = Capybara.save_path.to_s if Capybara.save_path
     end
 
     def needs_server?
@@ -23,7 +33,7 @@ module Capybara::Cuprite
     end
 
     def browser
-      @browser ||= Browser.start(@options)
+      @browser ||= Browser.new(@options)
     end
 
     def visit(url)
@@ -64,20 +74,20 @@ module Capybara::Cuprite
       browser.frame_title
     end
 
-    def find(method, selector)
-      browser.find(method, selector).map { |target_id, node| Node.new(self, target_id, node) }
-    end
-
     def find_xpath(selector)
-      find :xpath, selector
+      find(:xpath, selector)
     end
 
     def find_css(selector)
-      find :css, selector
+      find(:css, selector)
+    end
+
+    def find(method, selector)
+      browser.find(method, selector).map { |native| Node.new(self, native) }
     end
 
     def click(x, y)
-      browser.click_coordinates(x, y)
+      browser.mouse.click(x: x, y: y)
     end
 
     def evaluate_script(script, *args)
@@ -96,7 +106,14 @@ module Capybara::Cuprite
     end
 
     def switch_to_frame(locator)
-      browser.switch_to_frame(locator)
+      handle = case locator
+      when Capybara::Node::Element
+        locator.native.description["frameId"]
+      when :parent, :top
+        locator
+      end
+
+      browser.switch_to_frame(handle)
     end
 
     def current_window_handle
@@ -124,31 +141,47 @@ module Capybara::Cuprite
     end
 
     def no_such_window_error
-      NoSuchWindowError
+      Ferrum::NoSuchWindowError
     end
 
     def reset!
-      browser.reset
+      @zoom_factor = nil
+      @paper_size = nil
       browser.url_blacklist = @options[:url_blacklist]
       browser.url_whitelist = @options[:url_whitelist]
+      browser.reset
       @started = false
     end
 
     def save_screenshot(path, options = {})
-      browser.render(path, options)
+      options[:scale] = @zoom_factor if @zoom_factor
+
+      if pdf?(path, options)
+        options[:paperWidth] = @paper_size[:width].to_f if @paper_size
+        options[:paperHeight] = @paper_size[:height].to_f if @paper_size
+        browser.pdf(path: path, **options)
+      else
+        browser.screenshot(path: path, **options)
+      end
     end
     alias_method :render, :save_screenshot
 
     def render_base64(format = :png, options = {})
-      browser.render_base64(format, options)
+      if pdf?(nil, options)
+        options[:paperWidth] = @paper_size[:width].to_f if @paper_size
+        options[:paperHeight] = @paper_size[:height].to_f if @paper_size
+        browser.pdf(encoding: :base64, **options)
+      else
+        browser.screenshot(format: format, encoding: :base64, **options)
+      end
     end
 
-    def paper_size=(size = {})
-      browser.set_paper_size(size)
+    def zoom_factor=(value)
+      @zoom_factor = value.to_f
     end
 
-    def zoom_factor=(zoom_factor)
-      browser.set_zoom_factor(zoom_factor)
+    def paper_size=(value)
+      @paper_size = value
     end
 
     def resize(width, height)
@@ -179,15 +212,25 @@ module Capybara::Cuprite
     end
 
     def scroll_to(left, top)
-      browser.scroll_to(left, top)
+      browser.mouse.scroll_to(left, top)
     end
 
     def network_traffic(type = nil)
-      browser.network_traffic(type)
+      traffic = browser.network.traffic
+
+      case type.to_s
+      when "all"
+        traffic
+      when "blocked"
+        traffic.select(&:blocked?)
+      else
+        # when request isn't blocked
+        traffic.reject(&:blocked?)
+      end
     end
 
     def clear_network_traffic
-      browser.clear_network_traffic
+      browser.network.clear(:traffic)
     end
 
     def set_proxy(ip, port, type = nil, user = nil, password = nil, bypass = nil)
@@ -195,31 +238,31 @@ module Capybara::Cuprite
       server = type ? "#{type}=#{ip}:#{port}" : "#{ip}:#{port}"
       @options[:browser_options].merge!("proxy-server" => server)
       @options[:browser_options].merge!("proxy-bypass-list" => bypass) if bypass
-      browser.proxy_authorize(user, password)
+      browser.network.authorize(type: :proxy, user: user, password: password)
     end
 
     def headers
-      browser.headers
+      browser.headers.get
     end
 
     def headers=(headers)
-      browser.headers=(headers)
+      browser.headers.set(headers)
     end
 
     def add_headers(headers)
-      browser.add_headers(headers)
+      browser.headers.add(headers)
     end
 
     def add_header(name, value, permanent: true)
-      browser.add_header({ name => value }, permanent: permanent)
+      browser.headers.add({ name => value }, permanent: permanent)
     end
 
     def response_headers
-      browser.response_headers
+      browser.network.response&.headers
     end
 
     def cookies
-      browser.cookies
+      browser.cookies.all
     end
 
     def set_cookie(name, value, options = {})
@@ -227,31 +270,37 @@ module Capybara::Cuprite
       options[:name]   ||= name
       options[:value]  ||= value
       options[:domain] ||= default_domain
-
-      expires = options.delete(:expires).to_i
-      options[:expires] = expires if expires > 0
-
-      browser.set_cookie(options)
+      browser.cookies.set(**options)
     end
 
     def remove_cookie(name, **options)
       options[:domain] = default_domain if options.empty?
-      browser.remove_cookie(options.merge(name: name))
+      browser.cookies.remove(**options.merge(name: name))
     end
 
     def clear_cookies
-      browser.clear_cookies
+      browser.cookies.clear
     end
 
     def clear_memory_cache
-      browser.clear_memory_cache
+      browser.network.clear(:cache)
     end
 
     def basic_authorize(user, password)
-      browser.authorize(user, password)
+      browser.network.authorize(user: user, password: password)
     end
     alias_method :authorize, :basic_authorize
 
+    def debug
+      if @options[:inspector]
+        Process.spawn(browser.process.path, "http://#{browser.process.host}:#{browser.process.port}")
+        pause
+      else
+        raise Error, "To use the remote debugging, you have to launch " \
+                     "the driver with `inspector: true` configuration option"
+      end
+    end
+
     def pause
       # STDIN is not necessarily connected to a keyboard. It might even be closed.
       # So we need a method other than keypress to continue.
@@ -284,15 +333,17 @@ module Capybara::Cuprite
     end
 
     def invalid_element_errors
-      [Capybara::Cuprite::ObsoleteNode, Capybara::Cuprite::MouseEventFailed]
+      [Capybara::Cuprite::ObsoleteNode,
+       Capybara::Cuprite::MouseEventFailed,
+       Ferrum::NoExecutionContextError]
     end
 
     def go_back
-      browser.go_back
+      browser.back
     end
 
     def go_forward
-      browser.go_forward
+      browser.forward
     end
 
     def refresh
@@ -336,11 +387,7 @@ module Capybara::Cuprite
     end
 
     def native_args(args)
-      args.map { |arg| arg.is_a?(Capybara::Cuprite::Node) ? arg.native : arg }
-    end
-
-    def screen_size
-      @options[:screen_size] || [1366, 768]
+      args.map { |arg| arg.is_a?(Capybara::Cuprite::Node) ? arg.node : arg }
     end
 
     def session_wait_time
@@ -368,11 +415,17 @@ module Capybara::Cuprite
       when Array
         arg.map { |e| unwrap_script_result(e) }
       when Hash
-        return Capybara::Cuprite::Node.new(self, arg["target_id"], arg["node"]) if arg["target_id"]
         arg.each { |k, v| arg[k] = unwrap_script_result(v) }
+      when Ferrum::Node
+        Node.new(self, arg)
       else
         arg
       end
     end
+
+    def pdf?(path, options)
+      (path && File.extname(path).delete(".") == "pdf") ||
+      options[:format].to_s == "pdf"
+    end
   end
 end

data/lib/capybara/cuprite/errors.rb

@@ -3,7 +3,6 @@
 module Capybara
   module Cuprite
     class Error < StandardError; end
-    class NoSuchWindowError < Error; end
 
     class ClientError < Error
       attr_reader :response
@@ -13,45 +12,6 @@ module Capybara
       end
     end
 
-    class BrowserError < ClientError
-      def code
-        response["code"]
-      end
-
-      def data
-        response["data"]
-      end
-
-      def message
-        response["message"]
-      end
-    end
-
-    class JavaScriptError < ClientError
-      attr_reader :class_name, :message
-
-      def initialize(response)
-        super
-        @class_name, @message = response.values_at("className", "description")
-      end
-    end
-
-    class StatusFailError < ClientError
-      def message
-        "Request to #{response["url"]} failed to reach server, check DNS and/or server status"
-      end
-    end
-
-    class FrameNotFound < ClientError
-      def name
-        response["args"].first
-      end
-
-      def message
-        "The frame "#{name}" was not found."
-      end
-    end
-
     class InvalidSelector < ClientError
       def initialize(response, method, selector)
         super(response)
@@ -82,16 +42,14 @@ module Capybara
       end
     end
 
-    class NodeError < ClientError
+    class ObsoleteNode < ClientError
       attr_reader :node
 
       def initialize(node, response)
         @node = node
         super(response)
       end
-    end
 
-    class ObsoleteNode < NodeError
       def message
         "The element you are trying to interact with is either not part of the DOM, or is " \
         "not currently visible on the page (perhaps display: none is set). " \
@@ -100,26 +58,5 @@ module Capybara
         "new element."
       end
     end
-
-    class TimeoutError < Error
-      def message
-        "Timed out waiting for response. It's possible that this happened " \
-        "because something took a very long time (for example a page load " \
-        "was slow). If so, setting the Cuprite :timeout option to a higher " \
-        "value might help."
-      end
-    end
-
-    class ScriptTimeoutError < Error
-      def message
-        "Timed out waiting for evaluated script to resturn a value"
-      end
-    end
-
-    class DeadBrowser < Error
-      def initialize(message = "Chrome is dead")
-        super
-      end
-    end
   end
 end

data/lib/capybara/cuprite/{browser/javascripts → javascripts}/index.js

@@ -123,13 +123,17 @@ class Cuprite {
       value = value.substr(0, node.maxLength);
     }
 
+    let valueBefore = node.value;
+
     this.trigger(node, "focus");
     this.setValue(node, "");
 
     if (node.type == "number" || node.type == "date") {
       this.setValue(node, value);
+      this.input(node);
     } else if (node.type == "time") {
       this.setValue(node, new Date(value).toTimeString().split(" ")[0]);
+      this.input(node);
     } else if (node.type == "datetime-local") {
       value = new Date(value);
       let year = value.getFullYear();
@@ -139,20 +143,29 @@ class Cuprite {
       let min = ("0" + value.getMinutes()).slice(-2);
       let sec = ("0" + value.getSeconds()).slice(-2);
       this.setValue(node, `${year}-${month}-${date}T${hour}:${min}:${sec}`);
+      this.input(node);
     } else {
       for (let i = 0; i < value.length; i++) {
         let char = value[i];
         let keyCode = this.characterToKeyCode(char);
-        this.keyupdowned(node, "keydown", keyCode);
-        this.setValue(node, node.value + char);
+        // call the following functions in order, if one returns false (preventDefault),
+        // stop the call chain
+        [
+          () => this.keyupdowned(node, "keydown", keyCode),
+          () => this.keypressed(node, false, false, false, false, char.charCodeAt(0), char.charCodeAt(0)),
+          () => {
+            this.setValue(node, node.value + char)
+            this.input(node)
+          }
+        ].some(fn => fn())
 
-        this.keypressed(node, false, false, false, false, char.charCodeAt(0), char.charCodeAt(0));
         this.keyupdowned(node, "keyup", keyCode);
       }
     }
 
-    this.changed(node);
-    this.input(node);
+    if (valueBefore !== node.value) {
+      this.changed(node);
+    }
     this.trigger(node, "blur");
   }
 
@@ -172,14 +185,20 @@ class Cuprite {
     node.dispatchEvent(event);
   }
 
+  /**
+   * @return {boolean} false when an event handler called preventDefault()
+   */
   keyupdowned(node, eventName, keyCode) {
     let event = document.createEvent("UIEvents");
     event.initEvent(eventName, true, true);
     event.keyCode  = keyCode;
     event.charCode = 0;
-    node.dispatchEvent(event);
+    return !node.dispatchEvent(event);
   }
 
+  /**
+   * @return {boolean} false when an event handler called preventDefault()
+   */
   keypressed(node, altKey, ctrlKey, shiftKey, metaKey, keyCode, charCode) {
     event = document.createEvent("UIEvents");
     event.initEvent("keypress", true, true);
@@ -190,7 +209,7 @@ class Cuprite {
     event.metaKey  = metaKey;
     event.keyCode  = keyCode;
     event.charCode = charCode;
-    node.dispatchEvent(event);
+    return !node.dispatchEvent(event);
   }
 
   characterToKeyCode(char) {
@@ -450,19 +469,6 @@ class Cuprite {
     return node.contains(selectedNode);
   }
 
-  isCyclic(object) {
-    if (Array.isArray(object) && object.every(n => n instanceof Node)) {
-      return false;
-    }
-
-    try {
-      this._json.stringify(object);
-      return false;
-    } catch (e) {
-      return true;
-    }
-  }
-
   // This command is purely for testing error handling
   browserError() {
     throw new Error("zomg");

data/lib/capybara/cuprite/node.rb

@@ -1,24 +1,27 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module Capybara::Cuprite
   class Node < Capybara::Driver::Node
-    attr_reader :target_id, :node
+    attr_reader :node
 
-    def initialize(driver, target_id, node)
-      super(driver, self)
-      @target_id, @node = target_id, node
-    end
+    extend Forwardable
 
-    def browser
-      driver.browser
+    delegate %i(description) => :node
+    delegate %i(browser) => :driver
+
+    def initialize(driver, node)
+      super(driver, self)
+      @node = node
     end
 
     def command(name, *args)
-      browser.send(name, @node, *args)
-    rescue BrowserError => e
+      browser.send(name, node, *args)
+    rescue Ferrum::NodeNotFoundError => e
+      raise ObsoleteNode.new(self, e.response)
+    rescue Ferrum::BrowserError => e
       case e.message
-      when "No node with given id found"
-        raise ObsoleteNode.new(self, e.response)
       when "Cuprite.MouseEventFailed"
         raise MouseEventFailed.new(self, e.response)
       else
@@ -28,13 +31,7 @@ module Capybara::Cuprite
 
     def parents
       command(:parents).map do |parent|
-        self.class.new(driver, parent["target_id"], parent["node"])
-      end
-    end
-
-    def find(method, selector)
-      command(:find_within, method, selector).map do |node|
-        self.class.new(driver, @target_id, node)
+        self.class.new(driver, parent)
       end
     end
 
@@ -46,6 +43,12 @@ module Capybara::Cuprite
       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))
     end
@@ -69,7 +72,8 @@ module Capybara::Cuprite
     def [](name)
       # Although the attribute matters, the property is consistent. Return that in
       # preference to the attribute for links and images.
-      if ((tag_name == "img") && (name == "src")) || ((tag_name == "a") && (name == "href"))
+      if (tag_name == "img" && name == "src") ||
+         (tag_name == "a" && name == "href")
         # if attribute exists get the property
         return command(:attribute, name) && command(:property, name)
       end
@@ -121,7 +125,7 @@ module Capybara::Cuprite
     end
 
     def tag_name
-      @tag_name ||= @node["nodeName"].downcase
+      @tag_name ||= description["nodeName"].downcase
     end
 
     def visible?
@@ -141,15 +145,15 @@ module Capybara::Cuprite
     end
 
     def click(keys = [], offset = {})
-      command(:click, keys, offset)
+      prepare_and_click(:left, __method__, keys, offset)
     end
 
     def right_click(keys = [], offset = {})
-      command(:right_click, keys, offset)
+      prepare_and_click(:right, __method__, keys, offset)
     end
 
     def double_click(keys = [], offset = {})
-      command(:double_click, keys, offset)
+      prepare_and_click(:double, __method__, keys, offset)
     end
 
     def hover
@@ -157,7 +161,7 @@ module Capybara::Cuprite
     end
 
     def drag_to(other)
-      command(:drag, other.node)
+      command(:drag, other)
     end
 
     def drag_by(x, y)
@@ -192,10 +196,7 @@ module Capybara::Cuprite
     end
 
     def ==(other)
-      # We compare backendNodeId because once nodeId is sent to frontend backend
-      # never returns same nodeId sending 0. In other words frontend is
-      # responsible for keeping track of node ids.
-      @target_id == other.target_id && @node["backendNodeId"] == other.node["backendNodeId"]
+      node == other.native.node
     end
 
     def send_keys(*keys)
@@ -208,7 +209,7 @@ module Capybara::Cuprite
     end
 
     def inspect
-      %(#<#{self.class} @target_id=#{@target_id.inspect} @node=#{@node.inspect}>)
+      %(#<#{self.class} @node=#{@node.inspect}>)
     end
 
     # @api private
@@ -218,12 +219,17 @@ module Capybara::Cuprite
 
     # @api private
     def as_json(*)
-      # FIXME: Where this method is used and why attr is called id?
-      { ELEMENT: { target_id: @target_id, id: @node } }
+      # FIXME: Where is this method used and why attr is called id?
+      { ELEMENT: { node: node, id: node.node_id } }
     end
 
     private
 
+    def prepare_and_click(mode, name, keys, offset)
+      command(:before_click, name, keys, offset)
+      node.click(mode: mode, keys: keys, offset: offset)
+    end
+
     def filter_text(text)
       if Capybara::VERSION.to_f < 3
         Capybara::Helpers.normalize_whitespace(text.to_s)