capybara-chrome 0.1.22

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8541435afe87267dc82259cc09f0c1ca7484588a
+  data.tar.gz: b80fe620c9549091dab72dfe7e62a505dbbbe83b
+SHA512:
+  metadata.gz: c90f45a45e4f3f96ce46c48956b73afd65c01bb39b4b3830c9905fb3b101f4ccbe31f5806b581b74cc6d533ad9495b8f655a9af1270fa45e867a1c200dd118c1
+  data.tar.gz: c678cd3da799220fb700e873562a8586ec850b86460049c92cbb65b28e2921fc2a5e0cc511cfb647614e8406f4f90a3f50b6c2c0b4094e4ac1abce1e25f189bf

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in capybara-chrome.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Sandro Turriate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,110 @@
+# Capybara::Chrome
+
+Use [Capybara](https://github.com/teamcapybara/capybara) to drive Chrome in headless mode via the [debugging protocol](https://chromedevtools.github.io/devtools-protocol/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'capybara-chrome'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install capybara-chrome
+
+## Usage
+
+```ruby
+Capybara.javascript_driver = :chrome
+Capybara::Chrome.configuration.chrome_port = 9222 # optional
+```
+
+The standard port for the debugging protocol is `9222`. Visit `localhost:9222` in a Chrome tab to watch the tests execute. Note, the port will be random by default.
+
+### Using thin
+
+I like using [thin](https://github.com/macournoyer/thin) instead of WEBrick as
+my Capybara server. It's a little faster, gives me greater control of logging,
+shows errors, and allows me to disable signal handlers.
+Below are my settings:
+
+```ruby
+Capybara.register_server :thin do |app, port, host|
+  require "rack/handler/thin"
+  Thin::Logging.silent = false
+  # Thin::Logging.debug = true # uncomment to see request and response codes
+  # Thin::Logging.trace = true # uncomment to see full requests/responses
+  Rack::Handler::Thin.run(app, Host: host, Port: port, signals: false)
+end
+Capybara.server = :thin
+```
+
+### Debugging
+
+Use `byebug` instead of `binding.pry` when debugging a test. The Pry debugger tends to hang when `visit` is called.
+
+### Using the repl
+
+You can use the capybara-chrome browser without providing a rack app. This can be helpful in debugging.
+
+```
+[2] pry(main)> driver = Capybara::Chrome::Driver.new(nil, port:9222); driver.start; browser = driver.browser
+[3] pry(main)> browser.visit "http://google.com"
+=> true
+[4] pry(main)> browser.current_url
+=> "https://www.google.com/?gws_rd=ssl"
+[5] pry(main)>
+
+```
+
+Further, you can run a local netcat server and point the capybara-chrome browser to it to see the entire request that's being sent.
+
+Terminal one contains the browser:
+
+```
+[1] pry(main)> driver = Capybara::Chrome::Driver.new(nil, port:9222); driver.start; browser = driver.browser
+[2] pry(main)> browser.header "x-foo", "bar"
+[3] pry(main)> browser.visit "http://localhost:8000"
+```
+
+Terminal two prints the request
+
+```
+$ while true; do { echo -e "HTTP/1.1 200 OK \r\n"; echo "hi"; } | nc -l 8000; done
+GET / HTTP/1.1
+Host: localhost:8000
+Connection: keep-alive
+Upgrade-Insecure-Requests: 1
+User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) HeadlessChrome/68.0.3440.106 Safari/537.36
+x-foo: bar
+Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8
+Accept-Encoding: gzip, deflate
+```
+
+### Videos
+
+A video showing capybara-chrome running in a browser tab
+
+[![Preview of visualizing capybara-chrome](http://img.youtube.com/vi/SLmkx5z-lAA/0.jpg)](http://www.youtube.com/watch?v=SLmkx5z-lAA)
+
+A video demonstrating debugging an rspec test with `byebug`
+
+[![Preview of debugging capybara-chrome](http://img.youtube.com/vi/McEQG9YEAdE/0.jpg)](http://www.youtube.com/watch?v=McEQG9YEAdE)
+
+A video showing capybara-chrome running against a netcat backend
+
+[![Preview of debugging capybara-chrome with netcat](http://img.youtube.com/vi/B1__LeLyXBo/0.jpg)](http://www.youtube.com/watch?v=B1__LeLyXBo)
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/carezone/capybara-chrome.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+task :tag do
+  puts `git tag #{Capybara::Chrome::VERSION} && git tag | sort -V | tail`
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "capybara/chrome"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/capybara-chrome.gemspec

@@ -0,0 +1,31 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "capybara/chrome/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "capybara-chrome"
+  spec.version       = Capybara::Chrome::VERSION
+  spec.authors       = ["Sandro Turriate"]
+  spec.email         = ["sandro.turriate@gmail.com"]
+
+  spec.summary       = %q{Chrome driver for capybara using remote debugging protocol.}
+  spec.description   = %q{Chrome driver for capybara using remote debugging protocol.}
+  spec.homepage      = "https://github.com/carezone/capybara-chrome"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency("capybara")
+  spec.add_runtime_dependency("json")
+  spec.add_runtime_dependency("websocket-driver")
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/capybara-chrome.rb

@@ -0,0 +1 @@
+require "capybara/chrome"

data/lib/capybara/chrome.rb

@@ -0,0 +1,56 @@
+require "capybara/chrome/version"
+require "capybara"
+require "websocket/driver"
+
+module Capybara
+  module Chrome
+    require "capybara/chrome/errors"
+    autoload :Configuration, "capybara/chrome/configuration"
+
+    autoload :Driver, "capybara/chrome/driver"
+    autoload :Browser, "capybara/chrome/browser"
+    autoload :Node, "capybara/chrome/node"
+    autoload :Service, "capybara/chrome/service"
+
+    autoload :RDPClient, "capybara/chrome/rdp_client"
+    autoload :RDPWebSocketClient, "capybara/chrome/rdp_web_socket_client"
+    autoload :RDPSocket, "capybara/chrome/rdp_socket"
+
+    autoload :Debug, "capybara/chrome/debug"
+
+    def self.configure(reset: false)
+      @configuration = nil if reset
+      yield configuration
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.wants_to_quit
+      @wants_to_quit
+    end
+
+    def self.trap_interrupt
+      previous_interrupt = trap("INT") do
+        @wants_to_quit = true
+        if previous_interrupt.respond_to?(:call)
+          previous_interrupt.call
+        else
+          exit 1
+        end
+      end
+    end
+
+    Capybara.register_driver :chrome do |app|
+      driver = Capybara::Chrome::Driver.new(app, port: configuration.chrome_port)
+      if driver.browser.chrome_running?
+        driver = Capybara::Chrome::Driver.new(app)
+      end
+      driver.start
+      Capybara::Chrome.trap_interrupt if Capybara::Chrome.configuration.trap_interrupt?
+      driver
+    end
+
+  end
+end

data/lib/capybara/chrome/browser.rb

@@ -0,0 +1,393 @@
+module Capybara::Chrome
+
+  class Browser
+    require 'rbconfig'
+
+    RECOGNIZED_SCHEME = /^https?/
+
+    include Debug
+    include Service
+
+    attr_reader :remote, :driver, :console_messages, :error_messages
+    attr_accessor :chrome_port
+    def initialize(driver, host: "127.0.0.1", port: nil)
+      @driver = driver
+      @chrome_pid = nil
+      @chrome_host = host
+      @chrome_port = port || find_available_port(host)
+      @remote = nil
+      @responses = {}
+      @last_response = nil
+      @frame_mutex = Mutex.new
+      @network_mutex = Mutex.new
+      @console_messages = []
+      @error_messages = []
+      @js_dialog_handlers = Hash.new {|h,key| h[key] = []}
+      @unrecognized_scheme_requests = []
+      @loader_ids = []
+      @loaded_loaders = {}
+    end
+
+    def start
+      start_chrome
+      start_remote
+    end
+
+    def evaluate_script(script, *args)
+      val = execute_script(script, *args)
+      val["result"]["value"]
+    end
+
+    def execute_script(script, *args)
+      default_options = {expression: script, includeCommandLineAPI: true, awaitPromise: true}
+      opts = args[0].respond_to?(:merge) ? args[0] : {}
+      opts = default_options.merge(opts)
+      val = remote.send_cmd "Runtime.evaluate", opts
+      debug script, val
+      if details = val["exceptionDetails"]
+        if details["exception"]["className"] == "NodeNotFoundError"
+          raise Capybara::ElementNotFound
+        else
+          raise JSException.new(details["exception"].inspect)
+        end
+      end
+      val
+    end
+
+    def execute_script!(script, options={})
+      remote.send_cmd!("Runtime.evaluate", {expression: script, includeCommandLineAPI: true}.merge(options))
+    end
+
+    def evaluate_async_script(script, *args)
+      raise "i dunno"
+    end
+
+    def wait_for_load
+      remote.send_cmd "DOM.getDocument"
+      loop do
+        val = evaluate_script %(window.ChromeRemotePageLoaded), awaitPromise: false
+        break val if val
+      end
+    end
+
+    def visit(path, attributes={})
+      uri = URI.parse(path)
+      if uri.scheme.nil?
+        uri.host = Capybara.current_session.server.host unless uri.host.present?
+        uri.port = Capybara.current_session.server.port unless uri.port.present?
+      end
+      debug ["visit #{uri}"]
+      @last_navigate = remote.send_cmd "Page.navigate", url: uri.to_s, transitionType: "typed"
+      wait_for_load
+    end
+
+    def with_retry(n:10, timeout: 0.05, &block)
+      skip_retry = [Errno::EPIPE, EOFError, ResponseTimeoutError]
+      begin
+        block.call
+      rescue => e
+        if n == 0 || skip_retry.detect {|klass| e.instance_of?(klass)}
+          raise e
+        else
+          puts "RETRYING #{e}"
+          sleep timeout
+          with_retry(n: n-1, timeout: timeout, &block)
+        end
+      end
+    end
+
+    def track_network_events
+      return if @track_network_events
+      remote.on("Network.requestWillBeSent") do |req|
+        if req["type"] == "Document"
+          if !RECOGNIZED_SCHEME.match req["request"]["url"]
+            puts "ADDING SCHEME"
+            @unrecognized_scheme_requests << req["request"]["url"]
+          else
+            @last_response = nil
+          end
+        end
+      end
+      remote.on("Network.responseReceived") do |params|
+        debug params["response"]["url"], params["requestId"], params["loaderId"], params["type"]
+        if params["type"] == "Document"
+          @responses[params["requestId"]] = params["response"]
+          @last_response = params["response"]
+        end
+      end
+      remote.on("Network.loadingFailed") do |params|
+        debug ["loadingFailed", params]
+      end
+      @track_network_events = true
+    end
+
+    def last_response
+      @last_response
+    end
+
+    def last_response_or_err
+      loop do
+        break last_response if last_response
+        remote.read_and_process(0.01)
+      end
+    rescue Timeout::Error
+      raise Capybara::ExpectationNotMet
+    end
+
+    def status_code
+      last_response_or_err["status"]
+    end
+
+    def current_url
+      document_root["documentURL"]
+    end
+
+    def unrecognized_scheme_requests
+      remote.read_and_process(1)
+      @unrecognized_scheme_requests
+    end
+
+    def has_body?(resp)
+      debug
+      if resp["root"] && resp["root"]["children"]
+        resp["root"]["children"].detect do |child|
+          next unless child.has_key?("children")
+          child["children"].detect do |grandchild|
+            grandchild["localName"] == "body"
+          end
+        end
+      end
+    end
+
+    def get_document
+      val = remote.send_cmd "DOM.getDocument"
+    end
+
+    def document_root
+      @document_root = get_document["root"]
+    end
+
+    def root_node
+      @root_node = find_css("html")[0]
+    end
+
+    def unset_root_node
+      @root_node = nil
+    end
+
+    def html
+      val = root_node.html
+      debug "root", val.size
+      val
+    end
+
+    def find_css(query)
+      debug query
+      nodes = query_selector_all(query)
+      nodes
+    end
+
+    def query_selector_all(query, index=nil)
+      wait_for_load
+      query = query.dup
+      query.gsub!('"', '\"')
+      result = if index
+                 evaluate_script %( window.ChromeRemoteHelper && ChromeRemoteHelper.findCssWithin(#{index}, "#{query}") )
+               else
+                 evaluate_script %( window.ChromeRemoteHelper && ChromeRemoteHelper.findCss("#{query}") )
+               end
+      get_node_results result
+    end
+
+    # object_id represents a script that returned of an array of nodes
+    def request_nodes(object_id)
+      nodes = []
+      results = remote.send_cmd("Runtime.getProperties", objectId: object_id, ownProperties: true)
+      raise Capybara::ExpectationNotMet if results.nil?
+      results["result"].each do |prop|
+        if prop["value"]["subtype"] == "node"
+          lookup = remote.send_cmd("DOM.requestNode", objectId: prop["value"]["objectId"])
+          raise Capybara::ExpectationNotMet if lookup.nil?
+          id = lookup["nodeId"]
+          if id == 0
+            raise Capybara::ExpectationNotMet
+          else
+            nodes << Node.new(driver, self, id)
+          end
+        end
+      end
+      nodes
+    end
+
+    def get_node_results(result)
+      vals = result.split(",")
+      nodes = []
+      if vals.any?
+        nodes = result.split(",").map do |id|
+          Node.new driver, self, id.to_i
+        end
+      end
+      nodes
+    end
+
+    def find_xpath(query, index=nil)
+      wait_for_load
+      query = query.dup
+      query.gsub!('"', '\"')
+      result = if index
+                 evaluate_script %( window.ChromeRemoteHelper && ChromeRemoteHelper.findXPathWithin(#{index}, "#{query}") )
+               else
+                 evaluate_script %( window.ChromeRemoteHelper && ChromeRemoteHelper.findXPath("#{query}") )
+               end
+      get_node_results result
+    end
+
+    def title
+      nodes = find_xpath("/html/head/title")
+      if nodes && nodes.first
+        nodes[0].text
+      else
+        ""
+      end
+    end
+
+    def start_remote
+      # @remote = ChromeRemoteClient.new(::ChromeRemote.send(:get_ws_url, {host: "localhost", port: @chrome_port}))
+      @remote = RDPClient.new chrome_host: @chrome_host, chrome_port: @chrome_port, browser: self
+      remote.start
+      after_remote_start
+    end
+
+    def after_remote_start
+      track_network_events
+      enable_console_log
+      # enable_lifecycle_events
+      enable_js_dialog
+      enable_script_debug
+      enable_network_interception
+      set_viewport(width: 1680, height: 1050)
+    end
+
+    def set_viewport(width:, height:, device_scale_factor: 1, mobile: false)
+      remote.send_cmd!("Emulation.setDeviceMetricsOverride", width: width, height: height, deviceScaleFactor: device_scale_factor, mobile: mobile)
+    end
+
+    def enable_network_interception
+      remote.send_cmd! "Network.setRequestInterception", patterns: [{urlPattern: "*"}]
+      remote.on("Network.requestIntercepted") do |params|
+        if Capybara::Chrome.configuration.block_url?(params["request"]["url"]) || (Capybara::Chrome.configuration.skip_image_loading? && params["resourceType"] == "Image")
+          # p ["blocking", params["request"]["url"]]
+          remote.send_cmd "Network.continueInterceptedRequest", interceptionId: params["interceptionId"], errorReason: "ConnectionRefused"
+        else
+          # p ["allowing", params["request"]["url"]]
+          remote.send_cmd "Network.continueInterceptedRequest", interceptionId: params["interceptionId"]
+        end
+      end
+    end
+
+    def enable_script_debug
+      remote.send_cmd "Debugger.enable"
+      remote.on("Debugger.scriptFailedToParse") do |params|
+        puts "\n\n!!! ERROR: SCRIPT FAILED TO PARSE !!!\n\n"
+        p params
+      end
+    end
+
+    def enable_js_dialog
+      remote.on("Page.javascriptDialogOpening") do |params|
+        debug ["Dialog Opening", params]
+        handler = @js_dialog_handlers[params["type"]].last
+        if handler
+          debug ["have handler", handler]
+          args = {accept: handler[:accept]}
+          args.merge!(promptText: handler[:prompt_text]) if params[:type] == "prompt"
+          remote.send_cmd("Page.handleJavaScriptDialog", args)
+          @js_dialog_handlers[params["type"]].delete(params["type"].size - 1)
+        else
+          puts "WARNING: Accepting unhandled modal. Use #accept_modal or #dismiss_modal to handle this modal properly."
+          remote.send_cmd("Page.handleJavaScriptDialog", accept: true)
+        end
+      end
+    end
+
+    def accept_modal(type, text_or_options=nil, options={}, &block)
+      @js_dialog_handlers[type.to_s] << {accept: true}
+      block.call if block
+    end
+
+    def dismiss_modal(type, text_or_options=nil, options={}, &block)
+      @js_dialog_handlers[type.to_s] << {accept: false}
+      block.call if block
+      debug [type, text_or_options, options]
+    end
+
+    def enable_console_log
+      remote.send_cmd! "Console.enable"
+      remote.on "Console.messageAdded" do |params|
+        str = "#{params["message"]["source"]}:#{params["message"]["line"]} #{params["message"]["text"]}"
+        if params["message"]["level"] == "error"
+          @error_messages << str
+        else
+          @console_messages << str
+        end
+      end
+    end
+
+    def enable_lifecycle_events
+      remote.send_cmd! "Page.setLifecycleEventsEnabled", enabled: true
+      remote.on("Page.lifecycleEvent") do |params|
+        if params["name"] == "init"
+          @loader_ids.push(params["loaderId"])
+        elsif params["name"] == "load"
+          @loaded_loaders[params["loaderId"]] = true
+        elsif params["name"] == "networkIdle"
+        end
+      end
+    end
+
+    def loader_loaded?(loader_id)
+      @loaded_loaders[loader_id]
+    end
+
+    def save_screenshot(path, options={})
+      options[:width]  ||= 1000
+      options[:height] ||= 10
+      render path, options[:width], options[:height]
+    end
+
+    def render(path, width=nil, height=nil)
+      response = remote.send_cmd "Page.getLayoutMetrics"
+      width = response["contentSize"]["width"]
+      height = response["contentSize"]["height"]
+      response = remote.send_cmd "Page.captureScreenshot", clip: {width: width, height: height, x: 0, y: 0, scale: 1}
+      File.open path, "wb" do |f|
+        f.write Base64.decode64(response["data"])
+      end
+    end
+
+    def header(key, value)
+      if key.downcase == "user-agent"
+        remote.send_cmd!("Network.setUserAgentOverride", userAgent: value)
+      else
+        remote.send_cmd!("Network.setExtraHTTPHeaders", headers: {key => value})
+      end
+    end
+
+    def reset
+      unset_root_node
+      @responses.clear
+      @last_response = nil
+      @console_messages.clear
+      @error_messages.clear
+      @js_dialog_handlers.clear
+      @unrecognized_scheme_requests.clear
+      remote.reset
+      remote.send_cmd! "Network.clearBrowserCookies"
+      remote.send_cmd! "Runtime.discardConsoleEntries"
+      remote.send_cmd! "Network.setExtraHTTPHeaders", headers: {}
+      remote.send_cmd! "Network.setUserAgentOverride", userAgent: ""
+      visit "about:blank"
+    end
+  end
+
+end