cuprite 0.6.0 → 0.7.1

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

@@ -1,223 +0,0 @@
-# frozen_string_literal: true
-
-require "cliver"
-
-module Capybara::Cuprite
-  class Browser
-    class Process
-      KILL_TIMEOUT = 2
-      PROCESS_TIMEOUT = 1
-      BROWSER_PATH = ENV["BROWSER_PATH"]
-      BROWSER_HOST = "127.0.0.1"
-      BROWSER_PORT = "0"
-      DEFAULT_OPTIONS = {
-        "headless" => nil,
-        "disable-gpu" => nil,
-        "hide-scrollbars" => nil,
-        "mute-audio" => nil,
-        "enable-automation" => nil,
-        "disable-web-security" => nil,
-        "disable-session-crashed-bubble" => nil,
-        "disable-breakpad" => nil,
-        "disable-sync" => nil,
-        "no-first-run" => nil,
-        "use-mock-keychain" => nil,
-        "keep-alive-for-test" => nil,
-        "disable-popup-blocking" => nil,
-        "disable-extensions" => nil,
-        "disable-hang-monitor" => nil,
-        "disable-features" => "site-per-process,TranslateUI",
-        "disable-translate" => nil,
-        "disable-background-networking" => nil,
-        "enable-features" => "NetworkService,NetworkServiceInProcess",
-        "disable-background-timer-throttling" => nil,
-        "disable-backgrounding-occluded-windows" => nil,
-        "disable-client-side-phishing-detection" => nil,
-        "disable-default-apps" => nil,
-        "disable-dev-shm-usage" => nil,
-        "disable-ipc-flooding-protection" => nil,
-        "disable-prompt-on-repost" => nil,
-        "disable-renderer-backgrounding" => nil,
-        "force-color-profile" => "srgb",
-        "metrics-recording-only" => nil,
-        "safebrowsing-disable-auto-update" => nil,
-        "password-store" => "basic",
-        # 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,
-      }.freeze
-
-      attr_reader :host, :port, :ws_url, :pid, :path, :options, :cmd
-
-      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("USR1", pid)
-              start = Capybara::Helpers.monotonic_time
-              while ::Process.wait(pid, ::Process::WNOHANG).nil?
-                sleep 0.05
-                next unless (Capybara::Helpers.monotonic_time - 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 = {}
-
-        detect_browser_path(options)
-
-        # Doesn't work on MacOS, so we need to set it by CDP as well
-        @options.merge!("window-size" => options[:window_size].join(","))
-
-        port = options.fetch(:port, BROWSER_PORT)
-        @options.merge!("remote-debugging-port" => port)
-
-        host = options.fetch(:host, BROWSER_HOST)
-        @options.merge!("remote-debugging-address" => host)
-
-        @options.merge!("user-data-dir" => Dir.mktmpdir)
-
-        @options = DEFAULT_OPTIONS.merge(@options)
-
-        unless options.fetch(:headless, true)
-          @options.delete("headless")
-          @options.delete("disable-gpu")
-        end
-
-        @process_timeout = options.fetch(:process_timeout, PROCESS_TIMEOUT)
-
-        @options.merge!(options.fetch(:browser_options, {}))
-
-        @logger = options.fetch(:logger, nil)
-      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, @process_timeout)
-      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 detect_browser_path(options)
-        @path =
-          options[:browser_path] ||
-          BROWSER_PATH || (
-            if RUBY_PLATFORM.include?('darwin')
-              [
-                "/Applications/Chromium.app/Contents/MacOS/Chromium",
-                "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
-              ].find { |path| File.exist?(path) }
-            else
-              %w[chromium google-chrome-unstable google-chrome-beta google-chrome chrome chromium-browser google-chrome-stable].reduce(nil) do |path, exe|
-                path = Cliver.detect(exe)
-                break path if path
-              end
-            end
-          )
-
-        unless @path
-          message = "Could not find an executable for chrome. 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
-
-      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, timeout = PROCESS_TIMEOUT)
-        output = ""
-        start = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        max_time = start + timeout
-        regexp = /DevTools listening on (ws:\/\/.*)/
-        while (now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)) < max_time
-          begin
-            output += read_io.read_nonblock(512)
-          rescue IO::WaitReadable
-            IO.select([read_io], nil, nil, max_time - now)
-          else
-            if output.match(regexp)
-              @ws_url = Addressable::URI.parse(output.match(regexp)[1].strip)
-              @host = @ws_url.host
-              @port = @ws_url.port
-              break
-            end
-          end
-        end
-
-        unless @ws_url
-          @logger.puts output if @logger
-          raise "Chrome process did not produce websocket url within #{timeout} seconds"
-        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

