capybara-chrome 0.1.22

data/lib/capybara/chrome/rdp_client.rb

@@ -0,0 +1,204 @@
+module Capybara::Chrome
+
+  # Chrome Remote Debugging Protocol (RDP) Client
+  class RDPClient
+    require "open-uri"
+
+    include Debug
+
+    attr_reader :response_events, :response_messages, :loader_ids, :listen_mutex, :handler_calls, :ws, :handlers, :browser
+
+    def initialize(chrome_host:, chrome_port:, browser:)
+      @chrome_host = chrome_host
+      @chrome_port = chrome_port
+      @browser = browser
+      @last_id = 0
+      @ws = nil
+      @ws_thread = nil
+      @ws_mutex = Mutex.new
+      @handlers = Hash.new { |hash, key| hash[key] = [] }
+      @listen_mutex = Mutex.new
+      @response_messages = {}
+      @response_events = []
+      @read_mutex = Mutex.new
+      @handler_mutex = Mutex.new
+      @loader_ids = []
+      @handler_calls = []
+    end
+
+    def reset
+      @calling_handlers = false
+      response_messages.clear
+      response_events.clear
+      loader_ids.clear
+    end
+
+    def generate_unique_id
+      @last_id += 1
+    end
+
+    def send_cmd!(command, params={})
+      debug command, params
+      msg_id = generate_unique_id
+      send_msg({method: command, params: params, id: msg_id}.to_json)
+      msg_id
+    end
+
+    # Errno::EPIPE
+    def send_cmd(command, params={})
+      msg_id = send_cmd!(command, params)
+
+      debug "waiting #{command} #{msg_id}"
+      msg = nil
+      begin
+        until msg = @response_messages[msg_id]
+          read_and_process(1)
+        end
+        @response_messages.delete msg_id
+      rescue Timeout::Error
+        puts "TimeoutError #{command} #{params.inspect} #{msg_id}"
+        send_cmd! "Runtime.terminateExecution"
+        puts "Recovering"
+        recover_chrome_crash
+        raise ResponseTimeoutError
+      rescue WebSocketError => e
+        puts "send_cmd received websocket error #{e.inspect}"
+        recover_chrome_crash
+        raise e
+      rescue Errno::EPIPE, EOFError => e
+        puts "send_cmd received EPIPE or EOF error #{e.inspect}"
+        recover_chrome_crash
+        raise e
+      rescue => e
+        puts "send_cmd caught error #{e.inspect} when issuing #{command} #{params.inspect}"
+        puts caller
+        raise e
+      end
+      return msg["result"]
+    end
+
+    def recover_chrome_crash
+      $stderr.puts "Chrome Crashed... #{Capybara::Chrome.wants_to_quit.inspect} #{::RSpec.wants_to_quit.inspect}" unless Capybara::Chrome.wants_to_quit
+      browser.restart_chrome
+      browser.start_remote
+    end
+
+    def send_msg(msg)
+      retries ||= 0
+      ws.send_msg(msg)
+    rescue Errno::EPIPE, EOFError => exception
+      retries += 1
+      recover_chrome_crash
+      if retries < 5 && !::Capybara::Chrome.wants_to_quit
+        retry
+      else
+        raise exception
+      end
+    end
+
+    def on(event_name, &block)
+      handlers[event_name] << block
+    end
+
+    def wait_for(event_name, timeout=Capybara.default_max_wait_time)
+      @response_events.clear
+      msg = nil
+      loop do
+        msgs = @response_events.select {|v| v["method"] == event_name}
+        if msgs.any?
+          if block_given?
+            do_return = msgs.detect do |m|
+              val = yield m["params"]
+            end
+            if do_return
+              msg = do_return.dup
+              @response_events.delete do_return
+              break
+            else
+              read_and_process(1)
+              next
+            end
+          else
+            msg = msgs.first.dup
+            msgs.each {|m| @response_events.delete m}
+            break
+          end
+        else
+        end
+        read_and_process(1)
+      end
+      return msg && msg["params"]
+    rescue Timeout::Error
+      nil
+    end
+
+    def process_messages
+      n = 0
+      while @ws.messages.any? do
+        n += 1
+        msg_raw = @ws.messages.shift
+        if msg_raw
+          msg = JSON.parse(msg_raw)
+          if msg["method"]
+            hs = handlers[msg["method"]]
+            if hs.any?
+              @handler_calls << [msg["method"], msg["params"]]
+            end
+            @response_events << msg
+          else
+            @response_messages[msg["id"]] = msg
+            if msg["exceptionDetails"]
+              puts JSException.new(val["exceptionDetails"]["exception"].inspect)
+            end
+          end
+        else
+          p ["no msg_raw", msg_raw]
+        end
+      end
+      n
+    end
+
+    def read_and_process(timeout=0)
+      return unless Thread.current == Thread.main
+      ready = select [@ws.socket.io], [], [], timeout
+      if ready
+        @ws.parse_input
+        process_messages
+      end
+      if !@calling_handlers
+        @calling_handlers = true
+        while obj = @handler_calls.shift do
+          handlers[obj[0]].each {|h| h.call obj[1]}
+        end
+        @calling_handlers = false
+      end
+    end
+
+    def discover_ws_url
+      response = open("http://#{@chrome_host}:#{@chrome_port}/json")
+      data = JSON.parse(response.read)
+      first_page = data.detect {|e| e["type"] == "page"}
+      @ws_url = first_page["webSocketDebuggerUrl"]
+    end
+
+    def start
+      browser.wait_for_chrome
+      browser.with_retry do
+        discover_ws_url
+      end
+      @ws = RDPWebSocketClient.new @ws_url
+      send_cmd! "Network.enable"
+      send_cmd! "Network.clearBrowserCookies"
+      send_cmd! "Page.enable"
+      send_cmd! "DOM.enable"
+      send_cmd! "CSS.enable"
+      send_cmd! "Page.setDownloadBehavior", behavior: "allow", downloadPath: Capybara::Chrome.configuration.download_path
+      helper_js = File.expand_path(File.join("..", "..", "chrome_remote_helper.js"), File.dirname(__FILE__))
+      send_cmd! "Page.addScriptToEvaluateOnNewDocument", source: File.read(helper_js)
+
+      Thread.abort_on_exception = true
+      return
+    end
+  end
+
+end

