apparition 0.1.0 → 0.6.0

data/lib/capybara/apparition/browser/launcher.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'capybara/apparition/browser/launcher/local'
+require 'capybara/apparition/browser/launcher/remote'
+
+module Capybara::Apparition
+  class Browser
+    class Launcher
+      def self.start(options)
+        browser_options = options.fetch(:browser_options, {})
+
+        if options.fetch(:remote, false)
+          Remote.start(
+            browser_options
+          )
+        else
+          Local.start(
+            headless: options.fetch(:headless, true),
+            browser_options: browser_options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/capybara/apparition/browser/launcher/local.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Capybara::Apparition
+  class Browser
+    class Launcher
+      class Local
+        KILL_TIMEOUT = 5
+
+        def self.start(*args, **options)
+          new(*args, **options).tap(&:start)
+        end
+
+        def self.process_killer(pid)
+          proc do
+            sleep 1
+            if Capybara::Apparition.windows?
+              ::Process.kill('KILL', pid)
+            else
+              ::Process.kill('USR1', pid)
+              timer = Capybara::Helpers.timer(expire_in: KILL_TIMEOUT)
+              while ::Process.wait(pid, ::Process::WNOHANG).nil?
+                sleep 0.05
+                next unless timer.expired?
+
+                ::Process.kill('KILL', pid)
+                ::Process.wait(pid)
+                break
+              end
+            end
+          rescue Errno::ESRCH, Errno::ECHILD # rubocop:disable Lint/SuppressedException
+          end
+        end
+
+        def initialize(headless:, **options)
+          @path = ENV['BROWSER_PATH']
+          @options = DEFAULT_OPTIONS.merge(options[:browser_options] || {})
+          if headless
+            @options.merge!(HEADLESS_OPTIONS)
+            @options['disable-gpu'] = nil if Capybara::Apparition.windows?
+          end
+          @options['user-data-dir'] = Dir.mktmpdir
+        end
+
+        def start
+          @output = Queue.new
+
+          process_options = {}
+          process_options[:pgroup] = true unless Capybara::Apparition.windows?
+          cmd = [path] + @options.map { |k, v| v.nil? ? "--#{k}" : "--#{k}=#{v}" }
+
+          stdin, @stdout_stderr, wait_thr = Open3.popen2e(*cmd, process_options)
+          stdin.close
+
+          @pid = wait_thr.pid
+
+          @out_thread = Thread.new do
+            while !@stdout_stderr.eof? && (data = @stdout_stderr.readpartial(512))
+              @output << data
+            end
+          end
+
+          ObjectSpace.define_finalizer(self, self.class.process_killer(@pid))
+        end
+
+        def stop
+          return unless @pid
+
+          kill
+          ObjectSpace.undefine_finalizer(self)
+        end
+
+        def restart
+          stop
+          start
+        end
+
+        def host
+          @host ||= ws_url.host
+        end
+
+        def port
+          @port ||= ws_url.port
+        end
+
+        def ws_url
+          @ws_url ||= begin
+            regexp = %r{DevTools listening on (ws://.*)}
+            url = nil
+
+            sleep 3
+            loop do
+              break if (url = @output.pop.scan(regexp)[0])
+            end
+            @out_thread.kill
+            @out_thread.join # wait for thread to end before closing io
+            close_io
+            Addressable::URI.parse(url[0])
+          end
+        end
+
+      private
+
+        def kill
+          self.class.process_killer(@pid).call
+          @pid = nil
+        end
+
+        def close_io
+          @stdout_stderr.close unless @stdout_stderr.closed?
+        rescue IOError
+          raise unless RUBY_ENGINE == 'jruby'
+        end
+
+        def path
+          host_os = RbConfig::CONFIG['host_os']
+          @path ||= case RbConfig::CONFIG['host_os']
+          when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+            windows_path
+          when /darwin|mac os/
+            macosx_path
+          when /linux|solaris|bsd/
+            linux_path
+          else
+            raise ArgumentError, "unknown os: #{host_os.inspect}"
+          end
+
+          raise ArgumentError, 'Unable to find Chrome executeable' unless File.file?(@path.to_s) && File.executable?(@path.to_s)
+
+          @path
+        end
+
+        def windows_path
+          envs = %w[LOCALAPPDATA PROGRAMFILES PROGRAMFILES(X86)]
+          directories = %w[\\Google\\Chrome\\Application \\Chromium\\Application]
+          files = %w[chrome.exe]
+
+          directories.product(envs, files).lazy.map { |(dir, env, file)| "#{ENV[env]}\\#{dir}\\#{file}" }
+                     .find { |f| File.exist?(f) } || find_first_binary(*files)
+        end
+
+        def macosx_path
+          directories = ['', File.expand_path('~')]
+          files = ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+                   '/Applications/Chromium.app/Contents/MacOS/Chromium']
+          directories.product(files).map(&:join).find { |f| File.exist?(f) } ||
+            find_first_binary('Google Chrome', 'Chromium')
+        end
+
+        def linux_path
+          directories = %w[/usr/local/sbin /usr/local/bin /usr/sbin /usr/bin /sbin /bin /opt/google/chrome]
+          files = %w[google-chrome chrome chromium chromium-browser]
+
+          directories.product(files).map { |p| p.join('/') }.find { |f| File.exist?(f) } ||
+            find_first_binary(*files)
+        end
+
+        def find_first_binary(*binaries)
+          paths = ENV['PATH'].split(File::PATH_SEPARATOR)
+
+          binaries.product(paths).lazy.map do |(binary, path)|
+            Dir.glob(File.join(path, binary)).find { |f| File.executable?(f) }
+          end.reject(&:nil?).first
+        end
+
+        # Chromium command line options
+        # https://peter.sh/experiments/chromium-command-line-switches/
+        DEFAULT_BOOLEAN_OPTIONS = %w[
+          disable-background-networking
+          disable-background-timer-throttling
+          disable-breakpad
+          disable-client-side-phishing-detection
+          disable-default-apps
+          disable-dev-shm-usage
+          disable-extensions
+          disable-features=site-per-process
+          disable-hang-monitor
+          disable-infobars
+          disable-popup-blocking
+          disable-prompt-on-repost
+          disable-sync
+          disable-translate
+          disable-session-crashed-bubble
+          metrics-recording-only
+          no-first-run
+          safebrowsing-disable-auto-update
+          enable-automation
+          password-store=basic
+          use-mock-keychain
+          keep-alive-for-test
+        ].freeze
+        # 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
+        # disable-web-security
+        DEFAULT_VALUE_OPTIONS = {
+          'window-size' => '1024,768',
+          'homepage' => 'about:blank',
+          'remote-debugging-address' => '127.0.0.1'
+        }.freeze
+        DEFAULT_OPTIONS = DEFAULT_BOOLEAN_OPTIONS.each_with_object({}) { |opt, hsh| hsh[opt] = nil }
+                                                 .merge(DEFAULT_VALUE_OPTIONS)
+                                                 .freeze
+        HEADLESS_OPTIONS = {
+          'headless' => nil,
+          'hide-scrollbars' => nil,
+          'mute-audio' => nil
+        }.freeze
+      end
+    end
+  end
+end

data/lib/capybara/apparition/browser/launcher/remote.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'timeout'
+
+module Capybara::Apparition
+  class Browser
+    class Launcher
+      class Remote
+        attr_reader :ws_url
+
+        def self.start(options)
+          new(options).tap(&:start)
+        end
+
+        def initialize(options)
+          @remote_host = options.fetch('remote-debugging-address', '127.0.0.1')
+          @remote_port = options.fetch('remote-debugging-port', '9222')
+        end
+
+        def start
+          @ws_url = Addressable::URI.parse(get_ws_url(@remote_host, @remote_port))
+
+          true
+        end
+
+        def stop
+          # Remote instance cannot be stopped
+        end
+
+        def restart
+          # Remote instance cannot be restarted
+        end
+
+        def host
+          ws_url.host
+        end
+
+        def port
+          ws_url.port
+        end
+
+      protected
+
+        def get_ws_url(host, port)
+          response = Net::HTTP.get(host, '/json/version', port)
+          response = JSON.parse(response)
+          response['webSocketDebuggerUrl']
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          raise ArgumentError, "Cannot connect to remote Chrome at: 'http://#{host}:#{port}/json/version'"
+        end
+      end
+    end
+  end
+end

data/lib/capybara/apparition/browser/page_manager.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Capybara::Apparition
+  class Browser
+    class PageManager
+      def initialize(browser)
+        @browser = browser
+        @pages = {}
+      end
+
+      def ids
+        @pages.keys
+      end
+
+      def [](id)
+        @pages[id]
+      end
+
+      def each(&block)
+        @pages.each_value(&block)
+      end
+
+      def reset
+        @pages.each do |id, page|
+          begin
+            @browser.client.send_cmd(
+              'Target.disposeBrowserContext',
+              browserContextId: page.browser_context_id
+            ).discard_result
+          rescue WrongWorld
+            puts 'Unknown browserContextId'
+          end
+          @pages.delete(id)
+        end
+      end
+
+      def create(id, session, ctx_id, **options)
+        @pages[id] = Page.create(@browser, session, id, ctx_id, **options)
+      end
+
+      def delete(id)
+        @pages.delete(id)
+      end
+
+      def refresh(opener:, **page_options)
+        new_pages = @browser.command('Target.getTargets')['targetInfos'].select do |ti|
+          (ti['openerId'] == opener.target_id) && (ti['type'] == 'page') && (ti['attached'] == false)
+        end
+
+        sessions = new_pages.map do |page|
+          target_id = page['targetId']
+          session_result = @browser.client.send_cmd('Target.attachToTarget', targetId: target_id)
+          [target_id, session_result]
+        end
+
+        sessions = sessions.map do |(target_id, session_result)|
+          session = Capybara::Apparition::DevToolsProtocol::Session.new(
+            @browser,
+            @browser.client,
+            session_result.result['sessionId']
+          )
+          [target_id, session]
+        end
+
+        sessions.each do |(_id, session)|
+          session.async_commands 'Page.enable', 'Network.enable', 'Runtime.enable', 'Security.enable', 'DOM.enable'
+        end
+
+        sessions.each do |(target_id, session)|
+          new_page = Page.create(
+            @browser,
+            session,
+            target_id,
+            opener.browser_context_id,
+            **page_options
+          ).inherit(opener)
+          @pages[target_id] = new_page
+        end
+      end
+
+      def whitelist=(list)
+        @pages.each_value { |page| page.url_whitelist = list }
+      end
+
+      def blacklist=(list)
+        @pages.each_value { |page| page.url_blacklist = list }
+      end
+    end
+  end
+end

data/lib/capybara/apparition/browser/window.rb

@@ -3,64 +3,64 @@
 module Capybara::Apparition
   class Browser
     module Window
-      def window_handle
+      def current_window_handle
         @current_page_handle
       end
 
       def window_handles
-        @targets.window_handles
+        @pages.ids
       end
 
       def switch_to_window(handle)
-        target = @targets.get(handle)
-        raise NoSuchWindowError unless target&.page
+        page = @pages[handle]
+        unless page
+          page = @pages[find_window_handle(handle)]
+          warn 'Finding window by name, title, or url is deprecated, please use a block/proc ' \
+               'with Session#within_window/Session#switch_to_window instead.'
+        end
+        raise NoSuchWindowError unless page
 
-        target.page.wait_for_loaded
-        @current_page_handle = handle
+        page.wait_for_loaded
+        @current_page_handle = page.target_id
       end
 
       def open_new_window
-        context_id = current_target.context_id
-        info = command('Target.createTarget', url: 'about:blank', browserContextId: context_id)
-        target_id = info['targetId']
-        target = DevToolsProtocol::Target.new(self, info.merge('type' => 'page', 'inherit' => current_page))
-        target.page # Ensure page object construction happens
-        begin
-          puts "Adding #{target_id} - #{target.info}" if ENV['DEBUG']
-          @targets.add(target_id, target)
-        rescue ArgumentError
-          puts 'Target already existed' if ENV['DEBUG']
-        end
+        context_id = current_page.browser_context_id
+        target_id = command('Target.createTarget', url: 'about:blank', browserContextId: context_id)['targetId']
+        session_id = command('Target.attachToTarget', targetId: target_id)['sessionId']
+        session = Capybara::Apparition::DevToolsProtocol::Session.new(self, client, session_id)
+        @pages.create(target_id, session, context_id,
+                      ignore_https_errors: ignore_https_errors,
+                      js_errors: js_errors,
+                      url_whitelist: @url_whitelist,
+                      extensions: @extensions,
+                      url_blacklist: @url_blacklist).inherit(current_page(allow_nil: true))
+        @pages[target_id].send(:main_frame).loaded!
         target_id
       end
 
       def close_window(handle)
         @current_page_handle = nil if @current_page_handle == handle
-        win_target = @targets.delete(handle)
-        warn 'Window was already closed unexpectedly' if win_target.nil?
-        win_target&.close
-      end
+        page = @pages.delete(handle)
 
-      def within_window(locator)
-        original = window_handle
-        handle = find_window_handle(locator)
-        switch_to_window(handle)
-        yield
-      ensure
-        switch_to_window(original)
+        warn 'Window was already closed unexpectedly' unless page
+        command('Target.closeTarget', targetId: handle)
       end
     end
 
   private
 
     def find_window_handle(locator)
+      original = current_window_handle
       return locator if window_handles.include? locator
 
       window_handles.each do |handle|
         switch_to_window(handle)
-        return handle if evaluate('window.name') == locator
+        return handle if evaluate('[window.name, document.title, window.location.href]').include? locator
       end
       raise NoSuchWindowError
+    ensure
+      switch_to_window(original) if original
     end
   end
 end