cuprite 0.2.0

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

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require "cuprite/browser/dom"
+require "cuprite/browser/input"
+require "cuprite/browser/runtime"
+require "cuprite/browser/frame"
+require "cuprite/browser/client"
+require "cuprite/network/error"
+require "cuprite/network/request"
+require "cuprite/network/response"
+
+# RemoteObjectId is from a JavaScript world, and corresponds to any JavaScript
+# object, including JS wrappers for DOM nodes. There is a way to convert between
+# node ids and remote object ids (DOM.requestNode and DOM.resolveNode).
+#
+# NodeId is used for inspection, when backend tracks the node and sends updates to
+# the frontend. If you somehow got NodeId over protocol, backend should have
+# pushed to the frontend all of it's ancestors up to the Document node via
+# DOM.setChildNodes. After that, frontend is always kept up-to-date about anything
+# happening to the node.
+#
+# BackendNodeId is just a unique identifier for a node. Obtaining it does not send
+# any updates, for example, the node may be destroyed without any notification.
+# This is a way to keep a reference to the Node, when you don't necessarily want
+# to keep track of it. One example would be linking to the node from performance
+# data (e.g. relayout root node). BackendNodeId may be either resolved to
+# inspected node (DOM.pushNodesByBackendIdsToFrontend) or described in more
+# details (DOM.describeNode).
+module Capybara::Cuprite
+  class Browser
+    class Page
+      include Input, DOM, Runtime, Frame
+
+      attr_accessor :referrer
+      attr_reader :target_id, :status_code, :response_headers
+
+      def initialize(target_id, browser)
+        @wait = 0
+        @target_id, @browser = target_id, browser
+        @mutex, @resource = Mutex.new, ConditionVariable.new
+        @network_traffic = []
+
+        @frames = {}
+        @waiting_frames ||= Set.new
+        @frame_stack = []
+
+        begin
+          @session_id = @browser.command("Target.attachToTarget", targetId: @target_id)["sessionId"]
+        rescue BrowserError => e
+          if e.message == "No target with given id found"
+            raise NoSuchWindowError
+          else
+            raise
+          end
+        end
+
+        host = @browser.process.host
+        port = @browser.process.port
+        ws_url = "ws://#{host}:#{port}/devtools/page/#{@target_id}"
+        @client = Client.new(browser, ws_url)
+
+        subscribe_events
+        prepare_page
+      end
+
+      def timeout
+        @browser.timeout
+      end
+
+      def visit(url)
+        @wait = timeout
+        options = { url: url }
+        options.merge!(referrer: referrer) if referrer
+        response = command("Page.navigate", **options)
+        if response["errorText"] == "net::ERR_NAME_RESOLUTION_FAILED"
+          raise StatusFailError, "url" => url
+        end
+        response["frameId"]
+      end
+
+      def close
+        @browser.command("Target.detachFromTarget", sessionId: @session_id)
+        @browser.command("Target.closeTarget", targetId: @target_id)
+        close_connection
+      end
+
+      def close_connection
+        @client.close
+      end
+
+      def resize(width, height)
+        result = @browser.command("Browser.getWindowForTarget", targetId: @target_id)
+        @window_id, @bounds = result.values_at("windowId", "bounds")
+        @browser.command("Browser.setWindowBounds", windowId: @window_id, bounds: { width: width, height: height })
+        command("Emulation.setDeviceMetricsOverride", width: width, height: height, deviceScaleFactor: 1, mobile: false)
+      end
+
+      def refresh
+        @wait = timeout
+        command("Page.reload")
+      end
+
+      def network_traffic(type = nil)
+        case type
+        when "all"
+          @network_traffic
+        when "blocked"
+          @network_traffic # when request blocked
+        else
+          @network_traffic # when not request blocked
+        end
+      end
+
+      def clear_network_traffic
+        @network_traffic = []
+      end
+
+      def go_back
+        go(-1)
+      end
+
+      def go_forward
+        go(1)
+      end
+
+      def command(*args)
+        id = nil
+
+        @mutex.synchronize do
+          id = @client.command(*args)
+          stop_at = Time.now.to_f + @wait
+
+          while @wait > 0 && (remain = stop_at - Time.now.to_f) > 0
+            @resource.wait(@mutex, remain)
+          end
+
+          @wait = 0
+        end
+
+        response = @client.wait(id: id)
+      end
+
+      private
+
+      def subscribe_events
+        super
+
+        if @browser.logger
+          @client.subscribe("Runtime.consoleAPICalled") do |params|
+            params["args"].each { |r| @browser.logger.puts(r["value"]) }
+          end
+        end
+
+        @client.subscribe("Page.windowOpen") do
+          @browser.targets.refresh
+          @mutex.try_lock
+          sleep 0.3 # Dirty hack because new window doesn't have events at all
+          @mutex.unlock if @mutex.locked? && @mutex.owned?
+        end
+
+        @client.subscribe("Page.navigatedWithinDocument") do
+          signal if @waiting_frames.empty?
+        end
+
+        @client.subscribe("Page.domContentEventFired") do |params|
+          # `frameStoppedLoading` doesn't occur if status isn't success
+          if @status_code != 200
+            signal
+            @client.command("DOM.getDocument", depth: 0)
+          end
+        end
+
+        @client.subscribe("Network.requestWillBeSent") do |params|
+          if params["frameId"] == @frame_id
+            # Possible types:
+            # Document, Stylesheet, Image, Media, Font, Script, TextTrack, XHR,
+            # Fetch, EventSource, WebSocket, Manifest, SignedExchange, Ping,
+            # CSPViolationReport, Other
+            if params["type"] == "Document"
+              @mutex.try_lock
+              @request_id = params["requestId"]
+            end
+          end
+
+          id, time = params.values_at("requestId", "wallTime")
+          params = params["request"].merge("id" => id, "time" => time)
+          @network_traffic << Network::Request.new(params)
+        end
+
+        @client.subscribe("Network.responseReceived") do |params|
+          if params["requestId"] == @request_id
+            @response_headers = params.dig("response", "headers")
+            @status_code = params.dig("response", "status")
+          end
+
+          if request = @network_traffic.find { |r| r.id == params["requestId"] }
+            params = params["response"].merge("id" => params["requestId"])
+            request.response = Network::Response.new(params)
+          end
+        end
+
+        @client.subscribe("Network.requestIntercepted") do |params|
+          @client.command("Network.continueInterceptedRequest", interceptionId: params["interceptionId"], errorReason: "Aborted")
+        end
+
+        @client.subscribe("Log.entryAdded") do |params|
+          source = params.dig("entry", "source")
+          level = params.dig("entry", "level")
+          if source == "network" && level == "error"
+            id = params.dig("entry", "networkRequestId")
+            if request = @network_traffic.find { |r| r.id == id }
+              request.error = Network::Error.new(params["entry"])
+            end
+          end
+        end
+      end
+
+      def prepare_page
+        command("Page.enable")
+        command("DOM.enable")
+        command("CSS.enable")
+        command("Runtime.enable")
+        command("Log.enable")
+        command("Network.enable")
+
+        @browser.extensions.each do |extension|
+          @client.command("Page.addScriptToEvaluateOnNewDocument", source: extension)
+        end
+
+        inject_extensions
+
+        response = command("Page.getNavigationHistory")
+        if response.dig("entries", 0, "transitionType") != "typed"
+          # If we create page by clicking links, submiting forms and so on it
+          # opens a new window for which `frameStoppedLoading` event never
+          # occurs and thus search for nodes cannot be completed. Here we check
+          # the history and if the transitionType for example `link` then
+          # content is already loaded and we can try to get the document.
+          @client.command("DOM.getDocument", depth: 0)
+        end
+      end
+
+      def inject_extensions
+        @browser.extensions.each do |extension|
+          # https://github.com/GoogleChrome/puppeteer/issues/1443
+          # https://github.com/ChromeDevTools/devtools-protocol/issues/77
+          # https://github.com/cyrus-and/chrome-remote-interface/issues/319
+          # We also evaluate script just in case because
+          # `Page.addScriptToEvaluateOnNewDocument` doesn't work in popups.
+          @client.command("Runtime.evaluate", expression: extension,
+                                              contextId: execution_context_id,
+                                              returnByValue: true)
+        end
+      end
+
+      def signal
+        @wait = 0
+
+        if @mutex.locked? && @mutex.owned?
+          @resource.signal
+          @mutex.unlock
+        else
+          @mutex.synchronize { @resource.signal }
+        end
+      end
+
+      def go(delta)
+        history = command("Page.getNavigationHistory")
+        index, entries = history.values_at("currentIndex", "entries")
+
+        if entry = entries[index + delta]
+          @wait = 0.05 # Potential wait because of network event
+          command("Page.navigateToHistoryEntry", entryId: entry["id"])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require "cliver"
+
+module Capybara::Cuprite
+  class Browser
+    class Process
+      KILL_TIMEOUT = 2
+
+      BROWSER_PATH = ENV.fetch("BROWSER_PATH", "chrome")
+      BROWSER_HOST = "127.0.0.1"
+      BROWSER_PORT = "0"
+
+      # Chromium command line options
+      # https://peter.sh/experiments/chromium-command-line-switches/
+      DEFAULT_OPTIONS = {
+        "headless" => nil,
+        "disable-gpu" => nil,
+        "hide-scrollbars" => nil,
+        "mute-audio" => nil,
+        # Note: --no-sandbox is not needed if you properly setup a user in the container.
+        # https://github.com/ebidel/lighthouse-ci/blob/master/builder/Dockerfile#L35-L40
+        # "no-sandbox" => nil,
+        "enable-automation" => nil,
+        "disable-web-security" => nil,
+      }.freeze
+
+      attr_reader :host, :port, :ws_url, :pid, :options
+
+      def self.start(*args)
+        new(*args).tap(&:start)
+      end
+
+      def self.process_killer(pid)
+        proc do
+          begin
+            if Capybara::Cuprite.windows?
+              ::Process.kill("KILL", pid)
+            else
+              ::Process.kill("TERM", pid)
+              start = Time.now
+              while ::Process.wait(pid, ::Process::WNOHANG).nil?
+                sleep 0.05
+                next unless (Time.now - start) > KILL_TIMEOUT
+                ::Process.kill("KILL", pid)
+                ::Process.wait(pid)
+                break
+              end
+            end
+          rescue Errno::ESRCH, Errno::ECHILD
+          end
+        end
+      end
+
+      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
+
+        window_size = options.fetch(:window_size, [1024, 768])
+        @options = @options.merge("window-size" => window_size.join(","))
+
+        port = options.fetch(:port, BROWSER_PORT)
+        @options = @options.merge("remote-debugging-port" => port)
+
+        host = options.fetch(:host, BROWSER_HOST)
+        @options = @options.merge("remote-debugging-address" => host)
+
+        @options = DEFAULT_OPTIONS.merge(@options)
+      end
+
+      def start
+        read_io, write_io = IO.pipe
+        process_options = { in: File::NULL }
+        process_options[:pgroup] = true unless Capybara::Cuprite.windows?
+        if Capybara::Cuprite.mri?
+          process_options[:out] = process_options[:err] = write_io
+        end
+
+        redirect_stdout(write_io) do
+          cmd = [@path] + @options.map { |k, v| v.nil? ? "--#{k}" : "--#{k}=#{v}" }
+          @pid = ::Process.spawn(*cmd, process_options)
+          ObjectSpace.define_finalizer(self, self.class.process_killer(@pid))
+        end
+
+        parse_ws_url(read_io)
+      ensure
+        close_io(read_io, write_io)
+      end
+
+      def stop
+        return unless @pid
+        kill
+        ObjectSpace.undefine_finalizer(self)
+      end
+
+      def restart
+        stop
+        start
+      end
+
+      private
+
+      def redirect_stdout(write_io)
+        if Capybara::Cuprite.mri?
+          yield
+        else
+          begin
+            prev = STDOUT.dup
+            $stdout = write_io
+            STDOUT.reopen(write_io)
+            yield
+          ensure
+            STDOUT.reopen(prev)
+            $stdout = STDOUT
+            prev.close
+          end
+        end
+      end
+
+      def kill
+        self.class.process_killer(@pid).call
+        @pid = nil
+      end
+
+      def parse_ws_url(read_io)
+        output = ""
+        attempts = 3
+        regexp = /DevTools listening on (ws:\/\/.*)/
+        loop do
+          begin
+            output += read_io.read_nonblock(512)
+          rescue IO::WaitReadable
+            attempts -= 1
+            break if attempts <= 0
+            IO.select([read_io], nil, nil, 1)
+            retry
+          end
+
+          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
+
+      def close_io(*ios)
+        ios.each do |io|
+          begin
+            io.close unless io.closed?
+          rescue IOError
+            raise unless RUBY_ENGINE == 'jruby'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Capybara::Cuprite
+  class Browser
+    module Runtime
+      EXECUTE_OPTIONS = {
+        returnByValue: true,
+        functionDeclaration: %Q(function() { %s })
+      }.freeze
+      DEFAULT_OPTIONS = {
+        functionDeclaration: %Q(function() { return %s })
+      }.freeze
+      EVALUATE_ASYNC_OPTIONS = {
+        awaitPromise: true,
+        functionDeclaration: %Q(
+          function() {
+           return new Promise((__resolve, __reject) => {
+             try {
+               arguments[arguments.length] = r => __resolve(r);
+               arguments.length = arguments.length + 1;
+               setTimeout(() => __reject(new TimedOutPromise), %s);
+               %s
+             } catch(error) {
+               __reject(error);
+             }
+           });
+          }
+        )
+      }.freeze
+
+      def evaluate(expr, *args)
+        response = call(expr, nil, nil, *args)
+        handle(response)
+      end
+
+      def evaluate_in(context_id, expr)
+        response = call(expr, nil, { executionContextId: context_id })
+        handle(response)
+      end
+
+      def evaluate_on(node:, expr:, by_value: true, wait: 0)
+        object_id = command("DOM.resolveNode", nodeId: node["nodeId"]).dig("object", "objectId")
+        options = DEFAULT_OPTIONS.merge(objectId: object_id)
+        options[:functionDeclaration] = options[:functionDeclaration] % expr
+        options.merge!(returnByValue: by_value)
+
+        @wait = wait if wait > 0
+
+        response = command("Runtime.callFunctionOn", **options)
+          .dig("result").tap { |r| handle_error(r) }
+
+        by_value ? response.dig("value") : handle(response)
+      end
+
+      def evaluate_async(expr, wait_time, *args)
+        response = call(expr, wait_time * 1000, EVALUATE_ASYNC_OPTIONS, *args)
+        handle(response)
+      end
+
+      def execute(expr, *args)
+        call(expr, nil, EXECUTE_OPTIONS, *args)
+        true
+      end
+
+      private
+
+      def call(expr, wait_time, options = nil, *args)
+        options ||= {}
+        args = prepare_args(args)
+
+        options = DEFAULT_OPTIONS.merge(options)
+        expr = [wait_time, expr] if wait_time
+        options[:functionDeclaration] = options[:functionDeclaration] % expr
+        options = options.merge(arguments: args)
+        unless options[:executionContextId]
+          options = options.merge(executionContextId: execution_context_id)
+        end
+
+        command("Runtime.callFunctionOn", **options)
+          .dig("result").tap { |r| handle_error(r) }
+      end
+
+      # FIXME: We should have a central place to handle all type of errors
+      def handle_error(result)
+        return if result["subtype"] != "error"
+
+        case result["className"]
+        when "TimedOutPromise"
+          raise ScriptTimeoutError
+        when "MouseEventFailed"
+          raise MouseEventFailed.new(result["description"])
+        else
+          raise JavaScriptError.new(result)
+        end
+      end
+
+      def prepare_args(args)
+        args.map do |arg|
+          if arg.is_a?(Node)
+            node_id = arg.native.node["nodeId"]
+            resolved = command("DOM.resolveNode", nodeId: node_id)
+            { objectId: resolved["object"]["objectId"] }
+          elsif arg.is_a?(Hash) && arg["objectId"]
+            { objectId: arg["objectId"] }
+          else
+            { value: arg }
+          end
+        end
+      end
+
+      def handle(response, cleanup = true)
+        case response["type"]
+        when "boolean", "number", "string"
+          response["value"]
+        when "undefined"
+          nil
+        when "function"
+          {}
+        when "object"
+          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) }
+          when "array"
+            reduce_properties(response["objectId"], Array.new) do |memo, key, value|
+              next(memo) unless (Integer(key) rescue nil)
+              value = value["objectId"] ? handle(value, false) : value["value"]
+              memo.insert(key.to_i, value)
+            end
+          when "date"
+            response["description"]
+          when "null"
+            nil
+          else
+            reduce_properties(response["objectId"], Hash.new) do |memo, key, value|
+              value = value["objectId"] ? handle(value, false) : 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)"
+        else
+          properties(object_id).reduce(object) 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")
+      end
+    end
+  end
+end