apparition 0.0.1

data/lib/capybara/apparition/chrome_client.rb

@@ -0,0 +1,235 @@
+# frozen_string_literal: true
+
+require 'capybara/apparition/errors'
+require 'capybara/apparition/web_socket_client'
+
+module Capybara::Apparition
+  class ChromeClient
+    class << self
+      DEFAULT_OPTIONS = {
+        host: 'localhost',
+        port: 9222
+      }.freeze
+
+      def client(ws_url)
+        new(ws_url)
+      end
+
+    private
+
+      def get_ws_url(options)
+        response = Net::HTTP.get(options[:host], '/json', options[:port])
+        # TODO: handle unsuccesful request
+        response = JSON.parse(response)
+
+        first_page = response.find { |e| e['type'] == 'page' }
+        # TODO: handle no entry found
+        first_page['webSocketDebuggerUrl']
+      end
+    end
+
+    def initialize(ws_url)
+      @ws = WebSocketClient.new(ws_url)
+      @handlers = Hash.new { |hash, key| hash[key] = [] }
+
+      @responses = {}
+
+      @events = Queue.new
+
+      @send_mutex = Mutex.new
+      @msg_mutex = Mutex.new
+      @message_available = ConditionVariable.new
+      @session_handlers = Hash.new { |hash, key| hash[key] = Hash.new { |h, k| h[k] = [] } }
+      @timeout = nil
+      @async_ids = []
+
+      start_threads
+    end
+
+    attr_accessor :timeout
+
+    def stop
+      @ws.close
+    end
+
+    def on(event_name, session_id = nil, &block)
+      return @handlers[event_name] << block unless session_id
+
+      @session_handlers[session_id][event_name] << block
+    end
+
+    def send_cmd(command, params, async:)
+      msg_id, msg = generate_msg(command, params, async: async)
+      @send_mutex.synchronize do
+        puts "#{Time.now.to_i}: sending msg: #{msg}" if ENV['DEBUG']
+        @ws.send_msg(msg)
+      end
+
+      return nil if async
+
+      puts "waiting for session response for message #{msg_id}" if ENV['DEUG']
+      response = wait_for_msg_response(msg_id)
+
+      raise CDPError(response['error']) if response['error']
+
+      response['result']
+    end
+
+    def send_cmd_to_session(session_id, command, params, async:)
+      msg_id, msg = generate_msg(command, params, async: async)
+
+      send_cmd('Target.sendMessageToTarget', { sessionId: session_id, message: msg }, async: async)
+
+      return nil if async
+
+      puts "waiting for session response for message #{msg_id}" if ENV['DEBUG'] == 'V'
+      response = wait_for_msg_response(msg_id)
+
+      if (error = response['error'])
+        case error['code']
+        when -32_000
+          raise WrongWorld.new(nil, error)
+        else
+          raise CDPError.new(error)
+        end
+      end
+
+      response['result']
+    end
+
+    def listen_until
+      read_until { yield }
+    end
+
+    def listen
+      read_until { false }
+    end
+
+  private
+
+    def generate_msg(command, params, async:)
+      @send_mutex.synchronize do
+        msg_id = generate_unique_id
+        @async_ids.push(msg_id) if async
+        [msg_id, { method: command, params: params, id: msg_id }.to_json]
+      end
+    end
+
+    def wait_for_msg_response(msg_id)
+      @msg_mutex.synchronize do
+        start_time = Time.now
+        while (response = @responses.delete(msg_id)).nil?
+          if @timeout && ((Time.now - start_time) > @timeout)
+            puts "Timedout waiting for response for msg: #{msg_id}"
+            raise TimeoutError.new(msg_id)
+          end
+          @message_available.wait(@msg_mutex, 0.1)
+        end
+        response
+      end
+    end
+
+    def generate_unique_id
+      @last_id ||= 0
+      @last_id += 1
+    end
+
+    def read_until
+      loop do
+        msg = read_msg
+        return msg if yield(msg)
+      end
+    end
+
+    def read_msg
+      msg = JSON.parse(@ws.read_msg)
+      puts "#{Time.now.to_i}: got msg: #{msg}" if ENV['DEBUG']
+      # Check if it's an event and push on event queue
+      @events.push msg.dup if msg['method']
+
+      msg = JSON.parse(msg['params']['message']) if msg['method'] == 'Target.receivedMessageFromTarget'
+
+      if msg['id']
+        @msg_mutex.synchronize do
+          puts "broadcasting response to #{msg['id']}" if ENV['DEBUG'] == 'V'
+          @responses[msg['id']] = msg
+          @message_available.broadcast
+        end
+      end
+      msg
+    end
+
+    def cleanup_async_responses
+      loop do
+        @msg_mutex.synchronize do
+          @message_available.wait(@msg_mutex, 0.1)
+          (@responses.keys & @async_ids).each do |msg_id|
+            puts "Cleaning up response for #{msg_id}" if ENV['DEBUG'] == 'v'
+            @responses.delete(msg_id)
+            @async_ids.delete(msg_id)
+          end
+        end
+      end
+    end
+
+    def process_messages
+      # run handlers in own thread so as not to hang message processing
+      loop do
+        event = @events.pop
+        next unless event
+
+        event_name = event['method']
+        puts "popped event #{event_name}" if ENV['DEBUG'] == 'V'
+
+        if event_name == 'Target.receivedMessageFromTarget'
+          session_id = event.dig('params', 'sessionId')
+          event = JSON.parse(event.dig('params', 'message'))
+          event_name = event['method']
+          if event_name
+            puts "calling session handler for #{event_name}" if ENV['DEBUG'] == 'V'
+            @session_handlers[session_id][event_name].each do |handler|
+              handler.call(event['params'])
+            end
+          end
+        end
+
+        @handlers[event_name].each do |handler|
+          puts "calling handler for #{event_name}" if ENV['DEBUG'] == 'V'
+          handler.call(event['params'])
+        end
+      end
+    rescue CDPError => e
+      if e.code == -32_602
+        puts "Attempt to contact session that's gone away"
+      else
+        puts "Unexpected CDPError: #{e.message}"
+      end
+      retry
+    rescue StandardError => e
+      puts "Unexpected inner loop exception: #{e}: #{e.message}: #{e.backtrace}"
+      retry
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      puts "Unexpected Outer Loop exception: #{e}"
+      retry
+    end
+
+    def start_threads
+      @processor = Thread.new do
+        process_messages
+      end
+      @processor.abort_on_exception = true
+
+      @async_response_handler = Thread.new do
+        cleanup_async_responses
+      end
+      @async_response_handler.abort_on_exception = true
+
+      @listener = Thread.new do
+        begin
+          listen
+        rescue EOFError # rubocop:disable Lint/HandleExceptions
+        end
+      end
+    end
+  end
+end

