cuprite 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b3d43410a4b7875e111108b5ef1b53bf07589f833925ea3a9e336d725d99b95
+  data.tar.gz: 6cea0c2abdef1b5d8f8b6468f2924dac1cbbe5b51f1a4b6ce74bb980a86278ab
+SHA512:
+  metadata.gz: cd77da4241673d610343e552245f5e0421ee6fe8613cc437bd53d0e8bd3d63be8b422a4abf36fcfedf35d79bbed0b7db5fe26250e5b86f737ac4479c6e02281e
+  data.tar.gz: cd86413a1b47478e4b0545c28c5ba0ea54a592d889ef0420547d2192bfdac7bece55e9557d88d48cca0720a8d86562dbe281b0988e1234fc55a25d7fc44484c1

data/lib/capybara/cuprite.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "capybara"
+
+Thread.abort_on_exception = true
+Thread.report_on_exception = true
+
+module Capybara::Cuprite
+  require "cuprite/driver"
+  require "cuprite/browser"
+  require "cuprite/node"
+  require "cuprite/errors"
+  require "cuprite/cookie"
+
+  class << self
+    def windows?
+      RbConfig::CONFIG["host_os"] =~ /mingw|mswin|cygwin/
+    end
+
+    def mri?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"
+    end
+  end
+end
+
+Capybara.register_driver(:cuprite) do |app|
+  Capybara::Cuprite::Driver.new(app)
+end

