apparition 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9aa4f4946fd5bbdd57c5547b6dd179c2c9f91737e4810bc331ac7155b9efb542
-  data.tar.gz: 8bdbca6fc6c5598a8827627f10b4dc9dfbbe94df5b57ea006a80d13a8bf4402a
+  metadata.gz: 9e8fee05c8a55aecbed96ec2f5f1c7d36ffdea00488281be36fe4e6ac85ab9a4
+  data.tar.gz: 781e519f382127f2dfd6be4bda8a0b674d185bfdc8d1072962c5136cae773a1c
 SHA512:
-  metadata.gz: 47c7ddf86e36760c0d26c64e59a157d5e32871e106977dd166acceeca7cd3b07e27131d02e6ec1487d74cba6cdebad8831ea6b6a2e79fcf4d00dbe53fd02be70
-  data.tar.gz: 50d6f7f64911974d0f17687500a2059efba3ccd3f609f5c96f7fb09ba37a193f77d537c13c50b3fbf7a27d033ea3c0b591ee33023a991870637f211db5705ed3
+  metadata.gz: 96e43542fe127e373cb1f5167c4023922e4a0428b11fa11c13797e1dec0f304fad8ae6422e1c887891317d064905a1a54174c4696d989ad2741a18e6c278e901
+  data.tar.gz: 2667120038d46b9fc874f8009c9820fc6fee86e6a02e753ffcbd16c60398928bb1f1b8ad2cdbf2640d883de94920e2d569e6e127b433866c39809cc712cb34bd

data/README.md

@@ -172,6 +172,7 @@ end
     the browser. Useful for faking or mocking APIs.
 *   `:url_blacklist` (Array) - Default session url blacklist - expressed as an array of strings to match against requested URLs.
 *   `:url_whitelist` (Array) - Default session url whitelist - expressed as an array of strings to match against requested URLs.
+*   `:ignore_https_errors` (Boolean) - Ignore certificate errors when connecting to https URLs.
 *   `:browser_options` (Hash) - Extra command line options to pass to Chrome when starting
 
 ### URL Blacklisting & Whitelisting ###

data/lib/capybara/apparition/browser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'capybara/apparition/errors'
-require 'capybara/apparition/command'
 require 'capybara/apparition/dev_tools_protocol/target_manager'
 require 'capybara/apparition/page'
 require 'json'
@@ -9,7 +8,7 @@ require 'time'
 
 module Capybara::Apparition
   class Browser
-    attr_reader :client, :logger, :paper_size
+    attr_reader :client, :logger, :paper_size, :zoom_factor
 
     def initialize(client, logger = nil)
       @client = client
@@ -18,6 +17,7 @@ module Capybara::Apparition
       @targets = Capybara::Apparition::DevToolsProtocol::TargetManager.new
       @context_id = nil
       @js_errors = true
+      @ignore_https_errors = false
 
       initialize_handlers
 
@@ -34,7 +34,9 @@ module Capybara::Apparition
 
       self.debug = @debug if defined?(@debug)
       self.js_errors = @js_errors if defined?(@js_errors)
+      self.zoom_factor = @zoom_factor if defined?(@zoom_factor)
       self.extensions = @extensions if @extensions
+      current_page.clear_network_traffic
     end
 
     def visit(url)
@@ -130,9 +132,8 @@ module Capybara::Apparition
     end
 
     def close_window(handle)
-      @targets.delete(handle)
       @current_page_handle = nil if @current_page_handle == handle
-      command('Target.closeTarget', targetId: handle)
+      @targets.delete(handle).close
     end
 
     def within_window(locator)
@@ -150,9 +151,9 @@ module Capybara::Apparition
       @context_id = command('Target.createBrowserContext')['browserContextId']
       target_id = command('Target.createTarget', url: 'about:blank', browserContextId: @context_id)['targetId']
 
-      start = Time.now
+      timer = Capybara::Helpers.timer(expire_in: 5)
       until @targets.get(target_id)&.page&.usable?
-        if Time.now - start > 5
+        if timer.expired?
           puts 'Timedout waiting for reset'
           # byebug
           raise TimeoutError.new('reset')
@@ -168,26 +169,26 @@ module Capybara::Apparition
     end
 
     def render(path, options = {})
