cuprite 0.2.1 → 0.3.0

data/lib/capybara/cuprite/browser/input.rb

@@ -1,6 +1,27 @@
 module Capybara::Cuprite
   class Browser
     module Input
+      KEYS = JSON.parse(File.read(File.expand_path("../input.json", __FILE__)))
+      MODIFIERS = { "alt" => 1, "ctrl" => 2, "control" => 2, "meta" => 4, "command" => 4, "shift" => 8 }
+      KEYS_MAPPING = {
+        cancel: "Cancel", help: "Help", backspace: "Backspace", tab: "Tab",
+        clear: "Clear", return: "Enter", enter: "Enter", shift: "Shift",
+        ctrl: "Control", control: "Control", alt: "Alt", pause: "Pause",
+        escape: "Escape", space: "Space",  pageup: "PageUp", page_up: "PageUp",
+        pagedown: "PageDown", page_down: "PageDown", end: "End", home: "Home",
+        left: "ArrowLeft", up: "ArrowUp", right: "ArrowRight",
+        down: "ArrowDown", insert: "Insert", delete: "Delete",
+        semicolon: "Semicolon", equals: "Equal", numpad0: "Numpad0",
+        numpad1: "Numpad1", numpad2: "Numpad2", numpad3: "Numpad3",
+        numpad4: "Numpad4", numpad5: "Numpad5", numpad6: "Numpad6",
+        numpad7: "Numpad7", numpad8: "Numpad8", numpad9: "Numpad9",
+        multiply: "NumpadMultiply", add: "NumpadAdd",
+        separator: "NumpadDecimal", subtract: "NumpadSubtract",
+        decimal: "NumpadDecimal", divide: "NumpadDivide", f1: "F1", f2: "F2",
+        f3: "F3", f4: "F4", f5: "F5", f6: "F6", f7: "F7", f8: "F8", f9: "F9",
+        f10: "F10", f11: "F11", f12: "F12", meta: "Meta", command: "Meta",
+      }
+
       def click(node, keys = [], offset = {})
         x, y, modifiers = prepare_before_click(__method__, node, keys, offset)
         command("Input.dispatchMouseEvent", type: "mousePressed", modifiers: modifiers, button: "left", x: x, y: y, clickCount: 1)
@@ -59,21 +80,66 @@ module Capybara::Cuprite
       end
 
       def send_keys(node, keys)
+        keys = normalize_keys(Array(keys))
+
         click(node) if !evaluate_on(node: node, expr: %(_cuprite.containsSelection(this)))
 
-        keys.first.each_char do |char|
-          # Check puppeteer Input.js and USKeyboardLayout.js also send_keys and modifiers from poltergeist.
-          if /\n/.match?(char)
-            command("Input.insertText", text: char)
-            # command("Input.dispatchKeyEvent", type: "keyDown", code: "Enter", key: "Enter", text: "\r")
-            # command("Input.dispatchKeyEvent", type: "keyUp", code: "Enter", key: "Enter")
+        keys.each do |key|
+          type = key[:text] ? "keyDown" : "rawKeyDown"
+          command("Input.dispatchKeyEvent", type: type, **key)
+          command("Input.dispatchKeyEvent", type: "keyUp", **key)
+        end
+      end
+
+      def normalize_keys(keys, pressed_keys = [], memo = [])
+        case keys
+        when Array
+          pressed_keys.push([])
+          memo += combine_strings(keys).map { |k| normalize_keys(k, pressed_keys, memo) }
+          pressed_keys.pop
+          memo.flatten.compact
+        when Symbol
+          key = keys.to_s.downcase
+
+          if MODIFIERS.keys.include?(key)
+            pressed_keys.last.push(key)
+            nil
           else
