From e78f223ce3a0991af329eeac0134b7f6ebeb6b20 Mon Sep 17 00:00:00 2001
From: Dmitry Vorotilin <d.vorotilin@gmail.com>
Date: Thu, 20 Oct 2022 16:42:10 +0500
Subject: [PATCH] Support proxy for a page (#300)

* refactor: parse options with a dedicated Options class

* chore!: drop support for proxy `server: true` option

* fix: support options for xvfb

* style: fix rubocop warnings

* fix: missing Ferrum module

* feat: support :proxy option for Browser#create_page
---
 README.md                                |   14 +-
 lib/ferrum/browser.rb                    |  105 +--
 lib/ferrum/browser/client.rb             |    2 +-
 lib/ferrum/browser/command.rb            |   11 +-
 lib/ferrum/browser/options.rb            |   84 ++
 lib/ferrum/browser/options/base.rb       |    5 +-
 lib/ferrum/browser/options/chrome.rb     |   23 +-
 lib/ferrum/browser/options/firefox.rb    |    9 +-
 lib/ferrum/browser/process.rb            |   11 +-
 lib/ferrum/browser/xvfb.rb               |    2 +-
 lib/ferrum/context.rb                    |    5 +-
 lib/ferrum/contexts.rb                   |    4 +-
 lib/ferrum/page.rb                       |   28 +-
 lib/ferrum/target.rb                     |   10 +-
 spec/browser/binary_spec.rb              |  194 ++--
 spec/browser/version_info_spec.rb        |   88 +-
 spec/browser/xvfb_spec.rb                |  100 +-
 spec/browser_spec.rb                     |  827 +++++++++--------
 spec/context_spec.rb                     |   60 +-
 spec/cookies_spec.rb                     |  384 ++++----
 spec/dialog_spec.rb                      |  126 ++-
 spec/frame/runtime_spec.rb               |  268 ++++++
 spec/frame_spec.rb                       |  534 ++++++-----
 spec/headers_spec.rb                     |  312 ++++---
 spec/keyboard_spec.rb                    |   38 +-
 spec/mouse_spec.rb                       |  322 ++++---
 spec/network/auth_request_spec.rb        |    8 +-
 spec/network/error_spec.rb               |   24 +-
 spec/network/intercepted_request_spec.rb |    8 +-
 spec/network/request_spec.rb             |    8 +-
 spec/network/response_spec.rb            |  138 ++-
 spec/network_spec.rb                     |  596 ++++++------
 spec/node_spec.rb                        | 1062 +++++++++++-----------
 spec/page/animation_spec.rb              |   28 +-
 spec/page/screenshot_spec.rb             |  642 +++++++------
 spec/page/tracing_spec.rb                |  244 +++--
 spec/page_spec.rb                        |  284 +++---
 spec/rbga_spec.rb                        |   76 +-
 spec/runtime_spec.rb                     |  270 ------
 spec/spec_helper.rb                      |    2 +-
 spec/support/global_helpers.rb           |    2 +-
 spec/unit/browser_spec.rb                |   62 +-
 spec/unit/process_spec.rb                |   50 +-
 43 files changed, 3555 insertions(+), 3515 deletions(-)
 create mode 100644 lib/ferrum/browser/options.rb
 create mode 100644 spec/frame/runtime_spec.rb
 delete mode 100644 spec/runtime_spec.rb

diff --git a/README.md b/README.md
index 964d552b..441d3055 100644
--- a/README.md
+++ b/README.md
@@ -605,21 +605,24 @@ You can set a proxy with the `proxy` option.
 
 ```ruby
 browser = Ferrum::Browser.new(proxy: { host: "x.x.x.x", port: "8800" })
-browser = Ferrum::Browser.new(proxy: { host: "x.x.x.x", port: "8800", user: "user", pasword: "pa$$" })
+browser = Ferrum::Browser.new(proxy: { host: "x.x.x.x", port: "8800", user: "user", password: "pa$$" })
 ```
 
-Chrome Devtools Protocol does not support changing proxies after the browser is launched. If you want to change proxies, you must restart your browser, which may not be convenient. There is a workaround. Ferrum provides a wrapper for a proxy server that can rotate proxies. We can run a proxy in the same process and rotate proxies inside this proxy server:
+Chrome Devtools Protocol does not support changing proxies after the browser is launched. If you want to change proxies,
+you must restart your browser, which may not be convenient. There is a workaround. Ferrum provides a wrapper for a proxy
+server that can rotate proxies. We can run a proxy in the same process and rotate proxies inside this proxy server:
 
 ```ruby
-browser = Ferrum::Browser.new(proxy: { server: true })
+proxy = Ferrum::Proxy.start(**options)
+browser = Ferrum::Browser.new(proxy: { host: proxy.host, port: proxy.port })
 
-browser.proxy_server.rotate(host: "x.x.x.x", port: 31337, user: "user", password: "password")
+proxy.rotate(host: "x.x.x.x", port: 31337, user: "user", password: "password")
 browser.create_page(new_context: true) do |page|
   page.go_to("https://api.ipify.org?format=json")
   page.body # => "x.x.x.x"
 end
 
-browser.proxy_server.rotate(host: "y.y.y.y", port: 31337, user: "user", password: "password")
+proxy.rotate(host: "y.y.y.y", port: 31337, user: "user", password: "password")
 browser.create_page(new_context: true) do |page|
   page.go_to("https://api.ipify.org?format=json")
   page.body # => "y.y.y.y"
@@ -633,7 +636,6 @@ You can specify semi-colon-separated list of hosts for which proxy shouldn't be
 
 ```ruby
 browser = Ferrum::Browser.new(proxy: { host: "x.x.x.x", port: "8800", bypass: "*.google.com;*foo.com" })
-browser = Ferrum::Browser.new(proxy: { server: true, bypass: "*.google.com;*foo.com" })
 ```
 
 
diff --git a/lib/ferrum/browser.rb b/lib/ferrum/browser.rb
index 52823e93..7786de88 100644
--- a/lib/ferrum/browser.rb
+++ b/lib/ferrum/browser.rb
@@ -6,6 +6,7 @@
 require "ferrum/proxy"
 require "ferrum/contexts"
 require "ferrum/browser/xvfb"
+require "ferrum/browser/options"
 require "ferrum/browser/process"
 require "ferrum/browser/client"
 require "ferrum/browser/binary"
@@ -13,10 +14,6 @@
 
 module Ferrum
   class Browser
-    DEFAULT_TIMEOUT = ENV.fetch("FERRUM_DEFAULT_TIMEOUT", 5).to_i
-    WINDOW_SIZE = [1024, 768].freeze
-    BASE_URL_SCHEMA = %w[http https].freeze
-
     extend Forwardable
     delegate %i[default_context] => :contexts
     delegate %i[targets create_target page pages windows] => :default_context
@@ -33,10 +30,8 @@ class Browser
                 playback_rate playback_rate=] => :page
     delegate %i[default_user_agent] => :process
 
-    attr_reader :client, :process, :contexts, :logger, :js_errors, :pending_connection_errors,
-                :slowmo, :base_url, :options, :window_size, :ws_max_receive_size, :proxy_options,
-                :proxy_server
-    attr_writer :timeout
+    attr_reader :client, :process, :contexts, :options, :window_size, :base_url
+    attr_accessor :timeout
 
     #
     # Initializes the browser.
@@ -63,7 +58,7 @@ class Browser
     #
     # @option options [Integer, Float] :slowmo
     #   Set a delay in seconds to wait before sending command.
-    #   Usefull companion of headless option, so that you have time to see
+    #   Useful companion of headless option, so that you have time to see
     #   changes.
     #
     # @option options [Numeric] :timeout (5)
@@ -126,43 +121,12 @@ class Browser
     #   Environment variables you'd like to pass through to the process.
     #
     def initialize(options = nil)
-      options ||= {}
-
-      @client = nil
-      @window_size = options.fetch(:window_size, WINDOW_SIZE)
-      @original_window_size = @window_size
-
-      @options = Hash(options.merge(window_size: @window_size))
-      @logger, @timeout, @ws_max_receive_size =
-        @options.values_at(:logger, :timeout, :ws_max_receive_size)
-      @js_errors = @options.fetch(:js_errors, false)
-
-      if @options[:proxy]
-        @proxy_options = @options[:proxy]
-
-        if @proxy_options[:server]
-          @proxy_server = Proxy.start(**@proxy_options.slice(:host, :port, :user, :password))
-          @proxy_options.merge!(host: @proxy_server.host, port: @proxy_server.port)
-        end
-
-        @options[:browser_options] ||= {}
-        address = "#{@proxy_options[:host]}:#{@proxy_options[:port]}"
-        @options[:browser_options].merge!("proxy-server" => address)
-        @options[:browser_options].merge!("proxy-bypass-list" => @proxy_options[:bypass]) if @proxy_options[:bypass]
-      end
-
-      @pending_connection_errors = @options.fetch(:pending_connection_errors, true)
-      @slowmo = @options[:slowmo].to_f
-
-      self.base_url = @options[:base_url] if @options.key?(:base_url)
-
-      if ENV.fetch("FERRUM_DEBUG", nil) && !@logger
-        $stdout.sync = true
-        @logger = $stdout
-        @options[:logger] = @logger
-      end
+      @options = Options.new(options)
+      @client = @process = @contexts = nil
 
-      @options.freeze
+      @timeout = @options.timeout
+      @window_size = @options.window_size
+      @base_url = @options.base_url if @options.base_url
 
       start
     end
@@ -173,22 +137,39 @@ def initialize(options = nil)
     # @param [String] value
     #   The new base URL value.
     #
-    # @return [String]
-    #   The base URL value.
+    # @raise [ArgumentError] when path is not absolute or doesn't include schema
+    #
+    # @return [Addressable::URI]
+    #   The parsed base URI value.
     #
     def base_url=(value)
-      parsed = Addressable::URI.parse(value)
-      unless BASE_URL_SCHEMA.include?(parsed.normalized_scheme)
-        raise "Set `base_url` should be absolute and include schema: #{BASE_URL_SCHEMA}"
-      end
-
-      @base_url = parsed
+      @base_url = options.parse_base_url(value)
     end
 
-    def create_page(new_context: false)
-      page = if new_context
-               context = contexts.create
-               context.create_page
+    #
+    # Creates a new page.
+    #
+    # @param [Boolean] new_context
+    #   Whether to create a page in a new context or not.
+    #
+    # @param [Hash] proxy
+    #   Whether to use proxy for a page. The page will be created in a new context if so.
+    #
+    # @return [Ferrum::Page]
+    #   Created page.
+    #
+    def create_page(new_context: false, proxy: nil)
+      page = if new_context || proxy
+               params = {}
+
+               if proxy
+                 options.parse_proxy(proxy)
+                 params.merge!(proxyServer: "#{proxy[:host]}:#{proxy[:port]}")
+                 params.merge!(proxyBypassList: proxy[:bypass]) if proxy[:bypass]
+               end
+
+               context = contexts.create(**params)
+               context.create_page(proxy: proxy)
              else
                default_context.create_page
              end
@@ -202,7 +183,7 @@ def create_page(new_context: false)
     end
 
     def extensions
-      @extensions ||= Array(@options[:extensions]).map do |ext|
+      @extensions ||= Array(options.extensions).map do |ext|
         (ext.is_a?(Hash) && ext[:source]) || File.read(ext)
       end
     end
@@ -224,10 +205,6 @@ def evaluate_on_new_document(expression)
       extensions << expression
     end
 
-    def timeout
-      @timeout || DEFAULT_TIMEOUT
-    end
-
     def command(*args)
       @client.command(*args)
     rescue DeadBrowserError
@@ -250,7 +227,7 @@ def command(*args)
     #   browser.quit
     #
     def reset
-      @window_size = @original_window_size
+      @window_size = options.window_size
       contexts.reset
     end
 
@@ -289,7 +266,7 @@ def version
 
     def start
       Utils::ElapsedTime.start
-      @process = Process.start(@options)
+      @process = Process.start(options)
       @client = Client.new(self, @process.ws_url)
       @contexts = Contexts.new(self)
     end
diff --git a/lib/ferrum/browser/client.rb b/lib/ferrum/browser/client.rb
index eb59b218..7927a050 100644
--- a/lib/ferrum/browser/client.rb
+++ b/lib/ferrum/browser/client.rb
@@ -12,7 +12,7 @@ def initialize(browser, ws_url, id_starts_with: 0)
         @browser = browser
         @command_id = id_starts_with
         @pendings = Concurrent::Hash.new
-        @ws = WebSocket.new(ws_url, @browser.ws_max_receive_size, @browser.logger)
+        @ws = WebSocket.new(ws_url, @browser.options.ws_max_receive_size, @browser.options.logger)
         @subscriber, @interrupter = Subscriber.build(2)
 
         @thread = Thread.new do
diff --git a/lib/ferrum/browser/command.rb b/lib/ferrum/browser/command.rb
index 6fa7ed26..a04c8d68 100644
--- a/lib/ferrum/browser/command.rb
+++ b/lib/ferrum/browser/command.rb
@@ -10,7 +10,7 @@ class Command
       # Currently only these browsers support CDP:
       # https://github.com/cyrus-and/chrome-remote-interface#implementations
       def self.build(options, user_data_dir)
-        defaults = case options[:browser_name]
+        defaults = case options.browser_name
                    when :firefox
                      Options::Firefox.options
                    when :chrome, :opera, :edge, nil
@@ -29,14 +29,14 @@ def initialize(defaults, options, user_data_dir)
         @defaults = defaults
         @options = options
         @user_data_dir = user_data_dir
-        @path = options[:browser_path] || ENV.fetch("BROWSER_PATH", nil) || defaults.detect_path
+        @path = options.browser_path || ENV.fetch("BROWSER_PATH", nil) || defaults.detect_path
         raise BinaryNotFoundError, NOT_FOUND unless @path
 
         merge_options
       end
 
       def xvfb?
-        !!options[:xvfb]
+        !!options.xvfb
       end
 
       def to_a
@@ -47,9 +47,8 @@ def to_a
 
       def merge_options
         @flags = defaults.merge_required(@flags, options, @user_data_dir)
-        @flags = defaults.merge_default(@flags, options) unless options[:ignore_default_browser_options]
-
-        @flags.merge!(options.fetch(:browser_options, {}))
+        @flags = defaults.merge_default(@flags, options) unless options.ignore_default_browser_options
+        @flags.merge!(options.browser_options)
       end
     end
   end
diff --git a/lib/ferrum/browser/options.rb b/lib/ferrum/browser/options.rb
new file mode 100644
index 00000000..5addb72c
--- /dev/null
+++ b/lib/ferrum/browser/options.rb
@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Ferrum
+  class Browser
+    class Options
+      HEADLESS = true
+      BROWSER_PORT = "0"
+      BROWSER_HOST = "127.0.0.1"
+      WINDOW_SIZE = [1024, 768].freeze
+      BASE_URL_SCHEMA = %w[http https].freeze
+      DEFAULT_TIMEOUT = ENV.fetch("FERRUM_DEFAULT_TIMEOUT", 5).to_i
+      PROCESS_TIMEOUT = ENV.fetch("FERRUM_PROCESS_TIMEOUT", 10).to_i
+      DEBUG_MODE = !ENV.fetch("FERRUM_DEBUG", nil).nil?
+
+      attr_reader :window_size, :timeout, :logger, :ws_max_receive_size,
+                  :js_errors, :base_url, :slowmo, :pending_connection_errors,
+                  :url, :env, :process_timeout, :browser_name, :browser_path,
+                  :save_path, :extensions, :proxy, :port, :host, :headless,
+                  :ignore_default_browser_options, :browser_options, :xvfb
+
+      def initialize(options = nil)
+        @options = Hash(options&.dup)
+        @port = @options.fetch(:port, BROWSER_PORT)
+        @host = @options.fetch(:host, BROWSER_HOST)
+        @timeout = @options.fetch(:timeout, DEFAULT_TIMEOUT)
+        @window_size = @options.fetch(:window_size, WINDOW_SIZE)
+        @js_errors = @options.fetch(:js_errors, false)
+        @headless = @options.fetch(:headless, HEADLESS)
+        @pending_connection_errors = @options.fetch(:pending_connection_errors, true)
+        @process_timeout = @options.fetch(:process_timeout, PROCESS_TIMEOUT)
+        @browser_options = @options.fetch(:browser_options, {})
+        @slowmo = @options[:slowmo].to_f
+
+        @ws_max_receive_size, @env, @browser_name, @browser_path,
+          @save_path, @extensions, @ignore_default_browser_options, @xvfb = @options.values_at(
+            :ws_max_receive_size, :env, :browser_name, :browser_path, :save_path, :extensions,
+            :ignore_default_browser_options, :xvfb
+          )
+
+        @options[:window_size] = @window_size
+        @proxy = parse_proxy(@options[:proxy])
+        @logger = parse_logger(@options[:logger])
+        @base_url = parse_base_url(@options[:base_url]) if @options[:base_url]
+        @url = @options[:url].to_s if @options[:url]
+
+        @options.freeze
+        @browser_options.freeze
+      end
+
+      def to_h
+        @options
+      end
+
+      def parse_base_url(value)
+        parsed = Addressable::URI.parse(value)
+        unless BASE_URL_SCHEMA.include?(parsed&.normalized_scheme)
+          raise ArgumentError, "`base_url` should be absolute and include schema: #{BASE_URL_SCHEMA.join(' | ')}"
+        end
+
+        parsed
+      end
+
+      def parse_proxy(options)
+        return unless options
+
+        raise ArgumentError, "proxy options must be a Hash" unless options.is_a?(Hash)
+
+        if options[:host].nil? && options[:port].nil?
+          raise ArgumentError, "proxy options must be a Hash with at least :host | :port"
+        end
+
+        options
+      end
+
+      private
+
+      def parse_logger(logger)
+        return logger if logger
+
+        !logger && DEBUG_MODE ? $stdout.tap { |s| s.sync = true } : logger
+      end
+    end
+  end
+end
diff --git a/lib/ferrum/browser/options/base.rb b/lib/ferrum/browser/options/base.rb
index 3006fee8..6ebc63ba 100644
--- a/lib/ferrum/browser/options/base.rb
+++ b/lib/ferrum/browser/options/base.rb
@@ -4,11 +4,8 @@
 
 module Ferrum
   class Browser
-    module Options
+    class Options
       class Base
-        BROWSER_HOST = "127.0.0.1"
-        BROWSER_PORT = "0"
-
         include Singleton
 
         def self.options
diff --git a/lib/ferrum/browser/options/chrome.rb b/lib/ferrum/browser/options/chrome.rb
index 06ceaf10..1cce92df 100644
--- a/lib/ferrum/browser/options/chrome.rb
+++ b/lib/ferrum/browser/options/chrome.rb
@@ -2,7 +2,7 @@
 
 module Ferrum
   class Browser
-    module Options
+    class Options
       class Chrome < Base
         DEFAULT_OPTIONS = {
           "headless" => nil,
@@ -59,17 +59,22 @@ class Chrome < Base
         }.freeze
 
         def merge_required(flags, options, user_data_dir)
-          port = options.fetch(:port, BROWSER_PORT)
-          host = options.fetch(:host, BROWSER_HOST)
-          flags.merge("remote-debugging-port" => port,
-                      "remote-debugging-address" => host,
-                      # Doesn't work on MacOS, so we need to set it by CDP
-                      "window-size" => options[:window_size]&.join(","),
-                      "user-data-dir" => user_data_dir)
+          flags = flags.merge("remote-debugging-port" => options.port,
+                              "remote-debugging-address" => options.host,
+                              # Doesn't work on MacOS, so we need to set it by CDP
+                              "window-size" => options.window_size&.join(","),
+                              "user-data-dir" => user_data_dir)
+
+          if options.proxy
+            flags.merge!("proxy-server" => "#{options.proxy[:host]}:#{options.proxy[:port]}")
+            flags.merge!("proxy-bypass-list" => options.proxy[:bypass]) if options.proxy[:bypass]
+          end
+
+          flags
         end
 
         def merge_default(flags, options)
-          defaults = except("headless", "disable-gpu") unless options.fetch(:headless, true)
+          defaults = except("headless", "disable-gpu") unless options.headless
 
           defaults ||= DEFAULT_OPTIONS
           defaults.merge(flags)
diff --git a/lib/ferrum/browser/options/firefox.rb b/lib/ferrum/browser/options/firefox.rb
index 6b22383a..e8246bfc 100644
--- a/lib/ferrum/browser/options/firefox.rb
+++ b/lib/ferrum/browser/options/firefox.rb
@@ -2,7 +2,7 @@
 
 module Ferrum
   class Browser
-    module Options
+    class Options
       class Firefox < Base
         DEFAULT_OPTIONS = {
           "headless" => nil
@@ -23,14 +23,11 @@ class Firefox < Base
         }.freeze
 
         def merge_required(flags, options, user_data_dir)
-          port = options.fetch(:port, BROWSER_PORT)
-          host = options.fetch(:host, BROWSER_HOST)
-          flags.merge("remote-debugger" => "#{host}:#{port}",
-                      "profile" => user_data_dir)
+          flags.merge("remote-debugger" => "#{options.host}:#{options.port}", "profile" => user_data_dir)
         end
 
         def merge_default(flags, options)
-          defaults = except("headless") unless options.fetch(:headless, true)
+          defaults = except("headless") unless options.headless
 
           defaults ||= DEFAULT_OPTIONS
           defaults.merge(flags)
diff --git a/lib/ferrum/browser/process.rb b/lib/ferrum/browser/process.rb
index f7e73cb1..9bf1ce8c 100644
--- a/lib/ferrum/browser/process.rb
+++ b/lib/ferrum/browser/process.rb
@@ -15,7 +15,6 @@ class Browser
     class Process
       KILL_TIMEOUT = 2
       WAIT_KILLED = 0.05
-      PROCESS_TIMEOUT = ENV.fetch("FERRUM_PROCESS_TIMEOUT", 10).to_i
 
       attr_reader :host, :port, :ws_url, :pid, :command,
                   :default_user_agent, :browser_version, :protocol_version,
@@ -63,17 +62,17 @@ def self.directory_remover(path)
       def initialize(options)
         @pid = @xvfb = @user_data_dir = nil
 
-        if options[:url]
-          url = URI.join(options[:url].to_s, "/json/version")
+        if options.url
+          url = URI.join(options.url, "/json/version")
           response = JSON.parse(::Net::HTTP.get(url))
           self.ws_url = response["webSocketDebuggerUrl"]
           parse_browser_versions
           return
         end
 
-        @logger = options[:logger]
-        @process_timeout = options.fetch(:process_timeout, PROCESS_TIMEOUT)
-        @env = Hash(options[:env])
+        @logger = options.logger
+        @process_timeout = options.process_timeout
+        @env = Hash(options.env)
 
         tmpdir = Dir.mktmpdir("ferrum_user_data_dir_")
         ObjectSpace.define_finalizer(self, self.class.directory_remover(tmpdir))
diff --git a/lib/ferrum/browser/xvfb.rb b/lib/ferrum/browser/xvfb.rb
index 76c6b8db..e146d3ad 100644
--- a/lib/ferrum/browser/xvfb.rb
+++ b/lib/ferrum/browser/xvfb.rb
@@ -16,7 +16,7 @@ def initialize(options)
         @path = Binary.find("Xvfb")
         raise BinaryNotFoundError, NOT_FOUND unless @path
 
-        @screen_size = "#{options.fetch(:window_size, [1024, 768]).join('x')}x24"
+        @screen_size = "#{options.window_size.join('x')}x24"
         @display_id = (Time.now.to_f * 1000).to_i % 100_000_000
       end
 
diff --git a/lib/ferrum/context.rb b/lib/ferrum/context.rb
index a20405fa..875680c6 100644
--- a/lib/ferrum/context.rb
+++ b/lib/ferrum/context.rb
@@ -40,8 +40,9 @@ def windows(pos = nil, size = 1)
       windows.map(&:page)
     end
 
-    def create_page
-      create_target.page
+    def create_page(**options)
+      target = create_target
+      target.page = target.build_page(**options)
     end
 
     def create_target
diff --git a/lib/ferrum/contexts.rb b/lib/ferrum/contexts.rb
index fa2d8674..5e599252 100644
--- a/lib/ferrum/contexts.rb
+++ b/lib/ferrum/contexts.rb
@@ -23,8 +23,8 @@ def find_by(target_id:)
       context
     end
 
-    def create
-      response = @browser.command("Target.createBrowserContext")
+    def create(**options)
+      response = @browser.command("Target.createBrowserContext", **options)
       context_id = response["browserContextId"]
       context = Context.new(@browser, self, context_id)
       @contexts[context_id] = context
diff --git a/lib/ferrum/page.rb b/lib/ferrum/page.rb
index 654aca3e..2fff6ee6 100644
--- a/lib/ferrum/page.rb
+++ b/lib/ferrum/page.rb
@@ -71,7 +71,7 @@ def reset
     # @return [Cookies]
     attr_reader :cookies
 
-    def initialize(target_id, browser)
+    def initialize(target_id, browser, proxy: nil)
       @frames = {}
       @main_frame = Frame.new(nil, self)
       @browser = browser
@@ -83,6 +83,9 @@ def initialize(target_id, browser)
       ws_url = "ws://#{host}:#{port}/devtools/page/#{@target_id}"
       @client = Browser::Client.new(browser, ws_url, id_starts_with: 1000)
 
+      @proxy_user = proxy&.[](:user) || @browser.options.proxy&.[](:user)
+      @proxy_password = proxy&.[](:password) || @browser.options.proxy&.[](:password)
+
       @mouse = Mouse.new(self)
       @keyboard = Keyboard.new(self)
       @headers = Headers.new(self)
@@ -127,7 +130,7 @@ def go_to(url = nil)
 
       response["frameId"]
     rescue TimeoutError
-      if @browser.pending_connection_errors
+      if @browser.options.pending_connection_errors
         pendings = network.traffic.select(&:pending?).map(&:url).compact
         raise PendingConnectionsError.new(options[:url], pendings) unless pendings.empty?
       end
@@ -162,7 +165,7 @@ def resize(width: nil, height: nil, fullscreen: false)
     # The current position of the browser window.
     #
     # @return [(Integer, Integer)]
-    #   The left,top coordinates of the browser window.
+    #   The left, top coordinates of the browser window.
     #
     # @example
     #   browser.position # => [10, 20]
@@ -274,7 +277,7 @@ def set_window_bounds(bounds = {})
 
     def command(method, wait: 0, slowmoable: false, **params)
       iteration = @event.reset if wait.positive?
-      sleep(@browser.slowmo) if slowmoable && @browser.slowmo.positive?
+      sleep(@browser.options.slowmo) if slowmoable && @browser.options.slowmo.positive?
       result = @client.command(method, params)
 
       if wait.positive?
@@ -325,13 +328,13 @@ def subscribe
       frames_subscribe
       network.subscribe
 
-      if @browser.logger
+      if @browser.options.logger
         on("Runtime.consoleAPICalled") do |params|
           params["args"].each { |r| @browser.logger.puts(r["value"]) }
         end
       end
 
-      if @browser.js_errors
+      if @browser.options.js_errors
         on("Runtime.exceptionThrown") do |params|
           # FIXME: https://jvns.ca/blog/2015/11/27/why-rubys-timeout-is-dangerous-and-thread-dot-raise-is-terrifying/
           Thread.main.raise JavaScriptError.new(
@@ -358,21 +361,22 @@ def prepare_page
       command("Log.enable")
       command("Network.enable")
 
-      if @browser.proxy_options && @browser.proxy_options[:user] && @browser.proxy_options[:password]
-        auth_options = @browser.proxy_options.slice(:user, :password)
-        network.authorize(type: :proxy, **auth_options) do |request, _index, _total|
+      if @proxy_user && @proxy_password
+        network.authorize(user: @proxy_user,
+                          password: @proxy_password,
+                          type: :proxy) do |request, _index, _total|
           request.continue
         end
       end
 
-      if @browser.options[:save_path]
-        unless Pathname.new(@browser.options[:save_path]).absolute?
+      if @browser.options.save_path
+        unless Pathname.new(@browser.options.save_path).absolute?
           raise Error, "supply absolute path for `:save_path` option"
         end
 
         @browser.command("Browser.setDownloadBehavior",
                          browserContextId: context.id,
-                         downloadPath: @browser.options[:save_path],
+                         downloadPath: @browser.options.save_path,
                          behavior: "allow", eventsEnabled: true)
       end
 
diff --git a/lib/ferrum/target.rb b/lib/ferrum/target.rb
index de081569..23a33491 100644
--- a/lib/ferrum/target.rb
+++ b/lib/ferrum/target.rb
@@ -23,10 +23,12 @@ def attached?
     end
 
     def page
-      @page ||= begin
-        maybe_sleep_if_new_window
-        Page.new(id, @browser)
-      end
+      @page ||= build_page
+    end
+
+    def build_page(**options)
+      maybe_sleep_if_new_window
+      Page.new(id, @browser, **options)
     end
 
     def id
diff --git a/spec/browser/binary_spec.rb b/spec/browser/binary_spec.rb
index 14afdc05..4561bb75 100644
--- a/spec/browser/binary_spec.rb
+++ b/spec/browser/binary_spec.rb
@@ -1,104 +1,100 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Browser
-    describe Binary do
-      let(:tmp_bin) { "#{PROJECT_ROOT}/spec/tmp/bin" }
-      let(:bin1) { File.join(tmp_bin, "bin1") }
-      let(:bin1_exe) { File.join(tmp_bin, "bin1.exe") }
-      let(:bin2_no_x) { File.join(tmp_bin, "/bin2") }
-      let(:bin3) { File.join(tmp_bin, "/bin3") }
-      let(:bin4_exe) { File.join(tmp_bin, "/bin4.exe") }
-
-      before do
-        FileUtils.mkdir_p(tmp_bin)
-        FileUtils.touch([bin1, bin1_exe, bin2_no_x, bin3, bin4_exe])
-        FileUtils.chmod("u=rwx,go=rx", bin1)
-        FileUtils.chmod("u=rwx,go=rx", bin1_exe)
-        FileUtils.chmod("u=rw,go=r", bin2_no_x)
-        FileUtils.chmod("u=rwx,go=rx", bin3)
-        FileUtils.chmod("u=rwx,go=rx", bin4_exe)
-
-        @original_env_path = ENV.fetch("PATH", nil)
-        @original_env_pathext = ENV.fetch("PATHEXT", nil)
-        ENV["PATH"] = "#{tmp_bin}#{File::PATH_SEPARATOR}#{@original_env_path}"
-      end
-
-      after do
-        FileUtils.rm_rf(tmp_bin)
-        ENV["PATH"] = @original_env_path
-        ENV["PATHEXT"] = @original_env_pathext
-      end
-
-      describe "#find" do
-        it "finds one binary" do
-          expect(Binary.find("bin1")).to eq(bin1)
-        end
-
-        it "finds first binary when list is passed" do
-          expect(Binary.find(%w[bin1 bin3])).to eq(bin1)
-        end
-
-        it "finds binary with PATHEXT" do
-          ENV["PATHEXT"] = ".com;.exe"
-
-          expect(Binary.find(%w[bin4])).to eq(bin4_exe)
-        end
-
-        it "finds binary with absolute path" do
-          expect(Binary.find(bin4_exe)).to eq(bin4_exe)
-        end
-
-        it "finds binary without ext" do
-          ENV["PATHEXT"] = ".com;.exe"
-
-          expect(Binary.find("bin1")).to eq(bin1_exe)
-          FileUtils.rm_rf(bin1_exe)
-          expect(Binary.find("bin1")).to eq(bin1)
-        end
-
-        it "raises an error" do
-          ENV["PATH"] = ""
-
-          expect { Binary.find(%w[bin1]) }.to raise_error(Ferrum::EmptyPathError)
-        end
-      end
-
-      describe "#all" do
-        it "finds one binary" do
-          expect(Binary.all("bin1")).to eq([bin1])
-        end
-
-        it "finds multiple binaries with ext" do
-          ENV["PATHEXT"] = ".com;.exe"
-
-          expect(Binary.all("bin1")).to eq([bin1_exe, bin1])
-        end
-
-        it "finds all binary when list passed" do
-          expect(Binary.all(%w[bin1 bin3])).to eq([bin1, bin3])
-        end
-
-        it "finds binary with PATHEXT" do
-          ENV["PATHEXT"] = ".com;.exe"
-
-          expect(Binary.all(%w[bin4])).to eq([bin4_exe])
-        end
-
-        it "raises an error" do
-          ENV["PATH"] = ""
-
-          expect { Binary.all(%w[bin1]) }.to raise_error(Ferrum::EmptyPathError)
-        end
-      end
-
-      describe "#lazy_find" do
-        it "works lazily" do
-          enum = Binary.lazy_find(%w[ls which none])
-
-          expect(enum.instance_of?(Enumerator::Lazy)).to be_truthy
-        end
-      end
+describe Ferrum::Browser::Binary do
+  let(:tmp_bin) { "#{PROJECT_ROOT}/spec/tmp/bin" }
+  let(:bin1) { File.join(tmp_bin, "bin1") }
+  let(:bin1_exe) { File.join(tmp_bin, "bin1.exe") }
+  let(:bin2_no_x) { File.join(tmp_bin, "/bin2") }
+  let(:bin3) { File.join(tmp_bin, "/bin3") }
+  let(:bin4_exe) { File.join(tmp_bin, "/bin4.exe") }
+
+  before do
+    FileUtils.mkdir_p(tmp_bin)
+    FileUtils.touch([bin1, bin1_exe, bin2_no_x, bin3, bin4_exe])
+    FileUtils.chmod("u=rwx,go=rx", bin1)
+    FileUtils.chmod("u=rwx,go=rx", bin1_exe)
+    FileUtils.chmod("u=rw,go=r", bin2_no_x)
+    FileUtils.chmod("u=rwx,go=rx", bin3)
+    FileUtils.chmod("u=rwx,go=rx", bin4_exe)
+
+    @original_env_path = ENV.fetch("PATH", nil)
+    @original_env_pathext = ENV.fetch("PATHEXT", nil)
+    ENV["PATH"] = "#{tmp_bin}#{File::PATH_SEPARATOR}#{@original_env_path}"
+  end
+
+  after do
+    FileUtils.rm_rf(tmp_bin)
+    ENV["PATH"] = @original_env_path
+    ENV["PATHEXT"] = @original_env_pathext
+  end
+
+  describe "#find" do
+    it "finds one binary" do
+      expect(Ferrum::Browser::Binary.find("bin1")).to eq(bin1)
+    end
+
+    it "finds first binary when list is passed" do
+      expect(Ferrum::Browser::Binary.find(%w[bin1 bin3])).to eq(bin1)
+    end
+
+    it "finds binary with PATHEXT" do
+      ENV["PATHEXT"] = ".com;.exe"
+
+      expect(Ferrum::Browser::Binary.find(%w[bin4])).to eq(bin4_exe)
+    end
+
+    it "finds binary with absolute path" do
+      expect(Ferrum::Browser::Binary.find(bin4_exe)).to eq(bin4_exe)
+    end
+
+    it "finds binary without ext" do
+      ENV["PATHEXT"] = ".com;.exe"
+
+      expect(Ferrum::Browser::Binary.find("bin1")).to eq(bin1_exe)
+      FileUtils.rm_rf(bin1_exe)
+      expect(Ferrum::Browser::Binary.find("bin1")).to eq(bin1)
+    end
+
+    it "raises an error" do
+      ENV["PATH"] = ""
+
+      expect { Ferrum::Browser::Binary.find(%w[bin1]) }.to raise_error(Ferrum::EmptyPathError)
+    end
+  end
+
+  describe "#all" do
+    it "finds one binary" do
+      expect(Ferrum::Browser::Binary.all("bin1")).to eq([bin1])
+    end
+
+    it "finds multiple binaries with ext" do
+      ENV["PATHEXT"] = ".com;.exe"
+
+      expect(Ferrum::Browser::Binary.all("bin1")).to eq([bin1_exe, bin1])
+    end
+
+    it "finds all binary when list passed" do
+      expect(Ferrum::Browser::Binary.all(%w[bin1 bin3])).to eq([bin1, bin3])
+    end
+
+    it "finds binary with PATHEXT" do
+      ENV["PATHEXT"] = ".com;.exe"
+
+      expect(Ferrum::Browser::Binary.all(%w[bin4])).to eq([bin4_exe])
+    end
+
+    it "raises an error" do
+      ENV["PATH"] = ""
+
+      expect { Ferrum::Browser::Binary.all(%w[bin1]) }.to raise_error(Ferrum::EmptyPathError)
+    end
+  end
+
+  describe "#lazy_find" do
+    it "works lazily" do
+      enum = Ferrum::Browser::Binary.lazy_find(%w[ls which none])
+
+      expect(enum.instance_of?(Enumerator::Lazy)).to be_truthy
     end
   end
 end
diff --git a/spec/browser/version_info_spec.rb b/spec/browser/version_info_spec.rb
index 62b95743..9dc97b76 100644
--- a/spec/browser/version_info_spec.rb
+++ b/spec/browser/version_info_spec.rb
@@ -1,57 +1,53 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Browser
-    describe VersionInfo do
-      let(:protocol_version) { "1.3" }
-      let(:product)          { "HeadlessChrome/106.0.5249.91" }
-      let(:revision)         { "@fa96d5f07b1177d1bf5009f647a5b8c629762157" }
-      let(:user_agent)       do
-        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 " \
-          "(KHTML, like Gecko) HeadlessChrome/106.0.5249.91 Safari/537.36"
-      end
-      let(:js_version) { "10.6.194.17" }
-      let(:properties) do
-        {
-          "protocolVersion" => protocol_version,
-          "product" => product,
-          "revision" => revision,
-          "userAgent" => user_agent,
-          "jsVersion" => js_version
-        }
-      end
+describe Ferrum::Browser::VersionInfo do
+  let(:protocol_version) { "1.3" }
+  let(:product)          { "HeadlessChrome/106.0.5249.91" }
+  let(:revision)         { "@fa96d5f07b1177d1bf5009f647a5b8c629762157" }
+  let(:user_agent)       do
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 " \
+      "(KHTML, like Gecko) HeadlessChrome/106.0.5249.91 Safari/537.36"
+  end
+  let(:js_version) { "10.6.194.17" }
+  let(:properties) do
+    {
+      "protocolVersion" => protocol_version,
+      "product" => product,
+      "revision" => revision,
+      "userAgent" => user_agent,
+      "jsVersion" => js_version
+    }
+  end
 
-      subject { described_class.new(properties) }
+  subject { described_class.new(properties) }
 
-      describe "#protocol_version" do
-        it "must return the protocolVersion property" do
-          expect(subject.protocol_version).to eq(properties["protocolVersion"])
-        end
-      end
+  describe "#protocol_version" do
+    it "must return the protocolVersion property" do
+      expect(subject.protocol_version).to eq(properties["protocolVersion"])
+    end
+  end
 
-      describe "#product" do
-        it "must return the product property" do
-          expect(subject.product).to eq(properties["product"])
-        end
-      end
+  describe "#product" do
+    it "must return the product property" do
+      expect(subject.product).to eq(properties["product"])
+    end
+  end
 
-      describe "#revision" do
-        it "must return the revision property" do
-          expect(subject.revision).to eq(properties["revision"])
-        end
-      end
+  describe "#revision" do
+    it "must return the revision property" do
+      expect(subject.revision).to eq(properties["revision"])
+    end
+  end
 
-      describe "#user_agent" do
-        it "must return the userAgent property" do
-          expect(subject.user_agent).to eq(properties["userAgent"])
-        end
-      end
+  describe "#user_agent" do
+    it "must return the userAgent property" do
+      expect(subject.user_agent).to eq(properties["userAgent"])
+    end
+  end
 
-      describe "#js_version" do
-        it "must return the jsVersion property" do
-          expect(subject.js_version).to eq(properties["jsVersion"])
-        end
-      end
+  describe "#js_version" do
+    it "must return the jsVersion property" do
+      expect(subject.js_version).to eq(properties["jsVersion"])
     end
   end
 end
diff --git a/spec/browser/xvfb_spec.rb b/spec/browser/xvfb_spec.rb
index 9e396471..14131f47 100644
--- a/spec/browser/xvfb_spec.rb
+++ b/spec/browser/xvfb_spec.rb
@@ -1,68 +1,64 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Browser
-    describe Xvfb, skip: !Binary.find("Xvfb") do
-      let(:process) { xvfb_browser.process }
-      let(:xvfb_browser) { Browser.new(default_options.merge(options)) }
-      let(:default_options) { Hash(headless: true, xvfb: true) }
+describe Ferrum::Browser::Xvfb, skip: !Ferrum::Browser::Binary.find("Xvfb") do
+  let(:process) { xvfb_browser.process }
+  let(:xvfb_browser) { Ferrum::Browser.new(default_options.merge(options)) }
+  let(:default_options) { Hash(headless: true, xvfb: true) }
 
-      context "headless" do
-        context "with window_size" do
-          let(:options) { Hash(window_size: [1400, 1400]) }
+  context "headless" do
+    context "with window_size" do
+      let(:options) { Hash(window_size: [1400, 1400]) }
 
-          it "allows to run tests configured to xvfb" do
-            xvfb_browser.go_to(base_url)
+      it "allows to run tests configured to xvfb" do
+        xvfb_browser.go_to(base_url)
 
-            expect(xvfb_browser.body).to include("Hello world!")
-            expect(process_alive?(process.xvfb.pid)).to be(true)
-            expect(process.xvfb.screen_size).to eq("1400x1400x24")
-            expect(process.xvfb.to_env).to eq("DISPLAY" => ":#{process.xvfb.display_id}")
-          ensure
-            xvfb_browser&.quit
-            expect(process_alive?(process.xvfb.pid)).to be(false)
-          end
-        end
+        expect(xvfb_browser.body).to include("Hello world!")
+        expect(process_alive?(process.xvfb.pid)).to be(true)
+        expect(process.xvfb.screen_size).to eq("1400x1400x24")
+        expect(process.xvfb.to_env).to eq("DISPLAY" => ":#{process.xvfb.display_id}")
+      ensure
+        xvfb_browser&.quit
+        expect(process_alive?(process.xvfb.pid)).to be(false)
+      end
+    end
 
-        context "without window_size" do
-          let(:options) { {} }
+    context "without window_size" do
+      let(:options) { {} }
 
-          it "allows to run tests configured to xvfb" do
-            xvfb_browser.go_to(base_url)
+      it "allows to run tests configured to xvfb" do
+        xvfb_browser.go_to(base_url)
 
-            expect(xvfb_browser.body).to include("Hello world!")
-            expect(process_alive?(process.xvfb.pid)).to be(true)
-            expect(process.xvfb.screen_size).to eq("1024x768x24")
-            expect(process.xvfb.to_env).to eq("DISPLAY" => ":#{process.xvfb.display_id}")
-          ensure
-            xvfb_browser&.quit
-            expect(process_alive?(process.xvfb.pid)).to be(false)
-          end
-        end
+        expect(xvfb_browser.body).to include("Hello world!")
+        expect(process_alive?(process.xvfb.pid)).to be(true)
+        expect(process.xvfb.screen_size).to eq("1024x768x24")
+        expect(process.xvfb.to_env).to eq("DISPLAY" => ":#{process.xvfb.display_id}")
+      ensure
+        xvfb_browser&.quit
+        expect(process_alive?(process.xvfb.pid)).to be(false)
       end
+    end
+  end
 
-      context "headful" do
-        let(:options) { Hash(headless: false) }
+  context "headful" do
+    let(:options) { Hash(headless: false) }
 
-        it "allows to run tests configured to xvfb" do
-          xvfb_browser.go_to(base_url)
+    it "allows to run tests configured to xvfb" do
+      xvfb_browser.go_to(base_url)
 
-          expect(xvfb_browser.body).to include("Hello world!")
-          expect(process_alive?(process.xvfb.pid)).to be(true)
-          expect(process.xvfb.screen_size).to eq("1024x768x24")
-        ensure
-          xvfb_browser&.quit
-          expect(process_alive?(process.xvfb.pid)).to be(false)
-        end
-      end
+      expect(xvfb_browser.body).to include("Hello world!")
+      expect(process_alive?(process.xvfb.pid)).to be(true)
+      expect(process.xvfb.screen_size).to eq("1024x768x24")
+    ensure
+      xvfb_browser&.quit
+      expect(process_alive?(process.xvfb.pid)).to be(false)
+    end
+  end
 
-      def process_alive?(pid)
-        return false unless pid
+  def process_alive?(pid)
+    return false unless pid
 
-        ::Process.kill(0, pid) == 1
-      rescue Errno::ESRCH
-        false
-      end
-    end
+    ::Process.kill(0, pid) == 1
+  rescue Errno::ESRCH
+    false
   end
 end
diff --git a/spec/browser_spec.rb b/spec/browser_spec.rb
index 1d08844b..2d4ab27e 100644
--- a/spec/browser_spec.rb
+++ b/spec/browser_spec.rb
@@ -1,477 +1,479 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Browser do
-    describe "#new" do
-      let(:logger) { StringIO.new }
+describe Ferrum::Browser do
+  describe "#new" do
+    let(:logger) { StringIO.new }
 
-      context ":browser_path argument" do
-        it "includes the process output in the error" do
-          path = "#{PROJECT_ROOT}/spec/support/broken_chrome"
+    context ":browser_path argument" do
+      it "includes the process output in the error" do
+        path = "#{PROJECT_ROOT}/spec/support/broken_chrome"
 
-          expect do
-            Browser.new(browser_path: path)
-          end.to raise_error(Ferrum::ProcessTimeoutError) do |e|
-            expect(e.output).to include "Broken Chrome error message"
-          end
+        expect do
+          Ferrum::Browser.new(browser_path: path)
+        end.to raise_error(Ferrum::ProcessTimeoutError) do |e|
+          expect(e.output).to include "Broken Chrome error message"
         end
+      end
 
-        it "supports custom chrome path" do
-          original_path = "#{PROJECT_ROOT}/spec/support/chrome_path"
-          File.write(original_path, browser.process.path)
-
-          file = "#{PROJECT_ROOT}/spec/support/custom_chrome_called"
-          path = "#{PROJECT_ROOT}/spec/support/custom_chrome"
+      it "supports custom chrome path" do
+        original_path = "#{PROJECT_ROOT}/spec/support/chrome_path"
+        File.write(original_path, browser.process.path)
 
-          browser = Browser.new(browser_path: path)
+        file = "#{PROJECT_ROOT}/spec/support/custom_chrome_called"
+        path = "#{PROJECT_ROOT}/spec/support/custom_chrome"
 
-          # If the correct custom path is called, it will touch the file.
-          # We allow at least 10 secs for this to happen before failing.
+        browser = Ferrum::Browser.new(browser_path: path)
 
-          tries = 0
-          until File.exist?(file) || tries == 100
-            sleep 0.1
-            tries += 1
-          end
+        # If the correct custom path is called, it will touch the file.
+        # We allow at least 10 secs for this to happen before failing.
 
-          expect(File.exist?(file)).to be true
-        ensure
-          FileUtils.rm_f(original_path)
-          FileUtils.rm_f(file)
-          browser&.quit
+        tries = 0
+        until File.exist?(file) || tries == 100
+          sleep 0.1
+          tries += 1
         end
-      end
 
-      it "supports :logger argument" do
-        browser = Browser.new(logger: logger)
-        browser.go_to(base_url("/ferrum/console_log"))
-        expect(logger.string).to include("Hello world")
+        expect(File.exist?(file)).to be true
       ensure
+        FileUtils.rm_f(original_path)
+        FileUtils.rm_f(file)
         browser&.quit
       end
+    end
 
-      it "supports :ignore_default_browser_options argument" do
-        defaults = Browser::Options::Chrome.options.except("disable-web-security")
-        browser = Browser.new(ignore_default_browser_options: true, browser_options: defaults)
-        browser.go_to(base_url("/ferrum/console_log"))
-      ensure
-        browser&.quit
-      end
+    it "supports :logger argument" do
+      browser = Ferrum::Browser.new(logger: logger)
+      browser.go_to(base_url("/ferrum/console_log"))
+      expect(logger.string).to include("Hello world")
+    ensure
+      browser&.quit
+    end
 
-      it "supports :process_timeout argument" do
-        path = "#{PROJECT_ROOT}/spec/support/no_chrome"
+    it "supports :ignore_default_browser_options argument" do
+      defaults = Ferrum::Browser::Options::Chrome.options.except("disable-web-security")
+      browser = Ferrum::Browser.new(ignore_default_browser_options: true, browser_options: defaults)
+      browser.go_to(base_url("/ferrum/console_log"))
+    ensure
+      browser&.quit
+    end
 
-        expect do
-          Browser.new(browser_path: path, process_timeout: 2)
-        end.to raise_error(
-          Ferrum::ProcessTimeoutError,
-          "Browser did not produce websocket url within 2 seconds, try to increase `:process_timeout`. See https://github.com/rubycdp/ferrum#customization"
-        )
-      end
+    it "supports :process_timeout argument" do
+      path = "#{PROJECT_ROOT}/spec/support/no_chrome"
 
-      context ":extensions argument" do
-        it "extends the browser's world with files" do
-          browser = Browser.new(base_url: base_url,
-                                extensions: [File.expand_path("support/geolocation.js", __dir__)])
+      expect do
+        Ferrum::Browser.new(browser_path: path, process_timeout: 2)
+      end.to raise_error(
+        Ferrum::ProcessTimeoutError,
+        "Browser did not produce websocket url within 2 seconds, try to increase `:process_timeout`. See https://github.com/rubycdp/ferrum#customization"
+      )
+    end
 
-          browser.go_to("/ferrum/requiring_custom_extension")
+    context ":extensions argument" do
+      it "extends the browser's world with files" do
+        browser = Ferrum::Browser.new(base_url: base_url,
+                                      extensions: [File.expand_path("support/geolocation.js", __dir__)])
 
-          expect(
-            browser.body
-          ).to include(%(Location: <span id="location">1,-1</span>))
+        browser.go_to("/ferrum/requiring_custom_extension")
 
-          expect(
-            browser.evaluate(%(document.getElementById("location").innerHTML))
-          ).to eq("1,-1")
+        expect(
+          browser.body
+        ).to include(%(Location: <span id="location">1,-1</span>))
 
-          expect(
-            browser.evaluate("navigator.geolocation")
-          ).to_not eq(nil)
-        ensure
-          browser&.quit
-        end
+        expect(
+          browser.evaluate(%(document.getElementById("location").innerHTML))
+        ).to eq("1,-1")
 
-        it "extends the browser's world with source" do
-          browser = Browser.new(base_url: base_url,
-                                extensions: [{ source: "window.secret = 'top'" }])
+        expect(
+          browser.evaluate("navigator.geolocation")
+        ).to_not eq(nil)
+      ensure
+        browser&.quit
+      end
 
-          browser.go_to("/ferrum/requiring_custom_extension")
+      it "extends the browser's world with source" do
+        browser = Ferrum::Browser.new(base_url: base_url,
+                                      extensions: [{ source: "window.secret = 'top'" }])
 
-          expect(browser.evaluate(%(window.secret))).to eq("top")
-        ensure
-          browser&.quit
-        end
+        browser.go_to("/ferrum/requiring_custom_extension")
 
-        it "errors when extension is unavailable" do
-          browser = Browser.new(extensions: [File.expand_path("../support/non_existent.js", __dir__)])
-          expect { browser.go_to }.to raise_error(Errno::ENOENT)
-        ensure
-          browser&.quit
-        end
+        expect(browser.evaluate(%(window.secret))).to eq("top")
+      ensure
+        browser&.quit
       end
 
-      it "supports :port argument" do
-        browser = Browser.new(port: 12_345)
-        browser.go_to(base_url)
+      it "errors when extension is unavailable" do
+        browser = Ferrum::Browser.new(extensions: [File.expand_path("../support/non_existent.js", __dir__)])
+        expect { browser.go_to }.to raise_error(Errno::ENOENT)
+      ensure
+        browser&.quit
+      end
+    end
+
+    it "supports :port argument" do
+      browser = Ferrum::Browser.new(port: 12_345)
+      browser.go_to(base_url)
 
-        expect { TCPServer.new("127.0.0.1", 12_345) }.to raise_error(Errno::EADDRINUSE)
+      expect { TCPServer.new("127.0.0.1", 12_345) }.to raise_error(Errno::EADDRINUSE)
+    ensure
+      browser&.quit
+    end
+
+    it "supports :url argument" do
+      with_external_browser do |url|
+        browser = Ferrum::Browser.new(url: url)
+        browser.go_to(base_url)
+        expect(browser.body).to include("Hello world!")
       ensure
         browser&.quit
       end
+    end
+
+    it "supports :host argument", skip: ENV["BROWSER_TEST_HOST"].nil? do
+      # Use custom host "pointing" to localhost in /etc/hosts or iptables for this.
+      # https://superuser.com/questions/516208/how-to-change-ip-address-to-point-to-localhost
+      browser = Ferrum::Browser.new(host: ENV.fetch("BROWSER_TEST_HOST"), port: 12_345)
+      browser.go_to(base_url)
+
+      expect do
+        TCPServer.new(ENV.fetch("BROWSER_TEST_HOST"), 12_345)
+      end.to raise_error(Errno::EADDRINUSE)
+    ensure
+      browser&.quit
+    end
 
-      it "supports :url argument" do
-        with_external_browser do |url|
-          browser = Browser.new(url: url)
-          browser.go_to(base_url)
-          expect(browser.body).to include("Hello world!")
+    context ":proxy argument" do
+      let(:options) { {} }
+      let(:proxy) { Ferrum::Proxy.start(**options) }
+
+      after { proxy.stop }
+
+      context "without authorization" do
+        it "works without authorization" do
+          browser = Ferrum::Browser.new(
+            proxy: { host: proxy.host, port: proxy.port }
+          )
+
+          browser.go_to("https://example.com")
+          expect(browser.network.status).to eq(200)
+          expect(browser.body).to include("Example Domain")
         ensure
           browser&.quit
         end
       end
 
-      it "supports :host argument", skip: ENV["BROWSER_TEST_HOST"].nil? do
-        # Use custom host "pointing" to localhost in /etc/hosts or iptables for this.
-        # https://superuser.com/questions/516208/how-to-change-ip-address-to-point-to-localhost
-        browser = Browser.new(host: ENV.fetch("BROWSER_TEST_HOST"), port: 12_345)
-        browser.go_to(base_url)
+      context "with authorization" do
+        let(:options) { Hash(user: "user", password: "pa$$") }
 
-        expect do
-          TCPServer.new(ENV.fetch("BROWSER_TEST_HOST"), 12_345)
-        end.to raise_error(Errno::EADDRINUSE)
-      ensure
-        browser&.quit
-      end
+        it "works with right password" do
+          browser = Ferrum::Browser.new(
+            proxy: { host: proxy.host, port: proxy.port, **options }
+          )
 
-      context ":proxy argument" do
-        let(:options) { {} }
-        let(:proxy) { Ferrum::Proxy.start(**options) }
-
-        context "without authorization" do
-          it "works without authorization" do
-            browser = Ferrum::Browser.new(
-              proxy: { host: proxy.host, port: proxy.port }
-            )
-
-            browser.go_to("https://example.com")
-            expect(browser.network.status).to eq(200)
-            expect(browser.body).to include("Example Domain")
-          ensure
-            browser&.quit
-          end
+          browser.go_to("https://example.com")
+          expect(browser.network.status).to eq(200)
+          expect(browser.body).to include("Example Domain")
+        ensure
+          browser&.quit
         end
 
-        context "with authorization" do
-          let(:options) { Hash(user: "user", password: "pa$$") }
-
-          it "works with right password" do
-            browser = Ferrum::Browser.new(
-              proxy: { host: proxy.host, port: proxy.port, **options }
-            )
+        it "breaks with wrong password" do
+          browser = Ferrum::Browser.new(
+            proxy: { host: proxy.host, port: proxy.port, user: "u1", password: "p1" }
+          )
 
-            browser.go_to("https://example.com")
-            expect(browser.network.status).to eq(200)
-            expect(browser.body).to include("Example Domain")
-          ensure
-            browser&.quit
-          end
+          browser.go_to("https://example.com")
+          expect(browser.network.status).to eq(407)
+        ensure
+          browser&.quit
+        end
+      end
 
-          it "breaks with wrong password" do
-            browser = Ferrum::Browser.new(
-              proxy: { host: proxy.host, port: proxy.port, user: "u1", password: "p1" }
-            )
+      context "with rotation", skip: "Think how to make it working on CI" do
+        it "works after disposing context" do
+          browser = Ferrum::Browser.new(
+            proxy: { host: proxy.host, port: proxy.port, **options }
+          )
 
-            browser.go_to("https://example.com")
-            expect(browser.network.status).to eq(407)
-          ensure
-            browser&.quit
+          proxy.rotate(host: "host", port: 0, user: "user", password: "password")
+          browser.create_page(new_context: true) do |page|
+            page.go_to("https://api.ipify.org?format=json")
+            expect(page.network.status).to eq(200)
+            expect(page.body).to include("x.x.x.x")
           end
-        end
 
-        context "with rotation", skip: "Think how to make it working on CI" do
-          it "works after disposing context" do
-            browser = Ferrum::Browser.new(
-              proxy: { server: true }
-            )
-
-            browser.proxy_server.rotate(host: "host", port: 0, user: "user", password: "password")
-            browser.create_page(new_context: true) do |page|
-              page.go_to("https://api.ipify.org?format=json")
-              expect(page.network.status).to eq(200)
-              expect(page.body).to include("x.x.x.x")
-            end
-
-            browser.proxy_server.rotate(host: "host", port: 0, user: "user", password: "password")
-            browser.create_page(new_context: true) do |page|
-              page.go_to("https://api.ipify.org?format=json")
-              expect(page.network.status).to eq(200)
-              expect(page.body).to include("x.x.x.x")
-            end
-          ensure
-            browser&.quit
+          proxy.rotate(host: "host", port: 0, user: "user", password: "password")
+          browser.create_page(new_context: true) do |page|
+            page.go_to("https://api.ipify.org?format=json")
+            expect(page.network.status).to eq(200)
+            expect(page.body).to include("x.x.x.x")
           end
+        ensure
+          browser&.quit
         end
       end
+    end
 
-      it "supports :pending_connection_errors argument" do
-        browser = Browser.new(base_url: base_url, pending_connection_errors: false, timeout: 0.1)
+    it "supports :pending_connection_errors argument" do
+      browser = Ferrum::Browser.new(base_url: base_url, pending_connection_errors: false, timeout: 0.1)
 
-        expect { browser.go_to("/ferrum/really_slow") }.not_to raise_error
-      ensure
-        browser&.quit
-      end
+      expect { browser.go_to("/ferrum/really_slow") }.not_to raise_error
+    ensure
+      browser&.quit
+    end
 
-      context ":save_path argument" do
-        let(:filename) { "attachment.pdf" }
-        let(:browser) do
-          Ferrum::Browser.new(
-            base_url: Ferrum::Server.server.base_url,
-            save_path: save_path
-          )
-        end
+    context ":save_path argument" do
+      let(:filename) { "attachment.pdf" }
+      let(:browser) do
+        Ferrum::Browser.new(
+          base_url: Ferrum::Server.server.base_url,
+          save_path: save_path
+        )
+      end
 
-        context "with absolute path" do
-          let(:save_path) { "/tmp/ferrum" }
+      context "with absolute path" do
+        let(:save_path) { "/tmp/ferrum" }
 
-          it "saves an attachment" do
-            browser.go_to("/#{filename}")
+        it "saves an attachment" do
+          browser.go_to("/#{filename}")
 
-            expect(File.exist?("#{save_path}/#{filename}")).to be true
-          ensure
-            FileUtils.rm_rf(save_path)
-          end
+          expect(File.exist?("#{save_path}/#{filename}")).to be true
+        ensure
+          FileUtils.rm_rf(save_path)
         end
+      end
 
-        context "with local path" do
-          let(:save_path) { "spec/tmp" }
+      context "with local path" do
+        let(:save_path) { "spec/tmp" }
 
-          it "raises an error" do
-            expect do
-              browser.go_to("/#{filename}")
-            end.to raise_error(Ferrum::Error, "supply absolute path for `:save_path` option")
-          end
+        it "raises an error" do
+          expect do
+            browser.go_to("/#{filename}")
+          end.to raise_error(Ferrum::Error, "supply absolute path for `:save_path` option")
         end
       end
     end
+  end
 
-    describe "#crash" do
-      it "raises an error" do
-        expect { browser.crash }.to raise_error(Ferrum::DeadBrowserError)
-      end
+  describe "#crash" do
+    it "raises an error" do
+      expect { browser.crash }.to raise_error(Ferrum::DeadBrowserError)
+    end
 
-      it "restarts the client" do
-        expect { browser.crash }.to raise_error(Ferrum::DeadBrowserError)
+    it "restarts the client" do
+      expect { browser.crash }.to raise_error(Ferrum::DeadBrowserError)
 
-        browser.go_to
+      browser.go_to
 
-        expect(browser.body).to include("Hello world")
-      end
+      expect(browser.body).to include("Hello world")
     end
+  end
 
-    describe "#version" do
-      it "returns browser version information" do
-        version_info = browser.version
-
-        expect(version_info).to be_kind_of(Ferrum::Browser::VersionInfo)
-        expect(version_info.protocol_version).to_not be(nil)
-        expect(version_info.protocol_version).to_not be_empty
-        expect(version_info.product).to_not be(nil)
-        expect(version_info.product).to_not be_empty
-        expect(version_info.revision).to_not be(nil)
-        expect(version_info.revision).to_not be_empty
-        expect(version_info.user_agent).to_not be(nil)
-        expect(version_info.user_agent).to_not be_empty
-        expect(version_info.js_version).to_not be(nil)
-        expect(version_info.js_version).to_not be_empty
-      end
+  describe "#version" do
+    it "returns browser version information" do
+      version_info = browser.version
+
+      expect(version_info).to be_kind_of(Ferrum::Browser::VersionInfo)
+      expect(version_info.protocol_version).to_not be(nil)
+      expect(version_info.protocol_version).to_not be_empty
+      expect(version_info.product).to_not be(nil)
+      expect(version_info.product).to_not be_empty
+      expect(version_info.revision).to_not be(nil)
+      expect(version_info.revision).to_not be_empty
+      expect(version_info.user_agent).to_not be(nil)
+      expect(version_info.user_agent).to_not be_empty
+      expect(version_info.js_version).to_not be(nil)
+      expect(version_info.js_version).to_not be_empty
     end
+  end
 
-    describe "#quit" do
-      it "stops silently before go_to call" do
-        browser = Browser.new
-        expect { browser.quit }.not_to raise_error
-      end
+  describe "#quit" do
+    it "stops silently before go_to call" do
+      browser = Ferrum::Browser.new
+      expect { browser.quit }.not_to raise_error
+    end
 
-      it "supports stopping the session", skip: Utils::Platform.windows? do
-        browser = Browser.new
-        pid = browser.process.pid
+    it "supports stopping the session", skip: Ferrum::Utils::Platform.windows? do
+      browser = Ferrum::Browser.new
+      pid = browser.process.pid
 
-        expect(Process.kill(0, pid)).to eq(1)
-        browser.quit
+      expect(Process.kill(0, pid)).to eq(1)
+      browser.quit
 
-        expect { Process.kill(0, pid) }.to raise_error(Errno::ESRCH)
-      end
+      expect { Process.kill(0, pid) }.to raise_error(Errno::ESRCH)
     end
+  end
 
-    describe "#resize" do
-      it "allows the viewport to be resized" do
-        browser.go_to
-        browser.resize(width: 200, height: 400)
-        expect(browser.viewport_size).to eq([200, 400])
-      end
+  describe "#resize" do
+    it "allows the viewport to be resized" do
+      browser.go_to
+      browser.resize(width: 200, height: 400)
+      expect(browser.viewport_size).to eq([200, 400])
+    end
 
-      it "inherits size for a new window" do
-        browser.go_to
-        browser.resize(width: 1200, height: 800)
-        page = browser.create_page
-        expect(page.viewport_size).to eq [1200, 800]
-      end
+    it "inherits size for a new window" do
+      browser.go_to
+      browser.resize(width: 1200, height: 800)
+      page = browser.create_page
+      expect(page.viewport_size).to eq [1200, 800]
+    end
 
-      it "resizes windows" do
-        browser.go_to
+    it "resizes windows" do
+      browser.go_to
 
-        expect(browser.targets.size).to eq(1)
+      expect(browser.targets.size).to eq(1)
 
-        browser.execute <<-JS
+      browser.execute <<-JS
         window.open("/ferrum/simple", "popup1")
-        JS
+      JS
 
-        sleep 0.1
+      sleep 0.1
 
-        browser.execute <<-JS
+      browser.execute <<-JS
         window.open("/ferrum/simple", "popup2")
-        JS
-
-        popup1, popup2 = browser.windows(:last, 2)
-        popup1&.resize(width: 100, height: 200)
-        popup2&.resize(width: 200, height: 100)
-
-        expect(popup1&.viewport_size).to eq([100, 200])
-        expect(popup2&.viewport_size).to eq([200, 100])
-      end
+      JS
 
-      context "fullscreen" do
-        shared_examples "resize viewport by fullscreen" do
-          it "allows the viewport to be resized by fullscreen" do
-            expect(browser.viewport_size).to eq([1024, 768])
-            browser.go_to(path)
-            browser.resize(fullscreen: true)
-            expect(browser.viewport_size).to eq(viewport_size)
-          end
-        end
-
-        include_examples "resize viewport by fullscreen" do
-          let(:path) { "/ferrum/custom_html_size" }
-          let(:viewport_size) { [1280, 1024] }
-        end
+      popup1, popup2 = browser.windows(:last, 2)
+      popup1&.resize(width: 100, height: 200)
+      popup2&.resize(width: 200, height: 100)
 
-        include_examples "resize viewport by fullscreen" do
-          let(:path) { "/ferrum/custom_html_size_100%" }
-          let(:viewport_size) { [1272, 1008] }
-        end
+      expect(popup1&.viewport_size).to eq([100, 200])
+      expect(popup2&.viewport_size).to eq([200, 100])
+    end
 
-        it "resizes to normal from fullscreen window state" do
+    context "fullscreen" do
+      shared_examples "resize viewport by fullscreen" do
+        it "allows the viewport to be resized by fullscreen" do
+          expect(browser.viewport_size).to eq([1024, 768])
           browser.go_to(path)
           browser.resize(fullscreen: true)
-          browser.resize(width: 200, height: 400)
-          expect(browser.viewport_size).to eq([200, 400])
+          expect(browser.viewport_size).to eq(viewport_size)
         end
       end
-    end
 
-    describe "#evaluate_on_new_document" do
-      it "supports evaluation of JavaScript before page loads" do
-        browser = Browser.new(base_url: base_url)
+      include_examples "resize viewport by fullscreen" do
+        let(:path) { "/ferrum/custom_html_size" }
+        let(:viewport_size) { [1280, 1024] }
+      end
 
-        browser.evaluate_on_new_document <<~JS
-          Object.defineProperty(navigator, "languages", {
-            get: function() { return ["tlh"]; }
-          });
-        JS
+      include_examples "resize viewport by fullscreen" do
+        let(:path) { "/ferrum/custom_html_size_100%" }
+        let(:viewport_size) { [1272, 1008] }
+      end
 
-        browser.go_to("/ferrum/with_user_js")
-        language = browser.at_xpath("//*[@id='browser-languages']/text()").text
-        expect(language).to eq("tlh")
-      ensure
-        browser&.quit
+      it "resizes to normal from fullscreen window state" do
+        browser.go_to(path)
+        browser.resize(fullscreen: true)
+        browser.resize(width: 200, height: 400)
+        expect(browser.viewport_size).to eq([200, 400])
       end
     end
+  end
 
-    describe "#targets" do
-      it "lists the open windows" do
-        browser.go_to
-
-        browser.execute <<~JS
-          window.open("/ferrum/simple", "popup")
-        JS
-
-        sleep 0.1
+  describe "#evaluate_on_new_document" do
+    it "supports evaluation of JavaScript before page loads" do
+      browser = Ferrum::Browser.new(base_url: base_url)
+
+      browser.evaluate_on_new_document <<~JS
+        Object.defineProperty(navigator, "languages", {
+          get: function() { return ["tlh"]; }
+        });
+      JS
+
+      browser.go_to("/ferrum/with_user_js")
+      language = browser.at_xpath("//*[@id='browser-languages']/text()").text
+      expect(language).to eq("tlh")
+    ensure
+      browser&.quit
+    end
+  end
 
-        expect(browser.targets.size).to eq(2)
+  describe "#targets" do
+    it "lists the open windows" do
+      browser.go_to
 
-        browser.execute <<~JS
-          window.open("/ferrum/simple", "popup2")
-        JS
+      browser.execute <<~JS
+        window.open("/ferrum/simple", "popup")
+      JS
 
-        sleep 0.1
+      sleep 0.1
 
-        expect(browser.targets.size).to eq(3)
+      expect(browser.targets.size).to eq(2)
 
-        popup2, = browser.windows(:last)
-        expect(popup2.body).to include("Test")
-        # Browser isn't dead, current page after executing JS closes connection
-        # and we don't have a chance to push response to the Queue. Since the
-        # queue and websocket are closed and response is nil the proper guess
-        # would be that browser is dead, but in fact the page is dead and
-        # browser is fully alive.
-        begin
-          popup2.execute("window.close()")
-        rescue StandardError
-          Ferrum::DeadBrowserError
-        end
+      browser.execute <<~JS
+        window.open("/ferrum/simple", "popup2")
+      JS
+
+      sleep 0.1
+
+      expect(browser.targets.size).to eq(3)
+
+      popup2, = browser.windows(:last)
+      expect(popup2.body).to include("Test")
+      # Browser isn't dead, current page after executing JS closes connection
+      # and we don't have a chance to push response to the Queue. Since the
+      # queue and websocket are closed and response is nil the proper guess
+      # would be that browser is dead, but in fact the page is dead and
+      # browser is fully alive.
+      begin
+        popup2.execute("window.close()")
+      rescue StandardError
+        Ferrum::DeadBrowserError
+      end
 
-        sleep 0.1
+      sleep 0.1
 
-        expect(browser.targets.size).to eq(2)
-      end
+      expect(browser.targets.size).to eq(2)
     end
+  end
 
-    describe "#reset" do
-      it "clears local storage" do
-        browser.go_to
-        browser.execute <<~JS
-          localStorage.setItem("key", "value");
-        JS
-        value = browser.evaluate <<~JS
-          localStorage.getItem("key");
-        JS
-
-        expect(value).to eq("value")
-
-        browser.reset
-
-        browser.go_to
-        value = browser.evaluate <<~JS
-          localStorage.getItem("key");
-        JS
-        expect(value).to be_nil
-      end
+  describe "#reset" do
+    it "clears local storage" do
+      browser.go_to
+      browser.execute <<~JS
+        localStorage.setItem("key", "value");
+      JS
+      value = browser.evaluate <<~JS
+        localStorage.getItem("key");
+      JS
+
+      expect(value).to eq("value")
+
+      browser.reset
+
+      browser.go_to
+      value = browser.evaluate <<~JS
+        localStorage.getItem("key");
+      JS
+      expect(value).to be_nil
     end
+  end
 
-    describe "#create_page" do
-      it "supports calling without block" do
-        expect(browser.contexts.size).to eq(0)
-        expect(browser.targets.size).to eq(0)
-
-        page = browser.create_page
-        page.go_to("/ferrum/simple")
+  describe "#create_page" do
+    it "supports calling without block" do
+      expect(browser.contexts.size).to eq(0)
+      expect(browser.targets.size).to eq(0)
 
-        expect(browser.contexts.size).to eq(1)
-        expect(browser.targets.size).to eq(1)
-      end
+      page = browser.create_page
+      page.go_to("/ferrum/simple")
 
-      it "supports calling with block" do
-        expect(browser.contexts.size).to eq(0)
-        expect(browser.targets.size).to eq(0)
+      expect(browser.contexts.size).to eq(1)
+      expect(browser.targets.size).to eq(1)
+    end
 
-        browser.create_page do |page|
-          page.go_to("/ferrum/simple")
-        end
+    it "supports calling with block" do
+      expect(browser.contexts.size).to eq(0)
+      expect(browser.targets.size).to eq(0)
 
-        expect(browser.contexts.size).to eq(1)
-        expect(browser.targets.size).to eq(0)
+      browser.create_page do |page|
+        page.go_to("/ferrum/simple")
       end
 
-      it "supports calling with :new_context and without block" do
+      expect(browser.contexts.size).to eq(1)
+      expect(browser.targets.size).to eq(0)
+    end
+
+    context "with :new_context" do
+      it "supports calling without block" do
         expect(browser.contexts.size).to eq(0)
 
         page = browser.create_page(new_context: true)
@@ -486,7 +488,7 @@ module Ferrum
         expect(browser.contexts.size).to eq(0)
       end
 
-      it "supports calling with :new_context and with block" do
+      it "supports calling with block" do
         expect(browser.contexts.size).to eq(0)
 
         browser.create_page(new_context: true) do |page|
@@ -497,40 +499,87 @@ module Ferrum
       end
     end
 
-    context "with pty", if: Utils::Platform.mri? && !Utils::Platform.windows? do
-      require "pty"
-      require "timeout"
-
-      before do
-        Tempfile.open(%w[test rb]) do |file|
-          file.print(script)
-          file.flush
-
-          Timeout.timeout(10) do
-            PTY.spawn("bundle exec ruby #{file.path}") do |read, write, pid|
-              sleep 0.01 until read.readline.chomp == "Please type enter"
-              write.puts
-              sleep 0.1 until (status = PTY.check(pid))
-              @status = status
-            end
-          end
+    context "with :proxy" do
+      let(:options) { {} }
+      let(:proxy) { Ferrum::Proxy.start(**options) }
+
+      after { proxy.stop }
+
+      context "without authorization" do
+        it "succeeds" do
+          expect(browser.contexts.size).to eq(0)
+
+          page = browser.create_page(proxy: { host: proxy.host, port: proxy.port })
+          page.go_to("https://example.com")
+
+          expect(browser.contexts.size).to eq(1)
+          expect(page.context.targets.size).to eq(1)
+          expect(page.network.status).to eq(200)
+          expect(page.body).to include("Example Domain")
+
+          page = browser.create_page(proxy: { host: proxy.host, port: proxy.port })
+          expect(browser.contexts.size).to eq(2)
+          page.context.dispose
+          expect(browser.contexts.size).to eq(1)
         end
       end
 
-      let(:script) do
-        <<-RUBY
-          require "ferrum"
-          browser = Ferrum::Browser.new
-          browser.go_to("http://example.com")
-          puts "Please type enter"
-          sleep 1
-          browser.current_url
-        RUBY
+      context "with authorization" do
+        let(:options) { { user: "user", password: "password" } }
+
+        it "fails with wrong password" do
+          page = browser.create_page(proxy: { host: proxy.host, port: proxy.port,
+                                              user: options[:user], password: "$$" })
+          page.go_to("https://example.com")
+
+          expect(page.network.status).to eq(407)
+        end
+
+        it "succeeds with correct password" do
+          page = browser.create_page(proxy: { host: proxy.host, port: proxy.port,
+                                              user: options[:user], password: options[:password] })
+          page.go_to("https://example.com")
+
+          expect(page.network.status).to eq(200)
+          expect(page.body).to include("Example Domain")
+        end
       end
+    end
+  end
 
-      it do
-        expect(@status).to be_success
+  context "with pty", if: Ferrum::Utils::Platform.mri? && !Ferrum::Utils::Platform.windows? do
+    require "pty"
+    require "timeout"
+
+    before do
+      Tempfile.open(%w[test rb]) do |file|
+        file.print(script)
+        file.flush
+
+        Timeout.timeout(10) do
+          PTY.spawn("bundle exec ruby #{file.path}") do |read, write, pid|
+            sleep 0.01 until read.readline.chomp == "Please type enter"
+            write.puts
+            sleep 0.1 until (status = PTY.check(pid))
+            @status = status
+          end
+        end
       end
     end
+
+    let(:script) do
+      <<-RUBY
+        require "ferrum"
+        browser = Ferrum::Browser.new
+        browser.go_to("http://example.com")
+        puts "Please type enter"
+        sleep 1
+        browser.current_url
+      RUBY
+    end
+
+    it do
+      expect(@status).to be_success
+    end
   end
 end
diff --git a/spec/context_spec.rb b/spec/context_spec.rb
index 217cc4a9..c3ad38e6 100644
--- a/spec/context_spec.rb
+++ b/spec/context_spec.rb
@@ -1,43 +1,41 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Context do
-    describe "#windows" do
-      it "waits for the window to load" do
-        browser.go_to
-
-        browser.execute <<-JS
-          window.open("/ferrum/slow", "popup")
-        JS
-
-        popup, = browser.windows(:last)
-        expect(popup.body).to include("slow page")
-        popup.close
-      end
+describe Ferrum::Context do
+  describe "#windows" do
+    it "waits for the window to load" do
+      browser.go_to
+
+      browser.execute <<-JS
+        window.open("/ferrum/slow", "popup")
+      JS
+
+      popup, = browser.windows(:last)
+      expect(popup.body).to include("slow page")
+      popup.close
+    end
 
-      it "can access a second window of the same name" do
-        browser.go_to
+    it "can access a second window of the same name" do
+      browser.go_to
 
-        browser.execute <<-JS
-          window.open("/ferrum/simple", "popup")
-        JS
+      browser.execute <<-JS
+        window.open("/ferrum/simple", "popup")
+      JS
 
-        popup, = browser.windows(:last)
-        expect(popup.body).to include("Test")
-        popup.close
+      popup, = browser.windows(:last)
+      expect(popup.body).to include("Test")
+      popup.close
 
-        sleep 0.5 # https://github.com/ChromeDevTools/devtools-protocol/issues/145
+      sleep 0.5 # https://github.com/ChromeDevTools/devtools-protocol/issues/145
 
-        browser.execute <<-JS
-          window.open("/ferrum/simple", "popup")
-        JS
+      browser.execute <<-JS
+        window.open("/ferrum/simple", "popup")
+      JS
 
-        sleep 0.5 # https://github.com/ChromeDevTools/devtools-protocol/issues/145
+      sleep 0.5 # https://github.com/ChromeDevTools/devtools-protocol/issues/145
 
-        same, = browser.windows(:last)
-        expect(same.body).to include("Test")
-        same.close
-      end
+      same, = browser.windows(:last)
+      expect(same.body).to include("Test")
+      same.close
     end
   end
 end
diff --git a/spec/cookies_spec.rb b/spec/cookies_spec.rb
index 82c9f908..c81650b5 100644
--- a/spec/cookies_spec.rb
+++ b/spec/cookies_spec.rb
@@ -1,212 +1,210 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Cookies do
-    describe "#all" do
-      it "returns cookie object" do
-        browser.go_to("/set_cookie")
-
-        cookies = browser.cookies.all
-
-        expect(cookies).to eq({ "stealth" => Cookies::Cookie.new("name" => "stealth",
-                                                                 "value" => "test_cookie",
-                                                                 "domain" => "127.0.0.1",
-                                                                 "path" => "/",
-                                                                 "expires" => -1,
-                                                                 "size" => 18,
-                                                                 "httpOnly" => false,
-                                                                 "secure" => false,
-                                                                 "session" => true,
-                                                                 "priority" => "Medium",
-                                                                 "sameParty" => false,
-                                                                 "sourceScheme" => "NonSecure",
-                                                                 "sourcePort" => server.port) })
-      end
+describe Ferrum::Cookies do
+  describe "#all" do
+    it "returns cookie object" do
+      browser.go_to("/set_cookie")
+
+      cookies = browser.cookies.all
+
+      expect(cookies).to eq({ "stealth" => Ferrum::Cookies::Cookie.new("name" => "stealth",
+                                                                       "value" => "test_cookie",
+                                                                       "domain" => "127.0.0.1",
+                                                                       "path" => "/",
+                                                                       "expires" => -1,
+                                                                       "size" => 18,
+                                                                       "httpOnly" => false,
+                                                                       "secure" => false,
+                                                                       "session" => true,
+                                                                       "priority" => "Medium",
+                                                                       "sameParty" => false,
+                                                                       "sourceScheme" => "NonSecure",
+                                                                       "sourcePort" => server.port) })
     end
+  end
+
+  describe "#[]" do
+    it "returns cookie object" do
+      browser.go_to("/set_cookie")
+
+      cookie = browser.cookies["stealth"]
+      expect(cookie.name).to eq("stealth")
+      expect(cookie.value).to eq("test_cookie")
+      expect(cookie.domain).to eq("127.0.0.1")
+      expect(cookie.path).to eq("/")
+      expect(cookie.size).to eq(18)
+      expect(cookie.secure?).to be false
+      expect(cookie.httponly?).to be false
+      expect(cookie.session?).to be true
+      expect(cookie.expires).to be_nil
+    end
+  end
+
+  describe "#set" do
+    it "sets cookies" do
+      browser.cookies.set(name: "stealth", value: "omg")
+      browser.go_to("/get_cookie")
+      expect(browser.body).to include("omg")
+    end
+
+    it "sets cookies with custom settings" do
+      browser.cookies.set(
+        name: "stealth",
+        value: "omg",
+        path: "/ferrum",
+        httponly: true,
+        samesite: "Strict"
+      )
+
+      browser.go_to("/get_cookie")
+      expect(browser.body).to_not include("omg")
+
+      browser.go_to("/ferrum/get_cookie")
+      expect(browser.body).to include("omg")
+
+      expect(browser.cookies["stealth"].path).to eq("/ferrum")
+      expect(browser.cookies["stealth"].httponly?).to be_truthy
+      expect(browser.cookies["stealth"].samesite).to eq("Strict")
+    end
+
+    it "sets a retrieved cookie" do
+      browser.cookies.set(name: "stealth", value: "omg")
+      browser.go_to("/get_cookie")
+      expect(browser.body).to include("omg")
+
+      cookie = browser.cookies["stealth"]
+      browser.cookies.clear
+      browser.go_to("/get_cookie")
+      expect(browser.body).to_not include("omg")
 
-    describe "#[]" do
-      it "returns cookie object" do
-        browser.go_to("/set_cookie")
-
-        cookie = browser.cookies["stealth"]
-        expect(cookie.name).to eq("stealth")
-        expect(cookie.value).to eq("test_cookie")
-        expect(cookie.domain).to eq("127.0.0.1")
-        expect(cookie.path).to eq("/")
-        expect(cookie.size).to eq(18)
-        expect(cookie.secure?).to be false
-        expect(cookie.httponly?).to be false
-        expect(cookie.session?).to be true
-        expect(cookie.expires).to be_nil
-      end
+      browser.cookies.set(cookie)
+      browser.go_to("/get_cookie")
+      expect(browser.body).to include("omg")
     end
 
-    describe "#set" do
-      it "sets cookies" do
-        browser.cookies.set(name: "stealth", value: "omg")
-        browser.go_to("/get_cookie")
-        expect(browser.body).to include("omg")
-      end
-
-      it "sets cookies with custom settings" do
-        browser.cookies.set(
-          name: "stealth",
-          value: "omg",
-          path: "/ferrum",
-          httponly: true,
-          samesite: "Strict"
-        )
-
-        browser.go_to("/get_cookie")
-        expect(browser.body).to_not include("omg")
-
-        browser.go_to("/ferrum/get_cookie")
-        expect(browser.body).to include("omg")
-
-        expect(browser.cookies["stealth"].path).to eq("/ferrum")
-        expect(browser.cookies["stealth"].httponly?).to be_truthy
-        expect(browser.cookies["stealth"].samesite).to eq("Strict")
-      end
-
-      it "sets a retrieved cookie" do
-        browser.cookies.set(name: "stealth", value: "omg")
-        browser.go_to("/get_cookie")
-        expect(browser.body).to include("omg")
-
-        cookie = browser.cookies["stealth"]
-        browser.cookies.clear
-        browser.go_to("/get_cookie")
-        expect(browser.body).to_not include("omg")
-
-        browser.cookies.set(cookie)
-        browser.go_to("/get_cookie")
-        expect(browser.body).to include("omg")
-      end
-
-      it "sets a retrieved browser cookie" do
-        browser.go_to("/set_cookie")
-        cookie = browser.cookies["stealth"]
-        browser.go_to("/get_cookie")
-        expect(cookie.name).to eq("stealth")
-        expect(cookie.value).to eq("test_cookie")
-        expect(browser.body).to include("test_cookie")
-
-        browser.cookies.clear
-        browser.go_to("/get_cookie")
-        expect(browser.body).not_to include("test_cookie")
-
-        browser.cookies.set(cookie)
-        browser.go_to("/get_cookie")
-        expect(browser.body).to include("test_cookie")
-      end
-
-      it "retains the characteristics of the reference cookie" do
-        browser.cookies.set(name: "stealth", value: "omg", domain: "site.com")
-        expect(browser.cookies["stealth"].name).to eq("stealth")
-        expect(browser.cookies["stealth"].value).to eq("omg")
-        expect(browser.cookies["stealth"].domain).to eq("site.com")
-
-        cookie = browser.cookies["stealth"]
-        browser.cookies.clear
-        expect(browser.cookies["stealth"]).to eq(nil)
-        browser.cookies.set(cookie)
-
-        expect(browser.cookies["stealth"].name).to eq("stealth")
-        expect(browser.cookies["stealth"].value).to eq("omg")
-        expect(browser.cookies["stealth"].domain).to eq("site.com")
-
-        browser.cookies.clear
-        expect(browser.cookies["stealth"]).to eq(nil)
-        browser.cookies.set(cookie.attributes)
-
-        expect(browser.cookies["stealth"].name).to eq("stealth")
-        expect(browser.cookies["stealth"].value).to eq("omg")
-        expect(browser.cookies["stealth"].domain).to eq("site.com")
-      end
-
-      it "prevents side effects for params" do
-        cookie_params = { name: "stealth", value: "test_cookie" }
-        original_cookie_params = cookie_params.dup
-
-        browser.cookies.set(cookie_params)
-
-        expect(cookie_params).to eq(original_cookie_params)
-      end
-
-      it "prevents side effects for cookie object" do
-        browser.cookies.set(name: "stealth", value: "omg")
-        cookie = browser.cookies["stealth"]
-        cookie.instance_variable_set(
-          :@attributes,
-          { "name" => "stealth", "value" => "test_cookie", "domain" => "site.com" }
-        )
-        original_attributes = cookie.attributes.dup
-
-        browser.cookies.set(cookie)
-
-        expect(cookie.attributes).to eq(original_attributes)
-      end
-
-      it "sets cookies with an expires time" do
-        time = Time.at(Time.now.to_i + 10_000)
-        browser.go_to
-        browser.cookies.set(name: "foo", value: "bar", expires: time)
-        expect(browser.cookies["foo"].expires).to eq(time)
-      end
-
-      it "sets cookies for given domain" do
-        port = server.port
-        browser.cookies.set(name: "stealth", value: "127.0.0.1")
-        browser.cookies.set(name: "stealth", value: "localhost", domain: "localhost")
-
-        browser.go_to("http://localhost:#{port}/ferrum/get_cookie")
-        expect(browser.body).to include("localhost")
-
-        browser.go_to("http://127.0.0.1:#{port}/ferrum/get_cookie")
-        expect(browser.body).to include("127.0.0.1")
-      end
-
-      it "sets cookies correctly with :domain option when base_url isn't set" do
-        browser = Browser.new
-        browser.cookies.set(name: "stealth", value: "123456", domain: "localhost")
-
-        port = server.port
-        browser.go_to("http://localhost:#{port}/ferrum/get_cookie")
-        expect(browser.body).to include("123456")
-
-        browser.go_to("http://127.0.0.1:#{port}/ferrum/get_cookie")
-        expect(browser.body).not_to include("123456")
-      ensure
-        browser&.quit
-      end
+    it "sets a retrieved browser cookie" do
+      browser.go_to("/set_cookie")
+      cookie = browser.cookies["stealth"]
+      browser.go_to("/get_cookie")
+      expect(cookie.name).to eq("stealth")
+      expect(cookie.value).to eq("test_cookie")
+      expect(browser.body).to include("test_cookie")
+
+      browser.cookies.clear
+      browser.go_to("/get_cookie")
+      expect(browser.body).not_to include("test_cookie")
+
+      browser.cookies.set(cookie)
+      browser.go_to("/get_cookie")
+      expect(browser.body).to include("test_cookie")
     end
 
-    describe "#remove" do
-      it "removes a cookie" do
-        browser.go_to("/set_cookie")
+    it "retains the characteristics of the reference cookie" do
+      browser.cookies.set(name: "stealth", value: "omg", domain: "site.com")
+      expect(browser.cookies["stealth"].name).to eq("stealth")
+      expect(browser.cookies["stealth"].value).to eq("omg")
+      expect(browser.cookies["stealth"].domain).to eq("site.com")
+
+      cookie = browser.cookies["stealth"]
+      browser.cookies.clear
+      expect(browser.cookies["stealth"]).to eq(nil)
+      browser.cookies.set(cookie)
+
+      expect(browser.cookies["stealth"].name).to eq("stealth")
+      expect(browser.cookies["stealth"].value).to eq("omg")
+      expect(browser.cookies["stealth"].domain).to eq("site.com")
 
-        browser.go_to("/get_cookie")
-        expect(browser.body).to include("test_cookie")
+      browser.cookies.clear
+      expect(browser.cookies["stealth"]).to eq(nil)
+      browser.cookies.set(cookie.attributes)
 
-        browser.cookies.remove(name: "stealth")
+      expect(browser.cookies["stealth"].name).to eq("stealth")
+      expect(browser.cookies["stealth"].value).to eq("omg")
+      expect(browser.cookies["stealth"].domain).to eq("site.com")
+    end
+
+    it "prevents side effects for params" do
+      cookie_params = { name: "stealth", value: "test_cookie" }
+      original_cookie_params = cookie_params.dup
+
+      browser.cookies.set(cookie_params)
 
-        browser.go_to("/get_cookie")
-        expect(browser.body).to_not include("test_cookie")
-      end
+      expect(cookie_params).to eq(original_cookie_params)
     end
 
-    describe "#clear" do
-      it "clears cookies" do
-        browser.go_to("/set_cookie")
+    it "prevents side effects for cookie object" do
+      browser.cookies.set(name: "stealth", value: "omg")
+      cookie = browser.cookies["stealth"]
+      cookie.instance_variable_set(
+        :@attributes,
+        { "name" => "stealth", "value" => "test_cookie", "domain" => "site.com" }
+      )
+      original_attributes = cookie.attributes.dup
+
+      browser.cookies.set(cookie)
+
+      expect(cookie.attributes).to eq(original_attributes)
+    end
+
+    it "sets cookies with an expires time" do
+      time = Time.at(Time.now.to_i + 10_000)
+      browser.go_to
+      browser.cookies.set(name: "foo", value: "bar", expires: time)
+      expect(browser.cookies["foo"].expires).to eq(time)
+    end
+
+    it "sets cookies for given domain" do
+      port = server.port
+      browser.cookies.set(name: "stealth", value: "127.0.0.1")
+      browser.cookies.set(name: "stealth", value: "localhost", domain: "localhost")
+
+      browser.go_to("http://localhost:#{port}/ferrum/get_cookie")
+      expect(browser.body).to include("localhost")
+
+      browser.go_to("http://127.0.0.1:#{port}/ferrum/get_cookie")
+      expect(browser.body).to include("127.0.0.1")
+    end
+
+    it "sets cookies correctly with :domain option when base_url isn't set" do
+      browser = Ferrum::Browser.new
+      browser.cookies.set(name: "stealth", value: "123456", domain: "localhost")
+
+      port = server.port
+      browser.go_to("http://localhost:#{port}/ferrum/get_cookie")
+      expect(browser.body).to include("123456")
+
+      browser.go_to("http://127.0.0.1:#{port}/ferrum/get_cookie")
+      expect(browser.body).not_to include("123456")
+    ensure
+      browser&.quit
+    end
+  end
+
+  describe "#remove" do
+    it "removes a cookie" do
+      browser.go_to("/set_cookie")
+
+      browser.go_to("/get_cookie")
+      expect(browser.body).to include("test_cookie")
+
+      browser.cookies.remove(name: "stealth")
+
+      browser.go_to("/get_cookie")
+      expect(browser.body).to_not include("test_cookie")
+    end
+  end
+
+  describe "#clear" do
+    it "clears cookies" do
+      browser.go_to("/set_cookie")
 
-        browser.go_to("/get_cookie")
-        expect(browser.body).to include("test_cookie")
+      browser.go_to("/get_cookie")
+      expect(browser.body).to include("test_cookie")
 
-        browser.cookies.clear
+      browser.cookies.clear
 
-        browser.go_to("/get_cookie")
-        expect(browser.body).to_not include("test_cookie")
-      end
+      browser.go_to("/get_cookie")
+      expect(browser.body).to_not include("test_cookie")
     end
   end
 end
diff --git a/spec/dialog_spec.rb b/spec/dialog_spec.rb
index 12714564..7d199a43 100644
--- a/spec/dialog_spec.rb
+++ b/spec/dialog_spec.rb
@@ -1,92 +1,90 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Dialog do
-    describe "#accept" do
-      it "works with nested modals" do
-        browser.go_to("/ferrum/with_js")
-        browser.on(:dialog) do |dialog, _index, _total|
-          if dialog.match?("Are you sure?")
-            dialog.accept
-          else
-            dialog.dismiss
-          end
+describe Ferrum::Dialog do
+  describe "#accept" do
+    it "works with nested modals" do
+      browser.go_to("/ferrum/with_js")
+      browser.on(:dialog) do |dialog, _index, _total|
+        if dialog.match?("Are you sure?")
+          dialog.accept
+        else
+          dialog.dismiss
         end
-
-        browser.at_css("a#open-twice").click
-
-        expect(browser.at_xpath("//a[@id='open-twice' and @confirmed='false']")).to be
       end
 
-      it "works with second window" do
-        browser.go_to
+      browser.at_css("a#open-twice").click
 
-        browser.execute <<-JS
-          window.open("/ferrum/with_js", "popup")
-        JS
+      expect(browser.at_xpath("//a[@id='open-twice' and @confirmed='false']")).to be
+    end
 
-        popup, = browser.windows(:last)
+    it "works with second window" do
+      browser.go_to
 
-        popup.on(:dialog) do |dialog, _index, _total|
-          dialog.accept
-        end
-        popup.at_css("a#open-match").click
-        expect(popup.at_xpath("//a[@id='open-match' and @confirmed='true']")).to be
+      browser.execute <<-JS
+        window.open("/ferrum/with_js", "popup")
+      JS
+
+      popup, = browser.windows(:last)
 
-        popup.close
+      popup.on(:dialog) do |dialog, _index, _total|
+        dialog.accept
       end
-    end
+      popup.at_css("a#open-match").click
+      expect(popup.at_xpath("//a[@id='open-match' and @confirmed='true']")).to be
 
-    describe "#dismiss" do
-      it "works with second window" do
-        browser.go_to
+      popup.close
+    end
+  end
 
-        browser.execute <<-JS
-          window.open("/ferrum/with_js", "popup")
-        JS
+  describe "#dismiss" do
+    it "works with second window" do
+      browser.go_to
 
-        popup, = browser.windows(:last)
+      browser.execute <<-JS
+        window.open("/ferrum/with_js", "popup")
+      JS
 
-        popup.on(:dialog) do |dialog, _index, _total|
-          dialog.dismiss
-        end
-        popup.at_css("a#open-match").click
-        expect(popup.at_xpath("//a[@id='open-match' and @confirmed='true']")).not_to be
+      popup, = browser.windows(:last)
 
-        popup.close
+      popup.on(:dialog) do |dialog, _index, _total|
+        dialog.dismiss
       end
+      popup.at_css("a#open-match").click
+      expect(popup.at_xpath("//a[@id='open-match' and @confirmed='true']")).not_to be
+
+      popup.close
     end
+  end
 
-    describe "#match?" do
-      it "matches on partial strings" do
-        browser.go_to("/ferrum/with_js")
-        browser.on(:dialog) do |dialog, _index, _total|
-          if dialog.match?(Regexp.escape("[reg.exp] (chara©+er$)"))
-            dialog.accept
-          else
-            dialog.dismiss
-          end
+  describe "#match?" do
+    it "matches on partial strings" do
+      browser.go_to("/ferrum/with_js")
+      browser.on(:dialog) do |dialog, _index, _total|
+        if dialog.match?(Regexp.escape("[reg.exp] (chara©+er$)"))
+          dialog.accept
+        else
+          dialog.dismiss
         end
+      end
 
-        browser.at_css("a#open-match").click
+      browser.at_css("a#open-match").click
 
-        expect(browser.at_xpath("//a[@id='open-match' and @confirmed='true']")).to be
-      end
+      expect(browser.at_xpath("//a[@id='open-match' and @confirmed='true']")).to be
+    end
 
-      it "matches on regular expressions" do
-        browser.go_to("/ferrum/with_js")
-        browser.on(:dialog) do |dialog, _index, _total|
-          if dialog.match?(/^.t.ext.*\[\w{3}\.\w{3}\]/i)
-            dialog.accept
-          else
-            dialog.dismiss
-          end
+    it "matches on regular expressions" do
+      browser.go_to("/ferrum/with_js")
+      browser.on(:dialog) do |dialog, _index, _total|
+        if dialog.match?(/^.t.ext.*\[\w{3}\.\w{3}\]/i)
+          dialog.accept
+        else
+          dialog.dismiss
         end
+      end
 
-        browser.at_css("a#open-match").click
+      browser.at_css("a#open-match").click
 
-        expect(browser.at_xpath("//a[@id='open-match' and @confirmed='true']")).to be
-      end
+      expect(browser.at_xpath("//a[@id='open-match' and @confirmed='true']")).to be
     end
   end
 end
diff --git a/spec/frame/runtime_spec.rb b/spec/frame/runtime_spec.rb
new file mode 100644
index 00000000..bbe8bce9
--- /dev/null
+++ b/spec/frame/runtime_spec.rb
@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+describe Ferrum::Frame::Runtime do
+  describe "#execute" do
+    it "executes multiple lines of javascript" do
+      browser.execute <<-JS
+        var a = 1
+        var b = 2
+        window.result = a + b
+      JS
+      expect(browser.evaluate("window.result")).to eq(3)
+    end
+
+    context "with javascript errors" do
+      let(:browser) { Ferrum::Browser.new(base_url: base_url, js_errors: true) }
+
+      it "propagates a Javascript error to a ruby exception" do
+        expect do
+          browser.execute(%(throw new Error("zomg")))
+        end.to raise_error(Ferrum::JavaScriptError) { |e|
+          expect(e.message).to include("Error: zomg")
+        }
+      end
+
+      it "propagates an asynchronous Javascript error on the page to a ruby exception" do
+        expect do
+          browser.execute "setTimeout(function() { omg }, 0)"
+          sleep 0.01
+          browser.execute ""
+        end.to raise_error(Ferrum::JavaScriptError, /ReferenceError.*omg/)
+      end
+
+      it "propagates a synchronous Javascript error on the page to a ruby exception" do
+        expect do
+          browser.execute "omg"
+        end.to raise_error(Ferrum::JavaScriptError, /ReferenceError.*omg/)
+      end
+
+      it "does not re-raise a Javascript error if it is rescued" do
+        expect do
+          browser.execute "setTimeout(function() { omg }, 0)"
+          sleep 0.01
+          browser.execute ""
+        end.to raise_error(Ferrum::JavaScriptError, /ReferenceError.*omg/)
+
+        # should not raise again
+        expect(browser.evaluate("1+1")).to eq(2)
+      end
+
+      it "propagates a Javascript error during page load to a ruby exception" do
+        expect { browser.go_to("/ferrum/js_error") }.to raise_error(Ferrum::JavaScriptError)
+      end
+
+      it "does not propagate a Javascript error to ruby if error raising disabled" do
+        browser = Ferrum::Browser.new(base_url: base_url, js_errors: false)
+        browser.go_to("/ferrum/js_error")
+        browser.execute "setTimeout(function() { omg }, 0)"
+        sleep 0.1
+        expect(browser.body).to include("hello")
+      ensure
+        browser&.quit
+      end
+
+      it "does not propagate a Javascript error to ruby if error raising disabled and client restarted" do
+        browser = Ferrum::Browser.new(base_url: base_url, js_errors: false)
+        browser.restart
+        browser.go_to("/ferrum/js_error")
+        browser.execute "setTimeout(function() { omg }, 0)"
+        sleep 0.1
+        expect(browser.body).to include("hello")
+      ensure
+        browser&.quit
+      end
+    end
+  end
+
+  describe "#evaluate" do
+    it "returns an element" do
+      browser.go_to("/ferrum/type")
+      element = browser.evaluate(%(document.getElementById("empty_input")))
+      expect(element).to eq(browser.at_css("#empty_input"))
+    end
+
+    it "returns structures with elements" do
+      browser.go_to("/ferrum/type")
+      result = browser.evaluate <<~JS
+        {
+          a: document.getElementById("empty_input"),
+          b: { c: document.querySelectorAll("#empty_textarea, #filled_textarea") }
+        }
+      JS
+
+      expect(result).to eq(
+        "a" => browser.at_css("#empty_input"),
+        "b" => {
+          "c" => browser.css("#empty_textarea, #filled_textarea")
+        }
+      )
+    end
+
+    it "returns values properly" do
+      expect(browser.evaluate("null")).to be_nil
+      expect(browser.evaluate("false")).to be false
+      expect(browser.evaluate("true")).to be true
+      expect(browser.evaluate("undefined")).to eq(nil)
+
+      expect(browser.evaluate("3;")).to eq(3)
+      expect(browser.evaluate("31337")).to eq(31_337)
+      expect(browser.evaluate(%("string"))).to eq("string")
+      expect(browser.evaluate(%({foo: "bar"}))).to eq("foo" => "bar")
+
+      expect(browser.evaluate("new Object")).to eq({})
+      expect(browser.evaluate("new Date(2012, 0).toDateString()")).to eq("Sun Jan 01 2012")
+      expect(browser.evaluate("new Object({a: 1})")).to eq({ "a" => 1 })
+      expect(browser.evaluate("new Array")).to eq([])
+      expect(browser.evaluate("new Function")).to eq({})
+
+      expect do
+        browser.evaluate(%(throw "smth"))
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
+
+    context "when cyclic structure is returned" do
+      context "ignores seen" do
+        let(:code) do
+          <<~JS
+            (function() {
+              var a = {};
+              var b = {};
+              var c = {};
+              c.a = a;
+              a.a = a;
+              a.b = b;
+              a.c = c;
+              return %s;
+            })()
+          JS
+        end
+
+        it "returns object" do
+          expect(browser.evaluate(code % "a")).to eq(Ferrum::CyclicObject.instance)
+        end
+
+        it "returns array" do
+          expect(browser.evaluate(code % "[a]")).to eq([Ferrum::CyclicObject.instance])
+        end
+      end
+
+      it "backtracks what it has seen" do
+        expect(browser.evaluate("(function() { var a = {}; return [a, a] })()")).to eq([{}, {}])
+      end
+    end
+  end
+
+  describe "#evaluate_func" do
+    let(:function) do
+      <<~JS
+        function(c) {
+          let a = 1;
+          let b = 2;
+          return a + b + c;
+        }
+      JS
+    end
+
+    it "evaluates multiple lines of javascript function" do
+      expect(browser.evaluate_func(function, 3)).to eq(6)
+    end
+
+    it "evaluates a function on a node" do
+      browser.go_to("/ferrum/index")
+      node = browser.at_xpath(".//a")
+
+      function = <<~JS
+        function(attributeName) {
+          return this.getAttribute(attributeName);
+        }
+      JS
+
+      expect(browser.evaluate_func(function, "href", on: node)).to eq("js_redirect")
+    end
+  end
+
+  describe "#evaluate_async" do
+    it "handles values properly" do
+      expect(browser.evaluate_async("arguments[0](null)", 5)).to be_nil
+      expect(browser.evaluate_async("arguments[0](false)", 5)).to be false
+      expect(browser.evaluate_async("arguments[0](true)", 5)).to be true
+      expect(browser.evaluate_async(%(arguments[0]({foo: "bar"})), 5)).to eq("foo" => "bar")
+    end
+
+    it "times out" do
+      expect do
+        browser.evaluate_async("var callback=arguments[0]; setTimeout(function(){callback(true)}, 4000)", 1)
+      end.to raise_error(Ferrum::ScriptTimeoutError)
+    end
+  end
+
+  describe "#add_script_tag" do
+    it "adds by url" do
+      browser.go_to
+      expect do
+        browser.evaluate("$('a').first().text()")
+      end.to raise_error(Ferrum::JavaScriptError)
+
+      browser.add_script_tag(url: "/ferrum/jquery.min.js")
+
+      expect(browser.evaluate("$('a').first().text()")).to eq("Relative")
+    end
+
+    it "adds by path" do
+      browser.go_to
+      path = "#{Ferrum::Application::FERRUM_PUBLIC}/jquery-1.11.3.min.js"
+      expect do
+        browser.evaluate("$('a').first().text()")
+      end.to raise_error(Ferrum::JavaScriptError)
+
+      browser.add_script_tag(path: path)
+
+      expect(browser.evaluate("$('a').first().text()")).to eq("Relative")
+    end
+
+    it "adds by content" do
+      browser.go_to
+
+      browser.add_script_tag(content: "function yay() { return 'yay!'; }")
+
+      expect(browser.evaluate("yay()")).to eq("yay!")
+    end
+  end
+
+  describe "#add_style_tag" do
+    let(:font_size) do
+      <<~JS
+        window
+          .getComputedStyle(document.querySelector('a'))
+          .getPropertyValue('font-size')
+      JS
+    end
+
+    it "adds by url" do
+      browser.go_to
+      expect(browser.evaluate(font_size)).to eq("16px")
+
+      browser.add_style_tag(url: "/ferrum/add_style_tag.css")
+
+      expect(browser.evaluate(font_size)).to eq("50px")
+    end
+
+    it "adds by path" do
+      browser.go_to
+      path = "#{Ferrum::Application::FERRUM_PUBLIC}/add_style_tag.css"
+      expect(browser.evaluate(font_size)).to eq("16px")
+
+      browser.add_style_tag(path: path)
+
+      expect(browser.evaluate(font_size)).to eq("50px")
+    end
+
+    it "adds by content" do
+      browser.go_to
+
+      browser.add_style_tag(content: "a { font-size: 20px; }")
+
+      expect(browser.evaluate(font_size)).to eq("20px")
+    end
+  end
+end
diff --git a/spec/frame_spec.rb b/spec/frame_spec.rb
index 1c237d04..9bba6c96 100644
--- a/spec/frame_spec.rb
+++ b/spec/frame_spec.rb
@@ -1,354 +1,352 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Frame do
-    describe "#at_xpath" do
-      it "works correctly when JSON is overwritten" do
-        browser.go_to("/ferrum/index")
-        browser.execute("JSON = {};")
-        expect { browser.at_xpath("//a[text() = 'JS redirect']") }.not_to raise_error
-      end
-    end
-
-    it "supports selection by index" do
-      browser.go_to("/ferrum/frames")
-      frame = browser.at_xpath("//iframe").frame
-      expect(frame.url).to end_with("/ferrum/slow")
+describe Ferrum::Frame do
+  describe "#at_xpath" do
+    it "works correctly when JSON is overwritten" do
+      browser.go_to("/ferrum/index")
+      browser.execute("JSON = {};")
+      expect { browser.at_xpath("//a[text() = 'JS redirect']") }.not_to raise_error
     end
+  end
 
-    it "supports selection by element" do
-      browser.go_to("/ferrum/frames")
-      frame = browser.at_css("iframe[name]").frame
-      expect(frame.url).to end_with("/ferrum/slow")
-    end
+  it "supports selection by index" do
+    browser.go_to("/ferrum/frames")
+    frame = browser.at_xpath("//iframe").frame
+    expect(frame.url).to end_with("/ferrum/slow")
+  end
 
-    it "supports selection by element without name or id" do
-      browser.go_to("/ferrum/frames")
-      frame = browser.at_css("iframe:not([name]):not([id])").frame
-      expect(frame.url).to end_with("/ferrum/headers")
-    end
+  it "supports selection by element" do
+    browser.go_to("/ferrum/frames")
+    frame = browser.at_css("iframe[name]").frame
+    expect(frame.url).to end_with("/ferrum/slow")
+  end
 
-    it "supports selection by element with id but no name" do
-      browser.go_to("/ferrum/frames")
-      frame = browser.at_css("iframe[id]:not([name])").frame
-      expect(frame.url).to end_with("/ferrum/get_cookie")
-    end
+  it "supports selection by element without name or id" do
+    browser.go_to("/ferrum/frames")
+    frame = browser.at_css("iframe:not([name]):not([id])").frame
+    expect(frame.url).to end_with("/ferrum/headers")
+  end
 
-    it "finds main frame properly" do
-      browser.go_to("/ferrum/popup_frames")
+  it "supports selection by element with id but no name" do
+    browser.go_to("/ferrum/frames")
+    frame = browser.at_css("iframe[id]:not([name])").frame
+    expect(frame.url).to end_with("/ferrum/get_cookie")
+  end
 
-      browser.at_xpath("//a[text()='pop up']").click
+  it "finds main frame properly" do
+    browser.go_to("/ferrum/popup_frames")
 
-      expect(browser.pages.size).to eq(2)
-      opened_page = browser.pages.last
-      expect(opened_page.main_frame.url).to end_with("/frames")
-    end
+    browser.at_xpath("//a[text()='pop up']").click
 
-    it "waits for the frame to load" do
-      browser.go_to
-      browser.execute <<-JS
-        document.body.innerHTML += "<iframe src='/ferrum/slow' name='frame'>"
-      JS
+    expect(browser.pages.size).to eq(2)
+    opened_page = browser.pages.last
+    expect(opened_page.main_frame.url).to end_with("/frames")
+  end
 
-      frame = browser.at_xpath("//iframe[@name='frame']").frame
-      expect(frame.url).to end_with("/ferrum/slow")
-      expect(frame.body).to include("slow page")
+  it "waits for the frame to load" do
+    browser.go_to
+    browser.execute <<-JS
+      document.body.innerHTML += "<iframe src='/ferrum/slow' name='frame'>"
+    JS
 
-      expect(browser.main_frame.url).to end_with("/")
-    end
+    frame = browser.at_xpath("//iframe[@name='frame']").frame
+    expect(frame.url).to end_with("/ferrum/slow")
+    expect(frame.body).to include("slow page")
 
-    it "waits for the cross-domain frame to load" do
-      browser.go_to("/ferrum/frames")
-      expect(browser.current_url).to eq(base_url("/ferrum/frames"))
-      frame = browser.at_xpath("//iframe[@name='frame']").frame
+    expect(browser.main_frame.url).to end_with("/")
+  end
 
-      expect(frame.url).to end_with("/ferrum/slow")
-      expect(frame.body).to include("slow page")
+  it "waits for the cross-domain frame to load" do
+    browser.go_to("/ferrum/frames")
+    expect(browser.current_url).to eq(base_url("/ferrum/frames"))
+    frame = browser.at_xpath("//iframe[@name='frame']").frame
 
-      expect(browser.current_url).to end_with("/ferrum/frames")
-    end
+    expect(frame.url).to end_with("/ferrum/slow")
+    expect(frame.body).to include("slow page")
 
-    context "with src == about:blank" do
-      it "doesn't hang if no document created" do
-        browser.go_to
-        browser.execute <<-JS
-          document.body.innerHTML += "<iframe src='about:blank' name='frame'>"
-        JS
-        frame = browser.at_xpath("//iframe[@name='frame']").frame
-        expect(frame.body).to eq("<html><head></head><body></body></html>")
-      end
-
-      it "doesn't hang if built by JS" do
-        browser.go_to
-        browser.execute <<-JS
-          document.body.innerHTML += "<iframe src='about:blank' name='frame'>";
-          var iframeDocument = document.querySelector("iframe[name='frame']").contentWindow.document;
-          var content = "<html><body><p>Hello Frame</p></body></html>";
-          iframeDocument.open("text/html", "replace");
-          iframeDocument.write(content);
-          iframeDocument.close();
-        JS
-        frame = browser.at_xpath("//iframe[@name='frame']").frame
-        expect(frame.body).to include("Hello Frame")
-      end
-    end
+    expect(browser.current_url).to end_with("/ferrum/frames")
+  end
 
-    context "with no src attribute" do
-      it "doesn't hang if the srcdoc attribute is used" do
-        browser.go_to
-        browser.execute <<-JS
-          document.body.innerHTML += "<iframe srcdoc='<p>Hello Frame</p>' name='frame'>"
-        JS
-        frame = browser.at_xpath("//iframe[@name='frame']").frame
-        expect(frame.body).to include("Hello Frame")
-      end
-
-      it "doesn't hang if the frame is filled by JS" do
-        browser.go_to
-        browser.execute <<-JS
-          document.body.innerHTML += "<iframe id='frame' name='frame'>"
-        JS
-        browser.execute <<-JS
-          var iframeDocument = document.querySelector("#frame").contentWindow.document;
-          var content = "<html><body><p>Hello Frame</p></body></html>";
-          iframeDocument.open("text/html", "replace");
-          iframeDocument.write(content);
-          iframeDocument.close();
-        JS
-        frame = browser.at_xpath("//iframe[@name='frame']").frame
-        expect(frame.body).to include("Hello Frame")
-      end
+  context "with src == about:blank" do
+    it "doesn't hang if no document created" do
+      browser.go_to
+      browser.execute <<-JS
+        document.body.innerHTML += "<iframe src='about:blank' name='frame'>"
+      JS
+      frame = browser.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.body).to eq("<html><head></head><body></body></html>")
     end
 
-    it "supports clicking in a frame", skip: true do
+    it "doesn't hang if built by JS" do
       browser.go_to
       browser.execute <<-JS
-        document.body.innerHTML += "<iframe src='/ferrum/click_test' name='frame'>"
+        document.body.innerHTML += "<iframe src='about:blank' name='frame'>";
+        var iframeDocument = document.querySelector("iframe[name='frame']").contentWindow.document;
+        var content = "<html><body><p>Hello Frame</p></body></html>";
+        iframeDocument.open("text/html", "replace");
+        iframeDocument.write(content);
+        iframeDocument.close();
       JS
-      sleep 0.5
-      frame = browser.at_xpath("//iframe[@name = 'frame']").frame
-
-      log = frame.at_css("#log")
-      frame.at_css("#one").click
-      expect(log.text).to eq("one")
+      frame = browser.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.body).to include("Hello Frame")
     end
+  end
 
-    it "supports clicking in a frame with padding", skip: true do
+  context "with no src attribute" do
+    it "doesn't hang if the srcdoc attribute is used" do
       browser.go_to
       browser.execute <<-JS
-        document.body.innerHTML += "<iframe src='/ferrum/click_test' name='padded_frame' style='padding:100px;'>"
+        document.body.innerHTML += "<iframe srcdoc='<p>Hello Frame</p>' name='frame'>"
       JS
-      frame = browser.at_xpath("//iframe[@name = 'padded_frame']").frame
-
-      log = frame.at_css("#log")
-      frame.at_css("#one").click
-      expect(log.text).to eq("one")
+      frame = browser.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.body).to include("Hello Frame")
     end
 
-    it "supports clicking in a frame nested in a frame", skip: true do
+    it "doesn't hang if the frame is filled by JS" do
       browser.go_to
-
-      # The padding on the frame here is to differ the sizes of the two
-      # frames, ensuring that their offsets are being calculated seperately.
-      # This avoids a false positive where the same frame"s offset is
-      # calculated twice, but the click still works because both frames had
-      # the same offset.
       browser.execute <<-JS
-        document.body.innerHTML += "<iframe src='/ferrum/nested_frame_test' name='outer_frame' style='padding:200px'>"
+        document.body.innerHTML += "<iframe id='frame' name='frame'>"
       JS
+      browser.execute <<-JS
+        var iframeDocument = document.querySelector("#frame").contentWindow.document;
+        var content = "<html><body><p>Hello Frame</p></body></html>";
+        iframeDocument.open("text/html", "replace");
+        iframeDocument.write(content);
+        iframeDocument.close();
+      JS
+      frame = browser.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.body).to include("Hello Frame")
+    end
+  end
 
-      sleep 0.5
+  it "supports clicking in a frame", skip: true do
+    browser.go_to
+    browser.execute <<-JS
+      document.body.innerHTML += "<iframe src='/ferrum/click_test' name='frame'>"
+    JS
+    sleep 0.5
+    frame = browser.at_xpath("//iframe[@name = 'frame']").frame
+
+    log = frame.at_css("#log")
+    frame.at_css("#one").click
+    expect(log.text).to eq("one")
+  end
 
-      inner_frame = browser.frame_by(name: "inner_frame")
-      log = inner_frame.at_css("#log")
-      inner_frame.at_css("#one").click
-      expect(log.text).to eq("one")
-    end
+  it "supports clicking in a frame with padding", skip: true do
+    browser.go_to
+    browser.execute <<-JS
+      document.body.innerHTML += "<iframe src='/ferrum/click_test' name='padded_frame' style='padding:100px;'>"
+    JS
+    frame = browser.at_xpath("//iframe[@name = 'padded_frame']").frame
 
-    it "does not wait forever for the frame to load" do
-      browser.go_to
+    log = frame.at_css("#log")
+    frame.at_css("#one").click
+    expect(log.text).to eq("one")
+  end
 
-      frame = browser.frame_by(name: "omg")
+  it "supports clicking in a frame nested in a frame", skip: true do
+    browser.go_to
 
-      expect(frame).to be_nil
-    end
+    # The padding on the frame here is to differ the sizes of the two
+    # frames, ensuring that their offsets are being calculated seperately.
+    # This avoids a false positive where the same frame"s offset is
+    # calculated twice, but the click still works because both frames had
+    # the same offset.
+    browser.execute <<-JS
+      document.body.innerHTML += "<iframe src='/ferrum/nested_frame_test' name='outer_frame' style='padding:200px'>"
+    JS
 
-    it "can get the frames url" do
-      browser.go_to("/ferrum/frames")
+    sleep 0.5
 
-      frame = browser.at_xpath("//iframe").frame
-      expect(frame.url).to end_with("/ferrum/slow")
-      expect(browser.current_url).to end_with("/ferrum/frames")
-    end
+    inner_frame = browser.frame_by(name: "inner_frame")
+    log = inner_frame.at_css("#log")
+    inner_frame.at_css("#one").click
+    expect(log.text).to eq("one")
+  end
 
-    it "can set page content" do
-      browser.content = "<html><head></head><body>Voila!</body></html>"
+  it "does not wait forever for the frame to load" do
+    browser.go_to
 
-      expect(browser.body).to include("Voila!")
-    end
+    frame = browser.frame_by(name: "omg")
 
-    it "gets page doctype" do
-      browser.go_to("/ferrum/frames")
-      expect(browser.doctype).to eq("<!DOCTYPE html>")
+    expect(frame).to be_nil
+  end
 
-      doctype40 = %(<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">)
-      browser.content = "#{doctype40}<html><head></head><body>Voila!</body></html>"
-      expect(browser.doctype).to eq(doctype40)
+  it "can get the frames url" do
+    browser.go_to("/ferrum/frames")
 
-      browser.content = ""
-      expect(browser.doctype).to be_nil
-    end
+    frame = browser.at_xpath("//iframe").frame
+    expect(frame.url).to end_with("/ferrum/slow")
+    expect(browser.current_url).to end_with("/ferrum/frames")
+  end
+
+  it "can set page content" do
+    browser.content = "<html><head></head><body>Voila!</body></html>"
 
-    context "#xpath" do
-      it "returns given nodes" do
-        browser.go_to("/ferrum/with_js")
-        p = browser.xpath("//p[@id='remove_me']")
+    expect(browser.body).to include("Voila!")
+  end
+
+  it "gets page doctype" do
+    browser.go_to("/ferrum/frames")
+    expect(browser.doctype).to eq("<!DOCTYPE html>")
+
+    doctype40 = %(<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">)
+    browser.content = "#{doctype40}<html><head></head><body>Voila!</body></html>"
+    expect(browser.doctype).to eq(doctype40)
 
-        expect(p.size).to eq(1)
-      end
+    browser.content = ""
+    expect(browser.doctype).to be_nil
+  end
 
-      it "supports within" do
-        browser.go_to("/ferrum/with_js")
-        p = browser.xpath("//p[@id='with_content']").first
+  context "#xpath" do
+    it "returns given nodes" do
+      browser.go_to("/ferrum/with_js")
+      p = browser.xpath("//p[@id='remove_me']")
 
-        links = browser.xpath("./a", within: p)
+      expect(p.size).to eq(1)
+    end
 
-        expect(links.size).to eq(1)
-        expect(links.first.attribute(:id)).to eq("open-match")
-      end
+    it "supports within" do
+      browser.go_to("/ferrum/with_js")
+      p = browser.xpath("//p[@id='with_content']").first
 
-      it "throws an error on a wrong xpath" do
-        browser.go_to("/ferrum/with_js")
+      links = browser.xpath("./a", within: p)
 
-        expect do
-          browser.xpath("#remove_me")
-        end.to raise_error(Ferrum::JavaScriptError)
-      end
+      expect(links.size).to eq(1)
+      expect(links.first.attribute(:id)).to eq("open-match")
+    end
 
-      it "supports inside a given frame" do
-        browser.go_to("/ferrum/frames")
-        browser.execute <<-JS
-          document.body.innerHTML += "<iframe src='/ferrum/buttons' id='buttons_frame'>"
-        JS
-        browser.network.wait_for_idle
+    it "throws an error on a wrong xpath" do
+      browser.go_to("/ferrum/with_js")
+
+      expect do
+        browser.xpath("#remove_me")
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
+
+    it "supports inside a given frame" do
+      browser.go_to("/ferrum/frames")
+      browser.execute <<-JS
+        document.body.innerHTML += "<iframe src='/ferrum/buttons' id='buttons_frame'>"
+      JS
+      browser.network.wait_for_idle
 
-        frame = browser.at_xpath("//iframe[@id='buttons_frame']").frame
-        expect(frame.xpath("//button").size).to eq(3)
-      end
+      frame = browser.at_xpath("//iframe[@id='buttons_frame']").frame
+      expect(frame.xpath("//button").size).to eq(3)
     end
+  end
 
-    context "#at_xpath" do
-      it "returns given nodes" do
-        browser.go_to("/ferrum/with_js")
-        p = browser.at_xpath("//p[@id='remove_me']")
+  context "#at_xpath" do
+    it "returns given nodes" do
+      browser.go_to("/ferrum/with_js")
+      p = browser.at_xpath("//p[@id='remove_me']")
 
-        expect(p).not_to be_nil
-      end
+      expect(p).not_to be_nil
+    end
 
-      it "supports within" do
-        browser.go_to("/ferrum/with_js")
-        p = browser.at_xpath("//p[@id='with_content']")
+    it "supports within" do
+      browser.go_to("/ferrum/with_js")
+      p = browser.at_xpath("//p[@id='with_content']")
 
-        link = browser.at_xpath("./a", within: p)
+      link = browser.at_xpath("./a", within: p)
 
-        expect(link).not_to be_nil
-        expect(link.attribute(:id)).to eq("open-match")
-      end
+      expect(link).not_to be_nil
+      expect(link.attribute(:id)).to eq("open-match")
+    end
 
-      it "throws an error on a wrong xpath" do
-        browser.go_to("/ferrum/with_js")
+    it "throws an error on a wrong xpath" do
+      browser.go_to("/ferrum/with_js")
 
-        expect do
-          browser.at_xpath("#remove_me")
-        end.to raise_error(Ferrum::JavaScriptError)
-      end
+      expect do
+        browser.at_xpath("#remove_me")
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
 
-      it "supports inside a given frame" do
-        browser.go_to("/ferrum/frames")
-        browser.execute <<-JS
-          document.body.innerHTML += "<iframe src='/ferrum/buttons' id='buttons_frame'>"
-        JS
-        browser.network.wait_for_idle
+    it "supports inside a given frame" do
+      browser.go_to("/ferrum/frames")
+      browser.execute <<-JS
+        document.body.innerHTML += "<iframe src='/ferrum/buttons' id='buttons_frame'>"
+      JS
+      browser.network.wait_for_idle
 
-        frame = browser.at_xpath("//iframe[@id='buttons_frame']").frame
-        expect(frame.at_xpath("//button[@id='click_me_123']")).not_to be_nil
-      end
+      frame = browser.at_xpath("//iframe[@id='buttons_frame']").frame
+      expect(frame.at_xpath("//button[@id='click_me_123']")).not_to be_nil
     end
+  end
 
-    context "#css" do
-      it "returns given nodes" do
-        browser.go_to("/ferrum/with_js")
-        p = browser.css("p#remove_me")
+  context "#css" do
+    it "returns given nodes" do
+      browser.go_to("/ferrum/with_js")
+      p = browser.css("p#remove_me")
 
-        expect(p.size).to eq(1)
-      end
+      expect(p.size).to eq(1)
+    end
 
-      it "supports within" do
-        browser.go_to("/ferrum/with_js")
-        p = browser.css("p#with_content").first
+    it "supports within" do
+      browser.go_to("/ferrum/with_js")
+      p = browser.css("p#with_content").first
 
-        links = browser.css("a", within: p)
+      links = browser.css("a", within: p)
 
-        expect(links.size).to eq(1)
-        expect(links.first.attribute(:id)).to eq("open-match")
-      end
+      expect(links.size).to eq(1)
+      expect(links.first.attribute(:id)).to eq("open-match")
+    end
 
-      it "throws an error on an invalid selector" do
-        browser.go_to("/ferrum/table")
+    it "throws an error on an invalid selector" do
+      browser.go_to("/ferrum/table")
 
-        expect do
-          browser.css("table tr:last")
-        end.to raise_error(Ferrum::JavaScriptError)
-      end
+      expect do
+        browser.css("table tr:last")
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
 
-      it "supports inside a given frame" do
-        browser.go_to("/ferrum/frames")
-        browser.execute <<-JS
-          document.body.innerHTML += "<iframe src='/ferrum/buttons' id='buttons_frame'>"
-        JS
-        browser.network.wait_for_idle
+    it "supports inside a given frame" do
+      browser.go_to("/ferrum/frames")
+      browser.execute <<-JS
+        document.body.innerHTML += "<iframe src='/ferrum/buttons' id='buttons_frame'>"
+      JS
+      browser.network.wait_for_idle
 
-        frame = browser.at_css("iframe#buttons_frame").frame
-        expect(frame.css("button").size).to eq(3)
-      end
+      frame = browser.at_css("iframe#buttons_frame").frame
+      expect(frame.css("button").size).to eq(3)
     end
+  end
 
-    context "#at_css" do
-      it "returns given nodes" do
-        browser.go_to("/ferrum/with_js")
-        p = browser.at_css("p#remove_me")
+  context "#at_css" do
+    it "returns given nodes" do
+      browser.go_to("/ferrum/with_js")
+      p = browser.at_css("p#remove_me")
 
-        expect(p).not_to be_nil
-      end
+      expect(p).not_to be_nil
+    end
 
-      it "supports within" do
-        browser.go_to("/ferrum/with_js")
-        p = browser.at_css("p#with_content")
+    it "supports within" do
+      browser.go_to("/ferrum/with_js")
+      p = browser.at_css("p#with_content")
 
-        link = browser.at_css("a", within: p)
+      link = browser.at_css("a", within: p)
 
-        expect(link).not_to be_nil
-        expect(link.attribute(:id)).to eq("open-match")
-      end
+      expect(link).not_to be_nil
+      expect(link.attribute(:id)).to eq("open-match")
+    end
 
-      it "throws an error on an invalid selector" do
-        browser.go_to("/ferrum/table")
+    it "throws an error on an invalid selector" do
+      browser.go_to("/ferrum/table")
 
-        expect do
-          browser.at_css("table tr:last")
-        end.to raise_error(Ferrum::JavaScriptError)
-      end
+      expect do
+        browser.at_css("table tr:last")
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
 
-      it "supports inside a given frame" do
-        browser.go_to("/ferrum/frames")
-        browser.execute <<-JS
-          document.body.innerHTML += "<iframe src='/ferrum/buttons' id='buttons_frame'>"
-        JS
-        browser.network.wait_for_idle
+    it "supports inside a given frame" do
+      browser.go_to("/ferrum/frames")
+      browser.execute <<-JS
+        document.body.innerHTML += "<iframe src='/ferrum/buttons' id='buttons_frame'>"
+      JS
+      browser.network.wait_for_idle
 
-        frame = browser.at_css("iframe#buttons_frame").frame
-        expect(frame.at_css("button#click_me_123")).not_to be_nil
-      end
+      frame = browser.at_css("iframe#buttons_frame").frame
+      expect(frame.at_css("button#click_me_123")).not_to be_nil
     end
   end
 end
diff --git a/spec/headers_spec.rb b/spec/headers_spec.rb
index 25c8f6ae..2343937a 100644
--- a/spec/headers_spec.rb
+++ b/spec/headers_spec.rb
@@ -1,168 +1,166 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Headers do
-    describe "#set" do
-      it "allows headers to be set" do
-        browser.headers.set("Cookie" => "foo=bar", "YourName" => "your_value")
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).to include("COOKIE: foo=bar")
-        expect(browser.body).to include("YOURNAME: your_value")
-      end
-
-      it "supports User-Agent" do
-        browser.headers.set("User-Agent" => "foo")
-        browser.go_to
-        expect(browser.evaluate("window.navigator.userAgent")).to eq("foo")
-      end
-
-      it "sets headers for all HTTP requests" do
-        browser.headers.set("X-Omg" => "wat")
-        browser.go_to
-        browser.execute <<-JS
-          var request = new XMLHttpRequest();
-          request.open("GET", "/ferrum/headers", false);
-          request.send();
-
-          if (request.status === 200) {
-            document.body.innerHTML = request.responseText;
-          }
-        JS
-        expect(browser.body).to include("X_OMG: wat")
-      end
+describe Ferrum::Headers do
+  describe "#set" do
+    it "allows headers to be set" do
+      browser.headers.set("Cookie" => "foo=bar", "YourName" => "your_value")
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).to include("COOKIE: foo=bar")
+      expect(browser.body).to include("YOURNAME: your_value")
     end
 
-    describe "#get" do
-      it "allows headers to be read" do
-        expect(browser.headers.get).to eq({})
-        browser.headers.set("User-Agent" => "Browser", "Host" => "foo.com")
-        expect(browser.headers.get).to eq("User-Agent" => "Browser", "Host" => "foo.com")
-      end
+    it "supports User-Agent" do
+      browser.headers.set("User-Agent" => "foo")
+      browser.go_to
+      expect(browser.evaluate("window.navigator.userAgent")).to eq("foo")
     end
 
-    describe "#add" do
-      it "adds new headers" do
-        browser.headers.set("User-Agent" => "Browser", "YourName" => "your_value")
-        browser.headers.add({ "User-Agent" => "Super Browser", "Appended" => "true" })
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).to include("USER_AGENT: Super Browser")
-        expect(browser.body).to include("YOURNAME: your_value")
-        expect(browser.body).to include("APPENDED: true")
-      end
-
-      it "sets Accept-Language even if user-agent is not provided" do
-        browser.headers.add({ "Accept-Language" => "esperanto" })
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).to include("USER_AGENT: #{browser.default_user_agent}")
-        expect(browser.body).to match(/ACCEPT_LANGUAGE: esperanto/)
-      end
-
-      it "sets headers on the initial request for referer only" do
-        browser.headers.set("PermanentA" => "a")
-        browser.headers.add({ "PermanentB" => "b" })
-        browser.headers.add({ "Referer" => "http://google.com" }, permanent: false)
-        browser.headers.add({ "TempA" => "a" }, permanent: false) # simply ignored
-
-        browser.go_to("/ferrum/headers_with_ajax")
-        initial_request = browser.at_css("#initial_request").text
-        ajax_request = browser.at_css("#ajax_request").text
-
-        expect(initial_request).to include("PERMANENTA: a")
-        expect(initial_request).to include("PERMANENTB: b")
-        expect(initial_request).to include("REFERER: http://google.com")
-        expect(initial_request).to include("TEMPA: a")
-
-        expect(ajax_request).to include("PERMANENTA: a")
-        expect(ajax_request).to include("PERMANENTB: b")
-        expect(ajax_request).to_not include("REFERER: http://google.com")
-        expect(ajax_request).to include("TEMPA: a")
-      end
-
-      it "keeps added headers on redirects" do
-        browser.headers.add({ "X-Custom-Header" => "1" }, permanent: false)
-        browser.go_to("/ferrum/redirect_to_headers")
-        expect(browser.body).to include("X_CUSTOM_HEADER: 1")
-      end
+    it "sets headers for all HTTP requests" do
+      browser.headers.set("X-Omg" => "wat")
+      browser.go_to
+      browser.execute <<-JS
+        var request = new XMLHttpRequest();
+        request.open("GET", "/ferrum/headers", false);
+        request.send();
+
+        if (request.status === 200) {
+          document.body.innerHTML = request.responseText;
+        }
+      JS
+      expect(browser.body).to include("X_OMG: wat")
     end
+  end
+
+  describe "#get" do
+    it "allows headers to be read" do
+      expect(browser.headers.get).to eq({})
+      browser.headers.set("User-Agent" => "Browser", "Host" => "foo.com")
+      expect(browser.headers.get).to eq("User-Agent" => "Browser", "Host" => "foo.com")
+    end
+  end
+
+  describe "#add" do
+    it "adds new headers" do
+      browser.headers.set("User-Agent" => "Browser", "YourName" => "your_value")
+      browser.headers.add({ "User-Agent" => "Super Browser", "Appended" => "true" })
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).to include("USER_AGENT: Super Browser")
+      expect(browser.body).to include("YOURNAME: your_value")
+      expect(browser.body).to include("APPENDED: true")
+    end
+
+    it "sets Accept-Language even if user-agent is not provided" do
+      browser.headers.add({ "Accept-Language" => "esperanto" })
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).to include("USER_AGENT: #{browser.default_user_agent}")
+      expect(browser.body).to match(/ACCEPT_LANGUAGE: esperanto/)
+    end
+
+    it "sets headers on the initial request for referer only" do
+      browser.headers.set("PermanentA" => "a")
+      browser.headers.add({ "PermanentB" => "b" })
+      browser.headers.add({ "Referer" => "http://google.com" }, permanent: false)
+      browser.headers.add({ "TempA" => "a" }, permanent: false) # simply ignored
+
+      browser.go_to("/ferrum/headers_with_ajax")
+      initial_request = browser.at_css("#initial_request").text
+      ajax_request = browser.at_css("#ajax_request").text
+
+      expect(initial_request).to include("PERMANENTA: a")
+      expect(initial_request).to include("PERMANENTB: b")
+      expect(initial_request).to include("REFERER: http://google.com")
+      expect(initial_request).to include("TEMPA: a")
+
+      expect(ajax_request).to include("PERMANENTA: a")
+      expect(ajax_request).to include("PERMANENTB: b")
+      expect(ajax_request).to_not include("REFERER: http://google.com")
+      expect(ajax_request).to include("TEMPA: a")
+    end
+
+    it "keeps added headers on redirects" do
+      browser.headers.add({ "X-Custom-Header" => "1" }, permanent: false)
+      browser.go_to("/ferrum/redirect_to_headers")
+      expect(browser.body).to include("X_CUSTOM_HEADER: 1")
+    end
+  end
+
+  context "multiple windows", skip: true do
+    it "persists headers across popup windows" do
+      browser.headers.set(
+        "Cookie" => "foo=bar",
+        "Host" => "foo.com",
+        "User-Agent" => "foo"
+      )
+      browser.go_to("/ferrum/popup_headers")
+      browser.at_xpath("//a[text()='pop up']").click
+
+      page, = browser.windows(:last)
+
+      expect(page.body).to include("USER_AGENT: foo")
+      expect(page.body).to include("COOKIE: foo=bar")
+      expect(page.body).to include("HOST: foo.com")
+    end
+
+    it "sets headers in existing windows" do
+      page = browser.create_page
+      page.headers.set(
+        "Cookie" => "foo=bar",
+        "Host" => "foo.com",
+        "User-Agent" => "foo"
+      )
+      page.goto("/ferrum/headers")
+      expect(page.body).to include("USER_AGENT: foo")
+      expect(page.body).to include("COOKIE: foo=bar")
+      expect(page.body).to include("HOST: foo.com")
+
+      browser.switch_to_window browser.windows.last
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).to include("USER_AGENT: foo")
+      expect(browser.body).to include("COOKIE: foo=bar")
+      expect(browser.body).to include("HOST: foo.com")
+    end
+
+    it "keeps temporary headers local to the current window" do
+      browser.create_page
+      browser.headers.add("X-Custom-Header" => "1", permanent: false)
+
+      browser.switch_to_window browser.windows.last
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).not_to include("X_CUSTOM_HEADER: 1")
+
+      browser.switch_to_window browser.windows.first
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).to include("X_CUSTOM_HEADER: 1")
+    end
+
+    it "does not mix temporary headers with permanent ones when propagating to other windows" do
+      browser.create_page
+      browser.headers.add("X-Custom-Header" => "1", permanent: false)
+      browser.headers.add("Host" => "foo.com")
+
+      browser.switch_to_window browser.windows.last
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).to include("HOST: foo.com")
+      expect(browser.body).not_to include("X_CUSTOM_HEADER: 1")
+
+      browser.switch_to_window browser.windows.first
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).to include("HOST: foo.com")
+      expect(browser.body).to include("X_CUSTOM_HEADER: 1")
+    end
+
+    it "does not propagate temporary headers to new windows" do
+      browser.go_to
+      browser.headers.add("X-Custom-Header" => "1", permanent: false)
+      browser.create_page
+
+      browser.switch_to_window browser.windows.last
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).not_to include("X_CUSTOM_HEADER: 1")
 
-    context "multiple windows", skip: true do
-      it "persists headers across popup windows" do
-        browser.headers.set(
-          "Cookie" => "foo=bar",
-          "Host" => "foo.com",
-          "User-Agent" => "foo"
-        )
-        browser.go_to("/ferrum/popup_headers")
-        browser.at_xpath("//a[text()='pop up']").click
-
-        page, = browser.windows(:last)
-
-        expect(page.body).to include("USER_AGENT: foo")
-        expect(page.body).to include("COOKIE: foo=bar")
-        expect(page.body).to include("HOST: foo.com")
-      end
-
-      it "sets headers in existing windows" do
-        page = browser.create_page
-        page.headers.set(
-          "Cookie" => "foo=bar",
-          "Host" => "foo.com",
-          "User-Agent" => "foo"
-        )
-        page.goto("/ferrum/headers")
-        expect(page.body).to include("USER_AGENT: foo")
-        expect(page.body).to include("COOKIE: foo=bar")
-        expect(page.body).to include("HOST: foo.com")
-
-        browser.switch_to_window browser.windows.last
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).to include("USER_AGENT: foo")
-        expect(browser.body).to include("COOKIE: foo=bar")
-        expect(browser.body).to include("HOST: foo.com")
-      end
-
-      it "keeps temporary headers local to the current window" do
-        browser.create_page
-        browser.headers.add("X-Custom-Header" => "1", permanent: false)
-
-        browser.switch_to_window browser.windows.last
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).not_to include("X_CUSTOM_HEADER: 1")
-
-        browser.switch_to_window browser.windows.first
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).to include("X_CUSTOM_HEADER: 1")
-      end
-
-      it "does not mix temporary headers with permanent ones when propagating to other windows" do
-        browser.create_page
-        browser.headers.add("X-Custom-Header" => "1", permanent: false)
-        browser.headers.add("Host" => "foo.com")
-
-        browser.switch_to_window browser.windows.last
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).to include("HOST: foo.com")
-        expect(browser.body).not_to include("X_CUSTOM_HEADER: 1")
-
-        browser.switch_to_window browser.windows.first
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).to include("HOST: foo.com")
-        expect(browser.body).to include("X_CUSTOM_HEADER: 1")
-      end
-
-      it "does not propagate temporary headers to new windows" do
-        browser.go_to
-        browser.headers.add("X-Custom-Header" => "1", permanent: false)
-        browser.create_page
-
-        browser.switch_to_window browser.windows.last
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).not_to include("X_CUSTOM_HEADER: 1")
-
-        browser.switch_to_window browser.windows.first
-        browser.go_to("/ferrum/headers")
-        expect(browser.body).to include("X_CUSTOM_HEADER: 1")
-      end
+      browser.switch_to_window browser.windows.first
+      browser.go_to("/ferrum/headers")
+      expect(browser.body).to include("X_CUSTOM_HEADER: 1")
     end
   end
 end
diff --git a/spec/keyboard_spec.rb b/spec/keyboard_spec.rb
index e2f67c09..37346686 100644
--- a/spec/keyboard_spec.rb
+++ b/spec/keyboard_spec.rb
@@ -1,29 +1,27 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Keyboard do
-    describe "#down" do
-      before { browser.go_to("/ferrum/set") }
+describe Ferrum::Keyboard do
+  describe "#down" do
+    before { browser.go_to("/ferrum/set") }
 
-      it "sends down events from keyboard" do
-        expect { browser.keyboard.down("") }.to raise_error(ArgumentError, "empty keys passed")
-        expect { browser.keyboard.down([]) }.to raise_error(ArgumentError, "empty keys passed")
-        expect { browser.keyboard.down("arghhh") }.not_to raise_error
-        expect { browser.keyboard.down(:page_down) }.not_to raise_error
-        expect { browser.keyboard.down(1) }.to raise_error(ArgumentError, "unexpected argument")
-      end
+    it "sends down events from keyboard" do
+      expect { browser.keyboard.down("") }.to raise_error(ArgumentError, "empty keys passed")
+      expect { browser.keyboard.down([]) }.to raise_error(ArgumentError, "empty keys passed")
+      expect { browser.keyboard.down("arghhh") }.not_to raise_error
+      expect { browser.keyboard.down(:page_down) }.not_to raise_error
+      expect { browser.keyboard.down(1) }.to raise_error(ArgumentError, "unexpected argument")
     end
+  end
 
-    describe "#up" do
-      before { browser.go_to("/ferrum/set") }
+  describe "#up" do
+    before { browser.go_to("/ferrum/set") }
 
-      it "sends up events from keyboard" do
-        expect { browser.keyboard.up("") }.to raise_error(ArgumentError, "empty keys passed")
-        expect { browser.keyboard.up([]) }.to raise_error(ArgumentError, "empty keys passed")
-        expect { browser.keyboard.up("arghhh") }.not_to raise_error
-        expect { browser.keyboard.up(:page_down) }.not_to raise_error
-        expect { browser.keyboard.up(1) }.to raise_error(ArgumentError, "unexpected argument")
-      end
+    it "sends up events from keyboard" do
+      expect { browser.keyboard.up("") }.to raise_error(ArgumentError, "empty keys passed")
+      expect { browser.keyboard.up([]) }.to raise_error(ArgumentError, "empty keys passed")
+      expect { browser.keyboard.up("arghhh") }.not_to raise_error
+      expect { browser.keyboard.up(:page_down) }.not_to raise_error
+      expect { browser.keyboard.up(1) }.to raise_error(ArgumentError, "unexpected argument")
     end
   end
 end
diff --git a/spec/mouse_spec.rb b/spec/mouse_spec.rb
index 6f0c2d5a..ee1c7fcd 100644
--- a/spec/mouse_spec.rb
+++ b/spec/mouse_spec.rb
@@ -1,201 +1,199 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Mouse do
-    describe "#click" do
-      it "supports clicking precise coordinates" do
-        browser.go_to("/ferrum/click_coordinates")
-        browser.mouse.click(x: 100, y: 150)
-        expect(browser.body).to include("x: 100, y: 150")
-      end
+describe Ferrum::Mouse do
+  describe "#click" do
+    it "supports clicking precise coordinates" do
+      browser.go_to("/ferrum/click_coordinates")
+      browser.mouse.click(x: 100, y: 150)
+      expect(browser.body).to include("x: 100, y: 150")
+    end
 
-      it "has no trouble clicking elements when the size of a document changes", skip: true do
-        browser.go_to("/ferrum/long_page")
-        browser.at_css("#penultimate").click
-        browser.execute <<~JS
-          el = document.getElementById("penultimate")
-          el.parentNode.removeChild(el)
-        JS
-        browser.at_xpath("//a[text() = 'Phasellus blandit velit']").click
-        expect(browser.body).to include("Hello")
-      end
+    it "has no trouble clicking elements when the size of a document changes", skip: true do
+      browser.go_to("/ferrum/long_page")
+      browser.at_css("#penultimate").click
+      browser.execute <<~JS
+        el = document.getElementById("penultimate")
+        el.parentNode.removeChild(el)
+      JS
+      browser.at_xpath("//a[text() = 'Phasellus blandit velit']").click
+      expect(browser.body).to include("Hello")
+    end
 
-      it "handles click when the target is in the view, but the document is smaller than the viewport" do
-        browser.go_to("/ferrum/simple")
-        browser.at_xpath("//a[text() = 'Link']").click
-        expect(browser.body).to include("Hello world")
-      end
+    it "handles click when the target is in the view, but the document is smaller than the viewport" do
+      browser.go_to("/ferrum/simple")
+      browser.at_xpath("//a[text() = 'Link']").click
+      expect(browser.body).to include("Hello world")
+    end
 
-      it "handles clicks where a parent element has a border" do
-        browser.go_to("/ferrum/table")
-        browser.at_xpath("//a[text() = 'Link']").click
-        expect(browser.body).to include("Hello world")
-      end
+    it "handles clicks where a parent element has a border" do
+      browser.go_to("/ferrum/table")
+      browser.at_xpath("//a[text() = 'Link']").click
+      expect(browser.body).to include("Hello world")
     end
+  end
 
-    describe "#scroll_to" do
-      it "allows the page to be scrolled" do
-        browser.go_to("/ferrum/long_page")
-        browser.resize(width: 10, height: 10)
-        browser.mouse.scroll_to(200, 100)
-        expect(
-          browser.evaluate("[window.scrollX, window.scrollY]")
-        ).to eq([200, 100])
-      end
+  describe "#scroll_to" do
+    it "allows the page to be scrolled" do
+      browser.go_to("/ferrum/long_page")
+      browser.resize(width: 10, height: 10)
+      browser.mouse.scroll_to(200, 100)
+      expect(
+        browser.evaluate("[window.scrollX, window.scrollY]")
+      ).to eq([200, 100])
     end
+  end
 
-    describe "#move" do
-      let(:tracking_code) do
-        <<~JS
-          window.result = [];
-          document.addEventListener("mousemove", e => {
-            window.result.push([e.clientX, e.clientY]);
-          });
-          arguments[0]();
-        JS
-      end
+  describe "#move" do
+    let(:tracking_code) do
+      <<~JS
+        window.result = [];
+        document.addEventListener("mousemove", e => {
+          window.result.push([e.clientX, e.clientY]);
+        });
+        arguments[0]();
+      JS
+    end
 
-      it "splits into steps" do
-        browser.go_to("/ferrum/simple")
-        browser.mouse.move(x: 100, y: 100)
-        browser.evaluate_async(tracking_code, browser.timeout)
+    it "splits into steps" do
+      browser.go_to("/ferrum/simple")
+      browser.mouse.move(x: 100, y: 100)
+      browser.evaluate_async(tracking_code, browser.timeout)
 
-        browser.mouse.move(x: 200, y: 300, steps: 5)
+      browser.mouse.move(x: 200, y: 300, steps: 5)
 
-        expect(browser.evaluate("window.result")).to eq([
-          [120, 140],
-          [140, 180],
-          [160, 220],
-          [180, 260],
-          [200, 300]
-        ])
-      end
+      expect(browser.evaluate("window.result")).to eq([
+        [120, 140],
+        [140, 180],
+        [160, 220],
+        [180, 260],
+        [200, 300]
+      ])
     end
+  end
 
-    context "mouse support", skip: true do
-      before do
-        browser.go_to("/ferrum/click_test")
-      end
+  context "mouse support", skip: true do
+    before do
+      browser.go_to("/ferrum/click_test")
+    end
 
-      after do
-        browser.resize(width: 1024, height: 768)
-        browser.reset
-      end
+    after do
+      browser.resize(width: 1024, height: 768)
+      browser.reset
+    end
 
-      it "scrolls around so that elements can be clicked" do
-        browser.resize(width: 200, height: 200)
-        log = browser.at_css("#log")
+    it "scrolls around so that elements can be clicked" do
+      browser.resize(width: 200, height: 200)
+      log = browser.at_css("#log")
 
-        instructions = %w[one four one two three]
-        instructions.each do |instruction|
-          browser.at_css("##{instruction}").click
-          browser.screenshot(path: "a.png")
-          expect(log.text).to eq(instruction)
-        end
+      instructions = %w[one four one two three]
+      instructions.each do |instruction|
+        browser.at_css("##{instruction}").click
+        browser.screenshot(path: "a.png")
+        expect(log.text).to eq(instruction)
       end
+    end
 
-      it "fixes some weird layout issue that we are not entirely sure about the reason for" do
-        browser.go_to("/ferrum/datepicker")
-        browser.at_css("#datepicker").set("2012-05-11")
-        browser.at_xpath("//a[text() = 'some link']").click
-      end
+    it "fixes some weird layout issue that we are not entirely sure about the reason for" do
+      browser.go_to("/ferrum/datepicker")
+      browser.at_css("#datepicker").set("2012-05-11")
+      browser.at_xpath("//a[text() = 'some link']").click
+    end
 
-      it "can click an element inside an svg" do
-        expect { browser.at_css("#myrect").click }.not_to raise_error
-      end
+    it "can click an element inside an svg" do
+      expect { browser.at_css("#myrect").click }.not_to raise_error
+    end
 
-      context "with #two overlapping #one" do
-        before do
-          browser.execute <<-JS
-            var two = document.getElementById("two")
-            two.style.position = "absolute"
-            two.style.left     = "0px"
-            two.style.top      = "0px"
-          JS
-        end
+    context "with #two overlapping #one" do
+      before do
+        browser.execute <<-JS
+          var two = document.getElementById("two")
+          two.style.position = "absolute"
+          two.style.left     = "0px"
+          two.style.top      = "0px"
+        JS
+      end
 
-        it "detects if an element is obscured when clicking" do
-          expect do
-            browser.at_css("#one").click
-          end.to raise_error(Ferrum::MouseEventFailed) { |error|
-            expect(error.selector).to eq("html body div#two.box")
-            expect(error.message).to include("[200.0, 200.0]")
-          }
-        end
+      it "detects if an element is obscured when clicking" do
+        expect do
+          browser.at_css("#one").click
+        end.to raise_error(Ferrum::MouseEventFailed) { |error|
+          expect(error.selector).to eq("html body div#two.box")
+          expect(error.message).to include("[200.0, 200.0]")
+        }
+      end
 
-        it "clicks in the center of an element" do
-          expect do
-            browser.at_css("#one").click
-          end.to raise_error(Ferrum::MouseEventFailed) { |error|
-            expect(error.position).to eq([200, 200])
-          }
-        end
+      it "clicks in the center of an element" do
+        expect do
+          browser.at_css("#one").click
+        end.to raise_error(Ferrum::MouseEventFailed) { |error|
+          expect(error.position).to eq([200, 200])
+        }
+      end
 
-        it "clicks in the center of an element within the viewport, if part is outside the viewport" do
-          browser.resize(width: 200, height: 200)
+      it "clicks in the center of an element within the viewport, if part is outside the viewport" do
+        browser.resize(width: 200, height: 200)
 
-          expect do
-            browser.at_css("#one").click
-          end.to raise_error(Ferrum::MouseEventFailed) { |error|
-            expect(error.position.first).to eq(100)
-          }
-        end
+        expect do
+          browser.at_css("#one").click
+        end.to raise_error(Ferrum::MouseEventFailed) { |error|
+          expect(error.position.first).to eq(100)
+        }
       end
+    end
 
-      context "with #svg overlapping #one" do
-        before do
-          browser.execute <<-JS
-            var two = document.getElementById("svg")
-            two.style.position = "absolute"
-            two.style.left     = "0px"
-            two.style.top      = "0px"
-          JS
-        end
+    context "with #svg overlapping #one" do
+      before do
+        browser.execute <<-JS
+          var two = document.getElementById("svg")
+          two.style.position = "absolute"
+          two.style.left     = "0px"
+          two.style.top      = "0px"
+        JS
+      end
 
-        it "detects if an element is obscured when clicking" do
-          expect do
-            browser.at_css("#one").click
-          end.to raise_error(Ferrum::MouseEventFailed) { |error|
-            expect(error.selector).to eq("html body svg#svg.box")
-            expect(error.message).to include("[200.0, 200.0]")
-          }
-        end
+      it "detects if an element is obscured when clicking" do
+        expect do
+          browser.at_css("#one").click
+        end.to raise_error(Ferrum::MouseEventFailed) { |error|
+          expect(error.selector).to eq("html body svg#svg.box")
+          expect(error.message).to include("[200.0, 200.0]")
+        }
       end
+    end
 
-      context "with image maps", skip: true do
-        before { browser.go_to("/ferrum/image_map") }
+    context "with image maps", skip: true do
+      before { browser.go_to("/ferrum/image_map") }
 
-        it "can click" do
-          browser.at_css("map[name=testmap] area[shape=circle]").click
-          expect(browser).to have_css("#log", text: "circle clicked")
-          browser.at_css("map[name=testmap] area[shape=rect]").click
-          expect(browser).to have_css("#log", text: "rect clicked")
-        end
+      it "can click" do
+        browser.at_css("map[name=testmap] area[shape=circle]").click
+        expect(browser).to have_css("#log", text: "circle clicked")
+        browser.at_css("map[name=testmap] area[shape=rect]").click
+        expect(browser).to have_css("#log", text: "rect clicked")
+      end
 
-        it "doesn't click if the associated img is hidden" do
-          expect do
-            browser.at_css("map[name=testmap2] area[shape=circle]").click
-          end.to raise_error(Ferrum::ElementNotFound)
-          expect do
-            browser.at_css("map[name=testmap2] area[shape=circle]", visible: false).click
-          end.to raise_error(Ferrum::MouseEventFailed)
-        end
+      it "doesn't click if the associated img is hidden" do
+        expect do
+          browser.at_css("map[name=testmap2] area[shape=circle]").click
+        end.to raise_error(Ferrum::ElementNotFound)
+        expect do
+          browser.at_css("map[name=testmap2] area[shape=circle]", visible: false).click
+        end.to raise_error(Ferrum::MouseEventFailed)
       end
+    end
 
-      context "double click tests" do
-        before do
-          browser.go_to("/ferrum/double_click_test")
-        end
+    context "double click tests" do
+      before do
+        browser.go_to("/ferrum/double_click_test")
+      end
 
-        it "double clicks properly" do
-          browser.resize(width: 200, height: 200)
-          log = browser.at_css("#log")
+      it "double clicks properly" do
+        browser.resize(width: 200, height: 200)
+        log = browser.at_css("#log")
 
-          instructions = %w[one four one two three]
-          instructions.each do |instruction|
-            browser.at_css("##{instruction}").base.double_click
-            expect(log.text).to eq(instruction)
-          end
+        instructions = %w[one four one two three]
+        instructions.each do |instruction|
+          browser.at_css("##{instruction}").base.double_click
+          expect(log.text).to eq(instruction)
         end
       end
     end
diff --git a/spec/network/auth_request_spec.rb b/spec/network/auth_request_spec.rb
index 4e2f2547..99b29302 100644
--- a/spec/network/auth_request_spec.rb
+++ b/spec/network/auth_request_spec.rb
@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Network
-    describe AuthRequest do
-      skip
-    end
-  end
+describe Ferrum::Network::AuthRequest do
+  skip
 end
diff --git a/spec/network/error_spec.rb b/spec/network/error_spec.rb
index 83575bf9..01fd8687 100644
--- a/spec/network/error_spec.rb
+++ b/spec/network/error_spec.rb
@@ -1,21 +1,17 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Network
-    describe Error do
-      it "#canceled?" do
-        page.go_to("/ferrum/with_ajax_connection_canceled")
+describe Ferrum::Network::Error do
+  it "#canceled?" do
+    page.go_to("/ferrum/with_ajax_connection_canceled")
 
-        expect(network.idle?).to be_falsey
+    expect(network.idle?).to be_falsey
 
-        # FIXME: Hack to wait for content in the browser
-        Utils::Attempt.with_retry(errors: RuntimeError, max: 10, wait: 0.1) do
-          page.at_xpath("//h1[text() = 'Canceled']") || raise("Node not found")
-        end
-
-        expect(network.idle?).to be_truthy
-        expect(last_exchange.error.canceled?).to be_truthy
-      end
+    # FIXME: Hack to wait for content in the browser
+    Ferrum::Utils::Attempt.with_retry(errors: RuntimeError, max: 10, wait: 0.1) do
+      page.at_xpath("//h1[text() = 'Canceled']") || raise("Node not found")
     end
+
+    expect(network.idle?).to be_truthy
+    expect(last_exchange.error.canceled?).to be_truthy
   end
 end
diff --git a/spec/network/intercepted_request_spec.rb b/spec/network/intercepted_request_spec.rb
index 0bf30e5d..97f31e18 100644
--- a/spec/network/intercepted_request_spec.rb
+++ b/spec/network/intercepted_request_spec.rb
@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Network
-    describe InterceptedRequest do
-      skip
-    end
-  end
+describe Ferrum::Network::InterceptedRequest do
+  skip
 end
diff --git a/spec/network/request_spec.rb b/spec/network/request_spec.rb
index bddb6193..62f45d1e 100644
--- a/spec/network/request_spec.rb
+++ b/spec/network/request_spec.rb
@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Network
-    describe Request do
-      skip
-    end
-  end
+describe Ferrum::Network::Request do
+  skip
 end
diff --git a/spec/network/response_spec.rb b/spec/network/response_spec.rb
index 271f1e06..d34874a7 100644
--- a/spec/network/response_spec.rb
+++ b/spec/network/response_spec.rb
@@ -1,95 +1,91 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Network
-    describe Response do
-      describe "#status" do
-        it "captures responses" do
-          page.go_to("/ferrum/with_js")
+describe Ferrum::Network::Response do
+  describe "#status" do
+    it "captures responses" do
+      page.go_to("/ferrum/with_js")
 
-          expect(last_exchange.response.status).to eq(200)
-        end
+      expect(last_exchange.response.status).to eq(200)
+    end
 
-        it "determines status from the simple response" do
-          browser.go_to("/ferrum/status/500")
-          expect(browser.network.status).to eq(500)
-        end
+    it "determines status from the simple response" do
+      browser.go_to("/ferrum/status/500")
+      expect(browser.network.status).to eq(500)
+    end
 
-        it "determines status code when the page has a few resources" do
-          browser.go_to("/ferrum/with_different_resources")
-          expect(browser.network.status).to eq(200)
-        end
+    it "determines status code when the page has a few resources" do
+      browser.go_to("/ferrum/with_different_resources")
+      expect(browser.network.status).to eq(200)
+    end
 
-        it "determines status code even after redirect" do
-          browser.go_to("/ferrum/redirect")
-          expect(browser.network.status).to eq(200)
-        end
+    it "determines status code even after redirect" do
+      browser.go_to("/ferrum/redirect")
+      expect(browser.network.status).to eq(200)
+    end
 
-        it "determines status code when user goes to a page by using a link on it" do
-          browser.go_to("/ferrum/with_different_resources")
+    it "determines status code when user goes to a page by using a link on it" do
+      browser.go_to("/ferrum/with_different_resources")
 
-          browser.at_xpath("//a[text() = 'Go to 500']").click
+      browser.at_xpath("//a[text() = 'Go to 500']").click
 
-          expect(browser.network.status).to eq(500)
-        end
+      expect(browser.network.status).to eq(500)
+    end
 
-        it "determines properly status when user goes through a few pages" do
-          browser.go_to("/ferrum/with_different_resources")
+    it "determines properly status when user goes through a few pages" do
+      browser.go_to("/ferrum/with_different_resources")
 
-          browser.at_xpath("//a[text() = 'Go to 200']").click
-          browser.at_xpath("//a[text() = 'Go to 201']").click
-          browser.at_xpath("//a[text() = 'Do redirect']").click
-          browser.at_xpath("//a[text() = 'Go to 402']").click
+      browser.at_xpath("//a[text() = 'Go to 200']").click
+      browser.at_xpath("//a[text() = 'Go to 201']").click
+      browser.at_xpath("//a[text() = 'Do redirect']").click
+      browser.at_xpath("//a[text() = 'Go to 402']").click
 
-          expect(browser.network.status).to eq(402)
-        end
-      end
+      expect(browser.network.status).to eq(402)
+    end
+  end
 
-      describe "#body" do
-        it "gets response body" do
-          page.go_to("/ferrum/with_js")
-          responses = traffic.map(&:response)
+  describe "#body" do
+    it "gets response body" do
+      page.go_to("/ferrum/with_js")
+      responses = traffic.map(&:response)
 
-          expect(responses.size).to eq(4)
+      expect(responses.size).to eq(4)
 
-          expect(responses[0].url).to end_with("/ferrum/with_js")
-          expect(responses[0].body).to include("ferrum with_js")
+      expect(responses[0].url).to end_with("/ferrum/with_js")
+      expect(responses[0].body).to include("ferrum with_js")
 
-          expect(responses[1].url).to end_with("/ferrum/jquery.min.js")
-          expect(responses[1].body).to include("jQuery v1.11.3")
+      expect(responses[1].url).to end_with("/ferrum/jquery.min.js")
+      expect(responses[1].body).to include("jQuery v1.11.3")
 
-          expect(responses[2].url).to end_with("/ferrum/jquery-ui.min.js")
-          expect(responses[2].body).to include("jQuery UI - v1.11.4")
+      expect(responses[2].url).to end_with("/ferrum/jquery-ui.min.js")
+      expect(responses[2].body).to include("jQuery UI - v1.11.4")
 
-          expect(responses[3].url).to end_with("/ferrum/test.js")
-          expect(responses[3].body).to include("This is test.js file content")
-        end
-      end
+      expect(responses[3].url).to end_with("/ferrum/test.js")
+      expect(responses[3].body).to include("This is test.js file content")
+    end
+  end
 
-      describe "#error" do
-        it "captures errors" do
-          page.go_to("/ferrum/with_ajax_fail")
-          expect(page.at_xpath("//h1[text() = 'Done']")).to be
+  describe "#error" do
+    it "captures errors" do
+      page.go_to("/ferrum/with_ajax_fail")
+      expect(page.at_xpath("//h1[text() = 'Done']")).to be
 
-          expect(last_exchange.error).to be
-        end
-      end
+      expect(last_exchange.error).to be
+    end
+  end
 
-      describe "#body_size" do
-        it "counts network traffic for each loaded resource" do
-          page.go_to("/ferrum/with_js")
-          responses = traffic.map(&:response)
-          resources_size = {
-            %r{/ferrum/jquery.min.js$} => File.size("#{PROJECT_ROOT}/spec/support/public/jquery-1.11.3.min.js"),
-            %r{/ferrum/jquery-ui.min.js$} => File.size("#{PROJECT_ROOT}/spec/support/public/jquery-ui-1.11.4.min.js"),
-            %r{/ferrum/test.js$} => File.size("#{PROJECT_ROOT}/spec/support/public/test.js"),
-            %r{/ferrum/with_js$} => 2343
-          }
-
-          resources_size.each do |resource, size|
-            expect(responses.find { |r| r.url[resource] }.body_size).to eq(size)
-          end
-        end
+  describe "#body_size" do
+    it "counts network traffic for each loaded resource" do
+      page.go_to("/ferrum/with_js")
+      responses = traffic.map(&:response)
+      resources_size = {
+        %r{/ferrum/jquery.min.js$} => File.size("#{PROJECT_ROOT}/spec/support/public/jquery-1.11.3.min.js"),
+        %r{/ferrum/jquery-ui.min.js$} => File.size("#{PROJECT_ROOT}/spec/support/public/jquery-ui-1.11.4.min.js"),
+        %r{/ferrum/test.js$} => File.size("#{PROJECT_ROOT}/spec/support/public/test.js"),
+        %r{/ferrum/with_js$} => 2343
+      }
+
+      resources_size.each do |resource, size|
+        expect(responses.find { |r| r.url[resource] }.body_size).to eq(size)
       end
     end
   end
diff --git a/spec/network_spec.rb b/spec/network_spec.rb
index fa29fe5a..1b207aa3 100644
--- a/spec/network_spec.rb
+++ b/spec/network_spec.rb
@@ -1,417 +1,415 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Network do
-    describe "#traffic" do
-      it "keeps track of network traffic" do
-        page.go_to("/ferrum/with_js")
-        urls = traffic.map { |e| e.request.url }
-
-        expect(urls.size).to eq(4)
-        expect(urls.grep(%r{/ferrum/with_js$}).size).to eq(1)
-        expect(urls.grep(%r{/ferrum/jquery.min.js$}).size).to eq(1)
-        expect(urls.grep(%r{/ferrum/jquery-ui.min.js$}).size).to eq(1)
-        expect(urls.grep(%r{/ferrum/test.js$}).size).to eq(1)
-      end
-
-      it "keeps a running list between multiple web page views" do
-        page.go_to("/ferrum/with_js")
-        expect(traffic.length).to eq(4)
-
-        page.go_to("/ferrum/with_js")
-        expect(traffic.length).to eq(8)
-      end
+describe Ferrum::Network do
+  describe "#traffic" do
+    it "keeps track of network traffic" do
+      page.go_to("/ferrum/with_js")
+      urls = traffic.map { |e| e.request.url }
 
-      it "gets cleared on restart" do
-        browser.go_to("/ferrum/with_js")
-        expect(browser.network.traffic.length).to eq(4)
+      expect(urls.size).to eq(4)
+      expect(urls.grep(%r{/ferrum/with_js$}).size).to eq(1)
+      expect(urls.grep(%r{/ferrum/jquery.min.js$}).size).to eq(1)
+      expect(urls.grep(%r{/ferrum/jquery-ui.min.js$}).size).to eq(1)
+      expect(urls.grep(%r{/ferrum/test.js$}).size).to eq(1)
+    end
 
-        browser.restart
+    it "keeps a running list between multiple web page views" do
+      page.go_to("/ferrum/with_js")
+      expect(traffic.length).to eq(4)
 
-        browser.go_to("/ferrum/with_js")
-        expect(browser.network.traffic.length).to eq(4)
-      end
+      page.go_to("/ferrum/with_js")
+      expect(traffic.length).to eq(8)
     end
 
-    it "#wait_for_idle" do
-      page.go_to("/show_cookies")
-      expect(page.body).not_to include("test_cookie")
+    it "gets cleared on restart" do
+      browser.go_to("/ferrum/with_js")
+      expect(browser.network.traffic.length).to eq(4)
 
-      page.at_xpath("//button[text() = 'Set cookie slow']").click
-      network.wait_for_idle
-      page.refresh
+      browser.restart
 
-      expect(page.body).to include("test_cookie")
+      browser.go_to("/ferrum/with_js")
+      expect(browser.network.traffic.length).to eq(4)
     end
+  end
 
-    it "#idle?" do
-      page.go_to("/ferrum/with_slow_ajax_connection")
-      expect(page.at_xpath("//h1[text() = 'Slow AJAX']")).to be
-
-      expect(network.idle?).to be_falsey
-      network.wait_for_idle
-      expect(network.idle?).to be_truthy
-    end
+  it "#wait_for_idle" do
+    page.go_to("/show_cookies")
+    expect(page.body).not_to include("test_cookie")
 
-    it "#total_connections" do
-      expect(network.total_connections).to eq(0)
+    page.at_xpath("//button[text() = 'Set cookie slow']").click
+    network.wait_for_idle
+    page.refresh
 
-      page.go_to("/ferrum/with_ajax_connection_refused")
+    expect(page.body).to include("test_cookie")
+  end
 
-      expect(network.total_connections).to eq(3)
-    end
+  it "#idle?" do
+    page.go_to("/ferrum/with_slow_ajax_connection")
+    expect(page.at_xpath("//h1[text() = 'Slow AJAX']")).to be
 
-    it "#finished_connections" do
-      expect(network.finished_connections).to eq(0)
+    expect(network.idle?).to be_falsey
+    network.wait_for_idle
+    expect(network.idle?).to be_truthy
+  end
 
-      page.go_to("/ferrum/with_ajax_connection_refused")
-      network.wait_for_idle
+  it "#total_connections" do
+    expect(network.total_connections).to eq(0)
 
-      expect(network.finished_connections).to eq(3)
-    end
+    page.go_to("/ferrum/with_ajax_connection_refused")
 
-    it "#pending_connections" do
-      expect(network.pending_connections).to eq(0)
+    expect(network.total_connections).to eq(3)
+  end
 
-      page.go_to("/ferrum/with_slow_ajax_connection")
-      expect(network.pending_connections).to eq(1)
+  it "#finished_connections" do
+    expect(network.finished_connections).to eq(0)
 
-      network.wait_for_idle
-      expect(network.pending_connections).to eq(0)
-    end
+    page.go_to("/ferrum/with_ajax_connection_refused")
+    network.wait_for_idle
 
-    it "#request" do
-      skip
-    end
+    expect(network.finished_connections).to eq(3)
+  end
 
-    it "#response" do
-      skip
-    end
+  it "#pending_connections" do
+    expect(network.pending_connections).to eq(0)
 
-    it "#status" do
-      skip
-    end
+    page.go_to("/ferrum/with_slow_ajax_connection")
+    expect(network.pending_connections).to eq(1)
 
-    describe "#clear" do
-      it "raises error when type is not in the list" do
-        page.go_to("/ferrum/with_js")
-        expect(traffic.length).to eq(4)
+    network.wait_for_idle
+    expect(network.pending_connections).to eq(0)
+  end
 
-        expect { network.clear(:something) }.to raise_error(ArgumentError, ":type should be in [:traffic, :cache]")
+  it "#request" do
+    skip
+  end
 
-        expect(traffic.length).to eq(4)
-      end
+  it "#response" do
+    skip
+  end
 
-      it "clears all the traffic" do
-        page.go_to("/ferrum/with_js")
-        expect(traffic.length).to eq(4)
+  it "#status" do
+    skip
+  end
 
-        page.network.clear(:traffic)
+  describe "#clear" do
+    it "raises error when type is not in the list" do
+      page.go_to("/ferrum/with_js")
+      expect(traffic.length).to eq(4)
 
-        expect(traffic.length).to eq(0)
-      end
+      expect { network.clear(:something) }.to raise_error(ArgumentError, ":type should be in [:traffic, :cache]")
 
-      it "clears memory cache" do
-        page.network.clear(:cache)
+      expect(traffic.length).to eq(4)
+    end
 
-        page.go_to("/ferrum/cacheable")
-        expect(traffic.length).to eq(1)
-        expect(network.status).to eq(200)
-        expect(last_exchange.response.params.dig("response", "fromDiskCache")).to be_falsey
+    it "clears all the traffic" do
+      page.go_to("/ferrum/with_js")
+      expect(traffic.length).to eq(4)
 
-        page.at_xpath("//a").click
-        expect(traffic.length).to eq(2)
-        expect(network.status).to eq(200)
-        expect(last_exchange.response.params.dig("response", "fromDiskCache")).to be_truthy
+      page.network.clear(:traffic)
 
-        page.network.clear(:cache)
-        page.at_xpath("//a").click
-        expect(traffic.length).to eq(3)
-        expect(network.status).to eq(200)
-        expect(last_exchange.response.params.dig("response", "fromDiskCache")).to be_falsey
-      end
+      expect(traffic.length).to eq(0)
     end
 
-    describe "#blacklist=" do
-      let(:blocked_urls) { traffic.select(&:blocked?).map { |e| e.request.url } }
-
-      it "allows all requests when blacklist is not set" do
-        network.blacklist = nil
+    it "clears memory cache" do
+      page.network.clear(:cache)
 
-        page.go_to("/ferrum/url_blacklist")
+      page.go_to("/ferrum/cacheable")
+      expect(traffic.length).to eq(1)
+      expect(network.status).to eq(200)
+      expect(last_exchange.response.params.dig("response", "fromDiskCache")).to be_falsey
 
-        expect(blocked_urls).to be_empty
-        expect(page.body).not_to include("Disappearing header")
-      end
-
-      it "blocks with single pattern" do
-        network.blacklist = /jquery/
+      page.at_xpath("//a").click
+      expect(traffic.length).to eq(2)
+      expect(network.status).to eq(200)
+      expect(last_exchange.response.params.dig("response", "fromDiskCache")).to be_truthy
 
-        page.go_to("/ferrum/url_blacklist")
+      page.network.clear(:cache)
+      page.at_xpath("//a").click
+      expect(traffic.length).to eq(3)
+      expect(network.status).to eq(200)
+      expect(last_exchange.response.params.dig("response", "fromDiskCache")).to be_falsey
+    end
+  end
 
-        expect(blocked_urls.size).to eq(1)
-        expect(blocked_urls).not_to include(/unwanted/)
-        expect(blocked_urls).to include(/jquery/)
-        expect(page.body).to include("Disappearing header")
-      end
+  describe "#blacklist=" do
+    let(:blocked_urls) { traffic.select(&:blocked?).map { |e| e.request.url } }
 
-      it "blocks with array of patterns" do
-        network.blacklist = [/unwanted/, /jquery/]
+    it "allows all requests when blacklist is not set" do
+      network.blacklist = nil
 
-        page.go_to("/ferrum/url_blacklist")
+      page.go_to("/ferrum/url_blacklist")
 
-        expect(blocked_urls.size).to eq(4)
-        expect(blocked_urls).to include(/unwanted/)
-        expect(blocked_urls).to include(/jquery/)
-        expect(page.body).to include("Disappearing header")
-      end
+      expect(blocked_urls).to be_empty
+      expect(page.body).not_to include("Disappearing header")
+    end
 
-      it "supports wildcards" do
-        network.blacklist = /.*wanted/
-        page.go_to("/ferrum/url_whitelist")
+    it "blocks with single pattern" do
+      network.blacklist = /jquery/
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("We are loading some wanted action here")
+      page.go_to("/ferrum/url_blacklist")
 
-        frame = page.at_xpath("//iframe[@name = 'framename']").frame
-        expect(frame.body).not_to include("We should see this.")
+      expect(blocked_urls.size).to eq(1)
+      expect(blocked_urls).not_to include(/unwanted/)
+      expect(blocked_urls).to include(/jquery/)
+      expect(page.body).to include("Disappearing header")
+    end
 
-        frame = page.at_xpath("//iframe[@name = 'unwantedframe']").frame
-        expect(frame.body).not_to include("We shouldn't see this.")
-      end
+    it "blocks with array of patterns" do
+      network.blacklist = [/unwanted/, /jquery/]
 
-      it "blocks unwanted iframes" do
-        network.blacklist = /unwanted/
-        page.go_to("/ferrum/url_blacklist")
+      page.go_to("/ferrum/url_blacklist")
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("We are loading some unwanted action here")
-        frame = page.at_xpath("//iframe[@name = 'framename']").frame
-        expect(frame.body).not_to include("We shouldn't see this.")
-      end
+      expect(blocked_urls.size).to eq(4)
+      expect(blocked_urls).to include(/unwanted/)
+      expect(blocked_urls).to include(/jquery/)
+      expect(page.body).to include("Disappearing header")
+    end
 
-      it "works if set after page is loaded" do
-        network.blacklist = nil
-        page.go_to("/ferrum/url_blacklist")
-        expect(page.body).not_to include("Disappearing header")
+    it "supports wildcards" do
+      network.blacklist = /.*wanted/
+      page.go_to("/ferrum/url_whitelist")
 
-        network.blacklist = /jquery/
-        network.clear(:traffic)
-        page.go_to("/ferrum/url_blacklist")
+      expect(network.status).to eq(200)
+      expect(page.body).to include("We are loading some wanted action here")
 
-        expect(blocked_urls.size).to eq(1)
-        expect(blocked_urls).to include(/jquery/)
-        expect(page.body).to include("Disappearing header")
-      end
+      frame = page.at_xpath("//iframe[@name = 'framename']").frame
+      expect(frame.body).not_to include("We should see this.")
 
-      it "works with other subscriptions" do
-        @intercepted_request = nil
+      frame = page.at_xpath("//iframe[@name = 'unwantedframe']").frame
+      expect(frame.body).not_to include("We shouldn't see this.")
+    end
 
-        page.on(:request) do |request, _index, _total|
-          @intercepted_request ||= request
-        end
+    it "blocks unwanted iframes" do
+      network.blacklist = /unwanted/
+      page.go_to("/ferrum/url_blacklist")
 
-        network.blacklist = /jquery/
+      expect(network.status).to eq(200)
+      expect(page.body).to include("We are loading some unwanted action here")
+      frame = page.at_xpath("//iframe[@name = 'framename']").frame
+      expect(frame.body).not_to include("We shouldn't see this.")
+    end
 
-        page.go_to("/ferrum/url_blacklist")
+    it "works if set after page is loaded" do
+      network.blacklist = nil
+      page.go_to("/ferrum/url_blacklist")
+      expect(page.body).not_to include("Disappearing header")
 
-        expect(@intercepted_request).to be
-        expect(@intercepted_request.url).to include("/ferrum/url_blacklist")
-      end
+      network.blacklist = /jquery/
+      network.clear(:traffic)
+      page.go_to("/ferrum/url_blacklist")
 
-      it "gets cleared along with network traffic" do
-        network.blacklist = /unwanted/
-        page.go_to("/ferrum/url_blacklist")
-        expect(traffic.select(&:blocked?).length).to eq(3)
+      expect(blocked_urls.size).to eq(1)
+      expect(blocked_urls).to include(/jquery/)
+      expect(page.body).to include("Disappearing header")
+    end
 
-        network.clear(:traffic)
+    it "works with other subscriptions" do
+      @intercepted_request = nil
 
-        expect(traffic.select(&:blocked?).length).to eq(0)
+      page.on(:request) do |request, _index, _total|
+        @intercepted_request ||= request
       end
 
-      it "supports multiple pages each with their own blacklist" do
-        page_one = browser.create_page
-        page_one.network.blacklist = /unwanted/
+      network.blacklist = /jquery/
+
+      page.go_to("/ferrum/url_blacklist")
 
-        page_two = browser.create_page
-        page_two.network.blacklist = /jquery/
+      expect(@intercepted_request).to be
+      expect(@intercepted_request.url).to include("/ferrum/url_blacklist")
+    end
 
-        page_two.go_to("/ferrum/url_blacklist")
-        page_one.go_to("/ferrum/url_blacklist")
+    it "gets cleared along with network traffic" do
+      network.blacklist = /unwanted/
+      page.go_to("/ferrum/url_blacklist")
+      expect(traffic.select(&:blocked?).length).to eq(3)
 
-        blocked_two = page_two.network.traffic.select(&:blocked?).map { |e| e.request.url }
-        expect(blocked_two.size).to eq(1)
-        expect(blocked_two).not_to include(/unwanted/)
-        expect(blocked_two).to include(/jquery/)
-        expect(page_two.body).to include("Disappearing header")
+      network.clear(:traffic)
 
-        blocked_one = page_one.network.traffic.select(&:blocked?).map { |e| e.request.url }
-        expect(blocked_one.size).to eq(3)
-        expect(blocked_one).to include(/unwanted/)
-        expect(blocked_one).not_to include(/jquery/)
-        expect(page_one.body).not_to include("Disappearing header")
-      end
+      expect(traffic.select(&:blocked?).length).to eq(0)
     end
 
-    describe "#whitelist=" do
-      let(:blocked_urls) { traffic.select(&:blocked?).map { |e| e.request.url } }
+    it "supports multiple pages each with their own blacklist" do
+      page_one = browser.create_page
+      page_one.network.blacklist = /unwanted/
 
-      it "allows all requests when blacklist is not set" do
-        network.whitelist = nil
+      page_two = browser.create_page
+      page_two.network.blacklist = /jquery/
 
-        page.go_to("/ferrum/url_whitelist")
+      page_two.go_to("/ferrum/url_blacklist")
+      page_one.go_to("/ferrum/url_blacklist")
 
-        expect(blocked_urls).to be_empty
-        expect(page.body).not_to include("Disappearing header")
-      end
+      blocked_two = page_two.network.traffic.select(&:blocked?).map { |e| e.request.url }
+      expect(blocked_two.size).to eq(1)
+      expect(blocked_two).not_to include(/unwanted/)
+      expect(blocked_two).to include(/jquery/)
+      expect(page_two.body).to include("Disappearing header")
 
-      it "blocks with single pattern" do
-        network.whitelist = /url_whitelist|jquery/
+      blocked_one = page_one.network.traffic.select(&:blocked?).map { |e| e.request.url }
+      expect(blocked_one.size).to eq(3)
+      expect(blocked_one).to include(/unwanted/)
+      expect(blocked_one).not_to include(/jquery/)
+      expect(page_one.body).not_to include("Disappearing header")
+    end
+  end
 
-        page.go_to("/ferrum/url_whitelist")
+  describe "#whitelist=" do
+    let(:blocked_urls) { traffic.select(&:blocked?).map { |e| e.request.url } }
 
-        expect(blocked_urls.size).to eq(4)
-        expect(blocked_urls).to include(/unwanted/)
-        expect(blocked_urls).to include(/wanted/)
-        expect(page.body).not_to include("Disappearing header")
-      end
+    it "allows all requests when blacklist is not set" do
+      network.whitelist = nil
 
-      it "blocks with array of patterns" do
-        network.whitelist = [/url_whitelist/, /unwanted/, /jquery/]
+      page.go_to("/ferrum/url_whitelist")
 
-        page.go_to("/ferrum/url_whitelist")
+      expect(blocked_urls).to be_empty
+      expect(page.body).not_to include("Disappearing header")
+    end
 
-        expect(blocked_urls.size).to eq(3)
-        expect(blocked_urls).not_to include(/unwanted/)
-        expect(blocked_urls).not_to include(/jquery/)
-        expect(page.body).not_to include("Disappearing header")
-      end
+    it "blocks with single pattern" do
+      network.whitelist = /url_whitelist|jquery/
+
+      page.go_to("/ferrum/url_whitelist")
 
-      it "supports wildcards and frames" do
-        network.whitelist = %r{url_whitelist|/.*wanted}
-        page.go_to("/ferrum/url_whitelist")
+      expect(blocked_urls.size).to eq(4)
+      expect(blocked_urls).to include(/unwanted/)
+      expect(blocked_urls).to include(/wanted/)
+      expect(page.body).not_to include("Disappearing header")
+    end
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("We are loading some wanted action here")
+    it "blocks with array of patterns" do
+      network.whitelist = [/url_whitelist/, /unwanted/, /jquery/]
 
-        frame = page.at_xpath("//iframe[@name = 'framename']").frame
-        expect(frame.body).to include("We should see this.")
+      page.go_to("/ferrum/url_whitelist")
 
-        frame = page.at_xpath("//iframe[@name = 'unwantedframe']").frame
-        expect(frame.body).to include("We shouldn't see this.")
-      end
+      expect(blocked_urls.size).to eq(3)
+      expect(blocked_urls).not_to include(/unwanted/)
+      expect(blocked_urls).not_to include(/jquery/)
+      expect(page.body).not_to include("Disappearing header")
     end
 
-    describe "#intercept" do
-      it "supports custom responses" do
-        network.intercept
-        page.on(:request) do |request|
-          request.respond(body: "<h1>custom content that is more than 45 characters</h1>")
-        end
+    it "supports wildcards and frames" do
+      network.whitelist = %r{url_whitelist|/.*wanted}
+      page.go_to("/ferrum/url_whitelist")
 
-        page.go_to("/ferrum/non_existing")
+      expect(network.status).to eq(200)
+      expect(page.body).to include("We are loading some wanted action here")
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("custom content that is more than 45 characters")
-      end
-    end
+      frame = page.at_xpath("//iframe[@name = 'framename']").frame
+      expect(frame.body).to include("We should see this.")
 
-    describe "#authorize" do
-      it "raises error when authorize is without block" do
-        expect do
-          network.authorize(user: "login", password: "pass")
-        end.to raise_exception(ArgumentError,
-                               "Block is missing, call `authorize(...) { |r| r.continue } " \
-                               "or subscribe to `on(:request)` events before calling it")
-      end
+      frame = page.at_xpath("//iframe[@name = 'unwantedframe']").frame
+      expect(frame.body).to include("We shouldn't see this.")
+    end
+  end
 
-      it "raises no error when authorize is with block" do
-        expect do
-          network.authorize(user: "login", password: "pass") do |request, _index, _total|
-            request.continue
-          end
-        end.not_to raise_error
+  describe "#intercept" do
+    it "supports custom responses" do
+      network.intercept
+      page.on(:request) do |request|
+        request.respond(body: "<h1>custom content that is more than 45 characters</h1>")
       end
 
-      it "raises no error when authorize is without block but subscribed to events" do
-        expect do
-          page.on(:request, &:continue)
-          network.authorize(user: "login", password: "pass")
-        end.not_to raise_error
-      end
+      page.go_to("/ferrum/non_existing")
 
-      it "denies without credentials" do
-        page.go_to("/ferrum/basic_auth")
+      expect(network.status).to eq(200)
+      expect(page.body).to include("custom content that is more than 45 characters")
+    end
+  end
 
-        expect(network.status).to eq(401)
-        expect(page.body).not_to include("Welcome, authenticated client")
-      end
+  describe "#authorize" do
+    it "raises error when authorize is without block" do
+      expect do
+        network.authorize(user: "login", password: "pass")
+      end.to raise_exception(ArgumentError,
+                             "Block is missing, call `authorize(...) { |r| r.continue } " \
+                             "or subscribe to `on(:request)` events before calling it")
+    end
 
-      it "allows with given credentials" do
+    it "raises no error when authorize is with block" do
+      expect do
         network.authorize(user: "login", password: "pass") do |request, _index, _total|
           request.continue
         end
+      end.not_to raise_error
+    end
+
+    it "raises no error when authorize is without block but subscribed to events" do
+      expect do
+        page.on(:request, &:continue)
+        network.authorize(user: "login", password: "pass")
+      end.not_to raise_error
+    end
+
+    it "denies without credentials" do
+      page.go_to("/ferrum/basic_auth")
 
-        page.go_to("/ferrum/basic_auth")
+      expect(network.status).to eq(401)
+      expect(page.body).not_to include("Welcome, authenticated client")
+    end
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("Welcome, authenticated client")
+    it "allows with given credentials" do
+      network.authorize(user: "login", password: "pass") do |request, _index, _total|
+        request.continue
       end
 
-      it "allows even overwriting headers" do
-        network.authorize(user: "login", password: "pass") do |request, _index, _total|
-          request.continue
-        end
-        page.headers.set("Cuprite" => "true")
+      page.go_to("/ferrum/basic_auth")
 
-        page.go_to("/ferrum/basic_auth")
+      expect(network.status).to eq(200)
+      expect(page.body).to include("Welcome, authenticated client")
+    end
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("Welcome, authenticated client")
+    it "allows even overwriting headers" do
+      network.authorize(user: "login", password: "pass") do |request, _index, _total|
+        request.continue
       end
+      page.headers.set("Cuprite" => "true")
 
-      it "denies with wrong credentials" do
-        network.authorize(user: "user", password: "pass!") do |request, _index, _total|
-          request.continue
-        end
+      page.go_to("/ferrum/basic_auth")
 
-        page.go_to("/ferrum/basic_auth")
+      expect(network.status).to eq(200)
+      expect(page.body).to include("Welcome, authenticated client")
+    end
 
-        expect(network.status).to eq(401)
-        expect(page.body).not_to include("Welcome, authenticated client")
+    it "denies with wrong credentials" do
+      network.authorize(user: "user", password: "pass!") do |request, _index, _total|
+        request.continue
       end
 
-      it "allows on POST request" do
-        network.authorize(user: "login", password: "pass") do |request, _index, _total|
-          request.continue
-        end
+      page.go_to("/ferrum/basic_auth")
 
-        page.go_to("/ferrum/basic_auth")
-        page.at_css(%([type="submit"])).click
+      expect(network.status).to eq(401)
+      expect(page.body).not_to include("Welcome, authenticated client")
+    end
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("Authorized POST request")
+    it "allows on POST request" do
+      network.authorize(user: "login", password: "pass") do |request, _index, _total|
+        request.continue
       end
+
+      page.go_to("/ferrum/basic_auth")
+      page.at_css(%([type="submit"])).click
+
+      expect(network.status).to eq(200)
+      expect(page.body).to include("Authorized POST request")
     end
+  end
 
-    it "#emulate_network_conditions", skip: "doesn't work for now" do
-      page.network.emulate_network_conditions(latency: 500)
+  it "#emulate_network_conditions", skip: "doesn't work for now" do
+    page.network.emulate_network_conditions(latency: 500)
 
-      start = Utils::ElapsedTime.monotonic_time
-      page.go_to("/ferrum/with_js")
+    start = Ferrum::Utils::ElapsedTime.monotonic_time
+    page.go_to("/ferrum/with_js")
 
-      expect(Utils::ElapsedTime.elapsed_time(start)).to eq(2000)
-    end
+    expect(Ferrum::Utils::ElapsedTime.elapsed_time(start)).to eq(2000)
+  end
 
-    it "#offline_mode" do
-      page.network.offline_mode
+  it "#offline_mode" do
+    page.network.offline_mode
 
-      expect { page.go_to("/ferrum/with_js") }.to raise_error(
-        Ferrum::StatusError,
-        %r{Request to http://.*/ferrum/with_js failed to reach server, check DNS and server status}
-      )
+    expect { page.go_to("/ferrum/with_js") }.to raise_error(
+      Ferrum::StatusError,
+      %r{Request to http://.*/ferrum/with_js failed to reach server, check DNS and server status}
+    )
 
-      expect(page.body).to eq("<html><head></head><body></body></html>")
-    end
+    expect(page.body).to eq("<html><head></head><body></body></html>")
   end
 end
diff --git a/spec/node_spec.rb b/spec/node_spec.rb
index cff96b82..963a13a8 100644
--- a/spec/node_spec.rb
+++ b/spec/node_spec.rb
@@ -1,765 +1,763 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Node do
-    describe "#click" do
-      it "hovers an element before clicking it" do
-        browser.go_to("/ferrum/with_js")
+describe Ferrum::Node do
+  describe "#click" do
+    it "hovers an element before clicking it" do
+      browser.go_to("/ferrum/with_js")
 
-        browser.at_xpath("//a[span[text() = 'Hidden link']]").click
+      browser.at_xpath("//a[span[text() = 'Hidden link']]").click
 
-        expect(browser.current_url).to eq(base_url("/"))
-      end
+      expect(browser.current_url).to eq(base_url("/"))
+    end
 
-      it "does not run into content quads error" do
-        browser.go_to("/ferrum/index")
+    it "does not run into content quads error" do
+      browser.go_to("/ferrum/index")
 
-        allow_any_instance_of(Node).to receive(:content_quads)
-          .and_raise(Ferrum::CoordinatesNotFoundError, "Could not compute content quads")
+      allow_any_instance_of(Ferrum::Node).to receive(:content_quads)
+        .and_raise(Ferrum::CoordinatesNotFoundError, "Could not compute content quads")
 
-        browser.at_xpath("//a[text() = 'JS redirect']").click
-        expect(browser.body).to include("Hello world")
-      end
+      browser.at_xpath("//a[text() = 'JS redirect']").click
+      expect(browser.body).to include("Hello world")
+    end
 
-      it "synchronizes page loads properly" do
-        browser.go_to("/ferrum/index")
-        browser.at_xpath("//a[text() = 'JS redirect']").click
-        sleep 0.1
-        expect(browser.body).to include("Hello world")
-      end
+    it "synchronizes page loads properly" do
+      browser.go_to("/ferrum/index")
+      browser.at_xpath("//a[text() = 'JS redirect']").click
+      sleep 0.1
+      expect(browser.body).to include("Hello world")
+    end
 
-      it "raises an error if the element has been removed from the DOM" do
-        browser.go_to("/ferrum/with_js")
-        node = browser.at_css("#remove_me")
-        expect(node.text).to eq("Remove me")
+    it "raises an error if the element has been removed from the DOM" do
+      browser.go_to("/ferrum/with_js")
+      node = browser.at_css("#remove_me")
+      expect(node.text).to eq("Remove me")
 
-        browser.at_css("#remove").click
+      browser.at_css("#remove").click
 
-        expect { node.text }.to raise_error(Ferrum::NodeNotFoundError)
-      end
+      expect { node.text }.to raise_error(Ferrum::NodeNotFoundError)
+    end
 
-      it "raises an error if the element is not visible" do
-        browser.go_to("/ferrum/index")
+    it "raises an error if the element is not visible" do
+      browser.go_to("/ferrum/index")
 
-        browser.execute <<~JS
-          document.querySelector("a[href=js_redirect]").style.display = "none"
-        JS
+      browser.execute <<~JS
+        document.querySelector("a[href=js_redirect]").style.display = "none"
+      JS
 
-        sleep 0.2 # Wait for node to disappear
+      sleep 0.2 # Wait for node to disappear
 
-        expect do
-          browser.at_xpath("//a[text()='JS redirect']").click
-        end.to raise_error(
-          Ferrum::CoordinatesNotFoundError,
-          "Node is either not visible or not an HTMLElement"
-        )
-      end
+      expect do
+        browser.at_xpath("//a[text()='JS redirect']").click
+      end.to raise_error(
+        Ferrum::CoordinatesNotFoundError,
+        "Node is either not visible or not an HTMLElement"
+      )
+    end
 
-      context "when the element is not in the viewport" do
-        before do
-          browser.go_to("/ferrum/with_js")
-        end
+    context "when the element is not in the viewport" do
+      before do
+        browser.go_to("/ferrum/with_js")
+      end
 
-        it "raises a MouseEventFailed error", skip: "needs fix" do
-          expect do
-            browser.at_xpath("//a[text() = 'O hai']").click
-          end.to raise_error(Ferrum::MouseEventFailed)
-        end
+      it "raises a MouseEventFailed error", skip: "needs fix" do
+        expect do
+          browser.at_xpath("//a[text() = 'O hai']").click
+        end.to raise_error(Ferrum::MouseEventFailed)
+      end
 
-        it "clicks properly when then brought in with animate" do
-          browser.execute %($("#off-the-left").animate({left: "10"});)
+      it "clicks properly when then brought in with animate" do
+        browser.execute %($("#off-the-left").animate({left: "10"});)
 
-          expect { browser.at_xpath("//a[text() = 'O hai']") }.to_not raise_error
-        end
+        expect { browser.at_xpath("//a[text() = 'O hai']") }.to_not raise_error
       end
+    end
 
-      context "when the element is not in the viewport of parent element", skip: true do
-        before do
-          browser.go_to("/ferrum/scroll")
-        end
+    context "when the element is not in the viewport of parent element", skip: true do
+      before do
+        browser.go_to("/ferrum/scroll")
+      end
 
-        it "scrolls into view", skip: "needs fix" do
-          browser.at_xpath("//a[text() = 'Link outside viewport']").click
-          expect(browser.current_url).to eq("/")
-        end
+      it "scrolls into view", skip: "needs fix" do
+        browser.at_xpath("//a[text() = 'Link outside viewport']").click
+        expect(browser.current_url).to eq("/")
+      end
 
-        it "scrolls into view if scrollIntoViewIfNeeded fails" do
-          browser.click_link "Below the fold"
-          expect(browser.current_path).to eq("/")
-        end
+      it "scrolls into view if scrollIntoViewIfNeeded fails" do
+        browser.click_link "Below the fold"
+        expect(browser.current_path).to eq("/")
       end
     end
+  end
 
-    describe "#at_xpath" do
-      it "searches relatively current node" do
-        browser.go_to("/ferrum/with_js")
+  describe "#at_xpath" do
+    it "searches relatively current node" do
+      browser.go_to("/ferrum/with_js")
 
-        p = browser.at_xpath("//p[@id='with_content']")
+      p = browser.at_xpath("//p[@id='with_content']")
 
-        expect(p.at_xpath("a").text).to eq("Open for match")
-        expect(p.at_xpath(".//a").text).to eq("Open for match")
-      end
+      expect(p.at_xpath("a").text).to eq("Open for match")
+      expect(p.at_xpath(".//a").text).to eq("Open for match")
     end
+  end
 
-    describe "#xpath" do
-      it "searches relatively current node" do
-        browser.go_to("/ferrum/with_js")
+  describe "#xpath" do
+    it "searches relatively current node" do
+      browser.go_to("/ferrum/with_js")
 
-        p = browser.at_xpath("//p[@id='with_content']")
-        links = p.xpath("a")
+      p = browser.at_xpath("//p[@id='with_content']")
+      links = p.xpath("a")
 
-        expect(links.size).to eq(1)
-        expect(links.first.text).to eq("Open for match")
-      end
+      expect(links.size).to eq(1)
+      expect(links.first.text).to eq("Open for match")
     end
+  end
 
-    describe "#at_css" do
-      it "searches relatively current node" do
-        browser.go_to("/ferrum/with_js")
+  describe "#at_css" do
+    it "searches relatively current node" do
+      browser.go_to("/ferrum/with_js")
 
-        p = browser.at_css("p#with_content")
+      p = browser.at_css("p#with_content")
 
-        expect(p.at_css("a").text).to eq("Open for match")
-      end
+      expect(p.at_css("a").text).to eq("Open for match")
     end
+  end
 
-    describe "#css" do
-      it "searches relatively current node" do
-        browser.go_to("/ferrum/with_js")
+  describe "#css" do
+    it "searches relatively current node" do
+      browser.go_to("/ferrum/with_js")
 
-        p = browser.at_xpath("//p[@id='with_content']")
-        links = p.css("a")
+      p = browser.at_xpath("//p[@id='with_content']")
+      links = p.css("a")
 
-        expect(links.size).to eq(1)
-        expect(links.first.text).to eq("Open for match")
-      end
+      expect(links.size).to eq(1)
+      expect(links.first.text).to eq("Open for match")
     end
+  end
 
-    describe "#selected" do
-      before do
-        browser.goto("/ferrum/form")
-      end
+  describe "#selected" do
+    before do
+      browser.goto("/ferrum/form")
+    end
 
-      it "returns texts of selected options" do
-        expect(browser.at_xpath("//*[@id='form_region']").selected.map(&:text)).to eq(["Norway"])
-      end
+    it "returns texts of selected options" do
+      expect(browser.at_xpath("//*[@id='form_region']").selected.map(&:text)).to eq(["Norway"])
+    end
 
-      it "returns selected options within frame" do
-        frame = browser.at_xpath("//iframe[@name='frame']").frame
+    it "returns selected options within frame" do
+      frame = browser.at_xpath("//iframe[@name='frame']").frame
 
-        expect(frame.at_xpath("//*[@id='select']").selected.map(&:text)).to eq(["One"])
-      end
+      expect(frame.at_xpath("//*[@id='select']").selected.map(&:text)).to eq(["One"])
+    end
 
-      context "when options exists but no selected option" do
-        it "returns first option text as default value" do
-          expect(browser.at_xpath("//*[@id='form_title']").selected.map(&:text)).to eq(["Mrs"])
-        end
+    context "when options exists but no selected option" do
+      it "returns first option text as default value" do
+        expect(browser.at_xpath("//*[@id='form_title']").selected.map(&:text)).to eq(["Mrs"])
       end
+    end
 
-      context "when no selected options" do
-        it "returns empty array" do
-          expect(browser.at_xpath("//*[@id='form_tendency']").selected.map(&:text)).to eq([])
-        end
+    context "when no selected options" do
+      it "returns empty array" do
+        expect(browser.at_xpath("//*[@id='form_tendency']").selected.map(&:text)).to eq([])
       end
+    end
 
-      context "when selector is not <select>" do
-        it "raises JavaScriptError with proper message" do
-          expect { browser.at_xpath("//*[@id='customer_name']").selected.map(&:text) }
-            .to raise_exception(Ferrum::JavaScriptError, /Element is not a <select> element/)
-        end
+    context "when selector is not <select>" do
+      it "raises JavaScriptError with proper message" do
+        expect { browser.at_xpath("//*[@id='customer_name']").selected.map(&:text) }
+          .to raise_exception(Ferrum::JavaScriptError, /Element is not a <select> element/)
       end
     end
+  end
+
+  describe "#select" do
+    before do
+      browser.goto("/ferrum/form")
+    end
 
-    describe "#select" do
-      before do
-        browser.goto("/ferrum/form")
-      end
+    it "picks option in select by match string argument" do
+      expect(browser.at_xpath("//*[@id='form_title']").select("Miss").selected.map(&:text)).to eq(["Miss"])
+    end
 
-      it "picks option in select by match string argument" do
-        expect(browser.at_xpath("//*[@id='form_title']").select("Miss").selected.map(&:text)).to eq(["Miss"])
+    shared_examples "clears selected options with no exception" do |options|
+      it "clears selected options with no exception" do
+        expect(browser.at_xpath("//*[@id='form_title']").selected.map(&:text)).to eq(["Mrs"])
+        expect(browser.at_xpath("//*[@id='form_title']").select(options).selected.map(&:text)).to eq([])
       end
+    end
 
-      shared_examples "clears selected options with no exception" do |options|
-        it "clears selected options with no exception" do
-          expect(browser.at_xpath("//*[@id='form_title']").selected.map(&:text)).to eq(["Mrs"])
-          expect(browser.at_xpath("//*[@id='form_title']").select(options).selected.map(&:text)).to eq([])
-        end
-      end
+    context "when option with provided text does not exist" do
+      include_examples "clears selected options with no exception", "Gotcha"
+    end
 
-      context "when option with provided text does not exist" do
-        include_examples "clears selected options with no exception", "Gotcha"
-      end
+    context "when provided empty array" do
+      include_examples "clears selected options with no exception", []
+    end
 
-      context "when provided empty array" do
-        include_examples "clears selected options with no exception", []
-      end
+    context "when provided empty string" do
+      include_examples "clears selected options with no exception", ""
+    end
 
-      context "when provided empty string" do
-        include_examples "clears selected options with no exception", ""
+    context "when one of option with provided texts does not exist" do
+      it "picks only existed options with no exception" do
+        expect(browser.at_xpath("//*[@id='form_title']").selected.map(&:text)).to eq(["Mrs"])
+        expect(browser.at_xpath("//*[@id='form_title']").select(%w[Mrs SQL]).selected.map(&:text)).to eq(["Mrs"])
       end
+    end
 
-      context "when one of option with provided texts does not exist" do
-        it "picks only existed options with no exception" do
-          expect(browser.at_xpath("//*[@id='form_title']").selected.map(&:text)).to eq(["Mrs"])
-          expect(browser.at_xpath("//*[@id='form_title']").select(%w[Mrs SQL]).selected.map(&:text)).to eq(["Mrs"])
-        end
+    context "when select has multiple property" do
+      it "picks options in select by match arguments as array" do
+        expect(browser.at_xpath("//*[@id='form_languages']").select(%w[SQL Ruby]).selected.map(&:text))
+          .to eq(%w[Ruby SQL])
       end
 
-      context "when select has multiple property" do
-        it "picks options in select by match arguments as array" do
-          expect(browser.at_xpath("//*[@id='form_languages']").select(%w[SQL Ruby]).selected.map(&:text))
-            .to eq(%w[Ruby SQL])
-        end
-
-        it "picks options in select by match arguments as strings" do
-          expect(browser.at_xpath("//*[@id='form_languages']").select("SQL", "Ruby").selected.map(&:text))
-            .to eq(%w[Ruby SQL])
-        end
+      it "picks options in select by match arguments as strings" do
+        expect(browser.at_xpath("//*[@id='form_languages']").select("SQL", "Ruby").selected.map(&:text))
+          .to eq(%w[Ruby SQL])
       end
+    end
 
-      context "when selector is not <select>" do
-        it "raises JavaScriptError with proper message" do
-          expect { browser.at_xpath("//*[@id='customer_name']").select(anything) }
-            .to raise_exception(Ferrum::JavaScriptError, /Element is not a <select> element/)
-        end
+    context "when selector is not <select>" do
+      it "raises JavaScriptError with proper message" do
+        expect { browser.at_xpath("//*[@id='customer_name']").select(anything) }
+          .to raise_exception(Ferrum::JavaScriptError, /Element is not a <select> element/)
       end
+    end
 
-      context "when provided texts of disabled option" do
-        it "picks disabled option with no exception" do
-          expect(browser.at_xpath("//*[@id='form_title']").select(["Other"]).selected.map(&:text)).to eq(["Other"])
-        end
+    context "when provided texts of disabled option" do
+      it "picks disabled option with no exception" do
+        expect(browser.at_xpath("//*[@id='form_title']").select(["Other"]).selected.map(&:text)).to eq(["Other"])
       end
+    end
 
-      context "when option with text and value" do
-        it "picks option in select by matched text" do
-          expect(browser.at_xpath("//select[@id='form_locale']").select("Swedish", by: :text).selected.map(&:value))
-            .to eq(["sv"])
-        end
+    context "when option with text and value" do
+      it "picks option in select by matched text" do
+        expect(browser.at_xpath("//select[@id='form_locale']").select("Swedish", by: :text).selected.map(&:value))
+          .to eq(["sv"])
       end
+    end
 
-      context "when option with empty text/value" do
-        it "picks option in select by match string argument" do
-          expect(browser.at_xpath("//select[@id='empty_option']").select("AU").selected.map(&:value)).to eq(["AU"])
-        end
-
-        it "picks empty option by match empty value argument" do
-          expect(browser.at_xpath("//select[@id='empty_option']").select("").selected.map(&:value)).to eq([""])
-        end
+    context "when option with empty text/value" do
+      it "picks option in select by match string argument" do
+        expect(browser.at_xpath("//select[@id='empty_option']").select("AU").selected.map(&:value)).to eq(["AU"])
+      end
 
-        it "picks empty option by match empty text argument" do
-          expect(browser.at_xpath("//select[@id='empty_option']").select("", by: :text).selected.map(&:text))
-            .to eq([""])
-        end
+      it "picks empty option by match empty value argument" do
+        expect(browser.at_xpath("//select[@id='empty_option']").select("").selected.map(&:value)).to eq([""])
       end
 
-      it "picks option within frame" do
-        frame = browser.at_xpath("//iframe[@name='frame']").frame
-        expect(frame.at_xpath("//*[@id='select']").select("Two", by: :text).selected.map(&:text)).to eq(["Two"])
+      it "picks empty option by match empty text argument" do
+        expect(browser.at_xpath("//select[@id='empty_option']").select("", by: :text).selected.map(&:text))
+          .to eq([""])
       end
     end
 
-    describe "#[]" do
-      before do
-        browser.go_to("/ferrum/attributes_properties")
-      end
+    it "picks option within frame" do
+      frame = browser.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.at_xpath("//*[@id='select']").select("Two", by: :text).selected.map(&:text)).to eq(["Two"])
+    end
+  end
 
-      it "gets normalized href" do
-        expect(browser.at_xpath("//a[text() = 'Loop']").attribute("href"))
-          .to eq("/ferrum/attributes_properties")
-      end
+  describe "#[]" do
+    before do
+      browser.go_to("/ferrum/attributes_properties")
+    end
 
-      it "gets innerHTML" do
-        expect(browser.at_css(".some_other_class").property("innerHTML")).to eq "<p>foobar</p>"
-      end
+    it "gets normalized href" do
+      expect(browser.at_xpath("//a[text() = 'Loop']").attribute("href"))
+        .to eq("/ferrum/attributes_properties")
+    end
 
-      it "gets attribute" do
-        link = browser.at_xpath("//a[text() = 'Loop']")
-        expect(link.attribute("data-random")).to eq "42"
-        expect(link.attribute("onclick")).to eq "return false;"
-      end
+    it "gets innerHTML" do
+      expect(browser.at_css(".some_other_class").property("innerHTML")).to eq "<p>foobar</p>"
+    end
 
-      it "gets boolean attributes as booleans" do
-        expect(browser.at_css("input#checked").property("checked")).to be true
-        expect(browser.at_css("input#unchecked").property("checked")).to be false
-      end
+    it "gets attribute" do
+      link = browser.at_xpath("//a[text() = 'Loop']")
+      expect(link.attribute("data-random")).to eq "42"
+      expect(link.attribute("onclick")).to eq "return false;"
     end
 
-    describe "#==" do
-      it "does not equal a node from another page" do
-        browser.go_to("/ferrum/simple")
-        el1 = browser.at_css("#nav")
-        browser.go_to("/ferrum/set")
-        el2 = browser.at_css("#filled_div")
-        expect(el2 == el1).to be_falsey
-        expect(el1 == el2).to be_falsey
-      end
+    it "gets boolean attributes as booleans" do
+      expect(browser.at_css("input#checked").property("checked")).to be true
+      expect(browser.at_css("input#unchecked").property("checked")).to be false
     end
+  end
 
-    describe "#focusable?" do
-      before do
-        browser.go_to("/ferrum/form")
-      end
+  describe "#==" do
+    it "does not equal a node from another page" do
+      browser.go_to("/ferrum/simple")
+      el1 = browser.at_css("#nav")
+      browser.go_to("/ferrum/set")
+      el2 = browser.at_css("#filled_div")
+      expect(el2 == el1).to be_falsey
+      expect(el1 == el2).to be_falsey
+    end
+  end
 
-      context "with hidden input" do
-        it { expect(browser.at_css("#hidden_input").focusable?).to eq(false) }
-      end
+  describe "#focusable?" do
+    before do
+      browser.go_to("/ferrum/form")
+    end
 
-      context "with regular input" do
-        it { expect(browser.at_css("#form_name").focusable?).to eq(true) }
-      end
+    context "with hidden input" do
+      it { expect(browser.at_css("#hidden_input").focusable?).to eq(false) }
     end
 
-    describe "#computed_style" do
-      before do
-        browser.go_to("/ferrum/computed_style")
-      end
+    context "with regular input" do
+      it { expect(browser.at_css("#form_name").focusable?).to eq(true) }
+    end
+  end
 
-      it "returns the computed styles for the node" do
-        styles = browser.at_css("#test_node").computed_style
+  describe "#computed_style" do
+    before do
+      browser.go_to("/ferrum/computed_style")
+    end
 
-        expect(styles["color"]).to eq("rgb(255, 0, 0)")
-        expect(styles["font-weight"]).to eq("700")
-      end
+    it "returns the computed styles for the node" do
+      styles = browser.at_css("#test_node").computed_style
+
+      expect(styles["color"]).to eq("rgb(255, 0, 0)")
+      expect(styles["font-weight"]).to eq("700")
     end
+  end
 
-    context "whitespace stripping tests", skip: true do
-      before do
-        browser.go_to("/ferrum/filter_text_test")
-      end
+  context "whitespace stripping tests", skip: true do
+    before do
+      browser.go_to("/ferrum/filter_text_test")
+    end
 
-      it "gets text" do
-        expect(browser.at_css("#foo").text).to eq "foo"
-      end
+    it "gets text" do
+      expect(browser.at_css("#foo").text).to eq "foo"
+    end
 
-      it "gets text stripped whitespace" do
-        expect(browser.at_css("#bar").inner_text).to eq "bar"
-      end
+    it "gets text stripped whitespace" do
+      expect(browser.at_css("#bar").inner_text).to eq "bar"
+    end
 
-      it "gets text stripped whitespace and then converts nbsp to space" do
-        expect(browser.at_css("#baz").inner_text).to eq " baz    "
-      end
+    it "gets text stripped whitespace and then converts nbsp to space" do
+      expect(browser.at_css("#baz").inner_text).to eq " baz    "
+    end
 
-      it "gets text stripped whitespace" do
-        expect(browser.at_css("#qux").text).to eq "  \u3000 qux \u3000  "
-      end
+    it "gets text stripped whitespace" do
+      expect(browser.at_css("#qux").text).to eq "  \u3000 qux \u3000  "
     end
+  end
 
-    describe "#property" do
-      before do
-        browser.go_to("/ferrum/attributes_properties")
-      end
+  describe "#property" do
+    before do
+      browser.go_to("/ferrum/attributes_properties")
+    end
 
-      it "gets property innerHTML" do
-        expect(browser.at_css(".some_other_class").property("innerHTML")).to eq "<p>foobar</p>"
-      end
+    it "gets property innerHTML" do
+      expect(browser.at_css(".some_other_class").property("innerHTML")).to eq "<p>foobar</p>"
+    end
 
-      it "gets property outerHTML" do
-        el = browser.at_css(".some_other_class")
-        expect(el.property("outerHTML"))
-          .to eq %(<div class="some_other_class"><p>foobar</p></div>)
-      end
+    it "gets property outerHTML" do
+      el = browser.at_css(".some_other_class")
+      expect(el.property("outerHTML"))
+        .to eq %(<div class="some_other_class"><p>foobar</p></div>)
+    end
 
-      it "gets non existent property" do
-        el = browser.at_css(".some_other_class")
-        expect(el.property("does_not_exist")).to eq nil
-      end
+    it "gets non existent property" do
+      el = browser.at_css(".some_other_class")
+      expect(el.property("does_not_exist")).to eq nil
     end
+  end
 
-    describe "#text" do
-      it "skips BR" do
-        browser.go_to("/ferrum/simple")
-        el = browser.at_css("#break")
+  describe "#text" do
+    it "skips BR" do
+      browser.go_to("/ferrum/simple")
+      el = browser.at_css("#break")
 
-        expect(el.text).to eq("FooBar")
-      end
+      expect(el.text).to eq("FooBar")
+    end
 
-      context "SVG tests" do
-        before do
-          browser.go_to("/ferrum/svg_test")
-        end
+    context "SVG tests" do
+      before do
+        browser.go_to("/ferrum/svg_test")
+      end
 
-        it "gets text from tspan node" do
-          expect(browser.at_css("tspan").text).to eq("svg foo")
-        end
+      it "gets text from tspan node" do
+        expect(browser.at_css("tspan").text).to eq("svg foo")
       end
     end
+  end
 
-    describe "#inner_text" do
-      it "returns BR as new line" do
-        browser.go_to("/ferrum/simple")
-        el = browser.at_css("#break")
+  describe "#inner_text" do
+    it "returns BR as new line" do
+      browser.go_to("/ferrum/simple")
+      el = browser.at_css("#break")
 
-        expect(el.inner_text).to eq("Foo\nBar")
-      end
+      expect(el.inner_text).to eq("Foo\nBar")
     end
+  end
 
-    describe "#type" do
-      let(:empty_input) { browser.at_css("#empty_input") }
+  describe "#type" do
+    let(:empty_input) { browser.at_css("#empty_input") }
 
-      context "with mixed input" do
-        before { browser.go_to("/ferrum/type") }
+    context "with mixed input" do
+      before { browser.go_to("/ferrum/type") }
 
-        it "sends keys to empty input" do
-          empty_input.focus.type("Input")
+      it "sends keys to empty input" do
+        empty_input.focus.type("Input")
 
-          expect(empty_input.value).to eq("Input")
-        end
+        expect(empty_input.value).to eq("Input")
+      end
 
-        it "sends keys to filled input" do
-          input = browser.at_css("#filled_input")
+      it "sends keys to filled input" do
+        input = browser.at_css("#filled_input")
 
-          input.click.type(" appended")
+        input.click.type(" appended")
 
-          expect(input.value).to eq("Text appended")
-        end
+        expect(input.value).to eq("Text appended")
+      end
 
-        it "sends keys to empty textarea" do
-          input = browser.at_css("#empty_textarea")
+      it "sends keys to empty textarea" do
+        input = browser.at_css("#empty_textarea")
 
-          input.focus.type("Input")
+        input.focus.type("Input")
 
-          expect(input.value).to eq("Input")
-        end
+        expect(input.value).to eq("Input")
+      end
 
-        it "sends keys to filled textarea" do
-          input = browser.at_css("#filled_textarea")
+      it "sends keys to filled textarea" do
+        input = browser.at_css("#filled_textarea")
 
-          input.click.type(" appended")
+        input.click.type(" appended")
 
-          expect(input.value).to eq("Description appended")
-        end
+        expect(input.value).to eq("Description appended")
+      end
 
-        it "persists focus across multiple calls" do
-          input = browser.at_css("#empty_div")
+      it "persists focus across multiple calls" do
+        input = browser.at_css("#empty_div")
 
-          input.focus.type("helo").type(:Left).type("l")
+        input.focus.type("helo").type(:Left).type("l")
 
-          expect(input.text).to eq("hello")
-        end
+        expect(input.text).to eq("hello")
+      end
 
-        it "sends sequences" do
-          empty_input.focus.type([:Shift], "S", [:Alt], "t", "r", "i", "g", :Left, "n")
+      it "sends sequences" do
+        empty_input.focus.type([:Shift], "S", [:Alt], "t", "r", "i", "g", :Left, "n")
 
-          expect(empty_input.value).to eq("String")
-        end
+        expect(empty_input.value).to eq("String")
+      end
 
-        it "submits the form with sequence" do
-          input = browser.at_css("#without_submit_button input")
+      it "submits the form with sequence" do
+        input = browser.at_css("#without_submit_button input")
 
-          input.focus.type(:Enter)
+        input.focus.type(:Enter)
 
-          expect(input.value).to eq("Submitted")
-        end
+        expect(input.value).to eq("Submitted")
+      end
 
-        it "sends sequences with modifiers and letters" do
-          empty_input.focus.type([:Shift, "s"], "t", "r", "i", "n", "g")
+      it "sends sequences with modifiers and letters" do
+        empty_input.focus.type([:Shift, "s"], "t", "r", "i", "n", "g")
 
-          expect(empty_input.value).to eq("String")
-        end
+        expect(empty_input.value).to eq("String")
+      end
 
-        it "moves cursor in front and types char" do
-          keys = Utils::Platform.mac? ? %i[Alt Left] : %i[Ctrl Left]
+      it "moves cursor in front and types char" do
+        keys = Ferrum::Utils::Platform.mac? ? %i[Alt Left] : %i[Ctrl Left]
 
-          empty_input.focus.type("t", "r", "i", "n", "g", keys, "s")
+        empty_input.focus.type("t", "r", "i", "n", "g", keys, "s")
 
-          expect(empty_input.value).to eq("string")
-        end
+        expect(empty_input.value).to eq("string")
+      end
 
-        it "selects text and replaces with char" do
-          keys = Utils::Platform.mac? ? %i[Alt Shift Left] : %i[Ctrl Shift Left]
+      it "selects text and replaces with char" do
+        keys = Ferrum::Utils::Platform.mac? ? %i[Alt Shift Left] : %i[Ctrl Shift Left]
 
-          empty_input.focus.type("t", "r", "i", "n", "g", keys, "s")
+        empty_input.focus.type("t", "r", "i", "n", "g", keys, "s")
 
-          expect(empty_input.value).to eq("s")
-        end
+        expect(empty_input.value).to eq("s")
+      end
 
-        it "sends modifiers with sequences" do
-          empty_input.focus.type("s", [:Shift, "tring"])
+      it "sends modifiers with sequences" do
+        empty_input.focus.type("s", [:Shift, "tring"])
 
-          expect(empty_input.value).to eq("sTRING")
-        end
+        expect(empty_input.value).to eq("sTRING")
+      end
 
-        it "sends modifiers with multiple keys" do
-          empty_input.focus.type("helo", %i[Shift Left Left], "llo")
+      it "sends modifiers with multiple keys" do
+        empty_input.focus.type("helo", %i[Shift Left Left], "llo")
 
-          expect(empty_input.value).to eq("hello")
-        end
+        expect(empty_input.value).to eq("hello")
+      end
 
-        it "raises error for unknown keys" do
-          expect do
-            empty_input.focus.type("abc", :blah)
-          end.to raise_error(KeyError, "key not found: :blah")
-        end
+      it "raises error for unknown keys" do
+        expect do
+          empty_input.focus.type("abc", :blah)
+        end.to raise_error(KeyError, "key not found: :blah")
+      end
 
-        it "sets a date fields" do
-          browser.go_to("/ferrum/date_fields")
-          input = browser.at_css("#date_field")
+      it "sets a date fields" do
+        browser.go_to("/ferrum/date_fields")
+        input = browser.at_css("#date_field")
 
-          input.focus.type("02-02-2016")
+        input.focus.type("02-02-2016")
 
-          expect(input.value).to eq("2016-02-02")
-        end
+        expect(input.value).to eq("2016-02-02")
+      end
 
-        it "accepts numbers in a maxlength field" do
-          browser.go_to("/ferrum/with_js")
-          element = browser.at_css("#change_me_maxlength")
+      it "accepts numbers in a maxlength field" do
+        browser.go_to("/ferrum/with_js")
+        element = browser.at_css("#change_me_maxlength")
 
-          element.focus.type("100")
+        element.focus.type("100")
 
-          expect(element.value).to eq("100")
-        end
+        expect(element.value).to eq("100")
+      end
 
-        it "accepts negatives in a number field" do
-          browser.go_to("/ferrum/with_js")
-          element = browser.at_css("#change_me_number")
+      it "accepts negatives in a number field" do
+        browser.go_to("/ferrum/with_js")
+        element = browser.at_css("#change_me_number")
 
-          element.focus.type("-100")
+        element.focus.type("-100")
 
-          expect(element.value).to eq("-100")
-        end
+        expect(element.value).to eq("-100")
       end
+    end
 
-      context "with contenteditable" do
-        let(:delete_all) { [[(Utils::Platform.mac? ? :alt : :ctrl), :shift, :right], :backspace] }
+    context "with contenteditable" do
+      let(:delete_all) { [[(Ferrum::Utils::Platform.mac? ? :alt : :ctrl), :shift, :right], :backspace] }
 
-        before { browser.go_to("/ferrum/type") }
+      before { browser.go_to("/ferrum/type") }
 
-        it "sends keys to empty div" do
-          input = browser.at_css("#empty_div")
+      it "sends keys to empty div" do
+        input = browser.at_css("#empty_div")
 
-          input.click.type("Input")
+        input.click.type("Input")
 
-          expect(input.text).to eq("Input")
-        end
+        expect(input.text).to eq("Input")
+      end
 
-        it "sends keys to filled div" do
-          input = browser.at_css("#filled_div")
+      it "sends keys to filled div" do
+        input = browser.at_css("#filled_div")
 
-          input.click.type(" appended")
+        input.click.type(" appended")
 
-          expect(input.text).to eq("Content appended")
-        end
+        expect(input.text).to eq("Content appended")
+      end
 
-        it "sets content" do
-          input = browser.at_css("#filled_div")
+      it "sets content" do
+        input = browser.at_css("#filled_div")
 
-          input.focus.type(delete_all, "new text")
+        input.focus.type(delete_all, "new text")
 
-          expect(input.text).to eq("new text")
-        end
+        expect(input.text).to eq("new text")
+      end
 
-        it "sets multiple inputs" do
-          input = browser.at_css("#empty_div")
-          input.focus.type("new text")
-          expect(input.text).to eq("new text")
+      it "sets multiple inputs" do
+        input = browser.at_css("#empty_div")
+        input.focus.type("new text")
+        expect(input.text).to eq("new text")
 
-          input = browser.at_css("#filled_div")
-          input.focus.type(delete_all, "replacement text")
-          expect(input.text).to eq("replacement text")
-        end
+        input = browser.at_css("#filled_div")
+        input.focus.type(delete_all, "replacement text")
+        expect(input.text).to eq("replacement text")
+      end
 
-        it "sets children content" do
-          browser.go_to("/orig_with_js")
-          input = browser.at_css("#existing_content_editable_child")
+      it "sets children content" do
+        browser.go_to("/orig_with_js")
+        input = browser.at_css("#existing_content_editable_child")
 
-          input.click.type(" WYSIWYG")
+        input.click.type(" WYSIWYG")
 
-          expect(input.text).to eq("Content WYSIWYG")
-        end
+        expect(input.text).to eq("Content WYSIWYG")
       end
+    end
 
-      context "with correct key codes" do
-        let(:events_output) { browser.at_css("#key-events-output") }
+    context "with correct key codes" do
+      let(:events_output) { browser.at_css("#key-events-output") }
 
-        before { browser.go_to("/ferrum/type") }
+      before { browser.go_to("/ferrum/type") }
 
-        it "generates correct events with key codes for modified punctuation" do
-          empty_input.focus.type([:shift, "."], [:shift, "t"])
+      it "generates correct events with key codes for modified punctuation" do
+        empty_input.focus.type([:shift, "."], [:shift, "t"])
 
-          expect(events_output.text.strip).to eq("keydown:16 keydown:190 keydown:16 keydown:84")
-        end
+        expect(events_output.text.strip).to eq("keydown:16 keydown:190 keydown:16 keydown:84")
+      end
 
-        it "supports snake case specified keys" do
-          empty_input.focus.type(:PageUp, :page_up)
+      it "supports snake case specified keys" do
+        empty_input.focus.type(:PageUp, :page_up)
 
-          expect(events_output.text.strip).to eq("keydown:33 keydown:33")
-        end
+        expect(events_output.text.strip).to eq("keydown:33 keydown:33")
+      end
 
-        it "supports :control alias for :Ctrl" do
-          empty_input.focus.type([:Ctrl, "a"], [:control, "a"])
+      it "supports :control alias for :Ctrl" do
+        empty_input.focus.type([:Ctrl, "a"], [:control, "a"])
 
-          expect(events_output.text.strip).to eq("keydown:17 keydown:65 keydown:17 keydown:65")
-        end
+        expect(events_output.text.strip).to eq("keydown:17 keydown:65 keydown:17 keydown:65")
+      end
 
-        it "supports :command alias for :Meta" do
-          empty_input.focus.type([:Meta, "z"], [:command, "z"])
+      it "supports :command alias for :Meta" do
+        empty_input.focus.type([:Meta, "z"], [:command, "z"])
 
-          expect(events_output.text.strip).to eq("keydown:91 keydown:90 keydown:91 keydown:90")
-        end
+        expect(events_output.text.strip).to eq("keydown:91 keydown:90 keydown:91 keydown:90")
+      end
 
-        it "supports specified numpad keys" do
-          empty_input.focus.type(:numpad2, :numpad8, :divide, :decimal)
+      it "supports specified numpad keys" do
+        empty_input.focus.type(:numpad2, :numpad8, :divide, :decimal)
 
-          expect(events_output.text.strip).to eq("keydown:98 keydown:104 keydown:111 keydown:110")
-        end
+        expect(events_output.text.strip).to eq("keydown:98 keydown:104 keydown:111 keydown:110")
       end
+    end
 
-      context "with correct changes" do
-        let(:change_me) { browser.at_css("#change_me") }
+    context "with correct changes" do
+      let(:change_me) { browser.at_css("#change_me") }
 
-        before do
-          browser.go_to("/ferrum/with_js")
-          change_me.focus.type("Hello!")
-        end
+      before do
+        browser.go_to("/ferrum/with_js")
+        change_me.focus.type("Hello!")
+      end
 
-        it "fires the change event", skip: true do
-          expect(browser.at_css("#changes").text).to eq("Hello!")
-        end
+      it "fires the change event", skip: true do
+        expect(browser.at_css("#changes").text).to eq("Hello!")
+      end
 
-        it "fires the input event" do
-          expect(browser.at_css("#changes_on_input").text).to eq("Hello!")
-        end
+      it "fires the input event" do
+        expect(browser.at_css("#changes_on_input").text).to eq("Hello!")
+      end
 
-        it "fires the keydown event" do
-          expect(browser.at_css("#changes_on_keydown").text).to eq("6")
-        end
+      it "fires the keydown event" do
+        expect(browser.at_css("#changes_on_keydown").text).to eq("6")
+      end
 
-        it "fires the keyup event" do
-          expect(browser.at_css("#changes_on_keyup").text).to eq("6")
-        end
+      it "fires the keyup event" do
+        expect(browser.at_css("#changes_on_keyup").text).to eq("6")
+      end
 
-        it "fires the keypress event" do
-          expect(browser.at_css("#changes_on_keypress").text).to eq("6")
-        end
+      it "fires the keypress event" do
+        expect(browser.at_css("#changes_on_keypress").text).to eq("6")
+      end
 
-        it "fires the focus event" do
-          expect(browser.at_css("#changes_on_focus").text).to eq("Focus")
-        end
+      it "fires the focus event" do
+        expect(browser.at_css("#changes_on_focus").text).to eq("Focus")
+      end
 
-        it "fires the blur event" do
-          change_me.blur
+      it "fires the blur event" do
+        change_me.blur
 
-          expect(browser.at_css("#changes_on_blur").text).to eq("Blur")
-        end
+        expect(browser.at_css("#changes_on_blur").text).to eq("Blur")
+      end
 
-        it "fires the keydown event before the value is updated" do
-          expect(browser.at_css("#value_on_keydown").text).to eq("Hello")
-        end
+      it "fires the keydown event before the value is updated" do
+        expect(browser.at_css("#value_on_keydown").text).to eq("Hello")
+      end
 
-        it "fires the keyup event after the value is updated" do
-          expect(browser.at_css("#value_on_keyup").text).to eq("Hello!")
-        end
+      it "fires the keyup event after the value is updated" do
+        expect(browser.at_css("#value_on_keyup").text).to eq("Hello!")
+      end
 
-        it "clears the input" do
-          keys = Utils::Platform.mac? ? %i[Alt Shift Left] : %i[Ctrl Shift Left]
-          change_me.type(2.times.map { keys }, :backspace)
+      it "clears the input" do
+        keys = Ferrum::Utils::Platform.mac? ? %i[Alt Shift Left] : %i[Ctrl Shift Left]
+        change_me.type(2.times.map { keys }, :backspace)
 
-          expect(change_me.value).to eq("")
-        end
+        expect(change_me.value).to eq("")
+      end
 
-        it "supports special characters" do
-          change_me.type("$52.00")
+      it "supports special characters" do
+        change_me.type("$52.00")
 
-          expect(change_me.value).to eq("Hello!$52.00")
-        end
+        expect(change_me.value).to eq("Hello!$52.00")
       end
+    end
 
-      context "with correct events" do
-        let(:input) { browser.at_css("#input") }
-        let(:output) { browser.at_css("#output") }
+    context "with correct events" do
+      let(:input) { browser.at_css("#input") }
+      let(:output) { browser.at_css("#output") }
 
-        before { browser.go_to("/ferrum/input_events") }
+      before { browser.go_to("/ferrum/input_events") }
 
-        it "calls event handlers in the correct order" do
-          input.focus.type("a").blur
+      it "calls event handlers in the correct order" do
+        input.focus.type("a").blur
 
-          expect(output.text.strip).to eq("keydown keypress input keyup change")
-          expect(input.value).to eq("a")
-        end
+        expect(output.text.strip).to eq("keydown keypress input keyup change")
+        expect(input.value).to eq("a")
+      end
 
-        it "respects preventDefault() calls in keydown handlers" do
-          browser.execute "input.addEventListener('keydown', e => e.preventDefault())"
-          input.focus.type("a")
-          expect(output.text.strip).to eq("keydown keyup")
-          expect(input.value).to be_empty
-        end
+      it "respects preventDefault() calls in keydown handlers" do
+        browser.execute "input.addEventListener('keydown', e => e.preventDefault())"
+        input.focus.type("a")
+        expect(output.text.strip).to eq("keydown keyup")
+        expect(input.value).to be_empty
+      end
 
-        it "respects preventDefault() calls in keypress handlers" do
-          browser.execute "input.addEventListener('keypress', e => e.preventDefault())"
-          input.focus.type("a")
-          expect(output.text.strip).to eq("keydown keypress keyup")
-          expect(input.value).to be_empty
-        end
+      it "respects preventDefault() calls in keypress handlers" do
+        browser.execute "input.addEventListener('keypress', e => e.preventDefault())"
+        input.focus.type("a")
+        expect(output.text.strip).to eq("keydown keypress keyup")
+        expect(input.value).to be_empty
+      end
 
-        it "calls event handlers for each character input" do
-          input.focus.type("abc").blur
-          expect(output.text.strip).to eq("#{(['keydown keypress input keyup'] * 3).join(' ')} change")
-          expect(input.value).to eq("abc")
-        end
+      it "calls event handlers for each character input" do
+        input.focus.type("abc").blur
+        expect(output.text.strip).to eq("#{(['keydown keypress input keyup'] * 3).join(' ')} change")
+        expect(input.value).to eq("abc")
+      end
 
-        it "doesn't call the change event if there is no change" do
-          input.focus.type("a").blur
-          input.focus.type("a")
+      it "doesn't call the change event if there is no change" do
+        input.focus.type("a").blur
+        input.focus.type("a")
 
-          expect(output.text.strip).to eq("keydown keypress input keyup change keydown keypress input keyup")
-        end
+        expect(output.text.strip).to eq("keydown keypress input keyup change keydown keypress input keyup")
       end
     end
+  end
 
-    describe "#attach_file", skip: true do
-      it "handles obsolete node" do
-        browser.go_to("/ferrum/attach_file")
-        browser.attach_file "file", __FILE__
-      end
+  describe "#attach_file", skip: true do
+    it "handles obsolete node" do
+      browser.go_to("/ferrum/attach_file")
+      browser.attach_file "file", __FILE__
+    end
 
-      it "attaches a file when passed a Pathname" do
-        filename = Pathname.new("spec/tmp/a_test_pathname").expand_path
-        File.write(filename, "text")
+    it "attaches a file when passed a Pathname" do
+      filename = Pathname.new("spec/tmp/a_test_pathname").expand_path
+      File.write(filename, "text")
 
-        element = browser.at_css("#change_me_file")
-        element.set(filename)
-        expect(element.value).to eq("C:\\fakepath\\a_test_pathname")
-      ensure
-        FileUtils.rm_f(filename)
-      end
+      element = browser.at_css("#change_me_file")
+      element.set(filename)
+      expect(element.value).to eq("C:\\fakepath\\a_test_pathname")
+    ensure
+      FileUtils.rm_f(filename)
     end
+  end
 
-    describe "#drag_to", skip: true do
-      before { browser.go_to("/ferrum/drag") }
+  describe "#drag_to", skip: true do
+    before { browser.go_to("/ferrum/drag") }
 
-      it "supports drag_to" do
-        draggable = browser.at_css("#drag_to #draggable")
-        droppable = browser.at_css("#drag_to #droppable")
+    it "supports drag_to" do
+      draggable = browser.at_css("#drag_to #draggable")
+      droppable = browser.at_css("#drag_to #droppable")
 
-        draggable.drag_to(droppable)
-        expect(droppable).to have_content("Dropped")
-      end
+      draggable.drag_to(droppable)
+      expect(droppable).to have_content("Dropped")
+    end
 
-      it "supports drag_by on native element" do
-        draggable = browser.at_css("#drag_by .draggable")
+    it "supports drag_by on native element" do
+      draggable = browser.at_css("#drag_by .draggable")
 
-        top_before = browser.evaluate(%($("#drag_by .draggable").position().top))
-        left_before = browser.evaluate(%($("#drag_by .draggable").position().left))
+      top_before = browser.evaluate(%($("#drag_by .draggable").position().top))
+      left_before = browser.evaluate(%($("#drag_by .draggable").position().left))
 
-        draggable.native.drag_by(15, 15)
+      draggable.native.drag_by(15, 15)
 
-        top_after = browser.evaluate(%($("#drag_by .draggable").position().top))
-        left_after = browser.evaluate(%($("#drag_by .draggable").position().left))
+      top_after = browser.evaluate(%($("#drag_by .draggable").position().top))
+      left_after = browser.evaluate(%($("#drag_by .draggable").position().left))
 
-        expect(top_after).to eq(top_before + 15)
-        expect(left_after).to eq(left_before + 15)
-      end
+      expect(top_after).to eq(top_before + 15)
+      expect(left_after).to eq(left_before + 15)
     end
+  end
 
-    context "with disappearing node" do
-      it "raises an error if the element was on a previous page" do
-        browser.go_to("/ferrum/index")
-        node = browser.at_xpath(".//a")
+  context "with disappearing node" do
+    it "raises an error if the element was on a previous page" do
+      browser.go_to("/ferrum/index")
+      node = browser.at_xpath(".//a")
 
-        browser.execute "window.location = 'about:blank'"
+      browser.execute "window.location = 'about:blank'"
 
-        expect { node.text }.to raise_error(Ferrum::NodeNotFoundError)
-      end
+      expect { node.text }.to raise_error(Ferrum::NodeNotFoundError)
     end
   end
 end
diff --git a/spec/page/animation_spec.rb b/spec/page/animation_spec.rb
index e944414e..0e3cd1e9 100644
--- a/spec/page/animation_spec.rb
+++ b/spec/page/animation_spec.rb
@@ -1,25 +1,21 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Page
-    describe Animation do
-      describe "#playback_rate" do
-        it "gets default playback rate" do
-          browser.go_to("/animation")
+describe Ferrum::Page::Animation do
+  describe "#playback_rate" do
+    it "gets default playback rate" do
+      browser.go_to("/animation")
 
-          expect(browser.playback_rate).to eq(1)
-        end
-      end
+      expect(browser.playback_rate).to eq(1)
+    end
+  end
 
-      describe "#playback_rate=" do
-        it "sets playback rate" do
-          browser.playback_rate = 2000
+  describe "#playback_rate=" do
+    it "sets playback rate" do
+      browser.playback_rate = 2000
 
-          browser.go_to("/animation")
+      browser.go_to("/animation")
 
-          expect(browser.playback_rate).to eq(2000)
-        end
-      end
+      expect(browser.playback_rate).to eq(2000)
     end
   end
 end
diff --git a/spec/page/screenshot_spec.rb b/spec/page/screenshot_spec.rb
index 5190e133..683bcdeb 100644
--- a/spec/page/screenshot_spec.rb
+++ b/spec/page/screenshot_spec.rb
@@ -5,405 +5,401 @@
 require "chunky_png"
 require "ferrum/rgba"
 
-module Ferrum
-  class Page
-    describe Screenshot do
-      shared_examples "screenshot screen" do
-        it "supports screenshotting the whole of a page that goes outside the viewport" do
-          browser.go_to("/ferrum/long_page")
-
-          create_screenshot(path: file)
-
-          File.open(file, "rb") do |f|
-            expect(ImageSize.new(f.read).size).to eq(browser.viewport_size)
-          end
-
-          create_screenshot(path: file, full: true)
-
-          File.open(file, "rb") do |f|
-            expect(ImageSize.new(f.read).size).to eq(
-              browser.evaluate("[document.documentElement.clientWidth, document.documentElement.clientHeight]")
-            )
-          end
-        end
-
-        it "supports screenshotting the entire window when documentElement has no height" do
-          browser.go_to("/ferrum/fixed_positioning")
+describe Ferrum::Page::Screenshot do
+  shared_examples "screenshot screen" do
+    it "supports screenshotting the whole of a page that goes outside the viewport" do
+      browser.go_to("/ferrum/long_page")
 
-          create_screenshot(path: file, full: true)
+      create_screenshot(path: file)
 
-          File.open(file, "rb") do |f|
-            expect(ImageSize.new(f.read).size).to eq(browser.viewport_size)
-          end
-        end
+      File.open(file, "rb") do |f|
+        expect(ImageSize.new(f.read).size).to eq(browser.viewport_size)
+      end
 
-        it "supports screenshotting just the selected element" do
-          browser.go_to("/ferrum/long_page")
-
-          create_screenshot(path: file, selector: "#penultimate")
-
-          File.open(file, "rb") do |f|
-            size = browser.evaluate <<-JS
-              function() {
-                var ele  = document.getElementById("penultimate");
-                var rect = ele.getBoundingClientRect();
-                return [rect.width, rect.height];
-              }();
-            JS
-            expect(ImageSize.new(f.read).size).to eq(size)
-          end
-        end
+      create_screenshot(path: file, full: true)
 
-        it "ignores :selector in #save_screenshot if full: true" do
-          browser.go_to("/ferrum/long_page")
-          expect(browser.page).to receive(:warn).with(/Ignoring :selector/)
+      File.open(file, "rb") do |f|
+        expect(ImageSize.new(f.read).size).to eq(
+          browser.evaluate("[document.documentElement.clientWidth, document.documentElement.clientHeight]")
+        )
+      end
+    end
 
-          create_screenshot(path: file, full: true, selector: "#penultimate")
+    it "supports screenshotting the entire window when documentElement has no height" do
+      browser.go_to("/ferrum/fixed_positioning")
 
-          File.open(file, "rb") do |f|
-            expect(ImageSize.new(f.read).size).to eq(
-              browser.evaluate("[document.documentElement.clientWidth, document.documentElement.clientHeight]")
-            )
-          end
-        end
+      create_screenshot(path: file, full: true)
 
-        it "resets element positions after" do
-          browser.go_to("ferrum/long_page")
-          el = browser.at_css("#middleish")
-          # make the page scroll an element into view
-          el.click
-          position_script = "document.querySelector('#middleish').getBoundingClientRect()"
-          offset = browser.evaluate(position_script)
-          browser.screenshot(path: file)
-          expect(browser.evaluate(position_script)).to eq offset
-        end
+      File.open(file, "rb") do |f|
+        expect(ImageSize.new(f.read).size).to eq(browser.viewport_size)
       end
+    end
+
+    it "supports screenshotting just the selected element" do
+      browser.go_to("/ferrum/long_page")
 
-      shared_examples "when scale is set" do
-        it "changes image dimensions" do
-          browser.go_to("/ferrum/zoom_test")
+      create_screenshot(path: file, selector: "#penultimate")
 
-          black_pixels_count = lambda { |file|
-            img = ChunkyPNG::Image.from_file(file)
-            img.pixels.inject(0) { |i, p| p > 255 ? i + 1 : i }
-          }
+      File.open(file, "rb") do |f|
+        size = browser.evaluate <<-JS
+          function() {
+            var ele  = document.getElementById("penultimate");
+            var rect = ele.getBoundingClientRect();
+            return [rect.width, rect.height];
+          }();
+        JS
+        expect(ImageSize.new(f.read).size).to eq(size)
+      end
+    end
 
-          browser.screenshot(path: file)
-          before = black_pixels_count[file]
+    it "ignores :selector in #save_screenshot if full: true" do
+      browser.go_to("/ferrum/long_page")
+      expect(browser.page).to receive(:warn).with(/Ignoring :selector/)
 
-          browser.screenshot(path: file, scale: scale)
-          after = black_pixels_count[file]
+      create_screenshot(path: file, full: true, selector: "#penultimate")
 
-          expect(after.to_f / before).to eq(scale**2)
-        end
+      File.open(file, "rb") do |f|
+        expect(ImageSize.new(f.read).size).to eq(
+          browser.evaluate("[document.documentElement.clientWidth, document.documentElement.clientHeight]")
+        )
       end
+    end
 
-      describe "#screenshot" do
-        let(:format) { :png }
-        let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
-
-        def create_screenshot(**options)
-          browser.screenshot(**options)
-        end
+    it "resets element positions after" do
+      browser.go_to("ferrum/long_page")
+      el = browser.at_css("#middleish")
+      # make the page scroll an element into view
+      el.click
+      position_script = "document.querySelector('#middleish').getBoundingClientRect()"
+      offset = browser.evaluate(position_script)
+      browser.screenshot(path: file)
+      expect(browser.evaluate(position_script)).to eq offset
+    end
+  end
 
-        after do
-          FileUtils.rm_f("#{PROJECT_ROOT}/spec/tmp/screenshot.png")
-        end
+  shared_examples "when scale is set" do
+    it "changes image dimensions" do
+      browser.go_to("/ferrum/zoom_test")
 
-        it "supports screenshotting the page" do
-          browser.go_to
+      black_pixels_count = lambda { |file|
+        img = ChunkyPNG::Image.from_file(file)
+        img.pixels.inject(0) { |i, p| p > 255 ? i + 1 : i }
+      }
 
-          browser.screenshot(path: file)
+      browser.screenshot(path: file)
+      before = black_pixels_count[file]
 
-          expect(File.exist?(file)).to be true
-        end
+      browser.screenshot(path: file, scale: scale)
+      after = black_pixels_count[file]
 
-        it "supports screenshotting the page with a non-string path" do
-          browser.go_to
+      expect(after.to_f / before).to eq(scale**2)
+    end
+  end
 
-          browser.screenshot(path: Pathname(file))
+  describe "#screenshot" do
+    let(:format) { :png }
+    let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
 
-          expect(File.exist?(file)).to be true
-        end
+    def create_screenshot(**options)
+      browser.screenshot(**options)
+    end
 
-        it "supports screenshotting the page to file without extension when format is specified" do
-          file = "#{PROJECT_ROOT}/spec/tmp/screenshot"
-          browser.go_to
+    after do
+      FileUtils.rm_f("#{PROJECT_ROOT}/spec/tmp/screenshot.png")
+    end
 
-          browser.screenshot(path: file, format: "jpg")
+    it "supports screenshotting the page" do
+      browser.go_to
 
-          expect(File.exist?(file)).to be true
-        ensure
-          FileUtils.rm_f(file)
-        end
+      browser.screenshot(path: file)
 
-        it "supports screenshotting the page with different quality settings" do
-          file2 = "#{PROJECT_ROOT}/spec/tmp/screenshot2.jpeg"
-          file3 = "#{PROJECT_ROOT}/spec/tmp/screenshot3.jpeg"
-          FileUtils.rm_f([file2, file3])
-
-          begin
-            browser.go_to
-            browser.screenshot(path: file, quality: 0) # ignored for png
-            browser.screenshot(path: file2) # defaults to a quality of 75
-            browser.screenshot(path: file3, quality: 100)
-            expect(File.size(file)).to be > File.size(file2) # png by defult is bigger
-            expect(File.size(file2)).to be < File.size(file3)
-          ensure
-            FileUtils.rm_f([file2, file3])
-          end
-        end
+      expect(File.exist?(file)).to be true
+    end
 
-        include_examples "screenshot screen"
+    it "supports screenshotting the page with a non-string path" do
+      browser.go_to
 
-        context "with fullscreen" do
-          it "supports screenshotting of fullscreen" do
-            browser.go_to("/ferrum/custom_html_size")
-            expect(browser.viewport_size).to eq([1024, 768])
+      browser.screenshot(path: Pathname(file))
 
-            browser.screenshot(path: file, full: true)
+      expect(File.exist?(file)).to be true
+    end
 
-            File.open(file, "rb") do |f|
-              expect(ImageSize.new(f.read).size).to eq([1280, 1024])
-            end
-            expect(browser.viewport_size).to eq([1024, 768])
-          end
+    it "supports screenshotting the page to file without extension when format is specified" do
+      file = "#{PROJECT_ROOT}/spec/tmp/screenshot"
+      browser.go_to
 
-          it "keeps current viewport" do
-            browser.go_to
-            browser.resize(width: 800, height: 200)
+      browser.screenshot(path: file, format: "jpg")
 
-            browser.screenshot(path: file, full: true)
+      expect(File.exist?(file)).to be true
+    ensure
+      FileUtils.rm_f(file)
+    end
 
-            expect(File.exist?(file)).to be(true)
-            expect(browser.viewport_size).to eq([800, 200])
-          end
+    it "supports screenshotting the page with different quality settings" do
+      file2 = "#{PROJECT_ROOT}/spec/tmp/screenshot2.jpeg"
+      file3 = "#{PROJECT_ROOT}/spec/tmp/screenshot3.jpeg"
+      FileUtils.rm_f([file2, file3])
+
+      begin
+        browser.go_to
+        browser.screenshot(path: file, quality: 0) # ignored for png
+        browser.screenshot(path: file2) # defaults to a quality of 75
+        browser.screenshot(path: file3, quality: 100)
+        expect(File.size(file)).to be > File.size(file2) # png by defult is bigger
+        expect(File.size(file2)).to be < File.size(file3)
+      ensure
+        FileUtils.rm_f([file2, file3])
+      end
+    end
 
-          it "resets to previous viewport when exception is raised" do
-            browser.go_to("/ferrum/custom_html_size")
-            browser.resize(width: 100, height: 100)
+    include_examples "screenshot screen"
 
-            allow(browser.page).to receive(:command).and_call_original
-            expect(browser.page).to receive(:command)
-              .with("Page.captureScreenshot",
-                    format: "png", clip: { x: 0, y: 0, width: 1280, height: 1024, scale: 1.0 })
-              .and_raise(StandardError)
-            expect { browser.screenshot(path: file, full: true) }
-              .to raise_exception(StandardError)
+    context "with fullscreen" do
+      it "supports screenshotting of fullscreen" do
+        browser.go_to("/ferrum/custom_html_size")
+        expect(browser.viewport_size).to eq([1024, 768])
 
-            # Fix Ruby 3 `and_call_original` bug
-            RSpec::Mocks.space.proxy_for(browser.page).reset
+        browser.screenshot(path: file, full: true)
 
-            expect(File.exist?(file)).not_to be
-            expect(browser.viewport_size).to eq([100, 100])
-          end
+        File.open(file, "rb") do |f|
+          expect(ImageSize.new(f.read).size).to eq([1280, 1024])
         end
+        expect(browser.viewport_size).to eq([1024, 768])
+      end
 
-        context "with :background_color option" do
-          it "supports screenshotting page with the specific background color" do
-            file = "#{PROJECT_ROOT}/spec/tmp/screenshot.jpeg"
-            browser.go_to
-            browser.screenshot(path: file)
-            content = File.read(file)
-            browser.screenshot(path: file, background_color: RGBA.new(0, 0, 0, 0.0))
-            content_with_specific_bc = File.read(file)
-            expect(content).not_to eq(content_with_specific_bc)
-          ensure
-            FileUtils.rm_f([file])
-          end
-
-          it "raises ArgumentError with proper message" do
-            browser.go_to
-            expect do
-              browser.screenshot(path: file, background_color: "#FFF")
-            end.to raise_exception(ArgumentError, "Accept Ferrum::RGBA class only")
-          end
-        end
+      it "keeps current viewport" do
+        browser.go_to
+        browser.resize(width: 800, height: 200)
 
-        context "zoom in" do
-          let(:scale) { 2 }
-          include_examples "when scale is set"
-        end
+        browser.screenshot(path: file, full: true)
 
-        context "zoom out" do
-          let(:scale) { 0.5 }
-          include_examples "when scale is set"
-        end
+        expect(File.exist?(file)).to be(true)
+        expect(browser.viewport_size).to eq([800, 200])
+      end
+
+      it "resets to previous viewport when exception is raised" do
+        browser.go_to("/ferrum/custom_html_size")
+        browser.resize(width: 100, height: 100)
 
-        context "when encoding is base64" do
-          let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
+        allow(browser.page).to receive(:command).and_call_original
+        expect(browser.page).to receive(:command)
+          .with("Page.captureScreenshot",
+                format: "png", clip: { x: 0, y: 0, width: 1280, height: 1024, scale: 1.0 })
+          .and_raise(StandardError)
+        expect { browser.screenshot(path: file, full: true) }
+          .to raise_exception(StandardError)
 
-          def create_screenshot(path:, **options)
-            image = browser.screenshot(format: format, encoding: :base64, **options)
-            File.binwrite(path, Base64.decode64(image))
-          end
+        # Fix Ruby 3 `and_call_original` bug
+        RSpec::Mocks.space.proxy_for(browser.page).reset
 
-          it "defaults to base64 when path isn't set" do
-            browser.go_to
+        expect(File.exist?(file)).not_to be
+        expect(browser.viewport_size).to eq([100, 100])
+      end
+    end
 
-            screenshot = browser.screenshot(format: format)
+    context "with :background_color option" do
+      it "supports screenshotting page with the specific background color" do
+        file = "#{PROJECT_ROOT}/spec/tmp/screenshot.jpeg"
+        browser.go_to
+        browser.screenshot(path: file)
+        content = File.read(file)
+        browser.screenshot(path: file, background_color: Ferrum::RGBA.new(0, 0, 0, 0.0))
+        content_with_specific_bc = File.read(file)
+        expect(content).not_to eq(content_with_specific_bc)
+      ensure
+        FileUtils.rm_f([file])
+      end
 
-            expect(screenshot.length).to be > 100
-          end
+      it "raises ArgumentError with proper message" do
+        browser.go_to
+        expect do
+          browser.screenshot(path: file, background_color: "#FFF")
+        end.to raise_exception(ArgumentError, "Accept Ferrum::RGBA class only")
+      end
+    end
 
-          it "supports screenshotting the page in base64" do
-            browser.go_to
+    context "zoom in" do
+      let(:scale) { 2 }
+      include_examples "when scale is set"
+    end
 
-            screenshot = browser.screenshot(encoding: :base64)
+    context "zoom out" do
+      let(:scale) { 0.5 }
+      include_examples "when scale is set"
+    end
 
-            expect(screenshot.length).to be > 100
-          end
+    context "when encoding is base64" do
+      let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
 
-          context "with png" do
-            let(:format) { :png }
-            after { FileUtils.rm_f(file) }
+      def create_screenshot(path:, **options)
+        image = browser.screenshot(format: format, encoding: :base64, **options)
+        File.binwrite(path, Base64.decode64(image))
+      end
 
-            include_examples "screenshot screen"
-          end
+      it "defaults to base64 when path isn't set" do
+        browser.go_to
 
-          context "with jpeg" do
-            let(:format) { :jpeg }
-            after { FileUtils.rm_f(file) }
+        screenshot = browser.screenshot(format: format)
 
-            include_examples "screenshot screen"
-          end
-        end
+        expect(screenshot.length).to be > 100
       end
 
-      describe "#pdf" do
-        let(:format) { :pdf }
-        let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
+      it "supports screenshotting the page in base64" do
+        browser.go_to
 
-        after do
-          FileUtils.rm_f("#{PROJECT_ROOT}/spec/tmp/screenshot.pdf")
-        end
+        screenshot = browser.screenshot(encoding: :base64)
 
-        context "when :paper_width and :paper_height are set" do
-          it "changes pdf size" do
-            browser.go_to("/ferrum/long_page")
+        expect(screenshot.length).to be > 100
+      end
 
-            browser.pdf(path: file, paper_width: 1.0, paper_height: 1.0)
+      context "with png" do
+        let(:format) { :png }
+        after { FileUtils.rm_f(file) }
 
-            reader = PDF::Reader.new(file)
-            reader.pages.each do |page|
-              bbox = page.attributes[:MediaBox]
-              width = (bbox[2] - bbox[0]) / 72
-              expect(width).to eq(1)
-            end
-          end
-        end
+        include_examples "screenshot screen"
+      end
 
-        context "when format is passed" do
-          it "changes pdf size to A0" do
-            browser.go_to("/ferrum/long_page")
-
-            browser.pdf(path: file, format: :A0)
-
-            reader = PDF::Reader.new(file)
-            reader.pages.each do |page|
-              bbox = page.attributes[:MediaBox]
-              width = (bbox[2] - bbox[0]) / 72
-              expect(width.round(2)).to eq(33.10)
-            end
-          end
-
-          it "specifying format and paperWidth will cause exception" do
-            browser.go_to("/ferrum/long_page")
-
-            expect do
-              browser.pdf(path: file, format: :A0, paper_width: 1.0)
-            end.to raise_error(ArgumentError)
-          end
-
-          it "convert case correct" do
-            browser.go_to("/ferrum/long_page")
-
-            allow(browser.page).to receive(:command).with("Page.printToPDF", hash_including(
-                                                                               displayHeaderFooter: false,
-                                                                               ignoreInvalidPageRanges: false,
-                                                                               landscape: false,
-                                                                               marginBottom: 0.4,
-                                                                               marginLeft: 0.4,
-                                                                               marginRight: 0.4,
-                                                                               marginTop: 0.4,
-                                                                               pageRanges: "",
-                                                                               paperHeight: 11,
-                                                                               paperWidth: 8.5,
-                                                                               path: file,
-                                                                               preferCSSPageSize: false,
-                                                                               printBackground: false,
-                                                                               scale: 1
-                                                                             )) { { "stream" => "1" } }
-
-            allow(browser.page).to receive(:command).with("IO.read", hash_including(handle: "1")) {
-              { "data" => "", "base64Encoded" => false, "eof" => true }
-            }
-
-            browser.pdf(path: file,
-                        landscape: false,
-                        display_header_footer: false,
-                        print_background: false,
-                        scale: 1,
-                        paper_width: 8.5,
-                        paper_height: 11,
-                        margin_top: 0.4,
-                        margin_bottom: 0.4,
-                        margin_left: 0.4,
-                        margin_right: 0.4,
-                        page_ranges: "",
-                        ignore_invalid_page_ranges: false,
-                        prefer_css_page_size: false)
-          end
-        end
+      context "with jpeg" do
+        let(:format) { :jpeg }
+        after { FileUtils.rm_f(file) }
+
+        include_examples "screenshot screen"
       end
+    end
+  end
 
-      describe "#mhtml" do
-        let(:format) { :mhtml }
-        let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
+  describe "#pdf" do
+    let(:format) { :pdf }
+    let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
 
-        after do
-          FileUtils.rm_f("#{PROJECT_ROOT}/spec/tmp/screenshot.mhtml")
-        end
+    after do
+      FileUtils.rm_f("#{PROJECT_ROOT}/spec/tmp/screenshot.pdf")
+    end
 
-        it "returns data" do
-          browser.go_to("/ferrum/simple")
+    context "when :paper_width and :paper_height are set" do
+      it "changes pdf size" do
+        browser.go_to("/ferrum/long_page")
 
-          data = browser.mhtml
+        browser.pdf(path: file, paper_width: 1.0, paper_height: 1.0)
 
-          expect(data).to match(%r{/ferrum/simple})
-          expect(data).to match(/mhtml.blink/)
-          expect(data).to match(/<!DOCTYPE html>/)
-          expect(data).to match(/Foo<br>Bar/)
+        reader = PDF::Reader.new(file)
+        reader.pages.each do |page|
+          bbox = page.attributes[:MediaBox]
+          width = (bbox[2] - bbox[0]) / 72
+          expect(width).to eq(1)
         end
+      end
+    end
 
-        it "saves a file" do
-          browser.go_to("/ferrum/simple")
+    context "when format is passed" do
+      it "changes pdf size to A0" do
+        browser.go_to("/ferrum/long_page")
 
-          browser.mhtml(path: file)
+        browser.pdf(path: file, format: :A0)
 
-          content = File.read(file)
-          expect(content).to match(%r{/ferrum/simple})
-          expect(content).to match(/mhtml.blink/)
-          expect(content).to match(/<!DOCTYPE html>/)
-          expect(content).to match(/Foo<br>Bar/)
+        reader = PDF::Reader.new(file)
+        reader.pages.each do |page|
+          bbox = page.attributes[:MediaBox]
+          width = (bbox[2] - bbox[0]) / 72
+          expect(width.round(2)).to eq(33.10)
         end
       end
 
-      describe "#viewport_size" do
-        it "has a size of 1024x768 by default" do
-          browser.go_to
+      it "specifying format and paperWidth will cause exception" do
+        browser.go_to("/ferrum/long_page")
 
-          expect(browser.viewport_size).to eq([1024, 768])
-        end
+        expect do
+          browser.pdf(path: file, format: :A0, paper_width: 1.0)
+        end.to raise_error(ArgumentError)
+      end
 
-        it "supports specifying viewport size with an option" do
-          browser = Browser.new(window_size: [800, 600])
-          browser.go_to(base_url)
-          expect(browser.viewport_size).to eq([800, 600])
-        ensure
-          browser&.quit
-        end
+      it "convert case correct" do
+        browser.go_to("/ferrum/long_page")
+
+        allow(browser.page).to receive(:command).with("Page.printToPDF", hash_including(
+                                                                           displayHeaderFooter: false,
+                                                                           ignoreInvalidPageRanges: false,
+                                                                           landscape: false,
+                                                                           marginBottom: 0.4,
+                                                                           marginLeft: 0.4,
+                                                                           marginRight: 0.4,
+                                                                           marginTop: 0.4,
+                                                                           pageRanges: "",
+                                                                           paperHeight: 11,
+                                                                           paperWidth: 8.5,
+                                                                           path: file,
+                                                                           preferCSSPageSize: false,
+                                                                           printBackground: false,
+                                                                           scale: 1
+                                                                         )) { { "stream" => "1" } }
+
+        allow(browser.page).to receive(:command).with("IO.read", hash_including(handle: "1")) {
+          { "data" => "", "base64Encoded" => false, "eof" => true }
+        }
+
+        browser.pdf(path: file,
+                    landscape: false,
+                    display_header_footer: false,
+                    print_background: false,
+                    scale: 1,
+                    paper_width: 8.5,
+                    paper_height: 11,
+                    margin_top: 0.4,
+                    margin_bottom: 0.4,
+                    margin_left: 0.4,
+                    margin_right: 0.4,
+                    page_ranges: "",
+                    ignore_invalid_page_ranges: false,
+                    prefer_css_page_size: false)
       end
     end
   end
+
+  describe "#mhtml" do
+    let(:format) { :mhtml }
+    let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
+
+    after do
+      FileUtils.rm_f("#{PROJECT_ROOT}/spec/tmp/screenshot.mhtml")
+    end
+
+    it "returns data" do
+      browser.go_to("/ferrum/simple")
+
+      data = browser.mhtml
+
+      expect(data).to match(%r{/ferrum/simple})
+      expect(data).to match(/mhtml.blink/)
+      expect(data).to match(/<!DOCTYPE html>/)
+      expect(data).to match(/Foo<br>Bar/)
+    end
+
+    it "saves a file" do
+      browser.go_to("/ferrum/simple")
+
+      browser.mhtml(path: file)
+
+      content = File.read(file)
+      expect(content).to match(%r{/ferrum/simple})
+      expect(content).to match(/mhtml.blink/)
+      expect(content).to match(/<!DOCTYPE html>/)
+      expect(content).to match(/Foo<br>Bar/)
+    end
+  end
+
+  describe "#viewport_size" do
+    it "has a size of 1024x768 by default" do
+      browser.go_to
+
+      expect(browser.viewport_size).to eq([1024, 768])
+    end
+
+    it "supports specifying viewport size with an option" do
+      browser = Ferrum::Browser.new(window_size: [800, 600])
+      browser.go_to(base_url)
+      expect(browser.viewport_size).to eq([800, 600])
+    ensure
+      browser&.quit
+    end
+  end
 end
diff --git a/spec/page/tracing_spec.rb b/spec/page/tracing_spec.rb
index cada69da..576049a2 100644
--- a/spec/page/tracing_spec.rb
+++ b/spec/page/tracing_spec.rb
@@ -1,132 +1,128 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Page
-    describe Tracing do
-      let(:file_path) { "#{PROJECT_ROOT}/spec/tmp/trace.json" }
-      let(:file_path2) { "#{PROJECT_ROOT}/spec/tmp/trace2.json" }
-      let(:file_path3) { "#{PROJECT_ROOT}/spec/tmp/trace3.json" }
-      let(:content) { JSON.parse(File.read(file_path)) }
-      let(:trace_config) { JSON.parse(content["metadata"]["trace-config"]) }
-
-      after do
-        FileUtils.rm_f(file_path)
-        FileUtils.rm_f(file_path2)
-        FileUtils.rm_f(file_path3)
+describe Ferrum::Page::Tracing do
+  let(:file_path) { "#{PROJECT_ROOT}/spec/tmp/trace.json" }
+  let(:file_path2) { "#{PROJECT_ROOT}/spec/tmp/trace2.json" }
+  let(:file_path3) { "#{PROJECT_ROOT}/spec/tmp/trace3.json" }
+  let(:content) { JSON.parse(File.read(file_path)) }
+  let(:trace_config) { JSON.parse(content["metadata"]["trace-config"]) }
+
+  after do
+    FileUtils.rm_f(file_path)
+    FileUtils.rm_f(file_path2)
+    FileUtils.rm_f(file_path3)
+  end
+
+  describe "#record" do
+    it "outputs a trace to file" do
+      page.tracing.record(path: file_path) { page.go_to }
+
+      expect(File.exist?(file_path)).to be(true)
+    end
+
+    it "runs with custom options" do
+      page.tracing.record(
+        path: file_path,
+        trace_config: {
+          includedCategories: ["disabled-by-default-devtools.timeline"],
+          excludedCategories: ["*"]
+        }
+      ) { page.go_to }
+
+      expect(File.exist?(file_path)).to be(true)
+      expect(trace_config["excluded_categories"]).to eq(["*"])
+      expect(trace_config["included_categories"]).to eq(["disabled-by-default-devtools.timeline"])
+      expect(content["traceEvents"].any? { |o| o["cat"] == "toplevel" }).to eq(false)
+    end
+
+    it "runs with default categories" do
+      page.tracing.record(path: file_path) { page.go_to }
+
+      expect(File.exist?(file_path)).to be(true)
+      expect(trace_config["excluded_categories"]).to eq(["*"])
+      expect(trace_config["included_categories"])
+        .to match_array(%w[devtools.timeline v8.execute disabled-by-default-devtools.timeline
+                           disabled-by-default-devtools.timeline.frame toplevel blink.console
+                           blink.user_timing latencyInfo disabled-by-default-devtools.timeline.stack
+                           disabled-by-default-v8.cpu_profiler disabled-by-default-v8.cpu_profiler.hires])
+      expect(content["traceEvents"].any? { |o| o["cat"] == "toplevel" }).to eq(true)
+    end
+
+    it "raises an error when tracing is on two pages" do
+      page.tracing.record(path: file_path) do
+        page.go_to
+
+        expect do
+          another = browser.create_page
+          another.tracing.record(path: file_path2) { another.go_to }
+        end.to raise_exception(Ferrum::BrowserError, "Tracing has already been started (possibly in another tab).")
+        expect(File.exist?(file_path2)).to be(false)
+      end
+
+      expect(File.exist?(file_path)).to be(true)
+    end
+
+    it "raises an error when cannot handle stream" do
+      allow(page.tracing).to receive(:stream_handle).and_raise("boom")
+      expect do
+        page.tracing.record(path: file_path) { page.go_to }
+      end.to raise_error(RuntimeError, "boom")
+
+      expect(File.exist?(file_path)).to be(false)
+    end
+
+    it "handles tracing complete event once" do
+      expect(page.tracing).to receive(:stream_handle).exactly(3).times.and_call_original
+
+      page.tracing.record(path: file_path) { page.go_to }
+      expect(File.exist?(file_path)).to be(true)
+
+      page.tracing.record(path: file_path2) { page.go_to }
+      expect(File.exist?(file_path2)).to be(true)
+
+      page.tracing.record(path: file_path3) { page.go_to }
+      expect(File.exist?(file_path3)).to be(true)
+    end
+
+    it "returns base64 encoded string" do
+      trace = page.tracing.record(encoding: :base64) { page.go_to }
+
+      decoded = Base64.decode64(trace)
+      content = JSON.parse(decoded)
+      expect(content["traceEvents"].any?).to eq(true)
+    end
+
+    it "returns buffer with no encoding" do
+      trace = page.tracing.record { page.go_to }
+
+      content = JSON.parse(trace)
+      expect(content["traceEvents"].any?).to eq(true)
+    end
+
+    context "with screenshots enabled" do
+      it "fills file with screenshot data" do
+        page.tracing.record(path: file_path, screenshots: true) { page.go_to("/ferrum/grid") }
+
+        expect(File.exist?(file_path)).to be(true)
+        expect(trace_config["included_categories"]).to include("disabled-by-default-devtools.screenshot")
+        expect(content["traceEvents"].any? { |o| o["name"] == "Screenshot" }).to eq(true)
       end
 
-      describe "#record" do
-        it "outputs a trace to file" do
-          page.tracing.record(path: file_path) { page.go_to }
-
-          expect(File.exist?(file_path)).to be(true)
-        end
-
-        it "runs with custom options" do
-          page.tracing.record(
-            path: file_path,
-            trace_config: {
-              includedCategories: ["disabled-by-default-devtools.timeline"],
-              excludedCategories: ["*"]
-            }
-          ) { page.go_to }
-
-          expect(File.exist?(file_path)).to be(true)
-          expect(trace_config["excluded_categories"]).to eq(["*"])
-          expect(trace_config["included_categories"]).to eq(["disabled-by-default-devtools.timeline"])
-          expect(content["traceEvents"].any? { |o| o["cat"] == "toplevel" }).to eq(false)
-        end
-
-        it "runs with default categories" do
-          page.tracing.record(path: file_path) { page.go_to }
-
-          expect(File.exist?(file_path)).to be(true)
-          expect(trace_config["excluded_categories"]).to eq(["*"])
-          expect(trace_config["included_categories"])
-            .to match_array(%w[devtools.timeline v8.execute disabled-by-default-devtools.timeline
-                               disabled-by-default-devtools.timeline.frame toplevel blink.console
-                               blink.user_timing latencyInfo disabled-by-default-devtools.timeline.stack
-                               disabled-by-default-v8.cpu_profiler disabled-by-default-v8.cpu_profiler.hires])
-          expect(content["traceEvents"].any? { |o| o["cat"] == "toplevel" }).to eq(true)
-        end
-
-        it "raises an error when tracing is on two pages" do
-          page.tracing.record(path: file_path) do
-            page.go_to
-
-            expect do
-              another = browser.create_page
-              another.tracing.record(path: file_path2) { another.go_to }
-            end.to raise_exception(Ferrum::BrowserError, "Tracing has already been started (possibly in another tab).")
-            expect(File.exist?(file_path2)).to be(false)
-          end
-
-          expect(File.exist?(file_path)).to be(true)
-        end
-
-        it "raises an error when cannot handle stream" do
-          allow(page.tracing).to receive(:stream_handle).and_raise("boom")
-          expect do
-            page.tracing.record(path: file_path) { page.go_to }
-          end.to raise_error(RuntimeError, "boom")
-
-          expect(File.exist?(file_path)).to be(false)
-        end
-
-        it "handles tracing complete event once" do
-          expect(page.tracing).to receive(:stream_handle).exactly(3).times.and_call_original
-
-          page.tracing.record(path: file_path) { page.go_to }
-          expect(File.exist?(file_path)).to be(true)
-
-          page.tracing.record(path: file_path2) { page.go_to }
-          expect(File.exist?(file_path2)).to be(true)
-
-          page.tracing.record(path: file_path3) { page.go_to }
-          expect(File.exist?(file_path3)).to be(true)
-        end
-
-        it "returns base64 encoded string" do
-          trace = page.tracing.record(encoding: :base64) { page.go_to }
-
-          decoded = Base64.decode64(trace)
-          content = JSON.parse(decoded)
-          expect(content["traceEvents"].any?).to eq(true)
-        end
-
-        it "returns buffer with no encoding" do
-          trace = page.tracing.record { page.go_to }
-
-          content = JSON.parse(trace)
-          expect(content["traceEvents"].any?).to eq(true)
-        end
-
-        context "with screenshots enabled" do
-          it "fills file with screenshot data" do
-            page.tracing.record(path: file_path, screenshots: true) { page.go_to("/ferrum/grid") }
-
-            expect(File.exist?(file_path)).to be(true)
-            expect(trace_config["included_categories"]).to include("disabled-by-default-devtools.screenshot")
-            expect(content["traceEvents"].any? { |o| o["name"] == "Screenshot" }).to eq(true)
-          end
-
-          it "returns a buffer with screenshot data" do
-            trace = page.tracing.record(screenshots: true) { page.go_to("/ferrum/grid") }
-
-            expect(File.exist?(file_path)).to be(false)
-            content = JSON.parse(trace)
-            trace_config = JSON.parse(content["metadata"]["trace-config"])
-            expect(trace_config["included_categories"]).to include("disabled-by-default-devtools.screenshot")
-            expect(content["traceEvents"].any? { |o| o["name"] == "Screenshot" }).to eq(true)
-          end
-        end
-
-        it "waits for promise fill with timeout when it provided" do
-          expect(page.tracing).to receive(:subscribe_tracing_complete).with(no_args)
-          trace = page.tracing.record(timeout: 1) { page.go_to }
-          expect(trace).to be_nil
-        end
+      it "returns a buffer with screenshot data" do
+        trace = page.tracing.record(screenshots: true) { page.go_to("/ferrum/grid") }
+
+        expect(File.exist?(file_path)).to be(false)
+        content = JSON.parse(trace)
+        trace_config = JSON.parse(content["metadata"]["trace-config"])
+        expect(trace_config["included_categories"]).to include("disabled-by-default-devtools.screenshot")
+        expect(content["traceEvents"].any? { |o| o["name"] == "Screenshot" }).to eq(true)
       end
     end
+
+    it "waits for promise fill with timeout when it provided" do
+      expect(page.tracing).to receive(:subscribe_tracing_complete).with(no_args)
+      trace = page.tracing.record(timeout: 1) { page.go_to }
+      expect(trace).to be_nil
+    end
   end
 end
diff --git a/spec/page_spec.rb b/spec/page_spec.rb
index 2db5bdf3..6f42465b 100644
--- a/spec/page_spec.rb
+++ b/spec/page_spec.rb
@@ -1,179 +1,177 @@
 # frozen_string_literal: true
 
-module Ferrum
-  describe Page do
-    describe "#go_to" do
-      let(:port) { server.port }
-
-      context "with success response" do
-        it "works when DNS correct" do
-          expect { browser.go_to("http://localhost:#{port}/") }.not_to raise_error
-        end
-
-        it "reports no open resources when there are none" do
-          old_timeout = browser.timeout
-          browser.timeout = 4
-          expect { browser.go_to("/ferrum/really_slow") }.not_to raise_error
-        ensure
-          browser.timeout = old_timeout
-        end
+describe Ferrum::Page do
+  describe "#go_to" do
+    let(:port) { server.port }
+
+    context "with success response" do
+      it "works when DNS correct" do
+        expect { browser.go_to("http://localhost:#{port}/") }.not_to raise_error
       end
 
-      context "with failing response" do
-        it "handles when a non-existent file was specified" do
-          file_name = "file:non-existent"
-
-          expect do
-            page.go_to(file_name)
-          end.to raise_error(
-            Ferrum::StatusError,
-            "Request to #{file_name} failed to reach server, check DNS and server status"
-          )
-        end
-
-        it "handles when DNS is incorrect" do
-          expect { browser.go_to("http://nope:#{port}/") }.to raise_error(
-            Ferrum::StatusError,
-            %r{Request to http://nope:\d+/ failed to reach server, check DNS and server status}
-          )
-        end
-
-        it "has a descriptive message when DNS incorrect" do
-          url = "http://nope:#{port}/"
-
-          expect do
-            browser.go_to(url)
-          end.to raise_error(
-            Ferrum::StatusError,
-            /Request to #{url} failed to reach server, check DNS and server status/
-          )
-        end
-
-        it "reports open resource requests" do
-          old_timeout = browser.timeout
-          browser.timeout = 2
-          expect do
-            browser.go_to("/ferrum/visit_timeout")
-          end.to raise_error(
-            Ferrum::PendingConnectionsError,
-            %r{Request to http://.*/ferrum/visit_timeout reached server, but there are still pending connections: http://.*/ferrum/really_slow}
-          )
-        ensure
-          browser.timeout = old_timeout
-        end
-
-        it "reports open resource requests for main frame" do
-          prev_timeout = browser.timeout
-          browser.timeout = 0.1
-
-          expect do
-            browser.go_to("/ferrum/really_slow")
-          end.to raise_error(
-            Ferrum::PendingConnectionsError,
-            %r{Request to http://.*/ferrum/really_slow reached server, but there are still pending connections: http://.*/ferrum/really_slow}
-          )
-        ensure
-          browser.timeout = prev_timeout
-        end
+      it "reports no open resources when there are none" do
+        old_timeout = browser.timeout
+        browser.timeout = 4
+        expect { browser.go_to("/ferrum/really_slow") }.not_to raise_error
+      ensure
+        browser.timeout = old_timeout
       end
     end
 
-    describe "#position=" do
-      it "allows the window to be positioned", if: !Utils::Platform.mac? do
+    context "with failing response" do
+      it "handles when a non-existent file was specified" do
+        file_name = "file:non-existent"
+
         expect do
-          browser.position = { left: 10, top: 20 }
-        end.to change {
-          browser.position
-        }.from([0, 0]).to([10, 20])
+          page.go_to(file_name)
+        end.to raise_error(
+          Ferrum::StatusError,
+          "Request to #{file_name} failed to reach server, check DNS and server status"
+        )
       end
-    end
 
-    describe "#current_url" do
-      it "supports whitespace characters" do
-        browser.go_to("/ferrum/arbitrary_path/200/foo%20bar%20baz")
-        expect(browser.current_url).to eq(base_url("/ferrum/arbitrary_path/200/foo%20bar%20baz"))
+      it "handles when DNS is incorrect" do
+        expect { browser.go_to("http://nope:#{port}/") }.to raise_error(
+          Ferrum::StatusError,
+          %r{Request to http://nope:\d+/ failed to reach server, check DNS and server status}
+        )
       end
 
-      it "supports escaped characters" do
-        browser.go_to("/ferrum/arbitrary_path/200/foo?a%5Bb%5D=c")
-        expect(browser.current_url).to eq(base_url("/ferrum/arbitrary_path/200/foo?a%5Bb%5D=c"))
-      end
+      it "has a descriptive message when DNS incorrect" do
+        url = "http://nope:#{port}/"
 
-      it "supports url in parameter" do
-        browser.go_to("/ferrum/arbitrary_path/200/foo%20asd?a=http://example.com/asd%20asd")
-        expect(browser.current_url).to eq(base_url("/ferrum/arbitrary_path/200/foo%20asd?a=http://example.com/asd%20asd"))
+        expect do
+          browser.go_to(url)
+        end.to raise_error(
+          Ferrum::StatusError,
+          /Request to #{url} failed to reach server, check DNS and server status/
+        )
       end
 
-      it "supports restricted characters ' []:/+&='" do
-        browser.go_to("/ferrum/arbitrary_path/200/foo?a=%20%5B%5D%3A%2F%2B%26%3D")
-        expect(browser.current_url).to eq(base_url("/ferrum/arbitrary_path/200/foo?a=%20%5B%5D%3A%2F%2B%26%3D"))
+      it "reports open resource requests" do
+        old_timeout = browser.timeout
+        browser.timeout = 2
+        expect do
+          browser.go_to("/ferrum/visit_timeout")
+        end.to raise_error(
+          Ferrum::PendingConnectionsError,
+          %r{Request to http://.*/ferrum/visit_timeout reached server, but there are still pending connections: http://.*/ferrum/really_slow}
+        )
+      ensure
+        browser.timeout = old_timeout
       end
 
-      it "returns about:blank when on about:blank" do
-        browser.go_to("about:blank")
-        expect(browser.current_url).to eq("about:blank")
+      it "reports open resource requests for main frame" do
+        prev_timeout = browser.timeout
+        browser.timeout = 0.1
+
+        expect do
+          browser.go_to("/ferrum/really_slow")
+        end.to raise_error(
+          Ferrum::PendingConnectionsError,
+          %r{Request to http://.*/ferrum/really_slow reached server, but there are still pending connections: http://.*/ferrum/really_slow}
+        )
+      ensure
+        browser.timeout = prev_timeout
       end
+    end
+  end
 
-      it "handles hash changes" do
-        browser.go_to("/#omg")
-        expect(browser.current_url).to match(%r{/#omg$})
-        browser.execute <<-JS
-          window.onhashchange = function() { window.last_hashchange = window.location.hash }
-        JS
+  describe "#position=" do
+    it "allows the window to be positioned", if: !Ferrum::Utils::Platform.mac? do
+      expect do
+        browser.position = { left: 10, top: 20 }
+      end.to change {
+        browser.position
+      }.from([0, 0]).to([10, 20])
+    end
+  end
 
-        browser.go_to("/#foo")
+  describe "#current_url" do
+    it "supports whitespace characters" do
+      browser.go_to("/ferrum/arbitrary_path/200/foo%20bar%20baz")
+      expect(browser.current_url).to eq(base_url("/ferrum/arbitrary_path/200/foo%20bar%20baz"))
+    end
 
-        expect(browser.current_url).to match(%r{/#foo$})
-        expect(browser.evaluate("window.last_hashchange")).to eq("#foo")
-      end
+    it "supports escaped characters" do
+      browser.go_to("/ferrum/arbitrary_path/200/foo?a%5Bb%5D=c")
+      expect(browser.current_url).to eq(base_url("/ferrum/arbitrary_path/200/foo?a%5Bb%5D=c"))
     end
 
-    describe "#back" do
-      it "goes back when history state has been pushed" do
-        browser.go_to
-        browser.execute(%(window.history.pushState({foo: "bar"}, "title", "bar2.html");))
-        expect(browser.current_url).to eq(base_url("/bar2.html"))
-        expect { browser.back }.not_to raise_error
-        expect(browser.current_url).to eq(base_url("/"))
-      end
+    it "supports url in parameter" do
+      browser.go_to("/ferrum/arbitrary_path/200/foo%20asd?a=http://example.com/asd%20asd")
+      expect(browser.current_url).to eq(base_url("/ferrum/arbitrary_path/200/foo%20asd?a=http://example.com/asd%20asd"))
     end
 
-    describe "#forward" do
-      it "goes forward when history state is used" do
-        browser.go_to
-        browser.execute(%(window.history.pushState({foo: "bar"}, "title", "bar2.html");))
-        expect(browser.current_url).to eq(base_url("/bar2.html"))
-        # don't use #back here to isolate the test
-        browser.execute("window.history.go(-1);")
-        expect(browser.current_url).to eq(base_url("/"))
-        expect { browser.forward }.not_to raise_error
-        expect(browser.current_url).to eq(base_url("/bar2.html"))
-      end
+    it "supports restricted characters ' []:/+&='" do
+      browser.go_to("/ferrum/arbitrary_path/200/foo?a=%20%5B%5D%3A%2F%2B%26%3D")
+      expect(browser.current_url).to eq(base_url("/ferrum/arbitrary_path/200/foo?a=%20%5B%5D%3A%2F%2B%26%3D"))
     end
 
-    describe "#wait_for_reload" do
-      it "waits for page to be reloaded" do
-        browser.go_to("/ferrum/auto_refresh")
-        expect(browser.body).to include("Visited 0 times")
+    it "returns about:blank when on about:blank" do
+      browser.go_to("about:blank")
+      expect(browser.current_url).to eq("about:blank")
+    end
 
-        browser.wait_for_reload(5)
+    it "handles hash changes" do
+      browser.go_to("/#omg")
+      expect(browser.current_url).to match(%r{/#omg$})
+      browser.execute <<-JS
+        window.onhashchange = function() { window.last_hashchange = window.location.hash }
+      JS
 
-        expect(browser.body).to include("Visited 1 times")
-      end
+      browser.go_to("/#foo")
+
+      expect(browser.current_url).to match(%r{/#foo$})
+      expect(browser.evaluate("window.last_hashchange")).to eq("#foo")
+    end
+  end
+
+  describe "#back" do
+    it "goes back when history state has been pushed" do
+      browser.go_to
+      browser.execute(%(window.history.pushState({foo: "bar"}, "title", "bar2.html");))
+      expect(browser.current_url).to eq(base_url("/bar2.html"))
+      expect { browser.back }.not_to raise_error
+      expect(browser.current_url).to eq(base_url("/"))
+    end
+  end
+
+  describe "#forward" do
+    it "goes forward when history state is used" do
+      browser.go_to
+      browser.execute(%(window.history.pushState({foo: "bar"}, "title", "bar2.html");))
+      expect(browser.current_url).to eq(base_url("/bar2.html"))
+      # don't use #back here to isolate the test
+      browser.execute("window.history.go(-1);")
+      expect(browser.current_url).to eq(base_url("/"))
+      expect { browser.forward }.not_to raise_error
+      expect(browser.current_url).to eq(base_url("/bar2.html"))
     end
+  end
 
-    describe "#bypass_csp" do
-      it "can bypass csp headers" do
-        browser.go_to("/csp")
-        browser.add_script_tag(content: "window.__injected = 42")
-        expect(browser.evaluate("window.__injected")).to be_nil
+  describe "#wait_for_reload" do
+    it "waits for page to be reloaded" do
+      browser.go_to("/ferrum/auto_refresh")
+      expect(browser.body).to include("Visited 0 times")
 
-        browser.bypass_csp
-        browser.reload
-        browser.add_script_tag(content: "window.__injected = 42")
+      browser.wait_for_reload(5)
 
-        expect(browser.evaluate("window.__injected")).to eq(42)
-      end
+      expect(browser.body).to include("Visited 1 times")
+    end
+  end
+
+  describe "#bypass_csp" do
+    it "can bypass csp headers" do
+      browser.go_to("/csp")
+      browser.add_script_tag(content: "window.__injected = 42")
+      expect(browser.evaluate("window.__injected")).to be_nil
+
+      browser.bypass_csp
+      browser.reload
+      browser.add_script_tag(content: "window.__injected = 42")
+
+      expect(browser.evaluate("window.__injected")).to eq(42)
     end
   end
 end
diff --git a/spec/rbga_spec.rb b/spec/rbga_spec.rb
index 74ede694..2b3f88d6 100644
--- a/spec/rbga_spec.rb
+++ b/spec/rbga_spec.rb
@@ -1,50 +1,46 @@
 # frozen_string_literal: true
 
-require "ferrum/rgba"
-
-module Ferrum
-  describe RGBA do
-    describe "#new" do
-      it "raises ArgumentError for Integer value of alpha" do
-        expect do
-          RGBA.new(0, 0, 0, 0)
-        end.to raise_exception(
-          ArgumentError,
-          "Wrong alpha value 0 should be Float between 0.0 (fully transparent) and 1.0 (fully opaque)"
-        )
-      end
-
-      it "raises ArgumentError for wrong value of alpha" do
-        expect do
-          RGBA.new(0, 0, 0, 2.0)
-        end.to raise_exception(
-          ArgumentError,
-          "Wrong alpha value 2.0 should be Float between 0.0 (fully transparent) and 1.0 (fully opaque)"
-        )
-      end
+describe Ferrum::RGBA do
+  describe "#new" do
+    it "raises ArgumentError for Integer value of alpha" do
+      expect do
+        Ferrum::RGBA.new(0, 0, 0, 0)
+      end.to raise_exception(
+        ArgumentError,
+        "Wrong alpha value 0 should be Float between 0.0 (fully transparent) and 1.0 (fully opaque)"
+      )
+    end
 
-      it "raises ArgumentError for wrong value of red" do
-        expect do
-          RGBA.new(-1, 0, 0, 0.0)
-        end.to raise_exception(ArgumentError, "Wrong value of -1 should be Integer from 0 to 255")
-      end
+    it "raises ArgumentError for wrong value of alpha" do
+      expect do
+        Ferrum::RGBA.new(0, 0, 0, 2.0)
+      end.to raise_exception(
+        ArgumentError,
+        "Wrong alpha value 2.0 should be Float between 0.0 (fully transparent) and 1.0 (fully opaque)"
+      )
+    end
 
-      it "raises ArgumentError for wrong value of green" do
-        expect do
-          RGBA.new(0, 256, 0, 0.0)
-        end.to raise_exception(ArgumentError, "Wrong value of 256 should be Integer from 0 to 255")
-      end
+    it "raises ArgumentError for wrong value of red" do
+      expect do
+        Ferrum::RGBA.new(-1, 0, 0, 0.0)
+      end.to raise_exception(ArgumentError, "Wrong value of -1 should be Integer from 0 to 255")
+    end
 
-      it "raises ArgumentError for wrong value of blue" do
-        expect do
-          RGBA.new(0, 0, 0.0, 0.0)
-        end.to raise_exception(ArgumentError, "Wrong value of 0.0 should be Integer from 0 to 255")
-      end
+    it "raises ArgumentError for wrong value of green" do
+      expect do
+        Ferrum::RGBA.new(0, 256, 0, 0.0)
+      end.to raise_exception(ArgumentError, "Wrong value of 256 should be Integer from 0 to 255")
     end
 
-    describe "#to_h" do
-      it { expect(RGBA.new(0, 0, 0, 0.0).to_h).to eq({ r: 0, g: 0, b: 0, a: 0.0 }) }
-      it { expect(RGBA.new(255, 255, 255, 1.0).to_h).to eq({ r: 255, g: 255, b: 255, a: 1.0 }) }
+    it "raises ArgumentError for wrong value of blue" do
+      expect do
+        Ferrum::RGBA.new(0, 0, 0.0, 0.0)
+      end.to raise_exception(ArgumentError, "Wrong value of 0.0 should be Integer from 0 to 255")
     end
   end
+
+  describe "#to_h" do
+    it { expect(Ferrum::RGBA.new(0, 0, 0, 0.0).to_h).to eq({ r: 0, g: 0, b: 0, a: 0.0 }) }
+    it { expect(Ferrum::RGBA.new(255, 255, 255, 1.0).to_h).to eq({ r: 255, g: 255, b: 255, a: 1.0 }) }
+  end
 end
diff --git a/spec/runtime_spec.rb b/spec/runtime_spec.rb
deleted file mode 100644
index 2a169f6b..00000000
--- a/spec/runtime_spec.rb
+++ /dev/null
@@ -1,270 +0,0 @@
-# frozen_string_literal: true
-
-module Ferrum
-  describe Frame::Runtime do
-    describe "#execute" do
-      it "executes multiple lines of javascript" do
-        browser.execute <<-JS
-          var a = 1
-          var b = 2
-          window.result = a + b
-        JS
-        expect(browser.evaluate("window.result")).to eq(3)
-      end
-
-      context "with javascript errors" do
-        let(:browser) { Browser.new(base_url: base_url, js_errors: true) }
-
-        it "propagates a Javascript error to a ruby exception" do
-          expect do
-            browser.execute(%(throw new Error("zomg")))
-          end.to raise_error(Ferrum::JavaScriptError) { |e|
-            expect(e.message).to include("Error: zomg")
-          }
-        end
-
-        it "propagates an asynchronous Javascript error on the page to a ruby exception" do
-          expect do
-            browser.execute "setTimeout(function() { omg }, 0)"
-            sleep 0.01
-            browser.execute ""
-          end.to raise_error(Ferrum::JavaScriptError, /ReferenceError.*omg/)
-        end
-
-        it "propagates a synchronous Javascript error on the page to a ruby exception" do
-          expect do
-            browser.execute "omg"
-          end.to raise_error(Ferrum::JavaScriptError, /ReferenceError.*omg/)
-        end
-
-        it "does not re-raise a Javascript error if it is rescued" do
-          expect do
-            browser.execute "setTimeout(function() { omg }, 0)"
-            sleep 0.01
-            browser.execute ""
-          end.to raise_error(Ferrum::JavaScriptError, /ReferenceError.*omg/)
-
-          # should not raise again
-          expect(browser.evaluate("1+1")).to eq(2)
-        end
-
-        it "propagates a Javascript error during page load to a ruby exception" do
-          expect { browser.go_to("/ferrum/js_error") }.to raise_error(Ferrum::JavaScriptError)
-        end
-
-        it "does not propagate a Javascript error to ruby if error raising disabled" do
-          browser = Browser.new(base_url: base_url, js_errors: false)
-          browser.go_to("/ferrum/js_error")
-          browser.execute "setTimeout(function() { omg }, 0)"
-          sleep 0.1
-          expect(browser.body).to include("hello")
-        ensure
-          browser&.quit
-        end
-
-        it "does not propagate a Javascript error to ruby if error raising disabled and client restarted" do
-          browser = Browser.new(base_url: base_url, js_errors: false)
-          browser.restart
-          browser.go_to("/ferrum/js_error")
-          browser.execute "setTimeout(function() { omg }, 0)"
-          sleep 0.1
-          expect(browser.body).to include("hello")
-        ensure
-          browser&.quit
-        end
-      end
-    end
-
-    describe "#evaluate" do
-      it "returns an element" do
-        browser.go_to("/ferrum/type")
-        element = browser.evaluate(%(document.getElementById("empty_input")))
-        expect(element).to eq(browser.at_css("#empty_input"))
-      end
-
-      it "returns structures with elements" do
-        browser.go_to("/ferrum/type")
-        result = browser.evaluate <<~JS
-          {
-            a: document.getElementById("empty_input"),
-            b: { c: document.querySelectorAll("#empty_textarea, #filled_textarea") }
-          }
-        JS
-
-        expect(result).to eq(
-          "a" => browser.at_css("#empty_input"),
-          "b" => {
-            "c" => browser.css("#empty_textarea, #filled_textarea")
-          }
-        )
-      end
-
-      it "returns values properly" do
-        expect(browser.evaluate("null")).to be_nil
-        expect(browser.evaluate("false")).to be false
-        expect(browser.evaluate("true")).to be true
-        expect(browser.evaluate("undefined")).to eq(nil)
-
-        expect(browser.evaluate("3;")).to eq(3)
-        expect(browser.evaluate("31337")).to eq(31_337)
-        expect(browser.evaluate(%("string"))).to eq("string")
-        expect(browser.evaluate(%({foo: "bar"}))).to eq("foo" => "bar")
-
-        expect(browser.evaluate("new Object")).to eq({})
-        expect(browser.evaluate("new Date(2012, 0).toDateString()")).to eq("Sun Jan 01 2012")
-        expect(browser.evaluate("new Object({a: 1})")).to eq({ "a" => 1 })
-        expect(browser.evaluate("new Array")).to eq([])
-        expect(browser.evaluate("new Function")).to eq({})
-
-        expect do
-          browser.evaluate(%(throw "smth"))
-        end.to raise_error(Ferrum::JavaScriptError)
-      end
-
-      context "when cyclic structure is returned" do
-        context "ignores seen" do
-          let(:code) do
-            <<~JS
-              (function() {
-                var a = {};
-                var b = {};
-                var c = {};
-                c.a = a;
-                a.a = a;
-                a.b = b;
-                a.c = c;
-                return %s;
-              })()
-            JS
-          end
-
-          it "returns object" do
-            expect(browser.evaluate(code % "a")).to eq(CyclicObject.instance)
-          end
-
-          it "returns array" do
-            expect(browser.evaluate(code % "[a]")).to eq([CyclicObject.instance])
-          end
-        end
-
-        it "backtracks what it has seen" do
-          expect(browser.evaluate("(function() { var a = {}; return [a, a] })()")).to eq([{}, {}])
-        end
-      end
-    end
-
-    describe "#evaluate_func" do
-      let(:function) do
-        <<~JS
-          function(c) {
-            let a = 1;
-            let b = 2;
-            return a + b + c;
-          }
-        JS
-      end
-
-      it "evaluates multiple lines of javascript function" do
-        expect(browser.evaluate_func(function, 3)).to eq(6)
-      end
-
-      it "evaluates a function on a node" do
-        browser.go_to("/ferrum/index")
-        node = browser.at_xpath(".//a")
-
-        function = <<~JS
-          function(attributeName) {
-            return this.getAttribute(attributeName);
-          }
-        JS
-
-        expect(browser.evaluate_func(function, "href", on: node)).to eq("js_redirect")
-      end
-    end
-
-    describe "#evaluate_async" do
-      it "handles values properly" do
-        expect(browser.evaluate_async("arguments[0](null)", 5)).to be_nil
-        expect(browser.evaluate_async("arguments[0](false)", 5)).to be false
-        expect(browser.evaluate_async("arguments[0](true)", 5)).to be true
-        expect(browser.evaluate_async(%(arguments[0]({foo: "bar"})), 5)).to eq("foo" => "bar")
-      end
-
-      it "times out" do
-        expect do
-          browser.evaluate_async("var callback=arguments[0]; setTimeout(function(){callback(true)}, 4000)", 1)
-        end.to raise_error(Ferrum::ScriptTimeoutError)
-      end
-    end
-
-    describe "#add_script_tag" do
-      it "adds by url" do
-        browser.go_to
-        expect do
-          browser.evaluate("$('a').first().text()")
-        end.to raise_error(Ferrum::JavaScriptError)
-
-        browser.add_script_tag(url: "/ferrum/jquery.min.js")
-
-        expect(browser.evaluate("$('a').first().text()")).to eq("Relative")
-      end
-
-      it "adds by path" do
-        browser.go_to
-        path = "#{Ferrum::Application::FERRUM_PUBLIC}/jquery-1.11.3.min.js"
-        expect do
-          browser.evaluate("$('a').first().text()")
-        end.to raise_error(Ferrum::JavaScriptError)
-
-        browser.add_script_tag(path: path)
-
-        expect(browser.evaluate("$('a').first().text()")).to eq("Relative")
-      end
-
-      it "adds by content" do
-        browser.go_to
-
-        browser.add_script_tag(content: "function yay() { return 'yay!'; }")
-
-        expect(browser.evaluate("yay()")).to eq("yay!")
-      end
-    end
-
-    describe "#add_style_tag" do
-      let(:font_size) do
-        <<~JS
-          window
-            .getComputedStyle(document.querySelector('a'))
-            .getPropertyValue('font-size')
-        JS
-      end
-
-      it "adds by url" do
-        browser.go_to
-        expect(browser.evaluate(font_size)).to eq("16px")
-
-        browser.add_style_tag(url: "/ferrum/add_style_tag.css")
-
-        expect(browser.evaluate(font_size)).to eq("50px")
-      end
-
-      it "adds by path" do
-        browser.go_to
-        path = "#{Ferrum::Application::FERRUM_PUBLIC}/add_style_tag.css"
-        expect(browser.evaluate(font_size)).to eq("16px")
-
-        browser.add_style_tag(path: path)
-
-        expect(browser.evaluate(font_size)).to eq("50px")
-      end
-
-      it "adds by content" do
-        browser.go_to
-
-        browser.add_style_tag(content: "a { font-size: 20px; }")
-
-        expect(browser.evaluate(font_size)).to eq("20px")
-      end
-    end
-  end
-end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index 4e2260e6..d000fc60 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -14,7 +14,7 @@
 ENV["FERRUM_NEW_WINDOW_WAIT"] ||= "0.8" if ENV["CI"]
 
 puts ""
-command = Ferrum::Browser::Command.build({}, nil)
+command = Ferrum::Browser::Command.build(Ferrum::Browser::Options.new, nil)
 puts `'#{command.path}' --version`
 puts ""
 
diff --git a/spec/support/global_helpers.rb b/spec/support/global_helpers.rb
index 0bbfe166..98a81269 100644
--- a/spec/support/global_helpers.rb
+++ b/spec/support/global_helpers.rb
@@ -33,7 +33,7 @@ def reset
   end
 
   def with_external_browser(host: "127.0.0.1", port: 32_001)
-    options = { host: host, port: port, window_size: [1400, 1400], headless: true }
+    options = Ferrum::Browser::Options.new(host: host, port: port, window_size: [1400, 1400], headless: true)
     process = Ferrum::Browser::Process.new(options)
 
     begin
diff --git a/spec/unit/browser_spec.rb b/spec/unit/browser_spec.rb
index f55afb6e..64c14c6c 100644
--- a/spec/unit/browser_spec.rb
+++ b/spec/unit/browser_spec.rb
@@ -3,45 +3,43 @@
 require "stringio"
 require "logger"
 
-module Ferrum
-  describe Browser do
-    it "logs requests and responses with native Logger" do
-      custom_logger = Class.new do
-        def initialize(logger)
-          @logger = logger
-        end
-
-        def puts(*args)
-          @logger << args
-        end
+describe Ferrum::Browser do
+  it "logs requests and responses with native Logger" do
+    custom_logger = Class.new do
+      def initialize(logger)
+        @logger = logger
+      end
+
+      def puts(*args)
+        @logger << args
       end
-      file_path = "test.log"
-      logger = custom_logger.new(Logger.new(file_path))
-      browser = Browser.new(logger: logger)
-      browser.body
-      file_log = File.read(file_path)
-      expect(file_log).to include("return document.documentElement.outerHTML")
-      expect(file_log).to include("<html><head></head><body></body></html>")
-    ensure
-      FileUtils.rm_f(file_path)
     end
+    file_path = "test.log"
+    logger = custom_logger.new(Logger.new(file_path))
+    browser = Ferrum::Browser.new(logger: logger)
+    browser.body
+    file_log = File.read(file_path)
+    expect(file_log).to include("return document.documentElement.outerHTML")
+    expect(file_log).to include("<html><head></head><body></body></html>")
+  ensure
+    FileUtils.rm_f(file_path)
+  end
 
-    it "logs requests and responses" do
-      logger = StringIO.new
-      browser = Browser.new(logger: logger)
+  it "logs requests and responses" do
+    logger = StringIO.new
+    browser = Ferrum::Browser.new(logger: logger)
 
-      browser.body
+    browser.body
 
-      expect(logger.string).to include("return document.documentElement.outerHTML")
-      expect(logger.string).to include("<html><head></head><body></body></html>")
-    end
+    expect(logger.string).to include("return document.documentElement.outerHTML")
+    expect(logger.string).to include("<html><head></head><body></body></html>")
+  end
 
-    it "shows command line options passed" do
-      browser = Browser.new(browser_options: { "blink-settings" => "imagesEnabled=false" })
+  it "shows command line options passed" do
+    browser = Ferrum::Browser.new(browser_options: { "blink-settings" => "imagesEnabled=false" })
 
-      arguments = browser.command("Browser.getBrowserCommandLine")["arguments"]
+    arguments = browser.command("Browser.getBrowserCommandLine")["arguments"]
 
-      expect(arguments).to include("--blink-settings=imagesEnabled=false")
-    end
+    expect(arguments).to include("--blink-settings=imagesEnabled=false")
   end
 end
diff --git a/spec/unit/process_spec.rb b/spec/unit/process_spec.rb
index 60851f03..440e1b75 100644
--- a/spec/unit/process_spec.rb
+++ b/spec/unit/process_spec.rb
@@ -1,42 +1,38 @@
 # frozen_string_literal: true
 
-module Ferrum
-  class Browser
-    describe Process do
-      subject { Browser.new(port: 6000, host: "127.0.0.1") }
+describe Ferrum::Browser::Process do
+  subject { Ferrum::Browser.new(port: 6000, host: "127.0.0.1") }
 
-      unless Utils::Platform.windows?
-        it "forcibly kills the child if it does not respond to SIGTERM" do
-          allow(::Process).to receive_messages(spawn: 5678)
-          allow(::Process).to receive(:wait).and_return(nil)
-          allow(Client).to receive(:new).and_return(double.as_null_object)
+  unless Ferrum::Utils::Platform.windows?
+    it "forcibly kills the child if it does not respond to SIGTERM" do
+      allow(::Process).to receive(:spawn).and_return(5678)
+      allow(::Process).to receive(:wait).and_return(nil)
+      allow(Ferrum::Browser::Client).to receive(:new).and_return(double.as_null_object)
 
-          allow_any_instance_of(Process).to receive(:parse_ws_url)
+      allow_any_instance_of(Ferrum::Browser::Process).to receive(:parse_ws_url)
 
-          subject.send(:start)
+      subject.send(:start)
 
-          expect(::Process).to receive(:kill).with("USR1", 5678).ordered
-          expect(::Process).to receive(:kill).with("KILL", 5678).ordered
+      expect(::Process).to receive(:kill).with("USR1", 5678).ordered
+      expect(::Process).to receive(:kill).with("KILL", 5678).ordered
 
-          subject.quit
-        end
-      end
+      subject.quit
+    end
+  end
 
-      context "env variables" do
-        subject { Browser.new(env: { "LD_PRELOAD" => "some.so" }) }
+  context "env variables" do
+    subject { Ferrum::Browser.new(env: { "LD_PRELOAD" => "some.so" }) }
 
-        it "passes through env" do
-          allow(::Process).to receive(:wait).and_return(nil)
-          allow(Client).to receive(:new).and_return(double.as_null_object)
+    it "passes through env" do
+      allow(::Process).to receive(:wait).and_return(nil)
+      allow(Ferrum::Browser::Client).to receive(:new).and_return(double.as_null_object)
 
-          allow(::Process).to receive(:spawn).with({ "LD_PRELOAD" => "some.so" }, any_args).and_return(123_456_789)
+      allow(::Process).to receive(:spawn).with({ "LD_PRELOAD" => "some.so" }, any_args).and_return(123_456_789)
 
-          allow_any_instance_of(Process).to receive(:parse_ws_url)
+      allow_any_instance_of(Ferrum::Browser::Process).to receive(:parse_ws_url)
 
-          subject.send(:start)
-          subject.quit
-        end
-      end
+      subject.send(:start)
+      subject.quit
     end
   end
 end