data/lib/capybara/apparition/command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Capybara::Apparition
+  class Command
+    attr_reader :id
+    attr_reader :name
+    attr_accessor :args
+
+    def initialize(name, params = {})
+      @id = SecureRandom.uuid
+      @name = name
+      @params = params
+    end
+
+    def message
+      JSON.dump('id' => @id, 'name' => @name, 'params' => @params)
+    end
+  end
+end

data/lib/capybara/apparition/cookie.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Capybara::Apparition
+  class Cookie
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def name
+      @attributes['name']
+    end
+
+    def value
+      @attributes['value']
+    end
+
+    def domain
+      @attributes['domain']
+    end
+
+    def path
+      @attributes['path']
+    end
+
+    def secure?
+      @attributes['secure']
+    end
+
+    def http_only?
+      @attributes['httpOnly']
+    end
+    alias httponly? http_only?
+
+    def httpOnly? # rubocop:disable Naming/MethodName
+      warn 'httpOnly? is deprecated, please use http_only? instead'
+      http_only?
+    end
+
+    def same_site
+      @attributes['sameSite']
+    end
+
+    def samesite
+      same_site
+    end
+
+    def expires
+      Time.at @attributes['expires'] unless [nil, 0, -1].include? @attributes['expires']
+    end
+  end
+end