data/lib/capybara/chrome/rdp_socket.rb

@@ -0,0 +1,29 @@
+module Capybara::Chrome
+  class RDPSocket
+    READ_LEN = 4096
+    attr_reader :url, :io
+
+    def initialize(url)
+      uri = URI.parse(url)
+      @url = uri.to_s
+      @io = TCPSocket.new(uri.host, uri.port)
+    end
+
+    def write(data)
+      io.sendmsg data
+    end
+
+    def read
+      buf = ""
+      loop do
+        buf << io.recv_nonblock(READ_LEN)
+      end
+    rescue IO::EAGAINWaitReadable
+      if buf.size == 0
+        puts "buf is #{buf.size}"
+        puts caller[0..10]
+      end
+      buf
+    end
+  end
+end

data/lib/capybara/chrome/rdp_web_socket_client.rb

@@ -0,0 +1,51 @@
+module Capybara::Chrome
+  class RDPWebSocketClient
+    attr_reader :socket, :driver, :messages, :status
+
+    def initialize(url)
+      @socket = RDPSocket.new(url)
+      @driver = ::WebSocket::Driver.client(socket)
+
+      @messages = []
+      @status = :closed
+
+      setup_driver
+      start_driver
+    end
+
+    def send_msg(msg)
+      driver.text msg
+    end
+
+    def parse_input
+      @driver.parse(@socket.read)
+    end
+
+    private
+
+    def setup_driver
+      driver.on(:message) do |e|
+        messages << e.data
+      end
+
+      driver.on(:error) do |e|
+        raise WebSocketError.new e.message
+      end
+
+      driver.on(:close) do |e|
+        raise "closed"
+        @status = :closed
+      end
+
+      driver.on(:open) do |e|
+        @status = :open
+      end
+    end
+
+    def start_driver
+      driver.start
+      select [socket.io]
+      parse_input until status == :open
+    end
+  end
+end

data/lib/capybara/chrome/repeat_timeout.rb

@@ -0,0 +1,15 @@
+module Capybara::Chrome
+  module DumbTimeout
+    class Error < StandardError
+    end
+
+    def self.timeout(n)
+      start_at = Time.now
+      loop do
+        raise Error.new("waited #{n}s") if (Time.now - start_at).to_i >= n
+        yield
+      end
+    end
+
+  end
+end

data/lib/capybara/chrome/service.rb