-            command("Input.dispatchKeyEvent", type: "keyDown", text: char)
-            command("Input.dispatchKeyEvent", type: "keyUp", text: char)
+            _key = KEYS.fetch(KEYS_MAPPING[key.to_sym] || key.to_sym)
+            _key[:modifiers] = pressed_keys.flatten.map { |k| MODIFIERS[k] }.reduce(0, :|)
+            to_options(_key)
+          end
+        when String
+          pressed = pressed_keys.flatten
+          keys.each_char.map do |char|
+            if pressed.empty?
+              key = KEYS[char] || {}
+              key = key.merge(text: char, unmodifiedText: char)
+              [to_options(key)]
+            else
+              key = KEYS[char] || {}
+              text = pressed == ["shift"] ? char.upcase : char
+              key = key.merge(
+                text: text,
+                unmodifiedText: text,
+                isKeypad: key["location"] == 3,
+                modifiers: pressed.map { |k| MODIFIERS[k] }.reduce(0, :|),
+              )
+
+              modifiers = pressed.map { |k| to_options(KEYS.fetch(KEYS_MAPPING[k.to_sym])) }
+              modifiers + [to_options(key)]
+            end.flatten
           end
         end
       end
 
+      def combine_strings(keys)
+        keys
+          .chunk { |k| k.is_a?(String) }
+          .map { |s, k| s ? [k.reduce(&:+)] : k }
+          .reduce(&:+)
+      end
+
       private
 
       def prepare_before_click(name, node, keys, offset)
@@ -81,8 +147,7 @@ module Capybara::Cuprite
         x, y = calculate_quads(node, offset[:x], offset[:y])
         evaluate_on(node: node, expr: "_cuprite.mouseEventTest(this, '#{name}', #{x}, #{y})")
 
-        click_modifiers = { alt: 1, ctrl: 2, control: 2, meta: 4, command: 4, shift: 8 }
-        modifiers = keys.map { |k| click_modifiers[k.to_sym] }.compact.reduce(0, :|)
+        modifiers = keys.map { |k| MODIFIERS[k.to_s] }.compact.reduce(0, :|)
 
         command("Input.dispatchMouseEvent", type: "mouseMoved", x: x, y: y)
 
@@ -117,6 +182,10 @@ module Capybara::Cuprite
            {x: quad[6], y: quad[7]}]
         end.first
       end
+
+      def to_options(hash)
+        hash.inject({}) { |memo, (k, v)| memo.merge(k.to_sym => v) }
+      end
     end
   end
 end

data/lib/capybara/cuprite/browser/javascripts/index.js