data/lib/capybara/apparition/dev_tools_protocol/session.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Capybara::Apparition
+  module DevToolsProtocol
+    class Session
+      attr_reader :browser, :connection, :target_id, :session_id
+
+      def initialize(browser, connection, target_id, session_id)
+        @browser = browser
+        @connection = connection
+        @target_id = target_id
+        @session_id = session_id
+        @handlers = []
+      end
+
+      def command(name, **params)
+        @browser.command_for_session(@session_id, name, params, async: false)
+      end
+
+      def async_command(name, **params)
+        @browser.command_for_session(@session_id, name, params, async: true)
+      end
+
+      def on(event_name, &block)
+        connection.on(event_name, @session_id, &block)
+      end
+    end
+  end
+end

data/lib/capybara/apparition/dev_tools_protocol/target.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'capybara/apparition/dev_tools_protocol/session'
+
+module Capybara::Apparition
+  module DevToolsProtocol
+    class Target
+      attr_accessor :info
+
+      def initialize(browser, info)
+        @browser = browser
+        @info = info
+        @page = nil
+      end
+
+      def id
+        info['targetId']
+      end
+
+      def title
+        info['title']
+      end
+
+      def url
+        info['url']
+      end
+
+      def page
+        @page ||= begin
+          if info['type'] == 'page'
+            Page.create(@browser, create_session, id,
+                        ignore_https_errors: true,
+                        js_errors: @browser.js_errors).inherit(info.delete('inherit'))
+          else
+            nil
+          end
+        end
+      end
+
+      def close
+        @browser.command('Target.closeTarget', targetId: id)
+      end
+
+    private
+
+      def create_session
+        session_id = @browser.command('Target.attachToTarget', targetId: id)['sessionId']
+        Session.new(@browser, @browser.client, id, session_id)
+      end
+    end
+  end
+end

data/lib/capybara/apparition/dev_tools_protocol/target_manager.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'capybara/apparition/dev_tools_protocol/target'
+
+module Capybara::Apparition
+  module DevToolsProtocol
+    class TargetManager
+      def initialize
+        @targets = {}
+      end
+
+      def get(id)
+        @targets[id]
+      end
+
+      def add(id, target)
+        @targets[id] = target
+      end
+
+      def delete(id)
+        @targets.delete(id)
+      end
+
+      def pages
+        @targets.values.select { |target| target.info['type'] == 'page' }.map(&:page)
+      end
+
+      def target?(id)
+        @targets.key?(id)
+      end
+
+      def window_handles
+        @targets.values.select { |target| target.info['type'] == 'page' }.map(&:id).compact
+      end
+    end
+  end
+end

data/lib/capybara/apparition/driver.rb