@@ -0,0 +1,109 @@
+module Capybara::Chrome
+  module Service
+
+      # "--disable-gpu",
+      # '--js-flags="--max-old-space-size=500"',
+    CHROME_ARGS = [
+      "--headless",
+      "--enable-automation",
+      "--crash-dumps-dir=/tmp",
+      "--disable-background-networking",
+      "--disable-background-timer-throttling",
+      "--disable-breakpad",
+      "--disable-client-side-phishing-detection",
+      "--disable-default-apps",
+      "--disable-dev-shm-usage",
+      "--disable-extensions",
+      "--disable-features=site-per-process",
+      "--disable-hang-monitor",
+      "--disable-popup-blocking",
+      "--disable-prompt-on-repost",
+      "--disable-sync",
+      "--disable-translate",
+      "--metrics-recording-only",
+      "--no-first-run",
+      "--no-pings",
+      "--safebrowsing-disable-auto-update",
+      "--hide-scrollbars",
+      "--mute-audio",
+    ]
+
+    def chrome_pid
+      @chrome_pid
+    end
+
+    def start_chrome
+      return if chrome_running?
+      debug "Starting Chrome", chrome_path, chrome_args
+      @chrome_pid = Process.spawn chrome_path, *chrome_args, :out=>"/dev/null"
+      at_exit { stop_chrome }
+    end
+
+    def stop_chrome
+      Process.kill "TERM", chrome_pid rescue nil
+    end
+
+    def restart_chrome
+      stop_chrome
+      if chrome_running?
+        @chrome_port = find_available_port(@chrome_host)
+      end
+      start_chrome
+    end
+
+    def wait_for_chrome
+      running = false
+      while !running
+        running = chrome_running?
+        sleep 0.02
+      end
+    end
+
+    def chrome_running?
+      socket = TCPSocket.new(@chrome_host, @chrome_port) rescue false
+      socket.close if socket
+      !!socket
+    end
+
+    def chrome_path
+      case os
+      when :macosx
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+      when :linux
+        # /opt/google/chrome/chrome
+        "google-chrome-stable"
+      end
+    end
+
+    def chrome_args
+      CHROME_ARGS + ["--remote-debugging-port=#{@chrome_port}"]
+    end
+
+    def os
+      @os ||= (
+        host_os = RbConfig::CONFIG['host_os']
+        case host_os
+        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+          :windows
+        when /darwin|mac os/
+          :macosx
+        when /linux/
+          :linux
+        when /solaris|bsd/
+          :unix
+        else
+          raise Error::WebDriverError, "unknown os: #{host_os.inspect}"
+        end
+      )
+    end
+
+    def find_available_port(host)
+      sleep rand * 0.7 # slight delay to account for concurrent browsers
+      server = TCPServer.new(host, 0)
+      server.addr[1]
+    ensure
+      server.close if server
+    end
+
+  end
+end

data/lib/capybara/chrome/version.rb

@@ -0,0 +1,5 @@
+module Capybara
+  module Chrome
+    VERSION = "0.1.22"
+  end
+end

data/lib/chrome_remote_helper.js