@@ -1,182 +0,0 @@
-# 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
-
-        begin
-          attempts ||= 1
-          response = command("Runtime.callFunctionOn", **options)
-          response.dig("result").tap { |r| handle_error(r) }
-        rescue BrowserError => e
-          case e.message
-          when "No node with given id found", "Could not find node with given id", "Cannot find context with specified id"
-            sleep 0.1
-            attempts += 1
-            options = options.merge(executionContextId: execution_context_id)
-            retry if attempts <= 3
-          end
-        end
-      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)
-        case response["type"]
-        when "boolean", "number", "string"
-          response["value"]
-        when "undefined"
-          nil
-        when "function"
-          {}
-        when "object"
-          object_id = response["objectId"]
-
-          case response["subtype"]
-          when "node"
-            begin
-              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 }
-            rescue BrowserError => e
-              # Node has disappeared while we were trying to get it
-              raise if e.message != "Could not find node with given id"
-            end
-          when "array"
-            reduce_props(object_id, []) do |memo, key, value|
-              next(memo) unless (Integer(key) rescue nil)
-              value = value["objectId"] ? handle(value) : value["value"]
-              memo.insert(key.to_i, value)
-            end.compact
-          when "date"
-            response["description"]
-          when "null"
-            nil
-          else
-            reduce_props(object_id, {}) do |memo, key, value|
-              value = value["objectId"] ? handle(value) : value["value"]
-              memo.merge(key => value)
-            end
-          end
-        end
-      end
-
-      def reduce_props(object_id, to)
-        if cyclic?(object_id).dig("result", "value")
-          return "(cyclic structure)"
-        else
-          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 cyclic?(object_id)
-        command("Runtime.callFunctionOn",
-                objectId: object_id,
-                returnByValue: true,
-                functionDeclaration: "function() { return _cuprite.isCyclic(this); }")
-      end
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-module Capybara::Cuprite
-  class Browser
-    class Targets
-      def initialize(browser)
-        @mutex = Mutex.new
-        @browser = browser
-        @_default = targets.first["targetId"]
-
-        @browser.subscribe("Target.detachedFromTarget") do |params|
-          page = remove_page(params["targetId"])
-          page&.close_connection
-        end
-
-        reset
-      end
-
-      def push(target_id, page = nil)
-        @targets[target_id] = page
-      end
-
-      def refresh
-        @mutex.synchronize do
-          targets.each { |t| push(t["targetId"]) if !default?(t) && !has?(t) }
-        end
-      end
-
-      def page
-        raise NoSuchWindowError unless @page
-        @page
-      end
-
-      def window_handle
-        page.target_id
-      end
-
-      def window_handles
-        @mutex.synchronize { @targets.keys }
-      end
-
-      def switch_to_window(target_id)
-        @page = find_or_create_page(target_id)
-      end
-
-      def open_new_window
-        target_id = @browser.command("Target.createTarget", url: "about:blank", browserContextId: @_context_id)["targetId"]
-        page = Page.new(target_id, @browser)
-        push(target_id, page)
-        target_id
-      end
-
-      def close_window(target_id)
-        remove_page(target_id)&.close
-      end
-
-      def within_window(locator)
-        original = window_handle
-
-        if Capybara::VERSION.to_f < 3.0
-          target_id = window_handles.find do |target_id|
-            page = find_or_create_page(target_id)
-            locator == page.frame_name
-          end
-          locator = target_id if target_id
-        end
-
-        if window_handles.include?(locator)
-          switch_to_window(locator)
-          yield
-        else
-          raise NoSuchWindowError
-        end
-      ensure
-        switch_to_window(original)
-      end
-
-      def reset
-        if @page
-          @page.close
-          @browser.command("Target.disposeBrowserContext", browserContextId: @_context_id)
-        end
-
-        @page = nil
-        @targets = {}
-        @_context_id = nil
-
-        @_context_id = @browser.command("Target.createBrowserContext")["browserContextId"]
-        target_id = @browser.command("Target.createTarget", url: "about:blank", browserContextId: @_context_id)["targetId"]
-        @page = Page.new(target_id, @browser)
-        push(target_id, @page)
-      end
-
-      private
-
-      def find_or_create_page(target_id)
-        page = @targets[target_id]
-        page ||= Page.new(target_id, @browser)
-        @targets[target_id] ||= page
-        page
-      end
-
-      def remove_page(target_id)
-        page = @targets.delete(target_id)
-        @page = nil if page && @page == page
-        page
-      end
-
-      def targets
-        attempts ||= 1
-        # Targets cannot be empty the must be at least one default target.
-        targets = @browser.command("Target.getTargets")["targetInfos"]
-        raise TypeError if targets.empty?
-        targets
-      rescue TypeError
-        attempts += 1
-        retry if attempts < 3
-      end
-
-      def default?(target)
-        @_default == target["targetId"]
-      end
-
-      def has?(target)
-        @targets.key?(target["targetId"])
-      end
-    end
-  end
-end

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "socket"
-require "websocket/driver"
-
-module Capybara::Cuprite
-  class Browser
-    class WebSocket
-      attr_reader :url, :messages
-
-      def initialize(url, logger)
-        @url      = url
-        @logger   = logger
-        uri       = URI.parse(@url)
-        @sock     = TCPSocket.new(uri.host, uri.port)
-        @driver   = ::WebSocket::Driver.client(self)
-        @messages = Queue.new
-
-        @driver.on(:open,    &method(:on_open))
-        @driver.on(:message, &method(:on_message))
-        @driver.on(:close,   &method(:on_close))
-
-        @thread = Thread.new do
-          begin
-            while data = @sock.readpartial(512)
-              @driver.parse(data)
-            end
-          rescue EOFError, Errno::ECONNRESET
-            @messages.close
-          end
-        end
-
-        @thread.priority = 1
-
-        @driver.start
-      end
-
-      def on_open(_event)
-        sleep 0.01 # https://github.com/faye/websocket-driver-ruby/issues/46
-      end
-
-      def on_message(event)
-        data = JSON.parse(event.data)
-        @messages.push(data)
-        @logger&.puts("    <<< #{event.data}\n")
-      end
-
-      def on_close(_event)
-        @messages.close
-        @thread.kill
-      end
-
-      def send_message(data)
-        json = data.to_json
-        @driver.text(json)
-        @logger&.puts("\n\n>>> #{json}")
-      end
-
-      def write(data)
-        @sock.write(data)
-      end
-
-      def close
-        @driver.close
-      end
-    end
-  end
-end