@@ -0,0 +1,505 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'capybara/apparition/chrome_client'
+require 'capybara/apparition/launcher'
+
+module Capybara::Apparition
+  class Driver < Capybara::Driver::Base
+    DEFAULT_TIMEOUT = 30
+
+    attr_reader :app, :options
+
+    def initialize(app, options = {})
+      @app       = app
+      @options   = options
+      @browser   = nil
+      @inspector = nil
+      @client    = nil
+      @started   = false
+    end
+
+    def needs_server?
+      true
+    end
+
+    def chrome_url
+      'ws://localhost:9223'
+    end
+
+    def browser
+      @browser ||= begin
+        browser = Browser.new(client, browser_logger)
+        browser.js_errors  = options[:js_errors] if options.key?(:js_errors)
+        browser.extensions = options.fetch(:extensions, [])
+        browser.debug      = true if options[:debug]
+        browser.url_blacklist = options[:url_blacklist] || []
+        browser.url_whitelist = options[:url_whitelist] || []
+        browser
+      end
+    end
+
+    def inspector
+      @inspector ||= options[:inspector] && Inspector.new(options[:inspector])
+    end
+
+    def client
+      @client ||= begin
+        browser_options = {}
+        browser_options['remote-debugging-port'] = options[:port] || 0
+        browser_options['remote-debugging-address'] = options[:host] if options[:host]
+        browser_options['window-size'] = options[:window_size].join(',') if options[:window_size]
+        @launcher ||= Browser::Launcher.start(
+          headless: options[:headless] != false,
+          browser: browser_options
+          )
+        ws_url = @launcher.ws_url
+        client = ::Capybara::Apparition::ChromeClient.client(ws_url.to_s)
+        sleep 3
+        client
+      end
+    end
+
+    def browser_options
+      list = options[:browser_options] || []
+
+      # TODO: configure SSL options
+      # PhantomJS defaults to only using SSLv3, which since POODLE (Oct 2014)
+      # many sites have dropped from their supported protocols (eg PayPal,
+      # Braintree).
+      # list += ["--ignore-ssl-errors=yes"] unless list.grep(/ignore-ssl-errors/).any?
+      # list += ["--ssl-protocol=TLSv1"] unless list.grep(/ssl-protocol/).any?
+      # list += ["--remote-debugger-port=#{inspector.port}", "--remote-debugger-autorun=yes"] if inspector
+      list
+    end
+
+    def restart
+      browser.restart
+    end
+
+    def quit
+      @client&.stop
+      @launcher&.stop
+    end
+
+    # logger should be an object that responds to puts, or nil
+    def logger
+      options[:logger] || (options[:debug] && STDERR)
+    end
+
+    # logger should be an object that behaves like IO or nil
+    def browser_logger
+      options.fetch(:browser_logger, nil)
+    end
+
+    def visit(url)
+      @started = true
+      browser.visit(url)
+    end
+
+    def current_url
+      browser.current_url
+    end
+
+    def status_code
+      browser.status_code
+    end
+
+    def html
+      browser.body
+    end
+    alias body html
+
+    def source
+      browser.source.to_s
+    end
+
+    def title
+      browser.title
+    end
+
+    def frame_title
+      browser.frame_title
+    end
+
+    def frame_url
+      browser.frame_url
+    end
+
+    def find(method, selector)
+      browser.find(method, selector).map { |page_id, id| Capybara::Apparition::Node.new(self, page_id, id) }
+    end
+
+    def find_xpath(selector)
+      find :xpath, selector.to_s
+    end
+
+    def find_css(selector)
+      find :css, selector.to_s
+    end
+
+    def click(x, y)
+      browser.click_coordinates(x, y)
+    end
+
+    def evaluate_script(script, *args)
+      result = browser.evaluate(script, *native_args(args))
+      unwrap_script_result(result)
+    end
+
+    def evaluate_async_script(script, *args)
+      result = browser.evaluate_async(script, session_wait_time, *native_args(args))
+      unwrap_script_result(result)
+    end
+
+    def execute_script(script, *args)
+      browser.execute(script, *native_args(args))
+      nil
+    end
+
+    def switch_to_frame(frame)
+      browser.switch_to_frame(frame)
+    end
+
+    def current_window_handle
+      browser.window_handle
+    end
+
+    def window_handles
+      browser.window_handles
+    end
+
+    def close_window(handle)
+      browser.close_window(handle)
+    end
+
+    def open_new_window
+      browser.open_new_window
+    end
+
+    def switch_to_window(handle)
+      browser.switch_to_window(handle)
+    end
+
+    def within_window(name, &block)
+      browser.within_window(name, &block)
+    end
+
+    def no_such_window_error
+      NoSuchWindowError
+    end
+
+    def reset!
+      browser.reset
+      # TODO: reset the black/whitelists
+      # browser.url_blacklist = options[:url_blacklist] || []
+      # browser.url_whitelist = options[:url_whitelist] || []
+      @started = false
+    end
+
+    def save_screenshot(path, options = {})
+      browser.render(path, options)
+    end
+    alias render save_screenshot
+
+    def render_base64(format = :png, options = {})
+      browser.render_base64(format, options)
+    end
+
+    def paper_size=(size = {})
+      browser.set_paper_size(size)
+    end
+
+    # def zoom_factor=(zoom_factor)
+    #   TODO: Implement if still necessary
+    #   browser.set_zoom_factor(zoom_factor)
+    # end
+
+    def resize(width, height)
+      browser.resize(width, height, screen: options[:screen_size])
+    end
+    alias resize_window resize
+
+    def resize_window_to(handle, width, height)
+      within_window(handle) do
+        resize(width, height)
+      end
+    end
+
+    def maximize_window(handle)
+      within_window(handle) do
+        browser.maximize
+      end
+    end
+
+    def fullscreen_window(handle)
+      within_window(handle) do
+        browser.fullscreen
+      end
+    end
+
+    def window_size(handle)
+      within_window(handle) do
+        evaluate_script('[window.innerWidth, window.innerHeight]')
+      end
+    end
+
+    def scroll_to(left, top)
+      browser.scroll_to(left, top)
+    end
+
+    def network_traffic(type = nil)
+      browser.network_traffic(type)
+    end
+
+    def clear_network_traffic
+      browser.clear_network_traffic
+    end
+
+    def set_proxy(ip, port, type = 'http', user = nil, password = nil)
+      browser.set_proxy(ip, port, type, user, password)
+    end
+
+    def headers
+      browser.get_headers
+    end
+
+    def headers=(headers)
+      browser.set_headers(headers)
+    end
+
+    def add_headers(headers)
+      browser.add_headers(headers)
+    end
+
+    def add_header(name, value, options = {})
+      browser.add_header({ name => value }, { permanent: true }.merge(options))
+    end
+
+    def response_headers
+      browser.response_headers.each_with_object({}) do |(key, value), hsh|
+        hsh[key.split('-').map(&:capitalize).join('-')] = value
+      end
+    end
+
+    def cookies
+      browser.cookies
+    end
+
+    def set_cookie(name, value, options = {})
+      options[:name]  ||= name
+      options[:value] ||= value
+      options[:domain] ||= begin
+        if @started
+          URI.parse(browser.current_url).host
+        else
+          URI.parse(default_cookie_host).host || '127.0.0.1'
+        end
+      end
+
+      browser.set_cookie(options)
+    end
+
+    def remove_cookie(name)
+      browser.remove_cookie(name)
+    end
+
+    def clear_cookies
+      browser.clear_cookies
+    end
+
+    def cookies_enabled=(flag)
+      browser.cookies_enabled = flag
+    end
+
+    def clear_memory_cache
+      browser.clear_memory_cache
+    end
+
+    def basic_authorize(user = nil, password = nil)
+      browser.set_http_auth(user, password)
+      # credentials = ["#{user}:#{password}"].pack('m*').strip
+      # add_header('Authorization', "Basic #{credentials}")
+    end
+
+    def debug
+      if @options[:inspector]
+        # Fall back to default scheme
+        scheme = begin
+                   URI.parse(browser.current_url).scheme
+                 rescue StandardError
+                   nil
+                 end
+        scheme = 'http' if scheme != 'https'
+        inspector.open(scheme)
+        pause
+      else
+        raise Error, 'To use the remote debugging, you have to launch the driver ' \
+                     'with `:inspector => true` configuration option'
+      end
+    end
+
+    def pause
+      # STDIN is not necessarily connected to a keyboard. It might even be closed.
+      # So we need a method other than keypress to continue.
+
+      # In jRuby - STDIN returns immediately from select
+      # see https://github.com/jruby/jruby/issues/1783
+      # TODO: This limitation is no longer true can we simplify?
+      read, write = IO.pipe
+      Thread.new do
+        IO.copy_stream(STDIN, write)
+        write.close
+      end
+
+      STDERR.puts "Apparition execution paused. Press enter (or run 'kill -CONT #{Process.pid}') to continue."
+
+      signal = false
+      old_trap = trap('SIGCONT') do
+        signal = true
+        STDERR.puts "\nSignal SIGCONT received"
+      end
+      # wait for data on STDIN or signal SIGCONT received
+      keyboard = IO.select([read], nil, nil, 1) until keyboard || signal
+
+      unless signal
+        begin
+          input = read.read_nonblock(80) # clear out the read buffer
+          puts unless input&.end_with?("\n")
+        rescue EOFError, IO::WaitReadable # rubocop:disable Lint/HandleExceptions
+          # Ignore problems reading from STDIN.
+        end
+      end
+    ensure
+      trap('SIGCONT', old_trap) # Restore the previous signal handler, if there was one.
+      STDERR.puts 'Continuing'
+    end
+
+    def wait?
+      true
+    end
+
+    def invalid_element_errors
+      [Capybara::Apparition::ObsoleteNode, Capybara::Apparition::MouseEventFailed]
+    end
+
+    def go_back
+      browser.go_back
+    end
+
+    def go_forward
+      browser.go_forward
+    end
+
+    def refresh
+      browser.refresh
+    end
+
+    def accept_modal(type, options = {})
+      case type
+      when :alert
+        browser.accept_alert
+      when :confirm
+        browser.accept_confirm
+      when :prompt
+        browser.accept_prompt options[:with]
+      end
+
+      yield if block_given?
+
+      find_modal(options)
+    end
+
+    def dismiss_modal(type, options = {})
+      case type
+      when :confirm
+        browser.dismiss_confirm
+      when :prompt
+        browser.dismiss_prompt
+      end
+
+      yield if block_given?
+      find_modal(options)
+    end
+
+    def timeout
+      client.timeout
+    end
+
+    def timeout=(sec)
+      client.timeout = sec
+    end
+
+  private
+
+    def screen_size
+      options[:screen_size] || [1366, 768]
+    end
+
+    def find_modal(options)
+      start_time    = Time.now
+      timeout_sec   = options.fetch(:wait) { session_wait_time }
+      expect_text   = options[:text]
+      expect_regexp = expect_text.is_a?(Regexp) ? expect_text : Regexp.escape(expect_text.to_s)
+      begin
+        modal_text = browser.modal_message
+        found_text ||= modal_text
+        raise Capybara::ModalNotFound if modal_text.nil? || (expect_text && !modal_text.match(expect_regexp))
+      rescue Capybara::ModalNotFound => e
+        if (Time.now - start_time) >= timeout_sec
+          raise e, 'Unable to find modal dialog'\
+                   "#{" with #{expect_text}" if expect_text}"\
+                   "#{", did find modal with #{found_text}" if found_text}"
+        end
+        sleep(0.5)
+        retry
+      end
+      modal_text
+    end
+
+    def session_wait_time
+      if respond_to?(:session_options)
+        session_options.default_max_wait_time
+      else
+        begin begin
+                Capybara.default_max_wait_time
+              rescue StandardError
+                Capybara.default_wait_time
+              end end
+      end
+    end
+
+    def default_cookie_host
+      if respond_to?(:session_options)
+        session_options.app_host
+      else
+        Capybara.app_host
+      end || ''
+    end
+
+    def native_args(args)
+      args.map { |arg| arg.is_a?(Capybara::Apparition::Node) ? arg.native : arg }
+    end
+
+    def unwrap_script_result(arg, object_cache = {})
+      return object_cache[arg] if object_cache.key? arg
+
+      case arg
+      when Array
+        object_cache[arg] = []
+        object_cache[arg].replace(arg.map { |e| unwrap_script_result(e, object_cache) })
+        object_cache[arg]
+      when Hash
+        if (arg['subtype'] == 'node') && arg['objectId']
+          Capybara::Apparition::Node.new(self, browser.current_page, arg['objectId'])
+        else
+          object_cache[arg] = {}
+          arg.each { |k, v| object_cache[arg][k] = unwrap_script_result(v, object_cache) }
+          object_cache[arg]
+        end
+      else
+        arg
+      end
+    end
+  end
+end