-      options[:format] ||= File.extname(path).downcase[1..-1]
-      check_render_options!(options)
-      options[:full] = !!options[:full]
+      check_render_options!(options, path)
       img_data = current_page.render(options)
       File.open(path, 'wb') { |f| f.write(Base64.decode64(img_data)) }
     end
 
-    def render_base64(_format, options = {})
+    def render_base64(options = {})
       check_render_options!(options)
-      options[:full] = !!options[:full]
       current_page.render(options)
     end
 
-    # def set_zoom_factor(zoom_factor)
-    #   TODO: implement if needed
-    #   command 'set_zoom_factor', zoom_factor
-    # end
+    attr_writer :zoom_factor
 
-    def set_paper_size(size)
-      @paper_size = size
+    def paper_size=(size)
+      @paper_size = if size.is_a? Hash
+        size
+      else
+        PAPER_SIZES.fetch(size) do
+          raise_errors ArgumentError, "Unknwon paper size: #{size}"
+        end
+      end
     end
 
     def resize(width, height, screen: nil)
@@ -223,18 +224,13 @@ module Capybara::Apparition
       # command('set_proxy', *args)
     end
 
-    def equals(page_id, id, other_id)
-      # TODO: Implement if still needed
-      # command('equals', page_id, id, other_id)
-    end
-
-    def get_headers
+    def headers
       current_page.extra_headers
     end
 
-    def set_headers(headers)
+    def headers=(headers)
       @targets.pages.each do |page|
-        page.perm_headers = headers
+        page.perm_headers = headers.dup
         page.temp_headers = {}
         page.temp_no_redirect_headers = {}
         page.update_headers
@@ -301,7 +297,7 @@ module Capybara::Apparition
       end
     end
 
-    attr_accessor :js_errors
+    attr_accessor :js_errors, :ignore_https_errors
 
     def extensions=(filenames)
       @extensions = filenames
@@ -329,26 +325,17 @@ module Capybara::Apparition
     end
 
     def command(name, params = {})
-      cmd = Command.new(name, params)
-      log cmd.message
-
-      response = client.send_cmd(name, params, async: false)
-      log response
+      result = client.send_cmd(name, params).result
+      log result
 
-      response || raise(Capybara::Apparition::ObsoleteNode.new(nil, nil))
+      result || raise(Capybara::Apparition::ObsoleteNode.new(nil, nil))
     rescue DeadClient
       restart
       raise
     end
 
-    def command_for_session(session_id, name, params, async: false)
-      cmd = Command.new(name, params)
-      log cmd.message
-
-      response = client.send_cmd_to_session(session_id, name, params, async: async)
-      log response
-
-      response
+    def command_for_session(session_id, name, params)
+      client.send_cmd_to_session(session_id, name, params)
     rescue DeadClient
       restart
       raise
@@ -378,16 +365,10 @@ module Capybara::Apparition
       current_page.add_modal(confirm: false)
     end
 
-    #
-    # press "OK" with text (response) or default value
-    #
     def accept_prompt(response)
       current_page.add_modal(prompt: response)
     end
 
-    #
-    # press "Cancel"
-    #
     def dismiss_prompt
       current_page.add_modal(prompt: false)
     end
@@ -411,11 +392,13 @@ module Capybara::Apparition
     end
 
     def log(message)
-      logger&.puts message
+      logger&.puts message if ENV['DEBUG']
     end
 
-    def check_render_options!(options)
+    def check_render_options!(options, path = nil)
+      options[:format] ||= File.extname(path).downcase[1..-1] if path
       options[:format] = :jpeg if options[:format].to_s == 'jpg'
+      options[:full] = !!options[:full]
       return unless options[:full] && options.key?(:selector)
 
       warn "Ignoring :selector in #render since :full => true was given at #{caller(1..1)}"
@@ -528,5 +511,15 @@ module Capybara::Apparition
         end
       end
     end
+
+    PAPER_SIZES = {
+      'A3' => { width: 11.69, height: 16.53 },
+      'A4' => { width: 8.27, height: 11.69 },
+      'A5' => { width: 5.83, height: 8.27 },
+      'Legal' => { width: 8.5, height: 14 },
+      'Letter' => { width: 8.5, height: 11 },
+      'Tabloid' => { width: 11, height: 17 },
+      'Ledger' => { width: 17, height: 11 }
+    }.freeze
   end
 end