@@ -10,6 +10,10 @@ const EVENTS = {
 }
 
 class Cuprite {
+  constructor() {
+    this._json = JSON; // In case someone overrides it like mootools
+  }
+
   find(method, selector, within = document) {
     try {
       let results = [];
@@ -386,7 +390,7 @@ class Cuprite {
       attrs[attr.name] = attr.value.replace("\n", "\\n");
     }
 
-    return JSON.stringify(attrs);
+    return this._json.stringify(attrs);
   }
 
   getAttribute(node, name) {
@@ -435,6 +439,15 @@ class Cuprite {
 
     return node.contains(selectedNode);
   }
+
+  isCyclic(object) {
+    try {
+      this._json.stringify(object);
+      return false;
+    } catch (e) {
+      return true;
+    }
+  }
 }
 
 window._cuprite = new Cuprite;

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

@@ -43,6 +43,8 @@ module Capybara::Cuprite
         @frames = {}
         @waiting_frames ||= Set.new
         @frame_stack = []
+        @accept_modal = []
+        @modal_messages = []
 
         begin
           @session_id = @browser.command("Target.attachToTarget", targetId: @target_id)["sessionId"]
@@ -72,7 +74,7 @@ module Capybara::Cuprite
         options = { url: url }
         options.merge!(referrer: referrer) if referrer
         response = command("Page.navigate", **options)
-        if response["errorText"] == "net::ERR_NAME_RESOLUTION_FAILED"
+        if %w[net::ERR_NAME_NOT_RESOLVED net::ERR_NAME_RESOLUTION_FAILED].include?(response["errorText"])
           raise StatusFailError, "url" => url
         end
         response["frameId"]
@@ -123,6 +125,49 @@ module Capybara::Cuprite
         go(1)
       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_time    = Time.now
+        timeout_sec   = options.fetch(:wait) { session_wait_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
+
+        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 (Time.now - start_time) >= timeout_sec
+          sleep(0.05)
+          retry
+        end
+
+        modal_text
+      end
+
+      def reset_modals
+        @accept_modal = []
+        @modal_response = nil
+        @modal_messages = []
+      end
+
       def command(*args)
         id = nil
 
@@ -151,6 +196,19 @@ module Capybara::Cuprite
           end
         end
 
+        @client.subscribe("Page.javascriptDialogOpening") do |params|
+          accept_modal = @accept_modal.last
+          if accept_modal == true || accept_modal == false
+            @accept_modal.pop
+            @modal_messages << params["message"]
+            options = { accept: accept_modal }
+            default = params["defaultPrompt"]
+            response = @modal_response || params["defaultPrompt"]
+            options.merge!(promptText: response) if response
+            @client.command("Page.handleJavaScriptDialog", **options)
+          end
+        end
+
         @client.subscribe("Page.windowOpen") do
           @browser.targets.refresh
           @mutex.try_lock

data/lib/capybara/cuprite/browser/process.rb

@@ -7,7 +7,7 @@ module Capybara::Cuprite
     class Process
       KILL_TIMEOUT = 2
 
-      BROWSER_PATH = ENV.fetch("BROWSER_PATH", "chrome")
+      BROWSER_PATH = ENV["BROWSER_PATH"]
       BROWSER_HOST = "127.0.0.1"
       BROWSER_PORT = "0"
 
@@ -25,7 +25,7 @@ module Capybara::Cuprite
         "disable-web-security" => nil,
       }.freeze
 
-      attr_reader :host, :port, :ws_url, :pid, :options
+      attr_reader :host, :port, :ws_url, :pid, :path, :options
 
       def self.start(*args)
         new(*args).tap(&:start)
@@ -54,15 +54,8 @@ module Capybara::Cuprite
 
       def initialize(options)
         @options = options.fetch(:browser, {})
-        exe = options[:path] || BROWSER_PATH
-        @path = Cliver.detect(exe)
 
-        unless @path
-          message = "Could not find an executable `#{exe}`. Try to make it " \
-                    "available on the PATH or set environment varible for " \
-                    "example BROWSER_PATH=\"/Applications/Chromium.app/Contents/MacOS/Chromium\""
-          raise Cliver::Dependency::NotFound.new(message)
-        end
+        detect_browser_path
 
         window_size = options.fetch(:window_size, [1024, 768])
         @options = @options.merge("window-size" => window_size.join(","))
@@ -106,6 +99,24 @@ module Capybara::Cuprite
         start
       end
 
+      def detect_browser_path
+        exe = @options[:path] || BROWSER_PATH
+        if RUBY_PLATFORM.include?('darwin')
+          exe ||= "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+          @path = exe if File.exist?(exe)
+        else
+          exe ||= "chrome"
+          @path = Cliver.detect(exe) || Cliver.detect("google-chrome")
+        end
+
+        unless @path
+          message = "Could not find an executable `#{exe}`. Try to make it " \
+                    "available on the PATH or set environment varible for " \
+                    "example BROWSER_PATH=\"/Applications/Chromium.app/Contents/MacOS/Chromium\""
+          raise Cliver::Dependency::NotFound.new(message)
+        end
+      end
+
       private
 
       def redirect_stdout(write_io)
@@ -130,26 +141,28 @@ module Capybara::Cuprite
         @pid = nil
       end
 
-      def parse_ws_url(read_io)
+      def parse_ws_url(read_io, timeout = 1)
         output = ""
-        attempts = 3
+        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        max_time = start + timeout
         regexp = /DevTools listening on (ws:\/\/.*)/
-        loop do
+        while (now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)) < max_time
           begin
             output += read_io.read_nonblock(512)
           rescue IO::WaitReadable
-            attempts -= 1
-            break if attempts <= 0
-            IO.select([read_io], nil, nil, 1)
-            retry
+            IO.select([read_io], nil, nil, max_time - now)
+          else
+            if output.match(regexp)
+              @ws_url = Addressable::URI.parse(output.match(regexp)[1])
+              @host = @ws_url.host
+              @port = @ws_url.port
+              break
+            end
           end
+        end
 
-          if output.match?(regexp)
-            @ws_url = Addressable::URI.parse(output.match(regexp)[1])
-            @host = @ws_url.host
-            @port = @ws_url.port
-            break
-          end
+        unless @ws_url
+          raise "Chrome process did not produce websocket url within #{timeout} seconds"
         end
       end
 

data/lib/capybara/cuprite/browser/runtime.rb

@@ -108,7 +108,7 @@ module Capybara::Cuprite
         end
       end
 
-      def handle(response, cleanup = true)
+      def handle(response)
         case response["type"]
         when "boolean", "number", "string"
           response["value"]
@@ -117,15 +117,17 @@ module Capybara::Cuprite
         when "function"
           {}
         when "object"
+          object_id = response["objectId"]
+
           case response["subtype"]
           when "node"
-            node_id = command("DOM.requestNode", objectId: response["objectId"])["nodeId"]
-            node = command("DOM.describeNode", nodeId: node_id)["node"]
-            { "target_id" => target_id, "node" => node.merge("nodeId" => node_id) }
+            node_id = command("DOM.requestNode", objectId: object_id)["nodeId"]
+            node = command("DOM.describeNode", nodeId: node_id)["node"].merge("nodeId" => node_id)
+            { "target_id" => target_id, "node" => node }
           when "array"
-            reduce_properties(response["objectId"], Array.new) do |memo, key, value|
+            reduce_props(object_id, []) do |memo, key, value|
               next(memo) unless (Integer(key) rescue nil)
-              value = value["objectId"] ? handle(value, false) : value["value"]
+              value = value["objectId"] ? handle(value) : value["value"]
               memo.insert(key.to_i, value)
             end
           when "date"
@@ -133,61 +135,31 @@ module Capybara::Cuprite
           when "null"
             nil
           else
-            reduce_properties(response["objectId"], Hash.new) do |memo, key, value|
-              value = value["objectId"] ? handle(value, false) : value["value"]
+            reduce_props(object_id, {}) do |memo, key, value|
+              value = value["objectId"] ? handle(value) : value["value"]
               memo.merge(key => value)
             end
           end
         end
-      ensure
-        clean if cleanup
       end
 
-      def reduce_properties(object_id, object)
-        if visited?(object_id)
-          "(cyclic structure)"
+      def reduce_props(object_id, to)
+        if cyclic?(object_id).dig("result", "value")
+          return "(cyclic structure)"
         else
-          properties(object_id).reduce(object) do |memo, prop|
+          props = command("Runtime.getProperties", objectId: object_id)
+          props["result"].reduce(to) do |memo, prop|
             next(memo) unless prop["enumerable"]
             yield(memo, prop["name"], prop["value"])
           end
         end
       end
 
-      def properties(object_id)
-        command("Runtime.getProperties", objectId: object_id)["result"]
-      end
-
-      # Every `Runtime.getProperties` call on the same object returns new object
-      # id each time {"objectId":"{\"injectedScriptId\":1,\"id\":1}"} and it's
-      # impossible to check that two objects are actually equal. This workaround
-      # does equality check only in JS runtime. `_cuprite` can be inavailable here
-      # if page is about:blank for example.
-      def visited?(object_id)
-        expr = %Q(
-          let object = arguments[0];
-          let callback = arguments[1];
-
-          if (window._cupriteVisitedObjects === undefined) {
-            window._cupriteVisitedObjects = [];
-          }
-
-          let visited = window._cupriteVisitedObjects;
-          if (visited.some(o => o === object)) {
-            callback(true);
-          } else {
-            visited.push(object);
-            callback(false);
-          }
-        )
-
-        # FIXME: Is there a way we can use wait_time here?
-        response = call(expr, 5, EVALUATE_ASYNC_OPTIONS, { "objectId" => object_id })
-        handle(response, false)
-      end
-
-      def clean
-        execute("delete window._cupriteVisitedObjects")
+      def cyclic?(object_id)
+        command("Runtime.callFunctionOn",
+                objectId: object_id,
+                returnByValue: true,
+                functionDeclaration: "function() { return _cuprite.isCyclic(this); }")
       end
     end
   end