data/lib/capybara/cuprite/browser.rb

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+require "base64"
+require "forwardable"
+require "cuprite/browser/targets"
+require "cuprite/browser/process"
+require "cuprite/browser/client"
+require "cuprite/browser/page"
+
+module Capybara::Cuprite
+  class Browser
+    TIMEOUT = 5
+    EXTENSIONS = [
+      File.expand_path("browser/javascripts/index.js", __dir__)
+    ].freeze
+
+    extend Forwardable
+
+    attr_reader :headers
+
+    def self.start(*args)
+      new(*args)
+    end
+
+    delegate subscribe: :@client
+    delegate %i(window_handle window_handles switch_to_window open_new_window
+                close_window within_window page) => :targets
+    delegate %i(visit status_code body all_text property attributes attribute
+                value visible? disabled? resize path network_traffic
+                clear_network_traffic response_headers refresh click right_click
+                double_click hover set click_coordinates drag drag_by select
+                trigger scroll_to send_keys evaluate evaluate_on evaluate_async
+                execute frame_url frame_title within_frame switch_to_frame
+                current_url title go_back go_forward) => :page
+
+    attr_reader :process, :logger
+    attr_writer :timeout
+
+    def initialize(options = nil)
+      @options = Hash(options)
+      @logger, @timeout = @options.values_at(:logger, :timeout)
+
+      if ENV["CUPRITE_DEBUG"]
+        STDOUT.sync = true
+        @logger = STDOUT
+      end
+
+      start
+    end
+
+    def extensions
+      @extensions ||= begin
+        exts = @options.fetch(:extensions, [])
+        (EXTENSIONS + exts).map { |p| File.read(p) }
+      end
+    end
+
+    def timeout
+      @timeout || TIMEOUT
+    end
+
+    def source
+      raise NotImplementedError
+    end
+
+    def parents(node)
+      evaluate_on(node: node, expr: "_cuprite.parents(this)", by_value: false)
+    end
+
+    def find(method, selector)
+      find_all(method, selector)
+    end
+
+    def find_within(node, method, selector)
+      resolved = page.command("DOM.resolveNode", nodeId: node["nodeId"])
+      object_id = resolved.dig("object", "objectId")
+      find_all(method, selector, { "objectId" => object_id })
+    end
+
+    def visible_text(node)
+      begin
+        evaluate_on(node: node, expr: "_cuprite.visibleText(this)")
+      rescue BrowserError => e
+        # FIXME: ObsoleteNode first arg is node, so it should be in node class
+        if e.message == "No node with given id found"
+          raise ObsoleteNode.new(self, e.response)
+        end
+
+        raise
+      end
+    end
+
+    def delete_text(node)
+      raise NotImplementedError
+    end
+
+    def select_file(node, value)
+      raise NotImplementedError
+    end
+
+    def render(path, _options = {})
+      # check_render_options!(options)
+      # options[:full] = !!options[:full]
+      data = Base64.decode64(render_base64)
+      File.open(path.to_s, "wb") { |f| f.write(data) }
+    end
+
+    def render_base64(format = "png", _options = {})
+      # check_render_options!(options)
+      # options[:full] = !!options[:full]
+      page.command("Page.captureScreenshot", format: format)["data"]
+    end
+
+    def set_zoom_factor(zoom_factor)
+      raise NotImplementedError
+    end
+
+    def set_paper_size(size)
+      raise NotImplementedError
+    end
+
+    def set_proxy(ip, port, type, user, password)
+      raise NotImplementedError
+    end
+
+    def headers=(headers)
+      @headers = {}
+      add_headers(headers)
+    end
+
+    def add_headers(headers, permanent: true)
+      if headers["Referer"]
+        page.referrer = headers["Referer"]
+        headers.delete("Referer") unless permanent
+      end
+
+      @headers.merge!(headers)
+      user_agent = @headers["User-Agent"]
+      accept_language = @headers["Accept-Language"]
+
+      set_overrides(user_agent: user_agent, accept_language: accept_language)
+      page.command("Network.setExtraHTTPHeaders", headers: @headers)
+    end
+
+    def add_header(header, permanent: true)
+      add_headers(header, permanent: permanent)
+    end
+
+    def set_overrides(user_agent: nil, accept_language: nil, platform: nil)
+      options = Hash.new
+      options[:userAgent] = user_agent if user_agent
+      options[:acceptLanguage] = accept_language if accept_language
+      options[:platform] if platform
+
+      page.command("Network.setUserAgentOverride", **options) if !options.empty?
+    end
+
+    def cookies
+      cookies = page.command("Network.getAllCookies")["cookies"]
+      cookies.map { |c| [c["name"], Cookie.new(c)] }.to_h
+    end
+
+    def set_cookie(cookie)
+      page.command("Network.setCookie", **cookie)
+    end
+
+    def remove_cookie(options)
+      page.command("Network.deleteCookies", **options)
+    end
+
+    def clear_cookies
+      page.command("Network.clearBrowserCookies")
+    end
+
+    def set_http_auth(user, password)
+      raise NotImplementedError
+    end
+
+    def page_settings=(settings)
+      raise NotImplementedError
+    end
+
+    def url_whitelist=(whitelist)
+      @url_whitelist = Array(whitelist).map { |p| { urlPattern: p } }
+      page.command("Network.setRequestInterception", patterns: @url_whitelist)
+    end
+
+    def url_blacklist=(blacklist)
+      # FIXME: We have to change the format and make it compatible with Chrome not PhantomJS
+      @url_blacklist = Array(blacklist).map { |p| { urlPattern: p.include?("*") ? p : "*#{p}*" } }
+      page.command("Network.setRequestInterception", patterns: @url_blacklist)
+    end
+
+    def clear_memory_cache
+      page.command("Network.clearBrowserCache")
+    end
+
+    def accept_confirm
+      raise NotImplementedError
+    end
+
+    def dismiss_confirm
+      raise NotImplementedError
+    end
+
+    def accept_prompt(response)
+      raise NotImplementedError
+    end
+
+    def dismiss_prompt
+      raise NotImplementedError
+    end
+
+    def modal_message
+      raise NotImplementedError
+    end
+
+    def reset
+      @headers = {}
+      targets.reset
+    end
+
+    def restart
+      quit
+      start
+    end
+
+    def quit
+      @client.close
+      @process.stop
+      @client = @process = @targets = nil
+    end
+
+    def crash
+      command("Browser.crash")
+    end
+
+    def command(*args)
+      id = @client.command(*args)
+      @client.wait(id: id)
+    rescue DeadBrowser
+      restart
+      raise
+    end
+
+    def targets
+      @targets ||= Targets.new(self)
+    end
+
+    private
+
+    def start
+      @headers = {}
+      @process = Process.start(@options)
+      @client = Client.new(self, @process.ws_url)
+    end
+
+    def check_render_options!(options)
+      return if !options[:full] || !options.key?(:selector)
+      warn "Ignoring :selector in #render since :full => true was given at #{caller(1..1).first}"
+      options.delete(:selector)
+    end
+
+    def find_all(method, selector, within = nil)
+      begin
+        elements = if within
+          evaluate("_cuprite.find(arguments[0], arguments[1], arguments[2])", method, selector, within)
+        else
+          evaluate("_cuprite.find(arguments[0], arguments[1])", method, selector)
+        end
+
+        elements.map do |element|
+          # nodeType: 3, nodeName: "#text" e.g.
+          target_id, node = element.values_at("target_id", "node")
+          next if node["nodeType"] != 1
+          within ? node : [target_id, node]
+        end.compact
+      rescue JavaScriptError => e
+        if e.class_name == "InvalidSelector"
+          raise InvalidSelector.new(e.response, method, selector)
+        end
+        raise
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "timeout"
+require "cuprite/browser/web_socket"
+
+module Capybara::Cuprite
+  class Browser
+    class Client
+      class IdError < RuntimeError; end
+
+      def initialize(browser, ws_url)
+        @command_id = 0
+        @subscribed = Hash.new { |h, k| h[k] = [] }
+        @browser = browser
+        @commands = Queue.new
+        @ws = WebSocket.new(ws_url, @browser.logger)
+
+        @thread = Thread.new do
+          while message = @ws.messages.pop
+            method, params = message.values_at("method", "params")
+            if method
+              @subscribed[method].each { |b| b.call(params) }
+            else
+              @commands.push(message)
+            end
+          end
+
+          @commands.close
+        end
+      end
+
+      def command(method, params = {})
+        message = build_message(method, params)
+        @ws.send_message(message)
+        message[:id]
+      end
+
+      def wait(id:)
+        message = Timeout.timeout(@browser.timeout, TimeoutError) { @commands.pop }
+        raise DeadBrowser unless message
+        raise IdError if message["id"] != id
+        error, response = message.values_at("error", "result")
+        raise BrowserError.new(error) if error
+        response
+      rescue IdError
+        retry
+      end
+
+      def subscribe(event, &block)
+        @subscribed[event] << block
+        true
+      end
+
+      def close
+        @ws.close
+        @thread.kill
+      end
+
+      private
+
+      def build_message(method, params)
+        { method: method, params: params }.merge(id: next_command_id)
+      end
+
+      def next_command_id
+        @command_id += 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Capybara::Cuprite
+  class Browser
+    module DOM
+      def current_url
+        evaluate_in(@execution_context_id, "location.href")
+      end
+
+      def title
+        evaluate_in(@execution_context_id, "document.title")
+      end
+
+      def body
+        evaluate("document.documentElement.outerHTML")
+      end
+
+      def all_text(node)
+        evaluate_on(node: node, expr: "this.textContent")
+      end
+
+      def property(node, name)
+        evaluate_on(node: node, expr: %Q(this["#{name}"]))
+      end
+
+      def attributes(node)
+        value = evaluate_on(node: node, expr: "_cuprite.getAttributes(this)")
+        JSON.parse(value)
+      end
+
+      def attribute(node, name)
+        evaluate_on(node: node, expr: %Q(_cuprite.getAttribute(this, "#{name}")))
+      end
+
+      def value(node)
+        evaluate_on(node: node, expr: "_cuprite.value(this)")
+      end
+
+      def visible?(node)
+        evaluate_on(node: node, expr: "_cuprite.isVisible(this)")
+      end
+
+      def disabled?(node)
+        evaluate_on(node: node, expr: "_cuprite.isDisabled(this)")
+      end
+
+      def path(node)
+        evaluate_on(node: node, expr: "_cuprite.path(this)")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+module Capybara::Cuprite
+  class Browser
+    module Frame
+      def execution_context_id
+        @mutex.synchronize do
+          if !@frame_stack.empty?
+            @frames[@frame_stack.last]["execution_context_id"]
+          else
+            @execution_context_id
+          end
+        end
+      end
+
+      def frame_url
+        evaluate("window.location.href")
+      end
+
+      def frame_title
+        evaluate("document.title")
+      end
+
+      def switch_to_frame(handle)
+        case handle
+        when Capybara::Node::Base
+          @frame_stack << handle.native.node["frameId"]
+          inject_extensions
+        when :parent
+          @frame_stack.pop
+        when :top
+          @frame_stack = []
+        end
+      end
+
+      private
+
+      def subscribe_events
+        @client.subscribe("Page.frameAttached") do |params|
+          @frames[params["frameId"]] = { "parent_id" => params["parentFrameId"] }
+        end
+
+        @client.subscribe("Page.frameStartedLoading") do |params|
+          @waiting_frames << params["frameId"]
+          @mutex.try_lock
+        end
+
+        @client.subscribe("Page.frameNavigated") do |params|
+          id = params["frame"]["id"]
+          if frame = @frames[id]
+            frame.merge!(params["frame"].slice("name", "url"))
+          end
+        end
+
+        @client.subscribe("Page.frameScheduledNavigation") do |params|
+          # Trying to lock mutex if frame is the main frame
+          @waiting_frames << params["frameId"]
+          @mutex.try_lock
+        end
+
+        @client.subscribe("Page.frameStoppedLoading") do |params|
+          # `DOM.performSearch` doesn't work without getting #document node first.
+          # It returns node with nodeId 1 and nodeType 9 from which descend the
+          # tree and we save it in a variable because if we call that again root
+          # node will change the id and all subsequent nodes have to change id too.
+          # `command` is not allowed in the block as it will deadlock the process.
+          if params["frameId"] == @frame_id
+            signal if @waiting_frames.empty?
+            @client.command("DOM.getDocument", depth: 0)
+          end
+
+          if @waiting_frames.include?(params["frameId"])
+            @waiting_frames.delete(params["frameId"])
+            signal if @waiting_frames.empty?
+          end
+        end
+
+        @client.subscribe("Runtime.executionContextCreated") do |params|
+          frame_id = params.dig("context", "auxData", "frameId")
+          execution_context_id = params.dig("context", "id")
+
+          # Remember the very first frame since it's the main one
+          @frame_id ||= frame_id
+          @execution_context_id ||= execution_context_id
+
+          if @frames[frame_id]
+            @frames[frame_id].merge!("execution_context_id" => execution_context_id)
+          else
+            @frames[frame_id] = { "execution_context_id" => execution_context_id }
+          end
+        end
+
+        @client.subscribe("Runtime.executionContextDestroyed") do |params|
+          execution_context_id = params["executionContextId"]
+          id, frame = @frames.find { |_, p| p["execution_context_id"] == execution_context_id }
+          frame["execution_context_id"] = nil if frame
+
+          if @execution_context_id == execution_context_id
+            @execution_context_id = nil
+          end
+        end
+
+        @client.subscribe("Runtime.executionContextsCleared") do
+          # If we didn't have time to set context id at the beginning we have
+          # to set lock and release it when we set something.
+          @execution_context_id = nil
+        end
+      end
+    end
+  end
+end