data/lib/capybara/apparition/chrome_client.rb

@@ -2,6 +2,7 @@
 
 require 'capybara/apparition/errors'
 require 'capybara/apparition/web_socket_client'
+require 'capybara/apparition/response'
 
 module Capybara::Apparition
   class ChromeClient
@@ -58,68 +59,57 @@ module Capybara::Apparition
       @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']
+    def send_cmd(command, params)
+      time = Time.now
+      msg_id = send_msg(command, params)
+      Response.new(self, msg_id, send_time: time)
     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)
+    def send_cmd_to_session(session_id, command, params)
+      time = Time.now
+      msg_id, msg = generate_msg(command, params)
+      wrapper_msg_id = send_msg('Target.sendMessageToTarget', sessionId: session_id, message: msg)
+      Response.new(self, wrapper_msg_id, msg_id, send_time: time)
+    end
 
-      if (error = response['error'])
-        case error['code']
-        when -32_000
-          raise WrongWorld.new(nil, error)
-        else
-          raise CDPError.new(error)
-        end
+    def add_async_id(msg_id)
+      @msg_mutex.synchronize do
+        @async_ids.push(msg_id)
       end
-
-      response['result']
     end
 
-    def listen_until
-      read_until { yield }
-    end
+  private
 
-    def listen
-      read_until { false }
+    def handle_error(error)
+      case error['code']
+      when -32_000
+        raise WrongWorld.new(nil, error)
+      else
+        raise CDPError.new(error)
+      end
     end
 
-  private
+    def send_msg(command, params)
+      msg_id, msg = generate_msg(command, params)
+      @send_mutex.synchronize do
+        puts "#{Time.now.to_i}: sending msg: #{msg}" if ENV['DEBUG']
+        @ws.send_msg(msg)
+      end
+      msg_id
+    end
 
-    def generate_msg(command, params, async:)
+    def generate_msg(command, params)
       @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
+        timer = Capybara::Helpers.timer(expire_in: @timeout)
         while (response = @responses.delete(msg_id)).nil?
-          if @timeout && ((Time.now - start_time) > @timeout)
+          if @timeout && timer.expired?
             puts "Timedout waiting for response for msg: #{msg_id}"
             raise TimeoutError.new(msg_id)
           end
@@ -141,6 +131,14 @@ module Capybara::Apparition
       end
     end
 
+    def listen_until
+      read_until { yield }
+    end
+
+    def listen
+      read_until { false }
+    end
+
     def read_msg
       msg = JSON.parse(@ws.read_msg)
       puts "#{Time.now.to_i}: got msg: #{msg}" if ENV['DEBUG']
@@ -179,24 +177,15 @@ module Capybara::Apparition
         next unless event
 
         event_name = event['method']
-        puts "popped event #{event_name}" if ENV['DEBUG'] == 'V'
+        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
+          process_handlers(@session_handlers[session_id], event)
         end
 
-        @handlers[event_name].each do |handler|
-          puts "calling handler for #{event_name}" if ENV['DEBUG'] == 'V'
-          handler.call(event['params'])
-        end
+        process_handlers(@handlers, event)
       end
     rescue CDPError => e
       if e.code == -32_602
@@ -213,6 +202,14 @@ module Capybara::Apparition
       retry
     end
 
+    def process_handlers(handlers, event)
+      event_name = event['method']
+      handlers[event_name].each do |handler|
+        puts "Calling handler for #{event_name}" if ENV['DEBUG'] == 'V'
+        handler.call(event['params'])
+      end
+    end
+
     def start_threads
       @processor = Thread.new do
         process_messages

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

@@ -14,11 +14,11 @@ module Capybara::Apparition
       end
 
       def command(name, **params)
-        @browser.command_for_session(@session_id, name, params, async: false)
+        @browser.command_for_session(@session_id, name, params).result
       end
 
       def async_command(name, **params)
-        @browser.command_for_session(@session_id, name, params, async: true)
+        @browser.command_for_session(@session_id, name, params).discard_result
       end
 
       def on(event_name, &block)

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