data/lib/capybara/cuprite/network/error.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Capybara::Cuprite::Network
-  class Error
-    def initialize(data)
-      @data = data
-    end
-
-    def id
-      @data["networkRequestId"]
-    end
-
-    def url
-      @data["url"]
-    end
-
-    def description
-      @data["text"]
-    end
-
-    def time
-      @time ||= Time.strptime(@data["timestamp"].to_s, "%s")
-    end
-  end
-end

data/lib/capybara/cuprite/network/request.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "time"
-
-module Capybara::Cuprite::Network
-  class Request
-    attr_accessor :response, :error
-
-    def initialize(data)
-      @data = data
-    end
-
-    def id
-      @data["id"]
-    end
-
-    def url
-      @data["url"]
-    end
-
-    def method
-      @data["method"]
-    end
-
-    def headers
-      @data["headers"]
-    end
-
-    def time
-      @time ||= Time.strptime(@data["time"].to_s, "%s")
-    end
-  end
-end

data/lib/capybara/cuprite/network/response.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Capybara::Cuprite::Network
-  class Response
-    attr_accessor :body_size
-
-    def initialize(data)
-      @data = data
-    end
-
-    def id
-      @data["id"]
-    end
-
-    def url
-      @data["url"]
-    end
-
-    def status
-      @data["status"]
-    end
-
-    def status_text
-      @data["statusText"]
-    end
-
-    def headers
-      @data["headers"]
-    end
-
-    def headers_size
-      @data["encodedDataLength"]
-    end
-
-    # FIXME: didn't check if we have it on redirect response
-    def redirect_url
-      @data["redirectURL"]
-    end
-
-    def content_type
-      @content_type ||= @data.dig("headers", "contentType").sub(/;.*\z/, "")
-    end
-  end
-end