@@ -0,0 +1,340 @@
+window.ChromeRemotePageLoaded = document.readyState == "complete"
+window.ChromeRemoteHelper = {
+  DOMContentLoaded: document.readyState == "interactive" || document.readyState == "complete",
+  windowLoaded: document.readyState == "complete",
+  windowUnloading: false,
+  nextIndex: 0,
+  nodes: {},
+  nodeClicks: {},
+  TEXT_TYPES: ["date", "email", "number", "password", "search", "tel", "text", "textarea", "url"],
+  windowWaitPromise: null,
+
+  registerNode: function(node) {
+    this.nextIndex++;
+    this.nodes[this.nextIndex] = node;
+    return this.nextIndex;
+  },
+
+  waitPromise: function(truthFn, delay) {
+    var ms = 0;
+    var intId;
+    var p = new Promise(function(resolve, reject) {
+      var truthy = truthFn();
+      if (truthy) {
+        resolve(truthy);
+      } else if (this.windowUnloading) {
+        if (intId) {
+          window.clearInterval(intId);
+        }
+        resolve(false);
+      } else {
+        intId = window.setInterval(function() {
+          truthy = truthFn(intId);
+          ms += delay;
+          if (truthy || ms > 500) {
+            window.clearInterval(intId);
+            resolve(truthy);
+          } else if (this.windowUnloading) {
+            resolve(false);
+          } else {
+            console.log("not truthy", truthy, this);
+          }
+        }.bind(this), delay);
+      }
+    }.bind(this));
+    return p;
+  },
+
+  waitUnload: function() {
+    var ms = 0;
+    var delay = 1;
+    var intId;
+    var p = new Promise(function(resolve, reject) {
+      if (this.windowUnloading) {
+        resolve(true);
+      }
+      var fn = function() {
+        ms += delay;
+        if (ms >= 100) {
+          //clearInterval(intId);
+          return true;
+        } else {
+          if (this.windowUnloading) {
+            // clearInterval(intId);
+            return true;
+          } else {
+            return false;
+          }
+        }
+      }.bind(this);
+      var redo = function() {
+        if (fn()) {
+          return resolve(true);
+        } else {
+          window.setTimeout(redo, delay);
+        }
+      }.bind(this);
+      redo();
+
+      // intId = window.setInterval(, delay);
+    }.bind(this));
+    return p;
+  },
+
+  waitWindowLoaded: function() {
+    var ms = 0;
+    var delay = 0;
+    this.windowWaitPromise = this.waitPromise(function() {
+      return this.windowLoaded;
+    }.bind(this), delay);
+    return this.windowWaitPromise;
+  },
+
+  waitDOMContentLoaded: function() {
+    return this.waitPromise(function() {
+      return this.DOMContentLoaded;
+    }.bind(this), 5);
+  },
+
+  findCss: function(query) {
+    return this.findCssRelativeTo(document, query);
+  },
+
+  findCssWithin: function (index, query) {
+    return this.findCssRelativeTo(this.getNode(index), query);
+  },
+
+  findCssRelativeTo: function(reference, query) {
+    return this.waitDOMContentLoaded().then(function() {
+      var results = [];
+      var list = reference.querySelectorAll(query);
+      for (i = 0; i < list.length; i++) {
+        results.push(this.registerNode(list[i]));
+      }
+      return results.join(",");
+    }.bind(this));
+  },
+
+  findXPath: function(query) {
+    return this.findXpathRelativeTo(document, query);
+  },
+
+  findXPathWithin: function(index, query) {
+    return this.findXpathRelativeTo(this.getNode(index), query);
+  },
+
+  findXpathRelativeTo: function(reference, query) {
+    return this.waitDOMContentLoaded().then(function() {
+      var iterator = document.evaluate(query, reference, null, XPathResult.ORDERED_NODE_ITERATOR_TYPE, null);
+      var node;
+      var results = [];
+      while (node = iterator.iterateNext()) {
+        results.push(this.registerNode(node));
+      }
+      return results.join(",");
+    }.bind(this));
+  },
+
+  getXPathNode: function(node, path) {
+    path = path || [];
+    if (node.parentNode) {
+      path = this.getXPathNode(node.parentNode, path);
+    }
+
+    var first = node;
+    while (first.previousSibling)
+      first = first.previousSibling;
+
+    var count = 0;
+    var index = 0;
+    var iter = first;
+    while (iter) {
+      if (iter.nodeType == 1 && iter.nodeName == node.nodeName)
+        count++;
+      if (iter.isSameNode(node))
+        index = count;
+      iter = iter.nextSibling;
+      continue;
+    }
+
+    if (node.nodeType == 1)
+      path.push(node.nodeName.toLowerCase() + (node.id ? "[@id='"+node.id+"']" : count > 1 ? "["+index+"]" : ''));
+
+    return path;
+  },
+
+  nodePathForNode: function(index) {
+    return this.pathForNode(this.getNode(index));
+  },
+
+  pathForNode: function(node) {
+    return "/" + this.getXPathNode(node).join("/");
+  },
+
+  getNode: function(index) {
+    var node = this.nodes[index];
+    if (!node) {
+      throw new NodeNotFoundError("No node found with id:"+index+". Registered nodes:"+Object.keys(this.nodes).length);
+    }
+    return node;
+  },
+
+  onSelf: function(index, script) {
+    var node = this.getNode(index);
+    // console.log("onSelf " + index + " " + node.tagName + " " + (node.parentElement && node.parentElement.tagName) + " " + script);
+    var fn = Function("'use strict';"+script).bind(node)
+    var pp = new Promise(function(resolve) { resolve(fn()); });
+    return pp;
+  },
+
+  // args should be an array
+  onSelfValue: function(index, meth, args) {
+    var node = this.getNode(index);
+    var val = node[meth];
+    if (typeof val === "function") {
+      val.apply(node, args);
+    } else {
+      return val;
+    }
+  },
+
+  dispatchEvent: function(node, eventName) {
+    var eventObject;
+    if (eventName == "click") {
+      eventObject = new MouseEvent("click", {bubbles: true, cancelable: true});
+    } else {
+      eventObject = document.createEvent("HTMLEvents");
+      eventObject.initEvent(eventName, true, true);
+    }
+    return node.dispatchEvent(eventObject);
+  },
+
+  nodeSetType: function(index) {
+    var node = this.getNode(index);
+    return (node.type || node.tagName).toLowerCase();
+  },
+
+  nodeSet: function(index, value, type) {
+    var node = this.getNode(index);
+    if (type == "checkbox" || type == "radio") {
+      if (value == "true" && !node.checked) {
+        return node.click();
+      } else if (value == "false" && node.checked) {
+        return node.click();
+      }
+    } else {
+      return node.value = value;
+    }
+  },
+
+  nodeVisible: function(index) {
+    return this.visible(this.getNode(index));
+  },
+
+  visible: function(node) {
+    var styles = node.ownerDocument.defaultView.getComputedStyle(node);
+    if (styles["visibility"] == "hidden" || styles["display"] == "none" || styles["opacity"] == 0) {
+      return false;
+    }
+    while (node = node.parentElement) {
+      styles = node.ownerDocument.defaultView.getComputedStyle(node);
+      if (styles["display"] == "none" || styles["opacity"] == 0) {
+        return false;
+      }
+    }
+    return true;
+  },
+
+  nodeText: function(index) {
+    return this.text(this.getNode(index));
+  },
+
+  text: function(node) {
+    var type = node instanceof HTMLFormElement ? 'form' : (node.type || node.tagName).toLowerCase();
+    if (type == "textarea") {
+      return node.innerHTML;
+    } else {
+      var visible_text = node.innerText;
+      return typeof visible_text === "string" ? visible_text : node.textContent;
+    }
+  },
+
+  nodeIsNodeAtPosition: function(index, pos) {
+    return this.isNodeAtPosition(this.getNode(index), pos);
+  },
+
+  isNodeAtPosition: function(node, pos) {
+    var nodeAtPosition =
+      document.elementFromPoint(pos.relativeX, pos.relativeY);
+    var overlappingPath;
+
+
+    if (nodeAtPosition) {
+      // console.log("is node at position" + nodeAtPosition.tagName)
+      overlappingPath = this.pathForNode(nodeAtPosition)
+    }
+
+    if (!this.isNodeOrChildAtPosition(node, pos, nodeAtPosition)) {
+      // console.log("Would throw " + overlappingPath + " " + this.pathForNode(node))
+      return false;
+    }
+
+    return true;
+  },
+
+  isNodeOrChildAtPosition: function(expectedNode, pos, currentNode) {
+    if (currentNode == expectedNode) {
+      return true;
+    } else if (currentNode) {
+      return this.isNodeOrChildAtPosition(
+        expectedNode,
+        pos,
+        currentNode.parentNode
+      );
+    } else {
+      return false;
+    }
+  },
+
+  nodeGetDimensions: function(index) {
+    return this.getDimensions(this.getNode(index));
+  },
+
+  getDimensions: function(node) {
+    return JSON.stringify(node.getBoundingClientRect());
+  },
+
+  // don't attach state to the node because the node can go away after click
+  attachClickListener: function(index) {
+    var node = this.getNode(index);
+    this.nodeClicks[index] = false;
+    var fn = function() {
+      this.nodeClicks[index] = true;
+      node.removeEventListener("click", fn);
+    }.bind(this);
+    node.addEventListener("click", fn);
+  },
+
+  nodeVerifyClicked: function(index) {
+    return this.nodeClicks[index];
+  }
+}
+
+document.addEventListener("DOMContentLoaded", function() {
+  ChromeRemoteHelper.DOMContentLoaded = true;
+});
+
+window.addEventListener("load", function() {
+  ChromeRemoteHelper.windowLoaded = true;
+  ChromeRemotePageLoaded = true;
+});
+
+window.addEventListener("beforeunload", function() {
+  ChromeRemoteHelper.windowUnloading = true;
+  ChromeRemoteHelper.windowLoaded = true;
+});
+
+window.addEventListener("unload", function() {
+});
+
+class NodeNotFoundError extends Error{}