@@ -29,7 +29,7 @@ module Capybara::Apparition
         @page ||= begin
           if info['type'] == 'page'
             Page.create(@browser, create_session, id,
-                        ignore_https_errors: true,
+                        ignore_https_errors: @browser.ignore_https_errors,
                         js_errors: @browser.js_errors).inherit(info.delete('inherit'))
           else
             nil

data/lib/capybara/apparition/driver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'uri'
+require 'forwardable'
 require 'capybara/apparition/chrome_client'
 require 'capybara/apparition/launcher'
 
@@ -8,8 +9,21 @@ module Capybara::Apparition
   class Driver < Capybara::Driver::Base
     DEFAULT_TIMEOUT = 30
 
+    extend Forwardable
+
     attr_reader :app, :options
 
+    delegate %i[restart current_url status_code body
+                title frame_title frame_url switch_to_frame
+                window_handles close_window open_new_window switch_to_window within_window
+                paper_size= zoom_factor=
+                scroll_to
+                network_traffic clear_network_traffic
+                headers headers= add_headers
+                cookies remove_cookie clear_cookies cookies_enabled=
+                clear_memory_cache
+                go_back go_forward refresh] => :browser
+
     def initialize(app, options = {})
       @app       = app
       @options   = options
@@ -30,7 +44,8 @@ module Capybara::Apparition
     def browser
       @browser ||= begin
         browser = Browser.new(client, browser_logger)
-        browser.js_errors  = options[:js_errors] if options.key?(:js_errors)
+        browser.js_errors = options[:js_errors] if options.key?(:js_errors)
+        browser.ignore_https_errors = options[:ignore_https_errors] if options.key?(:ignore_https_errors)
         browser.extensions = options.fetch(:extensions, [])
         browser.debug      = true if options[:debug]
         browser.url_blacklist = options[:url_blacklist] || []
@@ -52,17 +67,14 @@ module Capybara::Apparition
         @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
+        ::Capybara::Apparition::ChromeClient.client(ws_url.to_s)
       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,
@@ -70,13 +82,10 @@ module Capybara::Apparition
       # 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
+      # Note: Need to verify what Chrome command line options are valid for this
       list
     end
 
-    def restart
-      browser.restart
-    end
-
     def quit
       @client&.stop
       @launcher&.stop
@@ -89,7 +98,7 @@ module Capybara::Apparition
 
     # logger should be an object that behaves like IO or nil
     def browser_logger
-      options.fetch(:browser_logger, nil)
+      options.fetch(:browser_logger, $stdout)
     end
 
     def visit(url)
@@ -97,35 +106,12 @@ module Capybara::Apparition
       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
+    alias html body
 
     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
@@ -143,13 +129,11 @@ module Capybara::Apparition
     end
 
     def evaluate_script(script, *args)
-      result = browser.evaluate(script, *native_args(args))
-      unwrap_script_result(result)
+      unwrap_script_result(browser.evaluate(script, *native_args(args)))
     end
 
     def evaluate_async_script(script, *args)
-      result = browser.evaluate_async(script, session_wait_time, *native_args(args))
-      unwrap_script_result(result)
+      unwrap_script_result(browser.evaluate_async(script, session_wait_time, *native_args(args)))
     end
 
     def execute_script(script, *args)
@@ -157,43 +141,18 @@ module Capybara::Apparition
       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] || []
+      browser.url_blacklist = options[:url_blacklist] || []
+      browser.url_whitelist = options[:url_whitelist] || []
       @started = false
     end
 
@@ -203,18 +162,9 @@ module Capybara::Apparition
     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)
+      browser.render_base64(options.merge(format: format))
     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
@@ -244,34 +194,10 @@ module Capybara::Apparition
       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
@@ -282,10 +208,6 @@ module Capybara::Apparition
       end
     end
 
-    def cookies
-      browser.cookies
-    end
-
     def set_cookie(name, value, options = {})
       options[:name]  ||= name
       options[:value] ||= value
@@ -300,22 +222,6 @@ module Capybara::Apparition
       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
@@ -383,18 +289,6 @@ module Capybara::Apparition
       [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
@@ -437,21 +331,21 @@ module Capybara::Apparition
     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)
+      timer = Capybara::Helpers.timer(expire_in: timeout_sec)
       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
+        if timer.expired?
           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)
+        sleep(0.05)
         retry
       end
       modal_text