diff --git a/AGENTS.md b/AGENTS.md
index faa048d9..4c6d156e 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -35,6 +35,36 @@ The suite boots a real Chrome and a Sinatra/Puma test app (`spec/support/applica
   `lib/ferrum/contexts.rb` -> `spec/unit/contexts_spec.rb`, `lib/ferrum/client/web_socket.rb` ->
   `spec/unit/client/web_socket_spec.rb`. Never add them to the feature spec files in `spec/`.
 - Don't test private methods; cover them through the public API.
+- Structure every spec file in one of two shapes, nothing else:
+
+  ```ruby
+  describe Ferrum::Context do
+    describe "#windows" do
+      it "waits for the window to load" do
+  ```
+
+  ```ruby
+  describe Ferrum::Cookies do
+    describe "#each" do
+      context "when a block is given" do
+        it "yields each cookie" do
+  ```
+
+  The top `describe` is the class, and the file path mirrors that class's path in `lib/`, for feature and unit
+  specs alike: `Ferrum::Page::Screenshot` -> `spec/page/screenshot_spec.rb`, `Ferrum::Browser::Process` ->
+  `spec/unit/browser/process_spec.rb`. Each nested `describe` names one public method (`"#method"`, `".method"` for
+  class methods), never a topic like `"context scope"`.
+- A `describe` holds either only examples or only contexts, never a mix. Use contexts only for contrasting groups,
+  at least two that oppose each other (`"when a block is given"` / `"when no block is given"`). A single condition
+  next to plain examples isn't a context: keep the examples flat and put the condition in the example name, e.g.
+  `it "sets cookies for given domain when base_url isn't set"`. The one exception: a single context is fine when it
+  carries `let`, hooks (`before`/`after`/`around`) or tags that its examples share.
+- Every example must be runnable alone with `rspec spec/file_spec.rb:LINE`, so each one gets its own `it` on its
+  own line. No `shared_examples`/`include_examples` and no loops that generate examples. Share the steps and
+  assertions through a helper method in the `describe` instead, and call it from one-line examples, one per
+  variant. The only exception is the data-table loops in `spec/unit/frame/script_spec.rb`.
+- Start every example name with a verb in the third person: "yields each cookie", "returns the cookie with the
+  given name". Never "must ...", "should ..." or a bare noun.
 - Almost no comments in specs; the example name says what is checked.
 - For a bug fix, make sure the new spec fails without the fix and passes with it.
 
diff --git a/spec/accessibility/ax_node_spec.rb b/spec/accessibility/ax_node_spec.rb
new file mode 100644
index 00000000..bef90b1f
--- /dev/null
+++ b/spec/accessibility/ax_node_spec.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+describe Ferrum::Accessibility::AXNode do
+  describe "#value" do
+    before { browser.go_to("/accessibility") }
+
+    it "returns the raw CDP value for a range input as a Numeric (Chrome does not stringify it)" do
+      ax = browser.page.accessibility.node_for(browser.at_css("#volume"))
+      value = ax.value
+
+      # Chrome returns the range value as Integer 7, not the string "7"
+      expect(value).to eq(7)
+      expect(value).to be_a(Numeric)
+    end
+  end
+end
diff --git a/spec/accessibility_spec.rb b/spec/accessibility_spec.rb
index 6ce96549..98809830 100644
--- a/spec/accessibility_spec.rb
+++ b/spec/accessibility_spec.rb
@@ -28,6 +28,18 @@
       expect(nodes).to all(be_a(Ferrum::Accessibility::AXNode))
       expect(nodes.map(&:role)).to include("button")
     end
+
+    it "returns AXNodes for a node in an iframe" do
+      browser.go_to("/accessibility_iframe")
+      frame_node = browser.page.at_css("iframe").frame.at_css("#child_btn")
+
+      nodes = browser.page.accessibility.partial_tree(node: frame_node)
+
+      expect(nodes).to all(be_a(Ferrum::Accessibility::AXNode))
+      expect(nodes).not_to be_empty
+      expect(nodes.map(&:role)).to include("button")
+      expect(nodes.map(&:name)).to include("Frame button")
+    end
   end
 
   describe "#snapshot" do
@@ -63,34 +75,11 @@
 
       expect(nodes).to be_empty
     end
-  end
-
-  describe "across an iframe" do
-    before { browser.go_to("/accessibility_iframe") }
-
-    let(:frame_node) do
-      frame = browser.page.at_css("iframe").frame
-      frame.at_css("#child_btn")
-    end
 
-    it "node_for resolves the AXNode across the frame boundary" do
-      ax = frame_node.axnode
-
-      expect(ax).to be_a(Ferrum::Accessibility::AXNode)
-      expect(ax.role).to eq("button")
-      expect(ax.name).to eq("Frame button")
-    end
+    it "scopes the query to a node in an iframe" do
+      browser.go_to("/accessibility_iframe")
+      frame_node = browser.page.at_css("iframe").frame.at_css("#child_btn")
 
-    it "partial_tree returns AXNodes for a frame-resident node" do
-      nodes = browser.page.accessibility.partial_tree(node: frame_node)
-
-      expect(nodes).to all(be_a(Ferrum::Accessibility::AXNode))
-      expect(nodes).not_to be_empty
-      expect(nodes.map(&:role)).to include("button")
-      expect(nodes.map(&:name)).to include("Frame button")
-    end
-
-    it "query scoped to a frame-resident node returns the button" do
       nodes = browser.page.accessibility.query(name: "Frame button", node: frame_node)
 
       expect(nodes).not_to be_empty
@@ -105,21 +94,4 @@
       expect(browser.page.accessibility.root).to be_a(Ferrum::Accessibility::AXNode)
     end
   end
-
-  describe "#value" do
-    before { browser.go_to("/accessibility") }
-
-    it "returns the raw CDP value for a range input as a Numeric (Chrome does not stringify it)" do
-      ax = browser.page.accessibility.node_for(browser.at_css("#volume"))
-      value = ax.value
-
-      # Chrome returns the range value as Integer 7, not the string "7"
-      expect(value).to eq(7)
-      expect(value).to be_a(Numeric)
-    end
-  end
-
-  it "is reachable from the browser" do
-    expect(browser.accessibility).to be_a(described_class)
-  end
 end
diff --git a/spec/browser/binary_spec.rb b/spec/browser/binary_spec.rb
index 9c6d7623..12f4669f 100644
--- a/spec/browser/binary_spec.rb
+++ b/spec/browser/binary_spec.rb
@@ -28,7 +28,7 @@
     ENV["PATHEXT"] = @original_env_pathext
   end
 
-  describe "#find" do
+  describe ".find" do
     it "finds one binary" do
       expect(Ferrum::Browser::Binary.find("bin1")).to eq(bin1)
     end
@@ -62,7 +62,7 @@
     end
   end
 
-  describe "#all" do
+  describe ".all" do
     it "finds one binary" do
       expect(Ferrum::Browser::Binary.all("bin1")).to eq([bin1])
     end
@@ -90,7 +90,7 @@
     end
   end
 
-  describe "#lazy_find" do
+  describe ".lazy_find" do
     it "works lazily" do
       enum = Ferrum::Browser::Binary.lazy_find([%w[ls which none]])
 
diff --git a/spec/browser/version_info_spec.rb b/spec/browser/version_info_spec.rb
index 9dc97b76..64db0197 100644
--- a/spec/browser/version_info_spec.rb
+++ b/spec/browser/version_info_spec.rb
@@ -22,31 +22,31 @@
   subject { described_class.new(properties) }
 
   describe "#protocol_version" do
-    it "must return the protocolVersion property" do
+    it "returns the protocolVersion property" do
       expect(subject.protocol_version).to eq(properties["protocolVersion"])
     end
   end
 
   describe "#product" do
-    it "must return the product property" do
+    it "returns the product property" do
       expect(subject.product).to eq(properties["product"])
     end
   end
 
   describe "#revision" do
-    it "must return the revision property" do
+    it "returns the revision property" do
       expect(subject.revision).to eq(properties["revision"])
     end
   end
 
   describe "#user_agent" do
-    it "must return the userAgent property" do
+    it "returns 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
+    it "returns the jsVersion property" do
       expect(subject.js_version).to eq(properties["jsVersion"])
     end
   end
diff --git a/spec/browser/xvfb_spec.rb b/spec/browser/xvfb_spec.rb
index 0788399d..78e6abe1 100644
--- a/spec/browser/xvfb_spec.rb
+++ b/spec/browser/xvfb_spec.rb
@@ -5,11 +5,11 @@
   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
+  describe ".start" do
+    context "when headless with window_size" do
       let(:options) { Hash(window_size: [1400, 1400]) }
 
-      it "allows to run tests configured to xvfb" do
+      it "runs the browser in Xvfb" do
         xvfb_browser.go_to(base_url)
 
         expect(xvfb_browser.body).to include("Hello world!")
@@ -22,10 +22,10 @@
       end
     end
 
-    context "without window_size" do
+    context "when headless without window_size" do
       let(:options) { {} }
 
-      it "allows to run tests configured to xvfb" do
+      it "runs the browser in Xvfb" do
         xvfb_browser.go_to(base_url)
 
         expect(xvfb_browser.body).to include("Hello world!")
@@ -37,21 +37,21 @@
         expect(process_alive?(process.xvfb.pid)).to be(false)
       end
     end
-  end
 
-  context "headful" do
-    let(:options) { Hash(headless: false) }
+    context "when headful" do
+      let(:options) { Hash(headless: false) }
 
-    it "allows to run tests configured to xvfb" do
-      xvfb_browser.go_to(base_url)
+      it "runs the browser in 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
-      pid = process&.xvfb&.pid
-      expect(process_alive?(pid)).to be(false) if pid
+        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
+        pid = process&.xvfb&.pid
+        expect(process_alive?(pid)).to be(false) if pid
+      end
     end
   end
 
diff --git a/spec/browser_spec.rb b/spec/browser_spec.rb
index 5a278dba..58f9ea7b 100644
--- a/spec/browser_spec.rb
+++ b/spec/browser_spec.rb
@@ -4,256 +4,252 @@
 require "ferrum/proxy"
 
 describe Ferrum::Browser do
-  describe "#new" 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"
+    it "includes the process output in the error for a broken :browser_path" do
+      path = "#{PROJECT_ROOT}/spec/support/broken_chrome"
 
-        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
+      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", :launch do
-        original_path = "#{PROJECT_ROOT}/spec/support/chrome_path"
-        File.write(original_path, browser.process.path)
+    it "supports custom chrome path", :launch 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"
+      file = "#{PROJECT_ROOT}/spec/support/custom_chrome_called"
+      path = "#{PROJECT_ROOT}/spec/support/custom_chrome"
 
-        browser = Ferrum::Browser.new(browser_path: path)
+      browser = Ferrum::Browser.new(browser_path: path)
 
-        # If the correct custom path is called, it will touch the file.
-        # We allow at least 10 secs for this to happen before failing.
+      # If the correct custom path is called, it will touch the file.
+      # We allow at least 10 secs for this to happen before failing.
 
-        tries = 0
-        until File.exist?(file) || tries == 100
-          sleep 0.1
-          tries += 1
-        end
+      tries = 0
+      until File.exist?(file) || tries == 100
+        sleep 0.1
+        tries += 1
+      end
 
-        expect(File.exist?(file)).to be true
-      ensure
-        FileUtils.rm_f(original_path)
-        FileUtils.rm_f(file)
-        browser&.quit
+      expect(File.exist?(file)).to be true
+    ensure
+      FileUtils.rm_f(original_path)
+      FileUtils.rm_f(file)
+      browser&.quit
+    end
+
+    it "supports :logger argument", :launch do
+      browser = Ferrum::Browser.new(logger: logger)
+      browser.go_to(base_url("/console_log"))
+
+      wait_for { logger.string }.to include("Runtime.consoleAPICalled")
+      expect(logger.string).to include("DevTools listening on")
+      expect(logger.string).not_to include("[log] Hello world")
+    ensure
+      browser&.quit
+    end
+
+    it "writes to a Logger at debug level", :launch do
+      browser = Ferrum::Browser.new(logger: Logger.new(logger, level: :debug))
+      browser.go_to(base_url("/console_log"))
+
+      expect(logger.string).to include("DEBUG -- ferrum:browser: DevTools listening on")
+      expect(logger.string).to include("DEBUG -- ferrum:protocol: \n\n▶")
+    ensure
+      browser&.quit
+    end
+
+    it "writes nothing to a Logger above debug level", :launch do
+      browser = Ferrum::Browser.new(logger: Logger.new(logger, level: :info))
+      browser.go_to(base_url("/console_log"))
+
+      expect(logger.string).to be_empty
+    ensure
+      browser&.quit
+    end
+
+    it "logs to $stdout with FERRUM_LOG", :launch do
+      with_env("FERRUM_LOG" => "browser") do
+        expect do
+          Ferrum::Browser.new.quit
+        end.to output(/DevTools listening on/).to_stdout
       end
     end
 
-    context ":logger argument" do
-      it "supports :logger argument", :launch do
+    it "logs nothing with FERRUM_LOG=0", :launch do
+      with_env("FERRUM_LOG" => "0") do
         browser = Ferrum::Browser.new(logger: logger)
         browser.go_to(base_url("/console_log"))
 
-        wait_for { logger.string }.to include("Runtime.consoleAPICalled")
-        expect(logger.string).to include("DevTools listening on")
-        expect(logger.string).not_to include("[log] Hello world")
+        expect(logger.string).to be_empty
       ensure
         browser&.quit
       end
+    end
 
-      it "writes to a Logger at debug level", :launch do
-        browser = Ferrum::Browser.new(logger: Logger.new(logger, level: :debug))
+    it "logs everything with the deprecated FERRUM_DEBUG", :launch do
+      with_env("FERRUM_DEBUG" => "true") do
+        browser = Ferrum::Browser.new(logger: logger)
         browser.go_to(base_url("/console_log"))
 
-        expect(logger.string).to include("DEBUG -- ferrum:browser: DevTools listening on")
-        expect(logger.string).to include("DEBUG -- ferrum:protocol: \n\n▶")
+        expect(logger.string).to include("Page.navigate")
+        expect(logger.string).to include("DevTools listening on")
       ensure
         browser&.quit
       end
+    end
 
-      it "writes nothing to a Logger above debug level", :launch do
-        browser = Ferrum::Browser.new(logger: Logger.new(logger, level: :info))
+    it "leaves out the channels excluded in FERRUM_LOG", :launch do
+      with_env("FERRUM_LOG" => "*,-browser") do
+        browser = Ferrum::Browser.new(logger: logger)
         browser.go_to(base_url("/console_log"))
 
-        expect(logger.string).to be_empty
+        expect(logger.string).to include("Page.navigate")
+        expect(logger.string).not_to include("DevTools listening on")
       ensure
         browser&.quit
       end
+    end
 
-      it "logs to $stdout with FERRUM_LOG", :launch do
-        with_env("FERRUM_LOG" => "browser") do
-          expect do
-            Ferrum::Browser.new.quit
-          end.to output(/DevTools listening on/).to_stdout
-        end
-      end
-
-      it "logs nothing with FERRUM_LOG=0", :launch do
-        with_env("FERRUM_LOG" => "0") do
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
-
-          expect(logger.string).to be_empty
-        ensure
-          browser&.quit
-        end
-      end
-
-      it "logs everything with the deprecated FERRUM_DEBUG", :launch do
-        with_env("FERRUM_DEBUG" => "true") do
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
-
-          expect(logger.string).to include("Page.navigate")
-          expect(logger.string).to include("DevTools listening on")
-        ensure
-          browser&.quit
-        end
-      end
-
-      it "leaves out the channels excluded in FERRUM_LOG", :launch do
-        with_env("FERRUM_LOG" => "*,-browser") do
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
-
-          expect(logger.string).to include("Page.navigate")
-          expect(logger.string).not_to include("DevTools listening on")
-        ensure
-          browser&.quit
-        end
-      end
-
-      it "logs only CDP messages matching FERRUM_LOG", :launch do
-        with_env("FERRUM_LOG" => "Page.navigate") do
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
-
-          expect(logger.string).to include(%("method":"Page.navigate"))
-          expect(logger.string).to match(/"result":\{"frameId":"\h+","loaderId"/)
-          expect(logger.string).not_to include("Runtime.")
-          expect(logger.string).not_to include("DevTools listening on")
-        ensure
-          browser&.quit
-        end
-      end
-
-      it "leaves out CDP messages excluded in FERRUM_LOG", :launch do
-        with_env("FERRUM_LOG" => "protocol,-Network.*,-Page.navigate") do
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
-
-          wait_for { logger.string }.to include("Runtime.consoleAPICalled")
-          expect(logger.string).not_to include("Network.")
-          expect(logger.string).not_to include("Page.navigate")
-          expect(logger.string).not_to match(/"result":\{"frameId":"\h+","loaderId"/)
-        ensure
-          browser&.quit
-        end
-      end
-
-      it "writes CDP messages as JSON alone with FERRUM_LOG_FORMAT=json", :launch do
-        with_env("FERRUM_LOG" => "protocol", "FERRUM_LOG_FORMAT" => "json") do
-          def logger.tty? = true
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
+    it "logs only CDP messages matching FERRUM_LOG", :launch do
+      with_env("FERRUM_LOG" => "Page.navigate") do
+        browser = Ferrum::Browser.new(logger: logger)
+        browser.go_to(base_url("/console_log"))
 
-          messages = logger.string.lines.map { |line| JSON.parse(line) }
-          expect(messages).to include(a_hash_including("method" => "Page.navigate", "params" => { "url" => base_url("/console_log") }))
-          expect(messages).to include(a_hash_including("id" => a_kind_of(Integer), "result" => a_hash_including("frameId")))
-        ensure
-          browser&.quit
-        end
+        expect(logger.string).to include(%("method":"Page.navigate"))
+        expect(logger.string).to match(/"result":\{"frameId":"\h+","loaderId"/)
+        expect(logger.string).not_to include("Runtime.")
+        expect(logger.string).not_to include("DevTools listening on")
+      ensure
+        browser&.quit
       end
+    end
 
-      it "annotates CDP messages with FERRUM_LOG_FORMAT=annotated", :launch do
-        with_env("FERRUM_LOG_FORMAT" => "annotated") do
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
+    it "leaves out CDP messages excluded in FERRUM_LOG", :launch do
+      with_env("FERRUM_LOG" => "protocol,-Network.*,-Page.navigate") do
+        browser = Ferrum::Browser.new(logger: logger)
+        browser.go_to(base_url("/console_log"))
 
-          expect(logger.string).to match(%r{^▶ \d+\.\d{3} #\d+ Page\.navigate \{"url":"http://[^"]+/console_log"\} @\h{8}$})
-          id = logger.string[/▶ \S+ #(\d+) Page\.navigate/, 1]
-          expect(logger.string).to match(/^    ◀ \d+\.\d{3} ##{id} Page\.navigate \d+ms \{"frameId":"\h+",.+\} @\h{8}$/)
-          wait_for { logger.string }.to match(/^    ◀ \d+\.\d{3} Runtime\.consoleAPICalled \{"type":"log"/)
-        ensure
-          browser&.quit
-        end
+        wait_for { logger.string }.to include("Runtime.consoleAPICalled")
+        expect(logger.string).not_to include("Network.")
+        expect(logger.string).not_to include("Page.navigate")
+        expect(logger.string).not_to match(/"result":\{"frameId":"\h+","loaderId"/)
+      ensure
+        browser&.quit
       end
+    end
 
-      it "colors protocol lines written to a terminal", :launch do
+    it "writes CDP messages as JSON alone with FERRUM_LOG_FORMAT=json", :launch do
+      with_env("FERRUM_LOG" => "protocol", "FERRUM_LOG_FORMAT" => "json") do
         def logger.tty? = true
         browser = Ferrum::Browser.new(logger: logger)
         browser.go_to(base_url("/console_log"))
 
-        expect(logger.string).to include(%("method":"\e[1mPage.navigate\e[0m"))
-        expect(logger.string).to include("\e[36m▶\e[0m")
+        messages = logger.string.lines.map { |line| JSON.parse(line) }
+        expect(messages).to include(a_hash_including("method" => "Page.navigate", "params" => { "url" => base_url("/console_log") }))
+        expect(messages).to include(a_hash_including("id" => a_kind_of(Integer), "result" => a_hash_including("frameId")))
       ensure
         browser&.quit
       end
+    end
 
-      it "writes plain text when not writing to a terminal", :launch do
+    it "annotates CDP messages with FERRUM_LOG_FORMAT=annotated", :launch do
+      with_env("FERRUM_LOG_FORMAT" => "annotated") do
         browser = Ferrum::Browser.new(logger: logger)
         browser.go_to(base_url("/console_log"))
 
-        expect(logger.string).to include("Page.navigate")
-        expect(logger.string).not_to include("\e[")
+        expect(logger.string).to match(%r{^▶ \d+\.\d{3} #\d+ Page\.navigate \{"url":"http://[^"]+/console_log"\} @\h{8}$})
+        id = logger.string[/▶ \S+ #(\d+) Page\.navigate/, 1]
+        expect(logger.string).to match(/^    ◀ \d+\.\d{3} ##{id} Page\.navigate \d+ms \{"frameId":"\h+",.+\} @\h{8}$/)
+        wait_for { logger.string }.to match(/^    ◀ \d+\.\d{3} Runtime\.consoleAPICalled \{"type":"log"/)
       ensure
         browser&.quit
       end
+    end
 
-      it "colors lines written anywhere with FERRUM_LOG_COLOR=always", :launch do
-        with_env("FERRUM_LOG_COLOR" => "always") do
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
+    it "colors protocol lines written to a terminal", :launch do
+      def logger.tty? = true
+      browser = Ferrum::Browser.new(logger: logger)
+      browser.go_to(base_url("/console_log"))
 
-          expect(logger.string).to include("\e[36m▶\e[0m")
-        ensure
-          browser&.quit
-        end
-      end
+      expect(logger.string).to include(%("method":"\e[1mPage.navigate\e[0m"))
+      expect(logger.string).to include("\e[36m▶\e[0m")
+    ensure
+      browser&.quit
+    end
 
-      it "writes plain text to a terminal with FERRUM_LOG_COLOR=never", :launch do
-        with_env("FERRUM_LOG_COLOR" => "never") do
-          def logger.tty? = true
-          browser = Ferrum::Browser.new(logger: logger)
-          browser.go_to(base_url("/console_log"))
+    it "writes plain text when not writing to a terminal", :launch do
+      browser = Ferrum::Browser.new(logger: logger)
+      browser.go_to(base_url("/console_log"))
 
-          expect(logger.string).to include("Page.navigate")
-          expect(logger.string).not_to include("\e[")
-        ensure
-          browser&.quit
-        end
-      end
+      expect(logger.string).to include("Page.navigate")
+      expect(logger.string).not_to include("\e[")
+    ensure
+      browser&.quit
+    end
 
-      it "keeps the browser working when the logger fails", :launch do
-        broken = Object.new
-        def broken.puts(*) = raise(IOError, "closed stream")
-        browser = nil
+    it "colors lines written anywhere with FERRUM_LOG_COLOR=always", :launch do
+      with_env("FERRUM_LOG_COLOR" => "always") do
+        browser = Ferrum::Browser.new(logger: logger)
+        browser.go_to(base_url("/console_log"))
 
-        expect do
-          browser = Ferrum::Browser.new(logger: broken)
-          browser.go_to(base_url("/console_log"))
-        end.to output(/couldn't write to the logger, IOError: closed stream/).to_stderr
-        expect(browser.evaluate("1 + 1")).to eq(2)
+        expect(logger.string).to include("\e[36m▶\e[0m")
       ensure
         browser&.quit
       end
+    end
 
-      it "logs CDP messages nested deeper than JSON's default limit", :launch do
+    it "writes plain text to a terminal with FERRUM_LOG_COLOR=never", :launch do
+      with_env("FERRUM_LOG_COLOR" => "never") do
+        def logger.tty? = true
         browser = Ferrum::Browser.new(logger: logger)
-        browser.go_to(base_url("/deeply_nested"))
+        browser.go_to(base_url("/console_log"))
 
-        expect(browser.evaluate(%(document.getElementById("text"))).text).to eq("text")
-        expect(logger.string).to include("DOM.setChildNodes")
+        expect(logger.string).to include("Page.navigate")
+        expect(logger.string).not_to include("\e[")
       ensure
         browser&.quit
       end
+    end
 
-      it "shortens long strings in logged CDP messages", :launch, skip: Ferrum::Log::VALUE_LENGTH.zero? do
-        browser = Ferrum::Browser.new(logger: logger)
+    it "keeps the browser working when the logger fails", :launch do
+      broken = Object.new
+      def broken.puts(*) = raise(IOError, "closed stream")
+      browser = nil
+
+      expect do
+        browser = Ferrum::Browser.new(logger: broken)
         browser.go_to(base_url("/console_log"))
-        screenshot = browser.screenshot(encoding: :base64)
+      end.to output(/couldn't write to the logger, IOError: closed stream/).to_stderr
+      expect(browser.evaluate("1 + 1")).to eq(2)
+    ensure
+      browser&.quit
+    end
 
-        expect(logger.string).not_to include(screenshot)
-        expect(logger.string).to include("#{screenshot[0, Ferrum::Log::VALUE_LENGTH]}... (" \
-                                         "#{screenshot.size - Ferrum::Log::VALUE_LENGTH} more characters)")
-      ensure
-        browser&.quit
-      end
+    it "logs CDP messages nested deeper than JSON's default limit", :launch do
+      browser = Ferrum::Browser.new(logger: logger)
+      browser.go_to(base_url("/deeply_nested"))
+
+      expect(browser.evaluate(%(document.getElementById("text"))).text).to eq("text")
+      expect(logger.string).to include("DOM.setChildNodes")
+    ensure
+      browser&.quit
+    end
+
+    it "shortens long strings in logged CDP messages", :launch, skip: Ferrum::Log::VALUE_LENGTH.zero? do
+      browser = Ferrum::Browser.new(logger: logger)
+      browser.go_to(base_url("/console_log"))
+      screenshot = browser.screenshot(encoding: :base64)
+
+      expect(logger.string).not_to include(screenshot)
+      expect(logger.string).to include("#{screenshot[0, Ferrum::Log::VALUE_LENGTH]}... (" \
+                                       "#{screenshot.size - Ferrum::Log::VALUE_LENGTH} more characters)")
+    ensure
+      browser&.quit
     end
 
     it "keeps the output of the browser process", :launch do
@@ -300,106 +296,80 @@ def broken.puts(*) = raise(IOError, "closed stream")
       )
     end
 
-    context ":extensions argument" do
-      it "extends the browser's world with files", :launch do
-        browser = Ferrum::Browser.new(base_url: base_url,
-                                      extensions: [File.expand_path("support/geolocation.js", __dir__)])
-
-        browser.go_to("/requiring_custom_extension")
+    it "extends the browser's world with files", :launch 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>))
-
-        expect(
-          browser.evaluate(%(document.getElementById("location").innerHTML))
-        ).to eq("1,-1")
-
-        expect(
-          browser.evaluate("navigator.geolocation")
-        ).to_not eq(nil)
-      ensure
-        browser&.quit
-      end
+      browser.go_to("/requiring_custom_extension")
 
-      it "extends the browser's world with source", :launch do
-        browser = Ferrum::Browser.new(base_url: base_url,
-                                      extensions: [{ source: "window.secret = 'top'" }])
+      expect(
+        browser.body
+      ).to include(%(Location: <span id="location">1,-1</span>))
 
-        browser.go_to("/requiring_custom_extension")
+      expect(
+        browser.evaluate(%(document.getElementById("location").innerHTML))
+      ).to eq("1,-1")
 
-        expect(browser.evaluate(%(window.secret))).to eq("top")
-      ensure
-        browser&.quit
-      end
+      expect(
+        browser.evaluate("navigator.geolocation")
+      ).to_not eq(nil)
+    ensure
+      browser&.quit
+    end
 
-      it "extends a popup's world before its scripts run", :launch do
-        browser = Ferrum::Browser.new(base_url: base_url,
-                                      extensions: [File.expand_path("support/geolocation.js", __dir__)])
-        browser.go_to
+    it "extends the browser's world with source", :launch do
+      browser = Ferrum::Browser.new(base_url: base_url,
+                                    extensions: [{ source: "window.secret = 'top'" }])
 
-        browser.execute(%(window.open("/requiring_custom_extension", "popup")))
-        popup, = browser.windows(:last)
+      browser.go_to("/requiring_custom_extension")
 
-        expect(popup.at_css("#location").text).to eq("1,-1")
-      ensure
-        browser&.quit
-      end
+      expect(browser.evaluate(%(window.secret))).to eq("top")
+    ensure
+      browser&.quit
+    end
 
-      it "extends an out-of-process iframe's world before its scripts run", :launch do
-        report = <<~JS
-          if (window !== top) {
-            addEventListener("load", () => parent.postMessage(document.getElementById("location").textContent, "*"));
-          }
-        JS
-        browser = Ferrum::Browser.new(base_url: base_url,
-                                      browser_options: { "site-per-process" => nil },
-                                      extensions: [File.expand_path("support/geolocation.js", __dir__), { source: report }])
-        browser.go_to
-        browser.execute(<<~JS)
-          addEventListener("message", (event) => { window.iframeLocation = event.data });
-          document.body.innerHTML = `<iframe src="http://localhost:${location.port}/requiring_custom_extension">`;
-        JS
-
-        iframe_location = Ferrum::Utils::Attempt.with_retry(errors: RuntimeError, max: 50, wait: 0.1) do
-          browser.evaluate("window.iframeLocation") || raise("no message from the iframe yet")
-        end
+    it "extends a popup's world before its scripts run", :launch do
+      browser = Ferrum::Browser.new(base_url: base_url,
+                                    extensions: [File.expand_path("support/geolocation.js", __dir__)])
+      browser.go_to
 
-        expect(browser.targets.values.map(&:type)).to include("iframe")
-        expect(iframe_location).to eq("1,-1")
-      ensure
-        browser&.quit
-      end
+      browser.execute(%(window.open("/requiring_custom_extension", "popup")))
+      popup, = browser.windows(:last)
 
-      it "errors when extension is unavailable", :launch do
-        expect do
-          Ferrum::Browser.new(extensions: [File.expand_path("../support/non_existent.js", __dir__)])
-        end.to raise_error(Errno::ENOENT)
-      end
+      expect(popup.at_css("#location").text).to eq("1,-1")
+    ensure
+      browser&.quit
     end
 
-    describe "#add_extension" do
-      it "extends the world of pages opened afterwards", :launch do
-        browser = Ferrum::Browser.new(base_url: base_url)
-
-        browser.add_extension(source: "window.secret = 'top'")
-        page = browser.create_page
-        page.go_to("/requiring_custom_extension")
+    it "extends an out-of-process iframe's world before its scripts run", :launch do
+      report = <<~JS
+        if (window !== top) {
+          addEventListener("load", () => parent.postMessage(document.getElementById("location").textContent, "*"));
+        }
+      JS
+      browser = Ferrum::Browser.new(base_url: base_url,
+                                    browser_options: { "site-per-process" => nil },
+                                    extensions: [File.expand_path("support/geolocation.js", __dir__), { source: report }])
+      browser.go_to
+      browser.execute(<<~JS)
+        addEventListener("message", (event) => { window.iframeLocation = event.data });
+        document.body.innerHTML = `<iframe src="http://localhost:${location.port}/requiring_custom_extension">`;
+      JS
 
-        expect(page.evaluate("window.secret")).to eq("top")
-      ensure
-        browser&.quit
+      iframe_location = Ferrum::Utils::Attempt.with_retry(errors: RuntimeError, max: 50, wait: 0.1) do
+        browser.evaluate("window.iframeLocation") || raise("no message from the iframe yet")
       end
 
-      it "errors when extension is unavailable", :launch do
-        browser = Ferrum::Browser.new
+      expect(browser.targets.values.map(&:type)).to include("iframe")
+      expect(iframe_location).to eq("1,-1")
+    ensure
+      browser&.quit
+    end
 
-        expect do
-          browser.add_extension(File.expand_path("../support/non_existent.js", __dir__))
-        end.to raise_error(Errno::ENOENT)
-      ensure
-        browser&.quit
-      end
+    it "raises when an extension is unavailable", :launch do
+      expect do
+        Ferrum::Browser.new(extensions: [File.expand_path("../support/non_existent.js", __dir__)])
+      end.to raise_error(Errno::ENOENT)
     end
 
     it "supports :port argument", :launch do
@@ -564,127 +534,184 @@ def proxy_tunnel(socket, request, browser_url)
       browser&.quit
     end
 
-    context ":proxy argument" do
+    it "supports deprecated :pending_connection_errors argument", :launch do
+      Ferrum::Utils::Deprecate.reset!
+      browser = nil
+
+      expect { browser = Ferrum::Browser.new(base_url: base_url, pending_connection_errors: true, timeout: 0.5) }
+        .to output(/:pending_connection_errors will be removed in Ferrum 0\.22.*called from #{__FILE__}/m).to_stderr
+      expect { browser.go_to("/really_slow") }.to raise_error(Ferrum::PendingConnectionsError)
+    ensure
+      browser&.quit
+      Ferrum::Utils::Deprecate.reset!
+    end
+
+    it "stops process if an error is raised during process start", :launch do
+      process = Ferrum::Browser::Process.new(Ferrum::Browser::Options.new(process_timeout: 0))
+      allow(Ferrum::Browser::Process).to receive(:new).and_return(process)
+      expect { Ferrum::Browser.new }.to raise_error(Ferrum::ProcessTimeoutError)
+      expect(process.pid).to be(nil)
+    end
+
+    it "stops process if an error is raised during client creation", :launch do
+      process = Ferrum::Browser::Process.new(Ferrum::Browser::Options.new)
+      allow(Ferrum::Browser::Process).to receive(:new).and_return(process)
+
+      error = StandardError.new
+      allow(Ferrum::Client).to receive(:new).and_raise(error)
+
+      expect { Ferrum::Browser.new }.to raise_error(error)
+      expect(process.pid).to be(nil)
+    end
+
+    it "stops process if an error is raised during contexts creation", :launch do
+      process = Ferrum::Browser::Process.new(Ferrum::Browser::Options.new)
+      allow(Ferrum::Browser::Process).to receive(:new).and_return(process)
+
+      error = StandardError.new
+      allow(Ferrum::Contexts).to receive(:new).and_raise(error)
+
+      expect { Ferrum::Browser.new }.to raise_error(error)
+      expect(process.pid).to be(nil)
+    end
+
+    context "with :proxy without authorization" do
       let(:options) { {} }
       let(:proxy) { Ferrum::Proxy.start(**options) }
 
       after { proxy.stop }
 
-      context "without authorization" do
-        it "works without authorization", :launch do
-          browser = Ferrum::Browser.new(
-            proxy: { host: proxy.host, port: proxy.port }
-          )
+      it "works without authorization", :launch 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
+    end
 
-      context "with authorization" do
-        let(:options) { Hash(user: "user", password: "pa$$") }
+    context "with :proxy with authorization" do
+      let(:options) { Hash(user: "user", password: "pa$$") }
+      let(:proxy) { Ferrum::Proxy.start(**options) }
 
-        it "works with right password", :launch do
-          browser = Ferrum::Browser.new(
-            proxy: { host: proxy.host, port: proxy.port, **options }
-          )
+      after { proxy.stop }
 
-          browser.go_to("https://example.com")
-          expect(browser.network.status).to eq(200)
-          expect(browser.body).to include("Example Domain")
-        ensure
-          browser&.quit
-        end
+      it "works with right password", :launch do
+        browser = Ferrum::Browser.new(
+          proxy: { host: proxy.host, port: proxy.port, **options }
+        )
 
-        it "breaks with wrong password", :launch 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
 
-          expect { browser.go_to("https://example.com") }.to raise_error(
-            Ferrum::StatusError,
-            "Request to https://example.com failed (net::ERR_HTTP_RESPONSE_CODE_FAILURE)"
-          )
-          expect(browser.network.status).to eq(407)
-        ensure
-          browser&.quit
-        end
+      it "breaks with wrong password", :launch do
+        browser = Ferrum::Browser.new(
+          proxy: { host: proxy.host, port: proxy.port, user: "u1", password: "p1" }
+        )
 
-        it "lets requests be aborted", :launch do
-          browser = Ferrum::Browser.new(
-            proxy: { host: proxy.host, port: proxy.port, **options }
-          )
-          browser.network.intercept
-          browser.on(:request) { |request| request.match?(/example\.com/) ? request.abort : request.continue }
+        expect { browser.go_to("https://example.com") }.to raise_error(
+          Ferrum::StatusError,
+          "Request to https://example.com failed (net::ERR_HTTP_RESPONSE_CODE_FAILURE)"
+        )
+        expect(browser.network.status).to eq(407)
+      ensure
+        browser&.quit
+      end
 
-          expect { browser.go_to("https://example.com") }.to raise_error(
-            Ferrum::StatusError,
-            "Request to https://example.com failed (net::ERR_BLOCKED_BY_CLIENT)"
-          )
-        ensure
-          browser&.quit
-        end
+      it "lets requests be aborted", :launch do
+        browser = Ferrum::Browser.new(
+          proxy: { host: proxy.host, port: proxy.port, **options }
+        )
+        browser.network.intercept
+        browser.on(:request) { |request| request.match?(/example\.com/) ? request.abort : request.continue }
 
-        it "supports blacklist", :launch do
-          browser = Ferrum::Browser.new(
-            proxy: { host: proxy.host, port: proxy.port, **options }
-          )
-          browser.network.blacklist = [/example\.com/]
+        expect { browser.go_to("https://example.com") }.to raise_error(
+          Ferrum::StatusError,
+          "Request to https://example.com failed (net::ERR_BLOCKED_BY_CLIENT)"
+        )
+      ensure
+        browser&.quit
+      end
 
-          expect { browser.go_to("https://example.com") }.to raise_error(
-            Ferrum::StatusError,
-            "Request to https://example.com failed (net::ERR_BLOCKED_BY_CLIENT)"
-          )
-        ensure
-          browser&.quit
-        end
+      it "supports blacklist", :launch do
+        browser = Ferrum::Browser.new(
+          proxy: { host: proxy.host, port: proxy.port, **options }
+        )
+        browser.network.blacklist = [/example\.com/]
+
+        expect { browser.go_to("https://example.com") }.to raise_error(
+          Ferrum::StatusError,
+          "Request to https://example.com failed (net::ERR_BLOCKED_BY_CLIENT)"
+        )
+      ensure
+        browser&.quit
       end
+    end
 
-      context "with rotation" do
-        let(:upstream) { Ferrum::Proxy.start(user: "user", password: "pa$$") }
+    context "with :proxy and rotation" do
+      let(:options) { {} }
+      let(:proxy) { Ferrum::Proxy.start(**options) }
 
-        after { upstream.stop }
+      let(:upstream) { Ferrum::Proxy.start(user: "user", password: "pa$$") }
 
-        it "forwards connections to the upstream proxy in a new context", :launch do
-          browser = Ferrum::Browser.new(
-            proxy: { host: proxy.host, port: proxy.port }
-          )
+      after { proxy.stop }
+      after { upstream.stop }
 
-          proxy.rotate(host: upstream.host, port: upstream.port, user: "user", password: "pa$$")
-          browser.create_page(new_context: true) do |page|
-            page.go_to("https://example.com")
-            expect(page.network.status).to eq(200)
-            expect(page.body).to include("Example Domain")
-          end
+      it "forwards connections to the upstream proxy in a new context", :launch do
+        browser = Ferrum::Browser.new(
+          proxy: { host: proxy.host, port: proxy.port }
+        )
 
-          proxy.rotate(host: upstream.host, port: upstream.port, user: "user", password: "wrong")
-          browser.create_page(new_context: true) do |page|
-            expect { page.go_to("https://example.com") }.to raise_error(
-              Ferrum::StatusError, /ERR_TUNNEL_CONNECTION_FAILED/
-            )
-          end
-        ensure
-          browser&.quit
+        proxy.rotate(host: upstream.host, port: upstream.port, user: "user", password: "pa$$")
+        browser.create_page(new_context: true) do |page|
+          page.go_to("https://example.com")
+          expect(page.network.status).to eq(200)
+          expect(page.body).to include("Example Domain")
         end
+
+        proxy.rotate(host: upstream.host, port: upstream.port, user: "user", password: "wrong")
+        browser.create_page(new_context: true) do |page|
+          expect { page.go_to("https://example.com") }.to raise_error(
+            Ferrum::StatusError, /ERR_TUNNEL_CONNECTION_FAILED/
+          )
+        end
+      ensure
+        browser&.quit
       end
     end
 
-    it "supports deprecated :pending_connection_errors argument", :launch do
-      Ferrum::Utils::Deprecate.reset!
-      browser = nil
+    context "with an absolute :save_path" do
+      let(:filename) { "attachment.pdf" }
+      let(:browser) do
+        Ferrum::Browser.new(
+          base_url: Ferrum::Server.server.base_url,
+          save_path: save_path
+        )
+      end
 
-      expect { browser = Ferrum::Browser.new(base_url: base_url, pending_connection_errors: true, timeout: 0.5) }
-        .to output(/:pending_connection_errors will be removed in Ferrum 0\.22.*called from #{__FILE__}/m).to_stderr
-      expect { browser.go_to("/really_slow") }.to raise_error(Ferrum::PendingConnectionsError)
-    ensure
-      browser&.quit
-      Ferrum::Utils::Deprecate.reset!
+      let(:save_path) { "/tmp/ferrum-downloads" }
+
+      after { browser.quit }
+
+      it "saves an attachment" do
+        browser.go_to("/#{filename}")
+        browser.downloads.wait
+
+        expect(File.exist?("#{save_path}/#{filename}")).to be true
+      ensure
+        FileUtils.rm_rf(save_path)
+      end
     end
 
-    context ":save_path argument" do
+    context "with a relative :save_path" do
       let(:filename) { "attachment.pdf" }
       let(:browser) do
         Ferrum::Browser.new(
@@ -693,61 +720,75 @@ def proxy_tunnel(socket, request, browser_url)
         )
       end
 
-      after { browser.quit }
+      let(:save_path) { "spec/tmp" }
 
-      context "with absolute path" do
-        let(:save_path) { "/tmp/ferrum-downloads" }
+      after { browser.quit }
 
-        it "saves an attachment" do
+      it "raises an error", :launch do
+        expect do
           browser.go_to("/#{filename}")
-          browser.downloads.wait
-
-          expect(File.exist?("#{save_path}/#{filename}")).to be true
-        ensure
-          FileUtils.rm_rf(save_path)
-        end
+        end.to raise_error(Ferrum::Error, "supply absolute path for `:save_path` option")
       end
+    end
 
-      context "with local path" do
-        let(:save_path) { "spec/tmp" }
-
-        it "raises an error", :launch do
-          expect do
-            browser.go_to("/#{filename}")
-          end.to raise_error(Ferrum::Error, "supply absolute path for `:save_path` option")
+    context "in a pty", :launch, 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
-    end
 
-    context "with error on initialize" do
-      it "stops process if an error is raised during process start", :launch do
-        process = Ferrum::Browser::Process.new(Ferrum::Browser::Options.new(process_timeout: 0))
-        allow(Ferrum::Browser::Process).to receive(:new).and_return(process)
-        expect { Ferrum::Browser.new }.to raise_error(Ferrum::ProcessTimeoutError)
-        expect(process.pid).to be(nil)
+      let(:script) do
+        <<-RUBY
+        require "ferrum"
+        browser = Ferrum::Browser.new
+        browser.go_to("http://example.com")
+        puts "Please type enter"
+        sleep 1
+        browser.url
+        RUBY
       end
 
-      it "stops process if an error is raised during client creation", :launch do
-        process = Ferrum::Browser::Process.new(Ferrum::Browser::Options.new)
-        allow(Ferrum::Browser::Process).to receive(:new).and_return(process)
+      it "lets the script exit after reading from the terminal" do
+        expect(@status).to be_success
+      end
+    end
+  end
 
-        error = StandardError.new
-        allow(Ferrum::Client).to receive(:new).and_raise(error)
+  describe "#add_extension" do
+    it "extends the world of pages opened afterwards", :launch do
+      browser = Ferrum::Browser.new(base_url: base_url)
 
-        expect { Ferrum::Browser.new }.to raise_error(error)
-        expect(process.pid).to be(nil)
-      end
+      browser.add_extension(source: "window.secret = 'top'")
+      page = browser.create_page
+      page.go_to("/requiring_custom_extension")
 
-      it "stops process if an error is raised during contexts creation", :launch do
-        process = Ferrum::Browser::Process.new(Ferrum::Browser::Options.new)
-        allow(Ferrum::Browser::Process).to receive(:new).and_return(process)
+      expect(page.evaluate("window.secret")).to eq("top")
+    ensure
+      browser&.quit
+    end
 
-        error = StandardError.new
-        allow(Ferrum::Contexts).to receive(:new).and_raise(error)
+    it "errors when extension is unavailable", :launch do
+      browser = Ferrum::Browser.new
 
-        expect { Ferrum::Browser.new }.to raise_error(error)
-        expect(process.pid).to be(nil)
-      end
+      expect do
+        browser.add_extension(File.expand_path("../support/non_existent.js", __dir__))
+      end.to raise_error(Errno::ENOENT)
+    ensure
+      browser&.quit
     end
   end
 
@@ -874,32 +915,25 @@ def proxy_tunnel(socket, request, browser_url)
       expect(popup2&.viewport_size).to eq([200, 100])
     end
 
-    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, 681])
-          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) { "/custom_html_size" }
-        let(:viewport_size) { [1280, 1024] }
-      end
+    it "resizes the viewport to the page size with fullscreen: true" do
+      expect(browser.viewport_size).to eq([1024, 681])
+      browser.go_to("/custom_html_size")
+      browser.resize(fullscreen: true)
+      expect(browser.viewport_size).to eq([1280, 1024])
+    end
 
-      include_examples "resize viewport by fullscreen" do
-        let(:path) { "/custom_html_size_100%" }
-        let(:viewport_size) { [1272, 1008] }
-      end
+    it "resizes the viewport to the screen with fullscreen: true for a page of 100% size" do
+      expect(browser.viewport_size).to eq([1024, 681])
+      browser.go_to("/custom_html_size_100%")
+      browser.resize(fullscreen: true)
+      expect(browser.viewport_size).to eq([1272, 1008])
+    end
 
-      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
+    it "resizes to normal from fullscreen window state" do
+      browser.go_to("/custom_html_size_100%")
+      browser.resize(fullscreen: true)
+      browser.resize(width: 200, height: 400)
+      expect(browser.viewport_size).to eq([200, 400])
     end
   end
 
@@ -989,123 +1023,125 @@ def proxy_tunnel(socket, request, browser_url)
       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)
+    it "creates a page in a new context without a block" do
+      expect(browser.contexts.size).to eq(0)
 
-        page = browser.create_page(new_context: true)
-        page.go_to("/simple")
+      page = browser.create_page(new_context: true)
+      page.go_to("/simple")
 
-        context = browser.contexts[page.context_id]
-        expect(browser.contexts.size).to eq(1)
-        expect(context.targets.size).to eq(1)
+      context = browser.contexts[page.context_id]
+      expect(browser.contexts.size).to eq(1)
+      expect(context.targets.size).to eq(1)
 
-        context.create_page
-        expect(context.targets.size).to eq(2)
-        context.dispose
-        expect(browser.contexts.size).to eq(0)
-      end
+      context.create_page
+      expect(context.targets.size).to eq(2)
+      context.dispose
+      expect(browser.contexts.size).to eq(0)
+    end
 
-      it "closes page successfully" do
-        expect(browser.contexts.size).to eq(0)
+    it "closes a page in a new context" do
+      expect(browser.contexts.size).to eq(0)
 
-        page = browser.create_page(new_context: true)
-        context = browser.contexts[page.context_id]
-        page.go_to("/simple")
-        page.close
+      page = browser.create_page(new_context: true)
+      context = browser.contexts[page.context_id]
+      page.go_to("/simple")
+      page.close
 
-        expect(browser.contexts.size).to eq(1)
-        expect(context.targets.size).to be_between(0, 1) # needs some time to close target
+      expect(browser.contexts.size).to eq(1)
+      expect(context.targets.size).to be_between(0, 1) # needs some time to close target
 
-        context.dispose
-        expect(browser.contexts.size).to eq(0)
+      context.dispose
+      expect(browser.contexts.size).to eq(0)
+    end
+
+    it "creates a page in a new context with a block" do
+      expect(browser.contexts.size).to eq(0)
+
+      browser.create_page(new_context: true) do |page|
+        page.go_to("/simple")
       end
 
-      it "supports calling with block" do
-        expect(browser.contexts.size).to eq(0)
+      expect(browser.contexts.size).to eq(0)
+    end
+
+    it "propagates the original error when new context creation fails inside the block form" do
+      original_error = Ferrum::DeadBrowserError.new("simulated browser death")
+      allow(browser.contexts).to receive(:create).and_raise(original_error)
 
+      expect do
         browser.create_page(new_context: true) do |page|
           page.go_to("/simple")
         end
-
-        expect(browser.contexts.size).to eq(0)
-      end
-
-      it "propagates the original error when context creation fails inside the block form" do
-        original_error = Ferrum::DeadBrowserError.new("simulated browser death")
-        allow(browser.contexts).to receive(:create).and_raise(original_error)
-
-        expect do
-          browser.create_page(new_context: true) do |page|
-            page.go_to("/simple")
-          end
-        end.to raise_error(Ferrum::DeadBrowserError, "simulated browser death")
-      end
+      end.to raise_error(Ferrum::DeadBrowserError, "simulated browser death")
     end
 
-    context "with :proxy" do
+    context "with :proxy without authorization" 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)
+      it "creates a page behind the proxy" 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")
+        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(browser.contexts[page.context_id].targets.size).to eq(1)
-          expect(page.network.status).to eq(200)
-          expect(page.body).to include("Example Domain")
+        expect(browser.contexts.size).to eq(1)
+        expect(browser.contexts[page.context_id].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)
-          browser.contexts[page.context_id].dispose
-          expect(browser.contexts.size).to eq(1)
-        end
+        page = browser.create_page(proxy: { host: proxy.host, port: proxy.port })
+        expect(browser.contexts.size).to eq(2)
+        browser.contexts[page.context_id].dispose
+        expect(browser.contexts.size).to eq(1)
       end
+    end
 
-      context "with authorization" do
-        let(:options) { { user: "user", password: "password" } }
+    context "with :proxy with authorization" do
+      let(:options) { { user: "user", password: "password" } }
+      let(:proxy) { Ferrum::Proxy.start(**options) }
 
-        it "fails with wrong password" do
-          page = browser.create_page(proxy: { host: proxy.host, port: proxy.port,
-                                              user: options[:user], password: "$$" })
+      after { proxy.stop }
 
-          expect { page.go_to("https://example.com") }.to raise_error(
-            Ferrum::StatusError,
-            "Request to https://example.com failed (net::ERR_HTTP_RESPONSE_CODE_FAILURE)"
-          )
-          expect(page.network.status).to eq(407)
-        end
+      it "fails with a wrong password" do
+        page = browser.create_page(proxy: { host: proxy.host, port: proxy.port,
+                                            user: options[:user], password: "$$" })
 
-        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.go_to("https://example.com") }.to raise_error(
+          Ferrum::StatusError,
+          "Request to https://example.com failed (net::ERR_HTTP_RESPONSE_CODE_FAILURE)"
+        )
+        expect(page.network.status).to eq(407)
+      end
 
-          expect(page.network.status).to eq(200)
-          expect(page.body).to include("Example Domain")
-        end
+      it "succeeds with the 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
 
-  describe "#debug_url" do
-    it "parses the devtools frontend url correctly when devtoolsFrontendUrl is relative", :launch do
+  describe "#debug" do
+    it "opens the devtools frontend when devtoolsFrontendUrl is relative", :launch do
       browser = Ferrum::Browser.new(port: 12_345)
       uri = instance_double(URI)
 
       allow(browser).to receive(:URI).with("http://127.0.0.1:12345/json").and_return(uri)
       allow(Net::HTTP).to receive(:get).with(uri).and_return(%([{"devtoolsFrontendUrl":"/works"}]))
+      expect(Process).to receive(:spawn).with(browser.process.path, "http://127.0.0.1:12345/works")
 
-      expect(browser.send(:debug_url)).to eq("http://127.0.0.1:12345/works")
+      browser.debug(instance_double(Binding, irb: nil))
+    ensure
+      browser&.quit
     end
 
-    it "parses the devtools frontend url correctly when devtoolsFrontendUrl is fully qualified", :launch do
+    it "opens the devtools frontend when devtoolsFrontendUrl is fully qualified", :launch do
       browser = Ferrum::Browser.new(port: 12_346)
       uri = instance_double(URI)
 
@@ -1113,44 +1149,26 @@ def proxy_tunnel(socket, request, browser_url)
       allow(Net::HTTP).to receive(:get).with(uri).and_return(
         %([{"devtoolsFrontendUrl":"https://chrome-devtools-frontend.appspot.com/serve_rev?ws=123"}])
       )
+      expect(Process).to receive(:spawn)
+        .with(browser.process.path, "https://chrome-devtools-frontend.appspot.com/serve_rev?ws=123")
 
-      expect(browser.send(:debug_url)).to eq("https://chrome-devtools-frontend.appspot.com/serve_rev?ws=123")
+      browser.debug(instance_double(Binding, irb: nil))
+    ensure
+      browser&.quit
     end
   end
 
-  context "with pty", :launch, 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
+  describe "#console" do
+    it "returns the console of the page" do
+      browser.go_to("/console_log")
 
-    let(:script) do
-      <<-RUBY
-        require "ferrum"
-        browser = Ferrum::Browser.new
-        browser.go_to("http://example.com")
-        puts "Please type enter"
-        sleep 1
-        browser.url
-      RUBY
+      wait_for { browser.console.map(&:text) }.to eq(["Hello world"])
     end
+  end
 
-    it do
-      expect(@status).to be_success
+  describe "#accessibility" do
+    it "returns the accessibility of the page" do
+      expect(browser.accessibility).to be_a(Ferrum::Accessibility)
     end
   end
 end
diff --git a/spec/client_spec.rb b/spec/client_spec.rb
index d483ecf6..8396926e 100644
--- a/spec/client_spec.rb
+++ b/spec/client_spec.rb
@@ -1,114 +1,111 @@
 # frozen_string_literal: true
 
 describe Ferrum::Client do
-  describe "timeouts" do
-    it "names the command that timed out" do
-      expect { page.command("Page.navigate", timeout: 0.5, url: base_url("/really_slow")) }
-        .to raise_error(Ferrum::TimeoutError, /a response to Page.navigate \(session .+\)/)
-    end
-  end
-
-  describe "an unknown target" do
-    it "raises NoSuchTargetError" do
-      expect { page.command("Target.activateTarget", targetId: "missing") }
-        .to raise_error(Ferrum::NoSuchTargetError)
-    end
-  end
-
-  describe "a dead connection" do
-    let(:remote) { Ferrum::Browser.new(base_url: base_url, timeout: 10, protocol_timeout: 10) }
-
-    after { remote.quit }
+  describe "#command" do
+    let(:larger_than_socket_buffers) { "'#{'x' * (16 * 1024 * 1024)}'.length" }
 
     def messages
       remote.client.instance_variable_get(:@ws).messages
     end
 
-    it "releases the commands in flight", :launch do
-      page = remote.create_page
+    def evaluate_in_background(page, expression, timeout:)
       Thread.new do
-        sleep(0.2)
-        messages.close
+        page.command("Runtime.evaluate", expression: expression, timeout: timeout)
+      rescue Ferrum::Error => e
+        e
       end
-      start = Ferrum::Utils::ElapsedTime.monotonic_time
-
-      expect { page.go_to("/really_slow") }.to raise_error(Ferrum::DeadBrowserError)
-      expect(Ferrum::Utils::ElapsedTime.elapsed_time(start)).to be < 5
     end
 
-    it "fails the commands that follow without waiting", :launch do
-      page = remote.create_page
-      messages.close
-      start = Ferrum::Utils::ElapsedTime.monotonic_time
+    context "with a responsive browser" do
+      it "names the command that timed out" do
+        expect { page.command("Page.navigate", timeout: 0.5, url: base_url("/really_slow")) }
+          .to raise_error(Ferrum::TimeoutError, /a response to Page.navigate \(session .+\)/)
+      end
 
-      expect { page.go_to("/") }.to raise_error(Ferrum::DeadBrowserError)
-      expect(Ferrum::Utils::ElapsedTime.elapsed_time(start)).to be < 1
+      it "raises NoSuchTargetError for an unknown target" do
+        expect { page.command("Target.activateTarget", targetId: "missing") }
+          .to raise_error(Ferrum::NoSuchTargetError)
+      end
     end
 
-    it "closes the socket when the browser dies before answering the close frame", :launch do
-      remote.create_page
-      socket = remote.client.instance_variable_get(:@ws).instance_variable_get(:@sock)
-      Process.kill("KILL", -remote.process.pid)
+    context "when the connection is dead" do
+      let(:remote) { Ferrum::Browser.new(base_url: base_url, timeout: 10, protocol_timeout: 10) }
 
-      remote.quit
+      after { remote.quit }
 
-      expect(socket).to be_closed
-    end
+      it "releases the commands in flight", :launch do
+        page = remote.create_page
+        Thread.new do
+          sleep(0.2)
+          messages.close
+        end
+        start = Ferrum::Utils::ElapsedTime.monotonic_time
+
+        expect { page.go_to("/really_slow") }.to raise_error(Ferrum::DeadBrowserError)
+        expect(Ferrum::Utils::ElapsedTime.elapsed_time(start)).to be < 5
+      end
 
-    it "reports an unexpected reader error instead of raising in the main thread", :launch do
-      page = remote.create_page
-      driver = remote.client.instance_variable_get(:@ws).instance_variable_get(:@driver)
-      allow(driver).to receive(:parse).and_raise(Errno::ETIMEDOUT)
+      it "fails the commands that follow without waiting", :launch do
+        page = remote.create_page
+        messages.close
+        start = Ferrum::Utils::ElapsedTime.monotonic_time
 
-      expect do
         expect { page.go_to("/") }.to raise_error(Ferrum::DeadBrowserError)
-      end.to output(/websocket reader stopped, Errno::ETIMEDOUT/).to_stderr
-    end
-  end
+        expect(Ferrum::Utils::ElapsedTime.elapsed_time(start)).to be < 1
+      end
 
-  describe "a browser that stops reading", skip: Ferrum::Utils::Platform.windows? do
-    let(:remote) { Ferrum::Browser.new(base_url: base_url, timeout: 1, protocol_timeout: 1) }
-    let(:larger_than_socket_buffers) { "'#{'x' * (16 * 1024 * 1024)}'.length" }
+      it "reports an unexpected reader error instead of raising in the main thread", :launch do
+        page = remote.create_page
+        driver = remote.client.instance_variable_get(:@ws).instance_variable_get(:@driver)
+        allow(driver).to receive(:parse).and_raise(Errno::ETIMEDOUT)
 
-    after do
-      Process.kill("CONT", remote.process.pid)
-      remote.quit
+        expect do
+          expect { page.go_to("/") }.to raise_error(Ferrum::DeadBrowserError)
+        end.to output(/websocket reader stopped, Errno::ETIMEDOUT/).to_stderr
+      end
     end
 
-    def evaluate_in_background(page, expression, timeout:)
-      Thread.new do
-        page.command("Runtime.evaluate", expression: expression, timeout: timeout)
-      rescue Ferrum::Error => e
-        e
+    context "when the browser stops reading", skip: Ferrum::Utils::Platform.windows? do
+      let(:remote) { Ferrum::Browser.new(base_url: base_url, timeout: 1, protocol_timeout: 1) }
+
+      after do
+        Process.kill("CONT", remote.process.pid)
+        remote.quit
       end
-    end
 
-    it "closes the connection once the browser takes no data for protocol_timeout", :launch do
-      page = remote.create_page
-      Process.kill("STOP", remote.process.pid)
+      it "closes the connection once the browser takes no data for protocol_timeout", :launch do
+        page = remote.create_page
+        Process.kill("STOP", remote.process.pid)
 
-      sender = evaluate_in_background(page, larger_than_socket_buffers, timeout: 3)
+        sender = evaluate_in_background(page, larger_than_socket_buffers, timeout: 3)
 
-      expect(sender.join(2)).to eq(sender), "the command was still blocked after 2s"
-      expect(sender.value).to be_a(Ferrum::DeadBrowserError)
-      expect(sender.value.message).to match(/accepted no data for 1s/)
-    end
+        expect(sender.join(2)).to eq(sender), "the command was still blocked after 2s"
+        expect(sender.value).to be_a(Ferrum::DeadBrowserError)
+        expect(sender.value.message).to match(/accepted no data for 1s/)
+      end
 
-    it "fails the commands waiting to be sent behind it", :launch do
-      page = remote.create_page
-      Process.kill("STOP", remote.process.pid)
+      it "fails the commands waiting to be sent behind it", :launch do
+        page = remote.create_page
+        Process.kill("STOP", remote.process.pid)
 
-      evaluate_in_background(page, larger_than_socket_buffers, timeout: 3)
-      sleep(0.2)
-      waiting = evaluate_in_background(page, "1 + 1", timeout: 3)
+        evaluate_in_background(page, larger_than_socket_buffers, timeout: 3)
+        sleep(0.2)
+        waiting = evaluate_in_background(page, "1 + 1", timeout: 3)
 
-      expect(waiting.join(2)).to eq(waiting), "the command was still blocked after 2s"
-      expect(waiting.value).to be_a(Ferrum::DeadBrowserError)
+        expect(waiting.join(2)).to eq(waiting), "the command was still blocked after 2s"
+        expect(waiting.value).to be_a(Ferrum::DeadBrowserError)
+      end
     end
 
-    context "for less than protocol_timeout" do
+    context "when the browser stops reading for less than protocol_timeout",
+            skip: Ferrum::Utils::Platform.windows? do
       let(:remote) { Ferrum::Browser.new(base_url: base_url, protocol_timeout: 5) }
 
+      after do
+        Process.kill("CONT", remote.process.pid)
+        remote.quit
+      end
+
       it "times out a command waiting to be sent and keeps the connection", :launch do
         page = remote.create_page
         Process.kill("STOP", remote.process.pid)
@@ -127,7 +124,7 @@ def evaluate_in_background(page, expression, timeout:)
     end
   end
 
-  describe "event callbacks" do
+  describe "#on" do
     let(:remote) { Ferrum::Browser.new(base_url: base_url, timeout: 3, protocol_timeout: 3) }
 
     after { remote.quit }
@@ -145,4 +142,20 @@ def evaluate_in_background(page, expression, timeout:)
       expect(page.body).to include("Hello world!")
     end
   end
+
+  describe "#close" do
+    let(:remote) { Ferrum::Browser.new(base_url: base_url, timeout: 10, protocol_timeout: 10) }
+
+    after { remote.quit }
+
+    it "closes the socket when the browser dies before answering the close frame", :launch do
+      remote.create_page
+      socket = remote.client.instance_variable_get(:@ws).instance_variable_get(:@sock)
+      Process.kill("KILL", -remote.process.pid)
+
+      remote.quit
+
+      expect(socket).to be_closed
+    end
+  end
 end
diff --git a/spec/console_spec.rb b/spec/console_spec.rb
index a8c12ee6..8e7eac2c 100644
--- a/spec/console_spec.rb
+++ b/spec/console_spec.rb
@@ -3,124 +3,95 @@
 describe Ferrum::Console do
   let(:console) { page.console }
 
-  it "collects console API calls" do
-    page.go_to("/console_log")
-
-    wait_for { console.size }.to eq(1)
-    message = console.first
-    expect(message.type).to eq(:log)
-    expect(message.source).to eq(:console_api)
-    expect(message.text).to eq("Hello world")
-    expect(message.severity).to eq(:info)
-    expect(message.timestamp).to be_within(60).of(Time.now)
-    expect(message.location.url).to end_with("/console_log")
-    expect(message.location.function_name).to eq("window.onload")
-    expect(message.to_s).to start_with("[log] Hello world\n    at window.onload (")
-  end
-
-  it "converts arguments to Ruby values" do
-    page.go_to
-    page.execute(<<~JS)
-      console.log("text", 1, 1.5, true, null, undefined, NaN, 10n,
-                  { a: 1, b: "x", c: [1, 2] }, [1, "a", null], () => 1)
-    JS
-
-    wait_for { console.size }.to eq(1)
-    expect(console.first.args).to match(
-      ["text", 1, 1.5, true, nil, nil, be_nan, 10, { "a" => 1, "b" => "x", "c" => "Array(2)" }, [1, "a", nil], "() => 1"]
-    )
-    expect(console.first.text).to eq(
-      %(text 1 1.5 true null undefined NaN 10n {"a":1,"b":"x","c":"Array(2)"} [1,"a",null] () => 1)
-    )
-  end
-
-  it "tells errors and warnings apart" do
-    page.go_to
-    page.execute(<<~JS)
-      console.error("bad")
-      console.warn("careful")
-      console.info("fine")
-    JS
-
-    wait_for { console.size }.to eq(3)
-    expect(console.select(&:error?).map(&:text)).to eq(["bad"])
-    expect(console.select(&:warning?).map(&:text)).to eq(["careful"])
-    expect(console.map(&:type)).to eq(%i[error warning info])
-  end
-
-  it "collects uncaught exceptions" do
-    page.go_to
-    page.execute(%(setTimeout(() => { throw new Error("boom") })))
-
-    wait_for { console.size }.to eq(1)
-    message = console.first
-    expect(message.source).to eq(:exception)
-    expect(message).to be_error
-    expect(message.text).to start_with("Uncaught Error: boom")
-  end
-
-  it "collects browser log entries" do
-    page.go_to
-    page.execute(%(document.body.appendChild(document.createElement("img")).src = "/unexist.png"))
+  describe "#each" do
+    it "collects console API calls" do
+      page.go_to("/console_log")
 
-    wait_for { console.size }.to eq(1)
-    message = console.first
-    expect(message.source).to eq(:network)
-    expect(message).to be_error
-    expect(message).to be_match("404")
-    expect(message.location.url).to end_with("/unexist.png")
-  end
+      wait_for { console.size }.to eq(1)
+      message = console.first
+      expect(message.type).to eq(:log)
+      expect(message.source).to eq(:console_api)
+      expect(message.text).to eq("Hello world")
+      expect(message.severity).to eq(:info)
+      expect(message.timestamp).to be_within(60).of(Time.now)
+      expect(message.location.url).to end_with("/console_log")
+      expect(message.location.function_name).to eq("window.onload")
+      expect(message.to_s).to start_with("[log] Hello world\n    at window.onload (")
+    end
 
-  it "keeps only the most recent messages" do
-    page.go_to
-    page.execute("for (let i = 0; i < #{described_class::LIMIT + 5}; i++) console.log(i)")
+    it "converts arguments to Ruby values" do
+      page.go_to
+      page.execute(<<~JS)
+        console.log("text", 1, 1.5, true, null, undefined, NaN, 10n,
+                    { a: 1, b: "x", c: [1, 2] }, [1, "a", null], () => 1)
+      JS
+
+      wait_for { console.size }.to eq(1)
+      expect(console.first.args).to match(
+        ["text", 1, 1.5, true, nil, nil, be_nan, 10, { "a" => 1, "b" => "x", "c" => "Array(2)" }, [1, "a", nil], "() => 1"]
+      )
+      expect(console.first.text).to eq(
+        %(text 1 1.5 true null undefined NaN 10n {"a":1,"b":"x","c":"Array(2)"} [1,"a",null] () => 1)
+      )
+    end
 
-    wait_for { console.last&.text }.to eq((described_class::LIMIT + 4).to_s)
-    expect(console.size).to eq(described_class::LIMIT)
-    expect(console.first.text).to eq("5")
-  end
+    it "tells errors and warnings apart" do
+      page.go_to
+      page.execute(<<~JS)
+        console.error("bad")
+        console.warn("careful")
+        console.info("fine")
+      JS
+
+      wait_for { console.size }.to eq(3)
+      expect(console.select(&:error?).map(&:text)).to eq(["bad"])
+      expect(console.select(&:warning?).map(&:text)).to eq(["careful"])
+      expect(console.map(&:type)).to eq(%i[error warning info])
+    end
 
-  it "forgets messages on clear" do
-    page.go_to("/console_log")
-    wait_for { console.size }.to eq(1)
+    it "collects uncaught exceptions" do
+      page.go_to
+      page.execute(%(setTimeout(() => { throw new Error("boom") })))
 
-    console.clear
-    expect(console).to be_empty
+      wait_for { console.size }.to eq(1)
+      message = console.first
+      expect(message.source).to eq(:exception)
+      expect(message).to be_error
+      expect(message.text).to start_with("Uncaught Error: boom")
+    end
 
-    page.execute(%(console.log("again")))
-    wait_for { console.map(&:text) }.to eq(["again"])
-  end
+    it "collects browser log entries" do
+      page.go_to
+      page.execute(%(document.body.appendChild(document.createElement("img")).src = "/unexist.png"))
+
+      wait_for { console.size }.to eq(1)
+      message = console.first
+      expect(message.source).to eq(:network)
+      expect(message).to be_error
+      expect(message).to be_match("404")
+      expect(message.location.url).to end_with("/unexist.png")
+    end
 
-  it "is reachable through the browser" do
-    browser.go_to("/console_log")
+    it "keeps only the most recent messages" do
+      page.go_to
+      page.execute("for (let i = 0; i < #{described_class::LIMIT + 5}; i++) console.log(i)")
 
-    wait_for { browser.console.map(&:text) }.to eq(["Hello world"])
+      wait_for { console.last&.text }.to eq((described_class::LIMIT + 4).to_s)
+      expect(console.size).to eq(described_class::LIMIT)
+      expect(console.first.text).to eq("5")
+    end
   end
 
-  describe "page.on(:console)" do
-    it "yields new messages" do
-      messages = []
-      page.on(:console) { |message| messages << message.text }
-
+  describe "#clear" do
+    it "forgets the collected messages" do
       page.go_to("/console_log")
-      page.execute(%(console.warn("later")))
-
-      wait_for { messages }.to eq(["Hello world", "later"])
-    end
-
-    it "stops yielding after page.off(:console)" do
-      messages = []
-      id = page.on(:console) { |message| messages << message.text }
-
-      page.go_to
-      page.execute(%(console.log("first")))
-      wait_for { messages }.to eq(["first"])
+      wait_for { console.size }.to eq(1)
 
-      page.off(:console, id)
-      page.execute(%(console.log("second")))
-      wait_for { console.size }.to eq(2)
+      console.clear
+      expect(console).to be_empty
 
-      expect(messages).to eq(["first"])
+      page.execute(%(console.log("again")))
+      wait_for { console.map(&:text) }.to eq(["again"])
     end
   end
 end
diff --git a/spec/context_spec.rb b/spec/context_spec.rb
index efe6af68..3e47b2f9 100644
--- a/spec/context_spec.rb
+++ b/spec/context_spec.rb
@@ -14,7 +14,7 @@
       popup.close
     end
 
-    it "can access a second window of the same name" do
+    it "opens a second window under the same name" do
       browser.go_to
 
       browser.execute <<-JS
@@ -66,5 +66,94 @@
     ensure
       browser&.quit
     end
+
+    it "connects to a service worker on demand, keeping it alive" do
+      page.go_to
+      page.evaluate(%(await navigator.serviceWorker.register("/sw.js")), timeout: 5)
+
+      target = wait_for_target(&:service_worker?)
+      browser.attach_target(target.id)
+
+      expect(target.worker.evaluate("1 + 1")).to eq(2)
+    end
+  end
+
+  describe "#workers" do
+    it "returns a connected dedicated worker" do
+      page.go_to
+
+      page.execute <<~JS
+        new Worker(URL.createObjectURL(new Blob(
+          ["self.onmessage = () => self.postMessage(1 + 1)"],
+          { type: "application/javascript" }
+        )))
+      JS
+
+      target = wait_for_target(&:worker?)
+
+      expect(target.url).to start_with("blob:")
+      expect(target.connected?).to eq(true)
+      expect(browser.workers).to contain_exactly(target.worker)
+      expect(target.worker.evaluate("1 + 1")).to eq(2)
+    end
+
+    it "returns a connected shared worker" do
+      page.go_to
+
+      page.execute <<~JS
+        new SharedWorker(URL.createObjectURL(new Blob(
+          ["self.onconnect = () => {}"],
+          { type: "application/javascript" }
+        )))
+      JS
+
+      target = wait_for_target(&:shared_worker?)
+
+      expect(target.connected?).to eq(true)
+      expect(browser.workers).to contain_exactly(target.worker)
+      expect(target.worker.evaluate("1 + 1")).to eq(2)
+    end
+
+    it "leaves out a detached worker" do
+      page.go_to
+
+      page.execute <<~JS
+        new Worker(URL.createObjectURL(new Blob(
+          ["self.onmessage = () => {}"],
+          { type: "application/javascript" }
+        )))
+      JS
+
+      target = wait_for_target(&:worker?)
+      wait_for { browser.workers }.to contain_exactly(target.worker)
+      page.command("Target.detachFromTarget", sessionId: target.session_id)
+
+      wait_for { browser.workers }.to be_empty
+    end
+  end
+
+  describe "#service_workers" do
+    it "returns registered service workers without connecting to them" do
+      page.go_to
+      page.evaluate(%(await navigator.serviceWorker.register("/sw.js")), timeout: 5)
+
+      target = wait_for_target(&:service_worker?)
+
+      expect(target.url).to end_with("/sw.js")
+      expect(target.connected?).to eq(false)
+      expect(browser.service_workers).to contain_exactly(target)
+    end
+
+    it "detaches from them so Chrome can terminate them" do
+      page.go_to
+      page.execute(%(await navigator.serviceWorker.register("/sw.js")), timeout: 5)
+      target = wait_for_target(&:service_worker?)
+
+      wait_for do
+        browser.client.command("Target.getTargets")["targetInfos"]
+               .select { |info| info["type"] == "service_worker" }.map { |info| info["attached"] }
+      end.to eq([false])
+      expect(target.session_id).to be_nil
+    end
   end
 end
diff --git a/spec/contexts_spec.rb b/spec/contexts_spec.rb
index 301912fb..716e7251 100644
--- a/spec/contexts_spec.rb
+++ b/spec/contexts_spec.rb
@@ -5,23 +5,25 @@
   # browser context. Auto-attach runs with `waitForDebuggerOnStart`, so they arrive
   # paused, and nothing resumes a type we don't track: left alone they stay attached
   # and paused for the lifetime of the browser.
-  it "detaches from attached targets of a type it doesn't track" do
-    untracked = Concurrent::Array.new
-    detached = Concurrent::Array.new
+  describe ".new" do
+    it "detaches from attached targets of a type it doesn't track" do
+      untracked = Concurrent::Array.new
+      detached = Concurrent::Array.new
 
-    attached_id = browser.client.on("Target.attachedToTarget") do |params|
-      type = params["targetInfo"]["type"]
-      untracked << params["sessionId"] unless described_class::ALLOWED_TARGET_TYPES.include?(type)
-    end
-    detached_id = browser.client.on("Target.detachedFromTarget") { |params| detached << params["sessionId"] }
+      attached_id = browser.client.on("Target.attachedToTarget") do |params|
+        type = params["targetInfo"]["type"]
+        untracked << params["sessionId"] unless described_class::ALLOWED_TARGET_TYPES.include?(type)
+      end
+      detached_id = browser.client.on("Target.detachedFromTarget") { |params| detached << params["sessionId"] }
 
-    browser.contexts.create.create_page
+      browser.contexts.create.create_page
 
-    wait(5).for { untracked.size }.to be >= 2
-    wait(5).for { untracked - detached }.to be_empty
-  ensure
-    browser.client.off("Target.attachedToTarget", attached_id)
-    browser.client.off("Target.detachedFromTarget", detached_id)
+      wait(5).for { untracked.size }.to be >= 2
+      wait(5).for { untracked - detached }.to be_empty
+    ensure
+      browser.client.off("Target.attachedToTarget", attached_id)
+      browser.client.off("Target.detachedFromTarget", detached_id)
+    end
   end
 
   describe "#default_context" do
diff --git a/spec/cookies/cookie_spec.rb b/spec/cookies/cookie_spec.rb
index d7b92597..13684f86 100644
--- a/spec/cookies/cookie_spec.rb
+++ b/spec/cookies/cookie_spec.rb
@@ -22,116 +22,114 @@
   subject { described_class.new(attributes) }
 
   describe "#name" do
-    it "must return the 'name' attribute" do
+    it "returns the 'name' attribute" do
       expect(subject.name).to eq(attributes["name"])
     end
   end
 
   describe "#value" do
-    it "must return the 'value' attribute" do
+    it "returns the 'value' attribute" do
       expect(subject.value).to eq(attributes["value"])
     end
   end
 
   describe "#domain" do
-    it "must return the 'domain' attribute" do
+    it "returns the 'domain' attribute" do
       expect(subject.domain).to eq(attributes["domain"])
     end
   end
 
   describe "#path" do
-    it "must return the 'path' attribute" do
+    it "returns the 'path' attribute" do
       expect(subject.path).to eq(attributes["path"])
     end
   end
 
   describe "#size" do
-    it "must return the 'size' attribute" do
+    it "returns the 'size' attribute" do
       expect(subject.size).to eq(attributes["size"])
     end
   end
 
   describe "#secure?" do
-    it "must return the 'secure' attribute" do
+    it "returns the 'secure' attribute" do
       expect(subject.secure?).to eq(attributes["secure"])
     end
   end
 
   describe "#httponly?" do
-    it "must return the 'httpOnly' attribute" do
+    it "returns the 'httpOnly' attribute" do
       expect(subject.httponly?).to eq(attributes["httpOnly"])
     end
   end
 
   describe "#session?" do
-    it "must return the 'session' attribute" do
+    it "returns the 'session' attribute" do
       expect(subject.session?).to eq(attributes["session"])
     end
   end
 
   describe "#expires" do
-    it "must parse the 'expires' attribute as a Time object" do
+    it "parses the 'expires' attribute as a Time object" do
       expect(subject.expires).to eq(Time.at(attributes["expires"]))
     end
 
     context "when the 'expires' attribute is negative" do
       let(:attributes) { { "expires" => -1 } }
 
-      it "must return nil" do
+      it "returns nil" do
         expect(subject.expires).to be(nil)
       end
     end
   end
 
   describe "#priority" do
-    it "must return the 'priority' attribute" do
+    it "returns the 'priority' attribute" do
       expect(subject.priority).to eq(attributes["priority"])
     end
   end
 
   describe "#sameparty?" do
-    it "must return the 'sameParty' attribute" do
+    it "returns the 'sameParty' attribute" do
       expect(subject.sameparty?).to eq(attributes["sameParty"])
     end
   end
 
   describe "#source_scheme" do
-    it "must return the 'sourceScheme' attribute" do
+    it "returns the 'sourceScheme' attribute" do
       expect(subject.source_scheme).to eq(attributes["sourceScheme"])
     end
   end
 
   describe "#source_port" do
-    it "must return the 'sourcePort' attribute" do
+    it "returns the 'sourcePort' attribute" do
       expect(subject.source_port).to eq(attributes["sourcePort"])
     end
   end
 
   describe "#==" do
-    context "when given a #{described_class}" do
-      context "and the other #{described_class}'s attributes are the same" do
-        let(:other) { described_class.new(attributes) }
+    context "when the other cookie has the same attributes" do
+      let(:other) { described_class.new(attributes) }
 
-        it "must return true" do
-          expect(subject == other).to be(true)
-        end
+      it "returns true" do
+        expect(subject == other).to be(true)
       end
+    end
 
-      context "but the other #{described_class}'s attributes are different" do
-        let(:other) do
-          described_class.new("name" => "other", "value" => "other")
-        end
+    context "when the other cookie has different attributes" do
+      let(:other) do
+        described_class.new("name" => "other", "value" => "other")
+      end
 
-        it "must return false" do
-          expect(subject == other).to be(false)
-        end
+      it "returns false" do
+        expect(subject == other).to be(false)
       end
     end
 
-    context "when given another type of Object" do
+    context "when given another type of object" do
       let(:other) { Object.new }
 
-      it "must return false" do
+      it "returns false" do
         expect(subject == other).to be(false)
       end
     end
@@ -149,7 +147,7 @@
         }
       end
 
-      it "must only return 'name=value'" do
+      it "returns only 'name=value'" do
         expect(subject.to_s).to eq("#{name}=#{value}")
       end
     end
@@ -164,7 +162,7 @@
         }
       end
 
-      it "must include the 'Domain=' attribute in the String" do
+      it "includes the 'Domain=' attribute in the String" do
         expect(subject.to_s).to eq("#{name}=#{value}; Domain=#{domain}")
       end
     end
@@ -179,7 +177,7 @@
         }
       end
 
-      it "must include the 'Path=' attribute in the String" do
+      it "includes the 'Path=' attribute in the String" do
         expect(subject.to_s).to eq("#{name}=#{value}; Path=#{path}")
       end
     end
@@ -194,7 +192,7 @@
         }
       end
 
-      it "must include the 'Expires=' attribute and HTTP formatted time in the String" do
+      it "includes the 'Expires=' attribute and HTTP formatted time in the String" do
         expect(subject.to_s).to eq("#{name}=#{value}; Expires=#{Time.at(expires).httpdate}")
       end
     end
@@ -208,7 +206,7 @@
         }
       end
 
-      it "must include the 'httpOnly' flag in the String" do
+      it "includes the 'httpOnly' flag in the String" do
         expect(subject.to_s).to eq("#{name}=#{value}; httpOnly")
       end
     end
@@ -222,14 +220,14 @@
         }
       end
 
-      it "must include the 'Secure' flag in the String" do
+      it "includes the 'Secure' flag in the String" do
         expect(subject.to_s).to eq("#{name}=#{value}; Secure")
       end
     end
   end
 
   describe "#to_h" do
-    it "must return #attributes" do
+    it "returns #attributes" do
       expect(subject.to_h).to eq(subject.attributes)
     end
   end
diff --git a/spec/cookies_spec.rb b/spec/cookies_spec.rb
index 75b61d67..50618367 100644
--- a/spec/cookies_spec.rb
+++ b/spec/cookies_spec.rb
@@ -3,7 +3,7 @@
 describe Ferrum::Cookies do
   describe "#each" do
     context "when a block is given" do
-      it "must yield each Cookie" do
+      it "yields each cookie" do
         browser.go_to("/set_cookie")
 
         yielded_cookies = []
@@ -28,10 +28,26 @@
           ]
         )
       end
+
+      it "yields the cookies of every domain in the context" do
+        browser.cookies.set(name: "stealth", value: "local", domain: "127.0.0.1")
+        browser.cookies.set(name: "other", value: "elsewhere", domain: "localhost")
+
+        expect(browser.cookies.map(&:name)).to contain_exactly("stealth", "other")
+      end
+
+      it "leaves out the cookies of other contexts" do
+        browser.cookies.set(name: "stealth", value: "local")
+        context = browser.contexts.create
+
+        expect(context.cookies.to_a).to eq([])
+      ensure
+        context&.dispose
+      end
     end
 
     context "when no block is given" do
-      it "must return an Enumerator" do
+      it "returns an enumerator" do
         browser.go_to("/set_cookie")
 
         expect(browser.cookies.each.to_a).to eq(
@@ -82,26 +98,8 @@
     end
   end
 
-  describe "context scope" do
-    it "returns the cookies of every domain in the context" do
-      browser.cookies.set(name: "stealth", value: "local", domain: "127.0.0.1")
-      browser.cookies.set(name: "other", value: "elsewhere", domain: "localhost")
-
-      expect(browser.cookies.map(&:name)).to contain_exactly("stealth", "other")
-    end
-
-    it "keeps the cookies of other contexts apart" do
-      browser.cookies.set(name: "stealth", value: "local")
-      context = browser.contexts.create
-
-      expect(context.cookies.to_a).to eq([])
-    ensure
-      context&.dispose
-    end
-  end
-
   describe "#[]" do
-    it "returns cookie object" do
+    it "returns the cookie with the given name" do
       browser.go_to("/set_cookie")
 
       cookie = browser.cookies["stealth"]
@@ -259,7 +257,7 @@
       expect(browser.body).to include("127.0.0.1")
     end
 
-    it "sets cookies correctly with :domain option when base_url isn't set", :launch do
+    it "sets cookies for given domain when base_url isn't set", :launch do
       browser = Ferrum::Browser.new
       browser.cookies.set(name: "stealth", value: "123456", domain: "localhost")
 
@@ -328,7 +326,7 @@
   end
 
   describe "#load" do
-    it "stores cookies" do
+    it "loads cookies" do
       cookie = { "name" => "stealth", "value" => "hello world", "domain" => "127.0.0.1", "path" => "/" }
       File.write("test.yml", [cookie].to_yaml)
       browser.cookies.load("test.yml")
diff --git a/spec/frame/dom_spec.rb b/spec/frame/dom_spec.rb
new file mode 100644
index 00000000..6102e970
--- /dev/null
+++ b/spec/frame/dom_spec.rb
@@ -0,0 +1,436 @@
+# frozen_string_literal: true
+
+describe Ferrum::Frame::DOM do
+  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: "/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-3.7.1.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: "/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
+
+  describe "#current_url" do
+    around do |example|
+      Ferrum::Utils::Deprecate.reset!
+      example.run
+      Ferrum::Utils::Deprecate.reset!
+    end
+
+    it "returns the top window's url and warns that it is deprecated" do
+      page.go_to
+      page.execute(%(document.body.innerHTML += "<iframe src='/slow' name='frame'>"))
+      frame = page.at_xpath("//iframe[@name='frame']").frame
+
+      expect { expect(frame.current_url).to eq(page.url) }
+        .to output(/#current_url will be removed in Ferrum 0\.22.*called from #{__FILE__}/m).to_stderr
+    end
+  end
+
+  describe "#current_title" do
+    around do |example|
+      Ferrum::Utils::Deprecate.reset!
+      example.run
+      Ferrum::Utils::Deprecate.reset!
+    end
+
+    it "returns the top window's title and warns that it is deprecated" do
+      page.go_to
+      page.execute(%(document.body.innerHTML += "<iframe src='/slow' name='frame'>"))
+      frame = page.at_xpath("//iframe[@name='frame']").frame
+
+      expect { expect(frame.current_title).to eq(page.title) }
+        .to output(/#current_title will be removed in Ferrum 0\.22/).to_stderr
+    end
+  end
+
+  describe "#doctype" do
+    it "returns the doctype" do
+      page.go_to("/frames")
+      expect(page.doctype).to eq("<!DOCTYPE html>")
+
+      doctype40 = %(<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">)
+      page.content = "#{doctype40}<html><head></head><body>Voila!</body></html>"
+      expect(page.doctype).to eq(doctype40)
+
+      page.content = ""
+      expect(page.doctype).to be_nil
+    end
+  end
+
+  describe "#body" do
+    it "returns the body of an about:blank frame without a document" do
+      page.go_to
+      page.execute <<-JS
+        document.body.innerHTML += "<iframe src='about:blank' name='frame'>"
+      JS
+      frame = page.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.body).to eq("<html><head></head><body></body></html>")
+    end
+
+    it "returns the body of an about:blank frame built by JS" do
+      page.go_to
+      page.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 = page.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.body).to include("Hello Frame")
+    end
+
+    it "returns the body of a frame with srcdoc" do
+      page.go_to
+      page.execute <<-JS
+        document.body.innerHTML += "<iframe srcdoc='<p>Hello Frame</p>' name='frame'>"
+      JS
+      frame = page.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.body).to include("Hello Frame")
+    end
+
+    it "returns the body of a frame without src filled by JS" do
+      page.go_to
+      page.execute <<-JS
+        document.body.innerHTML += "<iframe id='frame' name='frame'>"
+      JS
+      page.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 = page.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.body).to include("Hello Frame")
+    end
+  end
+
+  describe "#frame_element" do
+    it "gets the frame element" do
+      page.go_to("/frame_parent")
+
+      frame_element = page.at_xpath("//iframe")
+      frame = frame_element.frame
+      expect(frame.frame_element).to eq(frame_element)
+      expect(frame.frame_element.frame_id).to eq frame.id
+      expect(frame.frame_element.attribute(:src)).to eq("/frame_child")
+    end
+
+    it "returns nil for a cross-origin frame" do
+      page.go_to("/frames")
+
+      frame = page.at_xpath("//iframe").frame
+      expect(frame.frame_element).to be_nil
+    end
+
+    it "returns nil if main frame" do
+      page.go_to("/frames")
+
+      parent_frame = page.at_xpath("//iframe").frame.parent
+      expect(parent_frame).to be_main
+      expect(parent_frame.frame_element).to be_nil
+    end
+
+    it "supports nested frames" do
+      page.go_to("/frames")
+      page.execute <<-JS
+        document.body.innerHTML += "<iframe src='/nested_frame_test' name='outer_frame' style='padding:200px'>"
+      JS
+      page.network.wait_for_idle
+
+      outer_frame_element = page.at_xpath("//iframe[@name='outer_frame']")
+      outer_frame = outer_frame_element.frame
+
+      inner_frame_element = outer_frame.at_xpath("//iframe")
+      inner_frame = inner_frame_element.frame
+
+      expect(outer_frame.frame_element).to eq(outer_frame_element)
+      expect(inner_frame.frame_element).to eq(inner_frame_element)
+    end
+  end
+
+  describe "#xpath" do
+    it "returns given nodes" do
+      page.go_to("/with_js")
+      p = page.xpath("//p[@id='remove_me']")
+
+      expect(p.size).to eq(1)
+    end
+
+    it "supports within" do
+      page.go_to("/with_js")
+      p = page.xpath("//p[@id='with_content']").first
+
+      links = page.xpath("./a", within: p)
+
+      expect(links.size).to eq(1)
+      expect(links.first.attribute(:id)).to eq("open-match")
+    end
+
+    it "throws an error on a wrong xpath" do
+      page.go_to("/with_js")
+
+      expect do
+        page.xpath("#remove_me")
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
+
+    it "supports inside a given frame" do
+      page.go_to("/frames")
+      page.execute <<-JS
+        document.body.innerHTML += "<iframe src='/buttons' id='buttons_frame'>"
+      JS
+      page.network.wait_for_idle
+
+      frame = page.at_xpath("//iframe[@id='buttons_frame']").frame
+      expect(frame.xpath("//button").size).to eq(3)
+    end
+  end
+
+  describe "#at_xpath" do
+    it "returns given nodes" do
+      page.go_to("/with_js")
+      p = page.at_xpath("//p[@id='remove_me']")
+
+      expect(p).not_to be_nil
+    end
+
+    it "supports within" do
+      page.go_to("/with_js")
+      p = page.at_xpath("//p[@id='with_content']")
+
+      link = page.at_xpath("./a", within: p)
+
+      expect(link).not_to be_nil
+      expect(link.attribute(:id)).to eq("open-match")
+    end
+
+    it "throws an error on a wrong xpath" do
+      page.go_to("/with_js")
+
+      expect do
+        page.at_xpath("#remove_me")
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
+
+    it "supports inside a given frame" do
+      page.go_to("/frames")
+      page.execute <<-JS
+        document.body.innerHTML += "<iframe src='/buttons' id='buttons_frame'>"
+      JS
+      page.network.wait_for_idle
+
+      frame = page.at_xpath("//iframe[@id='buttons_frame']").frame
+      expect(frame.at_xpath("//button[@id='click_me_123']")).not_to be_nil
+    end
+
+    it "works correctly when JSON is overwritten" do
+      page.go_to("/index")
+      page.execute("JSON = {};")
+      expect { page.at_xpath("//a[text() = 'JS redirect']") }.not_to raise_error
+    end
+  end
+
+  describe "#css" do
+    it "returns given nodes" do
+      page.go_to("/with_js")
+      p = page.css("p#remove_me")
+
+      expect(p.size).to eq(1)
+    end
+
+    it "supports within" do
+      page.go_to("/with_js")
+      p = page.css("p#with_content").first
+
+      links = page.css("a", within: p)
+
+      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
+      page.go_to("/table")
+
+      expect do
+        page.css("table tr:last")
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
+
+    it "supports inside a given frame" do
+      page.go_to("/frames")
+      page.execute <<-JS
+        document.body.innerHTML += "<iframe src='/buttons' id='buttons_frame'>"
+      JS
+      page.network.wait_for_idle
+
+      frame = page.at_css("iframe#buttons_frame").frame
+      expect(frame.css("button").size).to eq(3)
+    end
+  end
+
+  describe "#at_css" do
+    it "returns given nodes" do
+      page.go_to("/with_js")
+      p = page.at_css("p#remove_me")
+
+      expect(p).not_to be_nil
+    end
+
+    it "supports within" do
+      page.go_to("/with_js")
+      p = page.at_css("p#with_content")
+
+      link = page.at_css("a", within: p)
+
+      expect(link).not_to be_nil
+      expect(link.attribute(:id)).to eq("open-match")
+    end
+
+    it "throws an error on an invalid selector" do
+      page.go_to("/table")
+
+      expect do
+        page.at_css("table tr:last")
+      end.to raise_error(Ferrum::JavaScriptError)
+    end
+
+    it "supports inside a given frame" do
+      page.go_to("/frames")
+      page.execute <<-JS
+        document.body.innerHTML += "<iframe src='/buttons' id='buttons_frame'>"
+      JS
+      page.network.wait_for_idle
+
+      frame = page.at_css("iframe#buttons_frame").frame
+      expect(frame.at_css("button#click_me_123")).not_to be_nil
+    end
+  end
+
+  describe "#wait_for_selector" do
+    it "returns the node immediately when it's already present" do
+      page.go_to("/with_js")
+
+      expect(page.wait_for_selector(css: "p#remove_me")).not_to be_nil
+    end
+
+    it "waits for a css selector to appear" do
+      page.go_to("/with_js")
+      page.execute <<-JS
+        setTimeout(function () {
+          var div = document.createElement("div");
+          div.id = "appears_later";
+          document.body.appendChild(div);
+        }, 300);
+      JS
+
+      expect(page.wait_for_selector(css: "div#appears_later", timeout: 2)).not_to be_nil
+    end
+
+    it "waits for an xpath selector to appear" do
+      page.go_to("/with_js")
+      page.execute <<-JS
+        setTimeout(function () {
+          var div = document.createElement("div");
+          div.id = "appears_later";
+          document.body.appendChild(div);
+        }, 300);
+      JS
+
+      expect(page.wait_for_selector(xpath: "//div[@id='appears_later']", timeout: 2)).not_to be_nil
+    end
+
+    it "returns nil once timeout elapses without a match" do
+      page.go_to("/with_js")
+
+      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      node = page.wait_for_selector(css: "div#never_appears", timeout: 0.3, interval: 0.05)
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+
+      expect(node).to be_nil
+      expect(elapsed).to be >= 0.3
+    end
+
+    it "supports within" do
+      page.go_to("/with_js")
+      p = page.at_css("p#with_content")
+
+      link = page.wait_for_selector(css: "a", within: p)
+
+      expect(link).not_to be_nil
+      expect(link.attribute(:id)).to eq("open-match")
+    end
+
+    it "raises when neither css nor xpath is given" do
+      expect { page.wait_for_selector }.to raise_error(ArgumentError)
+    end
+
+    it "raises when both css and xpath are given" do
+      expect { page.wait_for_selector(css: "a", xpath: "//a") }.to raise_error(ArgumentError)
+    end
+  end
+end
diff --git a/spec/frame/runtime_spec.rb b/spec/frame/runtime_spec.rb
index 35a8948e..7c1366f0 100644
--- a/spec/frame/runtime_spec.rb
+++ b/spec/frame/runtime_spec.rb
@@ -101,160 +101,160 @@
   end
 
   describe "#evaluate" do
-    it "returns an element" do
-      browser.go_to("/type")
-      element = browser.evaluate(%(document.getElementById("empty_input")))
-      expect(element).to eq(browser.at_css("#empty_input"))
-    end
+    context "with an expression" do
+      it "returns an element" do
+        browser.go_to("/type")
+        element = browser.evaluate(%(document.getElementById("empty_input")))
+        expect(element).to eq(browser.at_css("#empty_input"))
+      end
 
-    it "returns deeply nested node" do
-      browser.go_to("/deeply_nested")
-      node = browser.evaluate(%(document.getElementById("text")))
-      expect(node.text).to eq("text")
-    end
+      it "returns deeply nested node" do
+        browser.go_to("/deeply_nested")
+        node = browser.evaluate(%(document.getElementById("text")))
+        expect(node.text).to eq("text")
+      end
 
-    it "returns structures with elements" do
-      browser.go_to("/type")
-      result = browser.evaluate <<~JS
-        {
-          a: document.getElementById("empty_input"),
-          b: { c: document.querySelectorAll("#empty_textarea, #filled_textarea") }
-        }
-      JS
+      it "returns structures with elements" do
+        browser.go_to("/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
+        expect(result).to eq(
+          "a" => browser.at_css("#empty_input"),
+          "b" => {
+            "c" => browser.css("#empty_textarea, #filled_textarea")
+          }
+        )
+      end
 
-    it "returns nodes of every type" do
-      browser.content = <<~HTML
-        <!DOCTYPE html>
-        <p class="a" id="b">text<!--comment--></p>
-        <iframe srcdoc="<b>inner</b>"></iframe>
-        <my-element></my-element>
-        <svg><circle r="1"/></svg>
-        <div id="host"></div>
-      HTML
-      nodes = browser.evaluate(<<~JS)
-        (() => {
-          const host = document.getElementById("host");
-          host.attachShadow({ mode: "open" });
-          const p = document.querySelector("p");
-          return [document, document.doctype, p, p.firstChild, p.lastChild, document.querySelector("iframe"),
-                  document.querySelector("my-element"), document.querySelector("circle"), host.shadowRoot];
-        })()
-      JS
+      it "returns nodes of every type" do
+        browser.content = <<~HTML
+          <!DOCTYPE html>
+          <p class="a" id="b">text<!--comment--></p>
+          <iframe srcdoc="<b>inner</b>"></iframe>
+          <my-element></my-element>
+          <svg><circle r="1"/></svg>
+          <div id="host"></div>
+        HTML
+        nodes = browser.evaluate(<<~JS)
+          (() => {
+            const host = document.getElementById("host");
+            host.attachShadow({ mode: "open" });
+            const p = document.querySelector("p");
+            return [document, document.doctype, p, p.firstChild, p.lastChild, document.querySelector("iframe"),
+                    document.querySelector("my-element"), document.querySelector("circle"), host.shadowRoot];
+          })()
+        JS
 
-      expect(nodes.map(&:tag_name)).to eq(
-        %w[#document html p #text #comment iframe my-element circle #document-fragment]
-      )
-      expect(nodes.map(&:node_type)).to eq([9, 10, 1, 3, 8, 1, 1, 1, 11])
-      expect(nodes.map(&:node?)).to eq([false, false, true, false, false, true, true, true, false])
-      expect(nodes[5].frame_id).to eq(browser.frames.reject(&:main?).first.id)
-      expect(nodes.values_at(0..4, 6..8).map(&:frame_id)).to all(be_nil)
-      expect(nodes[2].description).to include("nodeName" => "P", "attributes" => %w[class a id b])
-      expect(nodes[8].description).to include("shadowRootType" => "open")
-    end
+        expect(nodes.map(&:tag_name)).to eq(
+          %w[#document html p #text #comment iframe my-element circle #document-fragment]
+        )
+        expect(nodes.map(&:node_type)).to eq([9, 10, 1, 3, 8, 1, 1, 1, 11])
+        expect(nodes.map(&:node?)).to eq([false, false, true, false, false, true, true, true, false])
+        expect(nodes[5].frame_id).to eq(browser.frames.reject(&:main?).first.id)
+        expect(nodes.values_at(0..4, 6..8).map(&:frame_id)).to all(be_nil)
+        expect(nodes[2].description).to include("nodeName" => "P", "attributes" => %w[class a id b])
+        expect(nodes[8].description).to include("shadowRootType" => "open")
+      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
+      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)
 
-    it "raises when a string is thrown" do
-      expect do
-        browser.evaluate(%((() => { throw "smth" })()))
-      end.to raise_error(Ferrum::JavaScriptError, "Uncaught smth")
-    end
+        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")
 
-    it "raises when an object is thrown" do
-      expect do
-        browser.evaluate("(() => { throw { code: 1 } })()")
-      end.to raise_error(Ferrum::JavaScriptError) { |e| expect(e.class_name).to eq("Object") }
-    end
+        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({})
 
-    it "returns an Error object instead of raising" do
-      expect(browser.evaluate(%(new Error("smth")))).to eq({})
-    end
+        expect do
+          browser.evaluate(%(throw "smth"))
+        end.to raise_error(Ferrum::JavaScriptError)
+      end
 
-    it "keeps null and undefined in arrays" do
-      expect(browser.evaluate("[1, null, undefined, 3]")).to eq([1, nil, nil, 3])
-    end
+      it "raises when a string is thrown" do
+        expect do
+          browser.evaluate(%((() => { throw "smth" })()))
+        end.to raise_error(Ferrum::JavaScriptError, "Uncaught smth")
+      end
 
-    it "returns numbers JSON can't represent" do
-      expect(browser.evaluate("NaN")).to be_nan
-      expect(browser.evaluate("1 / 0")).to eq(Float::INFINITY)
-      expect(browser.evaluate("-1 / 0")).to eq(-Float::INFINITY)
-      expect(browser.evaluate("-0").to_s).to eq("-0.0")
-      expect(browser.evaluate("{ big: 2n ** 64n }")).to eq("big" => 2**64)
-    end
+      it "raises when an object is thrown" do
+        expect do
+          browser.evaluate("(() => { throw { code: 1 } })()")
+        end.to raise_error(Ferrum::JavaScriptError) { |e| expect(e.class_name).to eq("Object") }
+      end
 
-    it "returns dates as ISO strings" do
-      expect(browser.evaluate("[new Date(Date.UTC(2012, 0))]")).to eq(["2012-01-01T00:00:00.000Z"])
-    end
+      it "returns an Error object instead of raising" do
+        expect(browser.evaluate(%(new Error("smth")))).to eq({})
+      end
 
-    it "returns values of getters" do
-      expect(browser.evaluate("{ get a() { return 1 } }")).to eq("a" => 1)
-    end
+      it "keeps null and undefined in arrays" do
+        expect(browser.evaluate("[1, null, undefined, 3]")).to eq([1, nil, nil, 3])
+      end
 
-    it "returns objects without a Ruby equivalent as empty hashes" do
-      expect(browser.evaluate("[new Map([[1, 2]]), new Set([1]), /a/, Symbol('a')]")).to eq([{}, {}, {}, nil])
-    end
+      it "returns numbers JSON can't represent" do
+        expect(browser.evaluate("NaN")).to be_nan
+        expect(browser.evaluate("1 / 0")).to eq(Float::INFINITY)
+        expect(browser.evaluate("-1 / 0")).to eq(-Float::INFINITY)
+        expect(browser.evaluate("-0").to_s).to eq("-0.0")
+        expect(browser.evaluate("{ big: 2n ** 64n }")).to eq("big" => 2**64)
+      end
+
+      it "returns dates as ISO strings" do
+        expect(browser.evaluate("[new Date(Date.UTC(2012, 0))]")).to eq(["2012-01-01T00:00:00.000Z"])
+      end
 
-    it "converts an object shared by many references once" do
-      result = browser.evaluate("() => { let x = { v: 1 }; for (let i = 0; i < 20; i++) x = { l: x, r: x }; return x }")
+      it "returns values of getters" do
+        expect(browser.evaluate("{ get a() { return 1 } }")).to eq("a" => 1)
+      end
+
+      it "returns objects without a Ruby equivalent as empty hashes" do
+        expect(browser.evaluate("[new Map([[1, 2]]), new Set([1]), /a/, Symbol('a')]")).to eq([{}, {}, {}, nil])
+      end
 
-      expect(result["l"]).to equal(result["r"])
-      expect(result.dig(*["l"] * 20)).to eq("v" => 1)
+      it "converts an object shared by many references once" do
+        result = browser.evaluate("() => { let x = { v: 1 }; for (let i = 0; i < 20; i++) x = { l: x, r: x }; return x }")
+
+        expect(result["l"]).to equal(result["r"])
+        expect(result.dig(*["l"] * 20)).to eq("v" => 1)
+      end
     end
 
-    context "when cyclic structure is returned" do
+    context "with a cyclic structure" do
       let(:cyclic) { Ferrum::CyclicObject.instance }
 
-      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
+      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("a" => cyclic, "b" => {}, "c" => { "a" => cyclic })
-        end
+      it "marks seen objects in a returned object" do
+        expect(browser.evaluate(code % "a")).to eq("a" => cyclic, "b" => {}, "c" => { "a" => cyclic })
+      end
 
-        it "returns array" do
-          expect(browser.evaluate(code % "[a]")).to eq([{ "a" => cyclic, "b" => {}, "c" => { "a" => cyclic } }])
-        end
+      it "marks seen objects in a returned array" do
+        expect(browser.evaluate(code % "[a]")).to eq([{ "a" => cyclic, "b" => {}, "c" => { "a" => cyclic } }])
       end
 
       it "backtracks what it has seen" do
@@ -280,298 +280,298 @@
         expect(browser.page).to have_received(:command).once
       end
     end
-  end
 
-  describe "#evaluate with a positional function declaration" do
-    let(:function) do
-      <<~JS
-        function(c) {
-          let a = 1;
-          let b = 2;
-          return a + b + c;
-        }
-      JS
-    end
+    context "with a positional function declaration" 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(function, 3)).to eq(6)
-    end
+      it "evaluates multiple lines of javascript function" do
+        expect(browser.evaluate(function, 3)).to eq(6)
+      end
 
-    it "evaluates a function on a node" do
-      browser.go_to("/index")
-      node = browser.at_xpath(".//a")
+      it "evaluates a function on a node" do
+        browser.go_to("/index")
+        node = browser.at_xpath(".//a")
 
-      function = <<~JS
-        function(attributeName) {
-          return this.getAttribute(attributeName);
-        }
-      JS
+        function = <<~JS
+          function(attributeName) {
+            return this.getAttribute(attributeName);
+          }
+        JS
 
-      expect(node.evaluate(function, "href")).to eq("js_redirect")
+        expect(node.evaluate(function, "href")).to eq("js_redirect")
+      end
     end
-  end
 
-  describe "on a node of the previous page" do
-    it "does not retry if node is not around anymore" do
-      stub_const("Ferrum::Frame::Runtime::INTERMITTENT_SLEEP", 5)
+    context "with a node of the previous page" do
+      it "does not retry if node is not around anymore" do
+        stub_const("Ferrum::Frame::Runtime::INTERMITTENT_SLEEP", 5)
 
-      browser.go_to("/table")
-      node = browser.at_xpath(".//td")
+        browser.go_to("/table")
+        node = browser.at_xpath(".//td")
 
-      browser.go_to("/table")
+        browser.go_to("/table")
 
-      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      expect { node.evaluate("this.textContent") }.to raise_error(Ferrum::NodeNotFoundError)
-      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
+        started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        expect { node.evaluate("this.textContent") }.to raise_error(Ferrum::NodeNotFoundError)
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
 
-      expect(elapsed).to be < Ferrum::Frame::Runtime::INTERMITTENT_SLEEP
-    end
+        expect(elapsed).to be < Ferrum::Frame::Runtime::INTERMITTENT_SLEEP
+      end
 
-    it "raises NodeNotFoundError for a node resolved on the previous page" do
-      browser.go_to("/table")
-      node = browser.at_xpath(".//td")
-      object_id = browser.page.command("DOM.resolveNode", nodeId: node.node_id).dig("object", "objectId")
+      it "raises NodeNotFoundError for a node resolved on the previous page" do
+        browser.go_to("/table")
+        node = browser.at_xpath(".//td")
+        object_id = browser.page.command("DOM.resolveNode", nodeId: node.node_id).dig("object", "objectId")
 
-      browser.go_to("/table")
+        browser.go_to("/table")
 
-      expect do
-        browser.evaluate("arguments[0].textContent", { "objectId" => object_id })
-      end.to raise_error(Ferrum::NodeNotFoundError, /same JavaScript world/)
+        expect do
+          browser.evaluate("arguments[0].textContent", { "objectId" => object_id })
+        end.to raise_error(Ferrum::NodeNotFoundError, /same JavaScript world/)
+      end
     end
-  end
 
-  describe "#evaluate with named arguments" do
-    it "names arguments as function parameters" do
-      expect(browser.evaluate("a + b", a: 1, b: 2)).to eq(3)
-    end
+    context "with named arguments" do
+      it "names arguments as function parameters" do
+        expect(browser.evaluate("a + b", a: 1, b: 2)).to eq(3)
+      end
 
-    it "sends each argument separately so nodes stay live" do
-      browser.go_to("/index")
-      node = browser.at_xpath(".//a")
+      it "sends each argument separately so nodes stay live" do
+        browser.go_to("/index")
+        node = browser.at_xpath(".//a")
 
-      expect(browser.evaluate("el.getAttribute(name)", el: node, name: "href")).to eq("js_redirect")
-    end
+        expect(browser.evaluate("el.getAttribute(name)", el: node, name: "href")).to eq("js_redirect")
+      end
 
-    it "passes positional arguments to a function declaration" do
-      expect(browser.evaluate("function(a, b) { return a - b }", 5, 1)).to eq(4)
-      expect(browser.evaluate("(a, b) => a * b", 3, 4)).to eq(12)
-      expect(browser.evaluate("function({ x }, y = 0) { return x - y }", { x: 5 }, 1)).to eq(4)
-    end
+      it "passes positional arguments to a function declaration" do
+        expect(browser.evaluate("function(a, b) { return a - b }", 5, 1)).to eq(4)
+        expect(browser.evaluate("(a, b) => a * b", 3, 4)).to eq(12)
+        expect(browser.evaluate("function({ x }, y = 0) { return x - y }", { x: 5 }, 1)).to eq(4)
+      end
 
-    it "raises for named arguments to a function declaration" do
-      expect { browser.evaluate("function(a, b) { return a - b }", a: 5, b: 1) }
-        .to raise_error(ArgumentError, /A function declaration names its own parameters/)
-    end
+      it "raises for named arguments to a function declaration" do
+        expect { browser.evaluate("function(a, b) { return a - b }", a: 5, b: 1) }
+          .to raise_error(ArgumentError, /A function declaration names its own parameters/)
+      end
 
-    it "raises for a node inside an array or hash" do
-      browser.go_to("/index")
-      link = browser.at_xpath(".//a")
+      it "raises for a node inside an array or hash" do
+        browser.go_to("/index")
+        link = browser.at_xpath(".//a")
 
-      expect { browser.evaluate("links.length", links: [link]) }
-        .to raise_error(ArgumentError, /inside an Array or Hash can't be passed/)
-      expect { browser.evaluate("o.links", o: { links: [link] }) }
-        .to raise_error(ArgumentError, /inside an Array or Hash can't be passed/)
-    end
+        expect { browser.evaluate("links.length", links: [link]) }
+          .to raise_error(ArgumentError, /inside an Array or Hash can't be passed/)
+        expect { browser.evaluate("o.links", o: { links: [link] }) }
+          .to raise_error(ArgumentError, /inside an Array or Hash can't be passed/)
+      end
 
-    it "passes nil, hashes and arrays by value" do
-      expect(browser.evaluate("value", value: nil)).to be_nil
-      expect(browser.evaluate("value.foo", value: { foo: "bar" })).to eq("bar")
-      expect(browser.evaluate("value.length", value: [1, 2, 3])).to eq(3)
-    end
+      it "passes nil, hashes and arrays by value" do
+        expect(browser.evaluate("value", value: nil)).to be_nil
+        expect(browser.evaluate("value.foo", value: { foo: "bar" })).to eq("bar")
+        expect(browser.evaluate("value.length", value: [1, 2, 3])).to eq(3)
+      end
 
-    it "raises a SyntaxError for a reserved word as a name" do
-      expect { browser.evaluate("1", class: 1) }.to raise_error(Ferrum::JavaScriptError, /SyntaxError/)
-    end
+      it "raises a SyntaxError for a reserved word as a name" do
+        expect { browser.evaluate("1", class: 1) }.to raise_error(Ferrum::JavaScriptError, /SyntaxError/)
+      end
 
-    it "passes positional arguments through arguments" do
-      expect(browser.evaluate("arguments[0] + arguments[1]", 1, 2)).to eq(3)
+      it "passes positional arguments through arguments" do
+        expect(browser.evaluate("arguments[0] + arguments[1]", 1, 2)).to eq(3)
+      end
     end
-  end
 
-  describe "#evaluate with a function declaration" do
-    it "evaluates multiple statements" do
-      expect(browser.evaluate(<<~JS, 3)).to eq(6)
-        function(c) {
-          let a = 1;
-          let b = 2;
-          return a + b + c;
-        }
-      JS
-    end
+    context "with a function declaration" do
+      it "evaluates multiple statements" do
+        expect(browser.evaluate(<<~JS, 3)).to eq(6)
+          function(c) {
+            let a = 1;
+            let b = 2;
+            return a + b + c;
+          }
+        JS
+      end
 
-    it "evaluates a named function declaration" do
-      expect(browser.evaluate("function sum(a, b) { return a + b }", 1, 2)).to eq(3)
-    end
+      it "evaluates a named function declaration" do
+        expect(browser.evaluate("function sum(a, b) { return a + b }", 1, 2)).to eq(3)
+      end
 
-    it "treats an immediately invoked function as an expression, not a declaration" do
-      expect(browser.evaluate(<<~JS)).to eq(3)
-        function() {
-          let a = 1;
-          return a + 2;
-        }();
-      JS
-      expect(browser.evaluate("(function() { return 3 })()")).to eq(3)
-      expect(browser.evaluate("(() => 3)()")).to eq(3)
-    end
+      it "treats an immediately invoked function as an expression, not a declaration" do
+        expect(browser.evaluate(<<~JS)).to eq(3)
+          function() {
+            let a = 1;
+            return a + 2;
+          }();
+        JS
+        expect(browser.evaluate("(function() { return 3 })()")).to eq(3)
+        expect(browser.evaluate("(() => 3)()")).to eq(3)
+      end
 
-    it "accepts arrow functions with default and destructured parameters" do
-      expect(browser.evaluate("(a = 1) => a + 41")).to eq(42)
-      expect(browser.evaluate("({ x }) => x", { x: 1 })).to eq(1)
-    end
+      it "accepts arrow functions with default and destructured parameters" do
+        expect(browser.evaluate("(a = 1) => a + 41")).to eq(42)
+        expect(browser.evaluate("({ x }) => x", { x: 1 })).to eq(1)
+      end
 
-    it "reports errors on the line of the script they're on" do
-      expect { browser.evaluate("a +\nmissing", a: 1) }
-        .to raise_error(Ferrum::JavaScriptError, /missing is not defined\n\s+at <anonymous>:2:/)
-    end
+      it "reports errors on the line of the script they're on" do
+        expect { browser.evaluate("a +\nmissing", a: 1) }
+          .to raise_error(Ferrum::JavaScriptError, /missing is not defined\n\s+at <anonymous>:2:/)
+      end
 
-    it "includes the compiled function when a script doesn't compile" do
-      expect { browser.evaluate("a +", a: 1) }
-        .to raise_error(Ferrum::JavaScriptError, /Unexpected token '\)'\n  in: function\(a\) \{ return \(a \+\n\);/)
-    end
+      it "includes the compiled function when a script doesn't compile" do
+        expect { browser.evaluate("a +", a: 1) }
+          .to raise_error(Ferrum::JavaScriptError, /Unexpected token '\)'\n  in: function\(a\) \{ return \(a \+\n\);/)
+      end
 
-    it "includes a thrown value that isn't an Error in the message" do
-      expect { browser.evaluate("function() { throw 'boom' }") }
-        .to raise_error(Ferrum::JavaScriptError, "Uncaught boom")
-    end
+      it "includes a thrown value that isn't an Error in the message" do
+        expect { browser.evaluate("function() { throw 'boom' }") }
+          .to raise_error(Ferrum::JavaScriptError, "Uncaught boom")
+      end
 
-    it "ignores trailing comments and semicolons when detecting a declaration" do
-      expect(browser.evaluate("function(a) { return a } // adds nothing", 1)).to eq(1)
-      expect(browser.evaluate("function(a) { return a };", 1)).to eq(1)
-    end
+      it "ignores trailing comments and semicolons when detecting a declaration" do
+        expect(browser.evaluate("function(a) { return a } // adds nothing", 1)).to eq(1)
+        expect(browser.evaluate("function(a) { return a };", 1)).to eq(1)
+      end
 
-    it "keeps a // inside strings and regular expressions on the last line" do
-      expect(browser.evaluate("'http://example.com'")).to eq("http://example.com")
-      expect(browser.evaluate("function() { return 'http://example.com' }")).to eq("http://example.com")
-      expect(browser.evaluate("'a//b'.replace(/\\/\\//, '-')")).to eq("a-b")
-      expect(browser.evaluate("`${'http'}://example.com`")).to eq("http://example.com")
-    end
+      it "keeps a // inside strings and regular expressions on the last line" do
+        expect(browser.evaluate("'http://example.com'")).to eq("http://example.com")
+        expect(browser.evaluate("function() { return 'http://example.com' }")).to eq("http://example.com")
+        expect(browser.evaluate("'a//b'.replace(/\\/\\//, '-')")).to eq("a-b")
+        expect(browser.evaluate("`${'http'}://example.com`")).to eq("http://example.com")
+      end
 
-    it "calls a declaration in parentheses" do
-      expect(browser.evaluate("(function(v) { return v * 2 })", 21)).to eq(42)
-      expect(browser.evaluate("((a, b) => a + b)", 1, 2)).to eq(3)
-    end
+      it "calls a declaration in parentheses" do
+        expect(browser.evaluate("(function(v) { return v * 2 })", 21)).to eq(42)
+        expect(browser.evaluate("((a, b) => a + b)", 1, 2)).to eq(3)
+      end
 
-    it "ignores comments before a declaration" do
-      expect(browser.evaluate("// doubles\nfunction(a) { return a * 2 }", 2)).to eq(4)
-    end
+      it "ignores comments before a declaration" do
+        expect(browser.evaluate("// doubles\nfunction(a) { return a * 2 }", 2)).to eq(4)
+      end
 
-    it "reads scripts with non-ASCII text" do
-      expect(browser.evaluate("/* café */ a + 1 // ü", a: 1)).to eq(2)
-      expect(browser.evaluate("// 日本語\nfunction(名前) { return 名前 + '!' }", "é")).to eq("é!")
-    end
+      it "reads scripts with non-ASCII text" do
+        expect(browser.evaluate("/* café */ a + 1 // ü", a: 1)).to eq(2)
+        expect(browser.evaluate("// 日本語\nfunction(名前) { return 名前 + '!' }", "é")).to eq("é!")
+      end
 
-    it "does not call a function that is merely the result of an expression" do
-      expect(browser.evaluate("new Function")).to eq({})
-      expect(browser.evaluate("window.setTimeout")).to eq({})
+      it "does not call a function that is merely the result of an expression" do
+        expect(browser.evaluate("new Function")).to eq({})
+        expect(browser.evaluate("window.setTimeout")).to eq({})
+      end
     end
-  end
 
-  describe "#evaluate with promises" do
-    it "awaits an expression" do
-      expect(browser.evaluate("await Promise.resolve(42)")).to eq(42)
-    end
+    context "with a promise" do
+      it "awaits an expression" do
+        expect(browser.evaluate("await Promise.resolve(42)")).to eq(42)
+      end
 
-    it "awaits a promise returned by a function declaration" do
-      expect(browser.evaluate("function() { return new Promise(resolve => setTimeout(() => resolve(42), 100)) }"))
-        .to eq(42)
-    end
+      it "awaits a promise returned by a function declaration" do
+        expect(browser.evaluate("function() { return new Promise(resolve => setTimeout(() => resolve(42), 100)) }"))
+          .to eq(42)
+      end
 
-    it "awaits an async function declaration" do
-      expect(browser.evaluate("async function(a) { return await Promise.resolve(a) }", 7)).to eq(7)
-    end
+      it "awaits an async function declaration" do
+        expect(browser.evaluate("async function(a) { return await Promise.resolve(a) }", 7)).to eq(7)
+      end
 
-    it "propagates a rejection" do
-      expect { browser.evaluate(%(await Promise.reject(new Error("nope")))) }
-        .to raise_error(Ferrum::JavaScriptError, /nope/)
-    end
+      it "propagates a rejection" do
+        expect { browser.evaluate(%(await Promise.reject(new Error("nope")))) }
+          .to raise_error(Ferrum::JavaScriptError, /nope/)
+      end
 
-    it "doesn't run the script again when the page navigates while awaiting" do
-      browser.go_to("/index")
-      browser.execute("sessionStorage.runs = 0")
+      it "doesn't run the script again when the page navigates while awaiting" do
+        browser.go_to("/index")
+        browser.execute("sessionStorage.runs = 0")
 
-      expect do
-        browser.execute(<<~JS)
-          sessionStorage.runs++;
-          setTimeout(() => location.reload(), 50);
-          await new Promise(() => {});
-        JS
-      end.to raise_error(Ferrum::NodeNotFoundError)
-      expect(browser.evaluate("sessionStorage.runs")).to eq("1")
-    end
+        expect do
+          browser.execute(<<~JS)
+            sessionStorage.runs++;
+            setTimeout(() => location.reload(), 50);
+            await new Promise(() => {});
+          JS
+        end.to raise_error(Ferrum::NodeNotFoundError)
+        expect(browser.evaluate("sessionStorage.runs")).to eq("1")
+      end
 
-    it "times out" do
-      expect { browser.evaluate("new Promise(() => {})", timeout: 1) }
-        .to raise_error(Ferrum::ScriptTimeoutError)
-    end
+      it "times out" do
+        expect { browser.evaluate("new Promise(() => {})", timeout: 1) }
+          .to raise_error(Ferrum::ScriptTimeoutError)
+      end
 
-    it "waits past the page timeout when given a longer one" do
-      with_timeout(1) do
-        expect(browser.evaluate("new Promise(resolve => setTimeout(() => resolve(1), 1500))", timeout: 3)).to eq(1)
+      it "waits past the page timeout when given a longer one" do
+        with_timeout(1) do
+          expect(browser.evaluate("new Promise(resolve => setTimeout(() => resolve(1), 1500))", timeout: 3)).to eq(1)
+        end
       end
-    end
 
-    it "raises a script timeout that is also a Ferrum::TimeoutError" do
-      expect { browser.evaluate("new Promise(() => {})", timeout: 1) }.to raise_error(Ferrum::TimeoutError)
-    end
+      it "raises a script timeout that is also a Ferrum::TimeoutError" do
+        expect { browser.evaluate("new Promise(() => {})", timeout: 1) }.to raise_error(Ferrum::TimeoutError)
+      end
 
-    it "times out when the page replaces setTimeout" do
-      browser.execute("window.setTimeout = () => 0")
+      it "times out when the page replaces setTimeout" do
+        browser.execute("window.setTimeout = () => 0")
 
-      expect { browser.evaluate("new Promise(() => {})", timeout: 1) }.to raise_error(Ferrum::ScriptTimeoutError)
-    end
+        expect { browser.evaluate("new Promise(() => {})", timeout: 1) }.to raise_error(Ferrum::ScriptTimeoutError)
+      end
 
-    it "keeps working when the page replaces Promise" do
-      browser.execute("window.Promise = undefined")
+      it "keeps working when the page replaces Promise" do
+        browser.execute("window.Promise = undefined")
 
-      expect(browser.evaluate("a + 1", a: 1)).to eq(2)
-    end
+        expect(browser.evaluate("a + 1", a: 1)).to eq(2)
+      end
 
-    it "honours a timeout longer than the page timeout" do
-      script = "new Promise(resolve => setTimeout(() => resolve(1), 100))"
-      expect(browser.evaluate(script, timeout: browser.timeout + 5)).to eq(1)
+      it "honours a timeout longer than the page timeout" do
+        script = "new Promise(resolve => setTimeout(() => resolve(1), 100))"
+        expect(browser.evaluate(script, timeout: browser.timeout + 5)).to eq(1)
+      end
     end
-  end
 
-  describe "scripts written for the old API" do
-    it "awaits a returned promise and raises when it rejects" do
-      expect(browser.evaluate("new Promise(resolve => setTimeout(() => resolve(42), 100))")).to eq(42)
-      expect { browser.evaluate("Promise.reject(new Error('nope'))") }.to raise_error(Ferrum::JavaScriptError, /nope/)
-    end
+    context "with a script written for the old API" do
+      it "awaits a returned promise and raises when it rejects" do
+        expect(browser.evaluate("new Promise(resolve => setTimeout(() => resolve(42), 100))")).to eq(42)
+        expect { browser.evaluate("Promise.reject(new Error('nope'))") }.to raise_error(Ferrum::JavaScriptError, /nope/)
+      end
 
-    it "awaits a returned object with a then method" do
-      expect(browser.evaluate("({ then(resolve) { resolve(42) } })")).to eq(42)
-    end
+      it "awaits a returned object with a then method" do
+        expect(browser.evaluate("({ then(resolve) { resolve(42) } })")).to eq(42)
+      end
 
-    it "makes keywords parameters even when the script reads arguments" do
-      expect(browser.evaluate("[foo, arguments[0]]", foo: 1)).to eq([1, 1])
-    end
+      it "makes keywords parameters even when the script reads arguments" do
+        expect(browser.evaluate("[foo, arguments[0]]", foo: 1)).to eq([1, 1])
+      end
 
-    it "rejects mixing positional and named arguments" do
-      expect { browser.evaluate("a", 1, a: 2) }.to raise_error(ArgumentError, /either positionally or by name/)
-    end
+      it "rejects mixing positional and named arguments" do
+        expect { browser.evaluate("a", 1, a: 2) }.to raise_error(ArgumentError, /either positionally or by name/)
+      end
 
-    it "returns the value of the last of several statements" do
-      expect(browser.evaluate("1; 2")).to eq(2)
-      expect(browser.evaluate("document.title = 'x'\ndocument.title")).to eq("x")
-      expect(browser.evaluate("const a = 1")).to be_nil
-    end
+      it "returns the value of the last of several statements" do
+        expect(browser.evaluate("1; 2")).to eq(2)
+        expect(browser.evaluate("document.title = 'x'\ndocument.title")).to eq("x")
+        expect(browser.evaluate("const a = 1")).to be_nil
+      end
 
-    it "runs a script after a leading line break" do
-      expect(browser.evaluate("\n  1 + 1\n")).to eq(2)
-    end
+      it "runs a script after a leading line break" do
+        expect(browser.evaluate("\n  1 + 1\n")).to eq(2)
+      end
 
-    it "waits for a promise returned to #execute" do
-      browser.execute("return new Promise(resolve => setTimeout(() => { window.done = true; resolve() }, 100))")
+      it "waits for a promise returned to #execute" do
+        browser.execute("return new Promise(resolve => setTimeout(() => { window.done = true; resolve() }, 100))")
 
-      expect(browser.evaluate("window.done")).to be(true)
-    end
+        expect(browser.evaluate("window.done")).to be(true)
+      end
 
-    it "resolves nodes and dates from Node#evaluate" do
-      browser.go_to("/index")
-      node = browser.at_xpath(".//a")
+      it "resolves nodes and dates from Node#evaluate" do
+        browser.go_to("/index")
+        node = browser.at_xpath(".//a")
 
-      expect(node.evaluate("this.parentNode")).to be_a(Ferrum::Node)
-      expect(node.evaluate("new Date(0)")).to be_a(String)
+        expect(node.evaluate("this.parentNode")).to be_a(Ferrum::Node)
+        expect(node.evaluate("new Date(0)")).to be_a(String)
+      end
     end
   end
 
@@ -600,103 +600,4 @@
       expect(frame.evaluate_handle("({ title: document.title })").value).to eq("title" => "This is the child frame title")
     end
   end
-
-  describe "Ferrum::Node#evaluate" do
-    before { browser.go_to("/index") }
-
-    it "binds this to the node" do
-      expect(browser.at_xpath(".//a").evaluate("this.getAttribute('href')")).to eq("js_redirect")
-    end
-
-    it "accepts named arguments" do
-      expect(browser.at_xpath(".//a").evaluate("this.getAttribute(name)", name: "href")).to eq("js_redirect")
-    end
-
-    it "resolves nodes returned by a function declaration" do
-      expect(browser.at_xpath(".//a").evaluate("function() { return this.parentNode }")).to be_a(Ferrum::Node)
-    end
-
-    it "calls a named function with #execute" do
-      browser.execute("function setup() { window.ran = true }")
-
-      expect(browser.evaluate("window.ran")).to be(true)
-    end
-
-    it "runs statements with #execute" do
-      node = browser.at_xpath(".//a")
-      node.execute("this.dataset.touched = value", value: "yes")
-
-      expect(node.evaluate("this.dataset.touched")).to eq("yes")
-    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: "/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-3.7.1.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: "/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 8dda8a36..97855cd0 100644
--- a/spec/frame_spec.rb
+++ b/spec/frame_spec.rb
@@ -1,523 +1,88 @@
 # frozen_string_literal: true
 
 describe Ferrum::Frame do
-  describe "#at_xpath" do
-    it "works correctly when JSON is overwritten" do
-      page.go_to("/index")
-      page.execute("JSON = {};")
-      expect { page.at_xpath("//a[text() = 'JS redirect']") }.not_to raise_error
-    end
-  end
-
-  it "supports selection by index" do
-    page.go_to("/frames")
-    frame = page.at_xpath("//iframe").frame
-    expect(frame.url).to end_with("/slow")
-  end
-
-  it "supports selection by element" do
-    page.go_to("/frames")
-    frame = page.at_css("iframe[name]").frame
-    expect(frame.url).to end_with("/slow")
-  end
-
-  it "supports selection by element without name or id" do
-    page.go_to("/frames")
-    frame = page.at_css("iframe:not([name]):not([id])").frame
-    expect(frame.url).to end_with("/headers")
-  end
-
-  it "supports selection by element with id but no name" do
-    page.go_to("/frames")
-    frame = page.at_css("iframe[id]:not([name])").frame
-    expect(frame.url).to end_with("/get_cookie")
-  end
-
-  it "finds main frame properly" do
-    browser.go_to("/popup_frames")
-
-    browser.at_xpath("//a[text()='pop up']").click
-
-    expect(browser.pages.size).to eq(2)
-    opened_page = browser.pages.last
-    expect(opened_page.main_frame.url).to end_with("/frames")
-  end
-
-  it "finds parent frame properly" do
-    page.go_to("/frames")
-    parent_frame = page.at_xpath("//iframe").frame.parent
-    expect(parent_frame.url).to end_with("/frames")
-  end
-
-  it "waits for the frame to load" do
-    page.go_to
-    page.execute <<-JS
-      document.body.innerHTML += "<iframe src='/slow' name='frame'>"
-    JS
-
-    frame = page.at_xpath("//iframe[@name='frame']").frame
-    expect(frame.url).to end_with("/slow")
-    expect(frame.body).to include("slow page")
-
-    expect(page.main_frame.url).to end_with("/")
-  end
-
-  it "waits for the cross-domain frame to load" do
-    page.go_to("/frames")
-    expect(page.url).to eq(base_url("/frames"))
-    frame = page.at_xpath("//iframe[@name='frame']").frame
-
-    expect(frame.url).to end_with("/slow")
-    expect(frame.body).to include("slow page")
-
-    expect(page.url).to end_with("/frames")
-  end
-
-  context "with src == about:blank" do
-    it "doesn't hang if no document created" do
-      page.go_to
-      page.execute <<-JS
-        document.body.innerHTML += "<iframe src='about:blank' name='frame'>"
-      JS
-      frame = page.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
-      page.go_to
-      page.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 = page.at_xpath("//iframe[@name='frame']").frame
-      expect(frame.body).to include("Hello Frame")
-    end
-  end
-
-  context "with no src attribute" do
-    it "doesn't hang if the srcdoc attribute is used" do
-      page.go_to
-      page.execute <<-JS
-        document.body.innerHTML += "<iframe srcdoc='<p>Hello Frame</p>' name='frame'>"
-      JS
-      frame = page.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
-      page.go_to
-      page.execute <<-JS
-        document.body.innerHTML += "<iframe id='frame' name='frame'>"
-      JS
-      page.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 = page.at_xpath("//iframe[@name='frame']").frame
-      expect(frame.body).to include("Hello Frame")
-    end
-  end
-
-  it "finishes a form submission that opens an inline PDF" do
-    page.go_to("/inline_pdf")
-    page.at_css("button").click
-
-    expect(page.url).to eq(base_url("/inline.pdf"))
-    expect(page.network.response.content_type).to eq("application/pdf")
-  end
-
-  it "keeps waiting for a loading frame when another one is removed" do
-    page.go_to("/removed_iframe")
-    page.at_css("button").click
-
-    expect(page.evaluate("document.querySelector('iframe').contentWindow.location.pathname"))
-      .to eq("/show_cookies/set_cookie_slow")
-  end
-
-  it "waits for a navigation a click starts after removing a loaded frame" do
-    page.go_to("/remove_iframe_and_navigate")
-    page.at_css("button").click
-
-    expect(page.evaluate("location.pathname")).to eq("/slow")
-  end
-
-  context "with lazy loading iframes" do
-    it "does not block visit on lazy iframe" do
-      expect { page.go_to("/lazy_iframe") }.not_to raise_error
-
-      states = page.frames.reject(&:main?).map(&:state)
-      expect(states).to eq(%i[stopped_loading stopped_loading])
-    end
-
-    it "does not block click whose handler attaches a lazy iframe" do
-      page.go_to("/lazy_iframe")
-
-      expect { page.at_css("#add_iframe").click }.not_to raise_error
-
-      states = page.frames.reject(&:main?).map(&:state)
-      expect(states).to eq(%i[stopped_loading stopped_loading stopped_loading])
-    end
-
-    it "loads in-viewport lazy iframes" do
-      page.go_to("/lazy_iframe")
-      frame = page.frame_by(name: "lazy_in_viewport")
-
-      states = page.frames.reject(&:main?).map(&:state)
-      expect(frame.body).to include("slow page")
-      expect(states).to eq(%i[stopped_loading stopped_loading])
-    end
-  end
-
-  it "supports clicking in a frame with padding" do
-    page.go_to
-    page.execute <<-JS
-      document.body.innerHTML += "<iframe src='/click_test' name='padded_frame' style='padding:100px;'>"
-    JS
-    sleep 0.5
-    frame = page.at_xpath("//iframe[@name = 'padded_frame']").frame
-
-    log = frame.at_css("#log")
-    frame.at_css("#one").scroll_into_view.click
-    expect(log.text).to eq("one")
-  end
-
-  it "supports clicking in a frame nested in a frame" do
-    page.go_to
-
-    # The padding on the frame here is to differ the sizes of the two
-    # frames, ensuring that their offsets are being calculated separately.
-    # 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.
-    page.execute <<-JS
-      document.body.innerHTML += "<iframe src='/nested_frame_test' name='outer_frame' style='padding:200px'>"
-    JS
-
-    sleep 0.5
-
-    inner_frame = page.frame_by(name: "inner_frame")
-    log = inner_frame.at_css("#log")
-    inner_frame.at_css("#one").scroll_into_view.click
-    expect(log.text).to eq("one")
-  end
-
-  it "does not wait forever for the frame to load" do
-    page.go_to
-
-    frame = page.frame_by(name: "omg")
-
-    expect(frame).to be_nil
-  end
-
-  it "can get the frames url" do
-    page.go_to("/frames")
-
-    frame = page.at_xpath("//iframe").frame
-    expect(frame.url).to end_with("/slow")
-    expect(page.url).to end_with("/frames")
-  end
-
-  describe "#current_url and #current_title" do
-    around do |example|
-      Ferrum::Utils::Deprecate.reset!
-      example.run
-      Ferrum::Utils::Deprecate.reset!
-    end
-
-    it "return the top window's and warn that they are deprecated" do
-      page.go_to
-      page.execute(%(document.body.innerHTML += "<iframe src='/slow' name='frame'>"))
-      frame = page.at_xpath("//iframe[@name='frame']").frame
-
-      expect { expect(frame.current_url).to eq(page.url) }
-        .to output(/#current_url will be removed in Ferrum 0\.22.*called from #{__FILE__}/m).to_stderr
-      expect { expect(frame.current_title).to eq(page.title) }
-        .to output(/#current_title will be removed in Ferrum 0\.22/).to_stderr
-    end
-  end
-
-  it "can set page content" do
-    page.content = "<html><head></head><body>Voila! <a href='#'>Link</a></body></html>"
-
-    expect(page.body).to include("Voila!")
-    expect(page.at_css("a").text).to eq("Link")
-  end
-
-  it "gets page doctype" do
-    page.go_to("/frames")
-    expect(page.doctype).to eq("<!DOCTYPE html>")
-
-    doctype40 = %(<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">)
-    page.content = "#{doctype40}<html><head></head><body>Voila!</body></html>"
-    expect(page.doctype).to eq(doctype40)
-
-    page.content = ""
-    expect(page.doctype).to be_nil
-  end
-
-  context "#frame_element" do
-    it "gets the frame element" do
-      page.go_to("/frame_parent")
-
-      frame_element = page.at_xpath("//iframe")
-      frame = frame_element.frame
-      expect(frame.frame_element).to eq(frame_element)
-      expect(frame.frame_element.frame_id).to eq frame.id
-      expect(frame.frame_element.attribute(:src)).to eq("/frame_child")
-    end
-
-    it "returns nil for a cross-origin frame" do
+  describe "#url" do
+    it "returns the url of a frame selected by index" do
       page.go_to("/frames")
-
       frame = page.at_xpath("//iframe").frame
-      expect(frame.frame_element).to be_nil
+      expect(frame.url).to end_with("/slow")
     end
 
-    it "returns nil if main frame" do
+    it "returns the url of a frame selected by element" do
       page.go_to("/frames")
-
-      parent_frame = page.at_xpath("//iframe").frame.parent
-      expect(parent_frame).to be_main
-      expect(parent_frame.frame_element).to be_nil
+      frame = page.at_css("iframe[name]").frame
+      expect(frame.url).to end_with("/slow")
     end
 
-    it "supports nested frames" do
+    it "returns the url of a frame without name or id" do
       page.go_to("/frames")
-      page.execute <<-JS
-        document.body.innerHTML += "<iframe src='/nested_frame_test' name='outer_frame' style='padding:200px'>"
-      JS
-      page.network.wait_for_idle
-
-      outer_frame_element = page.at_xpath("//iframe[@name='outer_frame']")
-      outer_frame = outer_frame_element.frame
-
-      inner_frame_element = outer_frame.at_xpath("//iframe")
-      inner_frame = inner_frame_element.frame
-
-      expect(outer_frame.frame_element).to eq(outer_frame_element)
-      expect(inner_frame.frame_element).to eq(inner_frame_element)
-    end
-  end
-
-  context "#xpath" do
-    it "returns given nodes" do
-      page.go_to("/with_js")
-      p = page.xpath("//p[@id='remove_me']")
-
-      expect(p.size).to eq(1)
-    end
-
-    it "supports within" do
-      page.go_to("/with_js")
-      p = page.xpath("//p[@id='with_content']").first
-
-      links = page.xpath("./a", within: p)
-
-      expect(links.size).to eq(1)
-      expect(links.first.attribute(:id)).to eq("open-match")
-    end
-
-    it "throws an error on a wrong xpath" do
-      page.go_to("/with_js")
-
-      expect do
-        page.xpath("#remove_me")
-      end.to raise_error(Ferrum::JavaScriptError)
+      frame = page.at_css("iframe:not([name]):not([id])").frame
+      expect(frame.url).to end_with("/headers")
     end
 
-    it "supports inside a given frame" do
+    it "returns the url of a frame with id but no name" do
       page.go_to("/frames")
-      page.execute <<-JS
-        document.body.innerHTML += "<iframe src='/buttons' id='buttons_frame'>"
-      JS
-      page.network.wait_for_idle
-
-      frame = page.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
-      page.go_to("/with_js")
-      p = page.at_xpath("//p[@id='remove_me']")
-
-      expect(p).not_to be_nil
+      frame = page.at_css("iframe[id]:not([name])").frame
+      expect(frame.url).to end_with("/get_cookie")
     end
 
-    it "supports within" do
-      page.go_to("/with_js")
-      p = page.at_xpath("//p[@id='with_content']")
-
-      link = page.at_xpath("./a", within: p)
-
-      expect(link).not_to be_nil
-      expect(link.attribute(:id)).to eq("open-match")
-    end
+    it "returns the url of the main frame of a popup" do
+      browser.go_to("/popup_frames")
 
-    it "throws an error on a wrong xpath" do
-      page.go_to("/with_js")
+      browser.at_xpath("//a[text()='pop up']").click
 
-      expect do
-        page.at_xpath("#remove_me")
-      end.to raise_error(Ferrum::JavaScriptError)
+      expect(browser.pages.size).to eq(2)
+      opened_page = browser.pages.last
+      expect(opened_page.main_frame.url).to end_with("/frames")
     end
 
-    it "supports inside a given frame" do
-      page.go_to("/frames")
+    it "returns the url of a frame once it loads" do
+      page.go_to
       page.execute <<-JS
-        document.body.innerHTML += "<iframe src='/buttons' id='buttons_frame'>"
+      document.body.innerHTML += "<iframe src='/slow' name='frame'>"
       JS
-      page.network.wait_for_idle
-
-      frame = page.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
-      page.go_to("/with_js")
-      p = page.css("p#remove_me")
+      frame = page.at_xpath("//iframe[@name='frame']").frame
+      expect(frame.url).to end_with("/slow")
+      expect(frame.body).to include("slow page")
 
-      expect(p.size).to eq(1)
+      expect(page.main_frame.url).to end_with("/")
     end
 
-    it "supports within" do
-      page.go_to("/with_js")
-      p = page.css("p#with_content").first
-
-      links = page.css("a", within: p)
-
-      expect(links.size).to eq(1)
-      expect(links.first.attribute(:id)).to eq("open-match")
-    end
+    it "returns the url of a cross-domain frame once it loads" do
+      page.go_to("/frames")
+      expect(page.url).to eq(base_url("/frames"))
+      frame = page.at_xpath("//iframe[@name='frame']").frame
 
-    it "throws an error on an invalid selector" do
-      page.go_to("/table")
+      expect(frame.url).to end_with("/slow")
+      expect(frame.body).to include("slow page")
 
-      expect do
-        page.css("table tr:last")
-      end.to raise_error(Ferrum::JavaScriptError)
+      expect(page.url).to end_with("/frames")
     end
 
-    it "supports inside a given frame" do
+    it "returns the url of the frame, not of the page" do
       page.go_to("/frames")
-      page.execute <<-JS
-        document.body.innerHTML += "<iframe src='/buttons' id='buttons_frame'>"
-      JS
-      page.network.wait_for_idle
 
-      frame = page.at_css("iframe#buttons_frame").frame
-      expect(frame.css("button").size).to eq(3)
+      frame = page.at_xpath("//iframe").frame
+      expect(frame.url).to end_with("/slow")
+      expect(page.url).to end_with("/frames")
     end
   end
 
-  context "#at_css" do
-    it "returns given nodes" do
-      page.go_to("/with_js")
-      p = page.at_css("p#remove_me")
-
-      expect(p).not_to be_nil
-    end
-
-    it "supports within" do
-      page.go_to("/with_js")
-      p = page.at_css("p#with_content")
-
-      link = page.at_css("a", within: p)
-
-      expect(link).not_to be_nil
-      expect(link.attribute(:id)).to eq("open-match")
-    end
-
-    it "throws an error on an invalid selector" do
-      page.go_to("/table")
-
-      expect do
-        page.at_css("table tr:last")
-      end.to raise_error(Ferrum::JavaScriptError)
-    end
-
-    it "supports inside a given frame" do
+  describe "#parent" do
+    it "returns the parent frame" do
       page.go_to("/frames")
-      page.execute <<-JS
-        document.body.innerHTML += "<iframe src='/buttons' id='buttons_frame'>"
-      JS
-      page.network.wait_for_idle
-
-      frame = page.at_css("iframe#buttons_frame").frame
-      expect(frame.at_css("button#click_me_123")).not_to be_nil
+      parent_frame = page.at_xpath("//iframe").frame.parent
+      expect(parent_frame.url).to end_with("/frames")
     end
   end
 
-  describe "#wait_for_selector" do
-    it "returns the node immediately when it's already present" do
-      page.go_to("/with_js")
-
-      expect(page.wait_for_selector(css: "p#remove_me")).not_to be_nil
-    end
-
-    it "waits for a css selector to appear" do
-      page.go_to("/with_js")
-      page.execute <<-JS
-        setTimeout(function () {
-          var div = document.createElement("div");
-          div.id = "appears_later";
-          document.body.appendChild(div);
-        }, 300);
-      JS
-
-      expect(page.wait_for_selector(css: "div#appears_later", timeout: 2)).not_to be_nil
-    end
-
-    it "waits for an xpath selector to appear" do
-      page.go_to("/with_js")
-      page.execute <<-JS
-        setTimeout(function () {
-          var div = document.createElement("div");
-          div.id = "appears_later";
-          document.body.appendChild(div);
-        }, 300);
-      JS
-
-      expect(page.wait_for_selector(xpath: "//div[@id='appears_later']", timeout: 2)).not_to be_nil
-    end
-
-    it "returns nil once timeout elapses without a match" do
-      page.go_to("/with_js")
-
-      started_at = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      node = page.wait_for_selector(css: "div#never_appears", timeout: 0.3, interval: 0.05)
-      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started_at
-
-      expect(node).to be_nil
-      expect(elapsed).to be >= 0.3
-    end
-
-    it "supports within" do
-      page.go_to("/with_js")
-      p = page.at_css("p#with_content")
-
-      link = page.wait_for_selector(css: "a", within: p)
-
-      expect(link).not_to be_nil
-      expect(link.attribute(:id)).to eq("open-match")
-    end
-
-    it "raises when neither css nor xpath is given" do
-      expect { page.wait_for_selector }.to raise_error(ArgumentError)
-    end
+  describe "#content=" do
+    it "sets the page content" do
+      page.content = "<html><head></head><body>Voila! <a href='#'>Link</a></body></html>"
 
-    it "raises when both css and xpath are given" do
-      expect { page.wait_for_selector(css: "a", xpath: "//a") }.to raise_error(ArgumentError)
+      expect(page.body).to include("Voila!")
+      expect(page.at_css("a").text).to eq("Link")
     end
   end
 end
diff --git a/spec/headers_spec.rb b/spec/headers_spec.rb
index 680083d6..91ae6a72 100644
--- a/spec/headers_spec.rb
+++ b/spec/headers_spec.rb
@@ -29,6 +29,27 @@
       JS
       expect(browser.body).to include("X_OMG: wat")
     end
+
+    it "keeps a user agent from network.emulate when setting other headers" do
+      browser.network.emulate(user_agent: "Bot/1.0")
+      browser.headers.set({ "X-Trace" => "1" })
+      browser.go_to
+      expect(browser.evaluate("navigator.userAgent")).to eq("Bot/1.0")
+    end
+
+    it "brings the user agent back when set no longer has one" do
+      browser.headers.set("User-Agent" => "foo")
+      browser.headers.set("X-Trace" => "1")
+      browser.go_to
+      expect(browser.evaluate("navigator.userAgent")).to eq(browser.default_user_agent)
+    end
+
+    it "brings client hints back when set no longer has a user agent" do
+      browser.headers.set("User-Agent" => "foo")
+      browser.headers.set("X-Trace" => "1")
+      browser.go_to("/headers")
+      expect(browser.body).to include("SEC_CH_UA_PLATFORM")
+    end
   end
 
   describe "#clear" do
@@ -57,43 +78,6 @@
     end
   end
 
-  describe "overrides" do
-    it "keeps a user agent from network.emulate when adding other headers" do
-      browser.network.emulate(user_agent: "Bot/1.0")
-      browser.headers.add({ "X-Trace" => "1" })
-      browser.go_to("/headers")
-      expect(browser.evaluate("navigator.userAgent")).to eq("Bot/1.0")
-      expect(browser.body).to include("USER_AGENT: Bot/1.0")
-    end
-
-    it "keeps a user agent from network.emulate when setting other headers" do
-      browser.network.emulate(user_agent: "Bot/1.0")
-      browser.headers.set({ "X-Trace" => "1" })
-      browser.go_to
-      expect(browser.evaluate("navigator.userAgent")).to eq("Bot/1.0")
-    end
-
-    it "brings the user agent back when set no longer has one" do
-      browser.headers.set("User-Agent" => "foo")
-      browser.headers.set("X-Trace" => "1")
-      browser.go_to
-      expect(browser.evaluate("navigator.userAgent")).to eq(browser.default_user_agent)
-    end
-
-    it "brings client hints back when set no longer has a user agent" do
-      browser.headers.set("User-Agent" => "foo")
-      browser.headers.set("X-Trace" => "1")
-      browser.go_to("/headers")
-      expect(browser.body).to include("SEC_CH_UA_PLATFORM")
-    end
-
-    it "keeps client hints when the headers have no user agent or language" do
-      browser.headers.add({ "X-Trace" => "1" })
-      browser.go_to("/headers")
-      expect(browser.body).to include("SEC_CH_UA_PLATFORM")
-    end
-  end
-
   describe "#get" do
     it "allows headers to be read" do
       expect(browser.headers.get).to eq({})
@@ -145,5 +129,19 @@
       browser.go_to("/redirect_to_headers")
       expect(browser.body).to include("X_CUSTOM_HEADER: 1")
     end
+
+    it "keeps a user agent from network.emulate when adding other headers" do
+      browser.network.emulate(user_agent: "Bot/1.0")
+      browser.headers.add({ "X-Trace" => "1" })
+      browser.go_to("/headers")
+      expect(browser.evaluate("navigator.userAgent")).to eq("Bot/1.0")
+      expect(browser.body).to include("USER_AGENT: Bot/1.0")
+    end
+
+    it "keeps client hints when the headers have no user agent or language" do
+      browser.headers.add({ "X-Trace" => "1" })
+      browser.go_to("/headers")
+      expect(browser.body).to include("SEC_CH_UA_PLATFORM")
+    end
   end
 end
diff --git a/spec/isolated_world_spec.rb b/spec/isolated_world_spec.rb
index 55aebb5a..f4019917 100644
--- a/spec/isolated_world_spec.rb
+++ b/spec/isolated_world_spec.rb
@@ -1,59 +1,61 @@
 # frozen_string_literal: true
 
 describe Ferrum::IsolatedWorld do
-  it "evaluates apart from the page's globals but shares its DOM" do
-    page.go_to("/simple")
-    world = page.isolated_world("ferrum")
+  describe "#evaluate" do
+    it "evaluates apart from the page's globals but shares its DOM" do
+      page.go_to("/simple")
+      world = page.isolated_world("ferrum")
 
-    world.execute("window.secret = 'isolated'")
+      world.execute("window.secret = 'isolated'")
 
-    expect(world.evaluate("window.secret")).to eq("isolated")
-    expect(world.evaluate("document.title")).to eq("Test")
-    expect(page.evaluate("window.secret")).to be_nil
-  end
+      expect(world.evaluate("window.secret")).to eq("isolated")
+      expect(world.evaluate("document.title")).to eq("Test")
+      expect(page.evaluate("window.secret")).to be_nil
+    end
 
-  it "reaches the world of a script added with evaluate_on_new_document" do
-    page.evaluate_on_new_document("window.secret = 'isolated'", world_name: "ferrum")
-    page.go_to("/simple")
+    it "reaches the world of a script added with evaluate_on_new_document" do
+      page.evaluate_on_new_document("window.secret = 'isolated'", world_name: "ferrum")
+      page.go_to("/simple")
 
-    expect(page.isolated_world("ferrum").evaluate("window.secret")).to eq("isolated")
-    expect(page.evaluate("window.secret")).to be_nil
-  end
+      expect(page.isolated_world("ferrum").evaluate("window.secret")).to eq("isolated")
+      expect(page.evaluate("window.secret")).to be_nil
+    end
 
-  it "starts over in a new document" do
-    page.go_to("/simple")
-    world = page.isolated_world("ferrum")
-    world.execute("window.secret = 'isolated'")
+    it "starts over in a new document" do
+      page.go_to("/simple")
+      world = page.isolated_world("ferrum")
+      world.execute("window.secret = 'isolated'")
 
-    page.go_to("/simple")
+      page.go_to("/simple")
 
-    expect(world.evaluate("window.secret")).to be_nil
-    expect(world.evaluate("document.title")).to eq("Test")
-  end
+      expect(world.evaluate("window.secret")).to be_nil
+      expect(world.evaluate("document.title")).to eq("Test")
+    end
 
-  it "takes and returns nodes" do
-    page.go_to("/simple")
-    world = page.isolated_world("ferrum")
+    it "takes and returns nodes" do
+      page.go_to("/simple")
+      world = page.isolated_world("ferrum")
 
-    expect(world.evaluate("arguments[0].id", page.at_css("#break"))).to eq("break")
-    expect(world.evaluate("document.querySelector('#nav')").text).to eq("Home")
-  end
+      expect(world.evaluate("arguments[0].id", page.at_css("#break"))).to eq("break")
+      expect(world.evaluate("document.querySelector('#nav')").text).to eq("Home")
+    end
 
-  it "takes named arguments and evaluates on its nodes" do
-    page.go_to("/simple")
-    world = page.isolated_world("ferrum")
-    world.execute("window.secret = 'isolated'")
+    it "takes named arguments and evaluates on its nodes" do
+      page.go_to("/simple")
+      world = page.isolated_world("ferrum")
+      world.execute("window.secret = 'isolated'")
 
-    node = world.evaluate("document.querySelector('#nav')")
+      node = world.evaluate("document.querySelector('#nav')")
 
-    expect(world.evaluate("el.id", el: page.at_css("#break"))).to eq("break")
-    expect(node.evaluate("this.textContent + window.secret")).to eq("Homeisolated")
-  end
+      expect(world.evaluate("el.id", el: page.at_css("#break"))).to eq("break")
+      expect(node.evaluate("this.textContent + window.secret")).to eq("Homeisolated")
+    end
 
-  it "evaluates in a frame" do
-    page.go_to("/frames")
-    frame = page.at_css("iframe[name]").frame
+    it "evaluates in a frame" do
+      page.go_to("/frames")
+      frame = page.at_css("iframe[name]").frame
 
-    expect(frame.isolated_world("ferrum").evaluate("location.pathname")).to eq("/slow")
+      expect(frame.isolated_world("ferrum").evaluate("location.pathname")).to eq("/slow")
+    end
   end
 end
diff --git a/spec/mouse_spec.rb b/spec/mouse_spec.rb
index b36471dc..519bbbc3 100644
--- a/spec/mouse_spec.rb
+++ b/spec/mouse_spec.rb
@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 describe Ferrum::Mouse do
+  let(:smooth_browser) do
+    defaults = Ferrum::Browser::Options::Chrome.options.except("disable-smooth-scrolling")
+    Ferrum::Browser.new(ignore_default_browser_options: true, browser_options: defaults.merge("no-sandbox" => nil))
+  end
+
   describe "#click" do
     it "supports clicking precise coordinates" do
       browser.go_to("/click_coordinates")
@@ -30,6 +35,32 @@
       browser.at_xpath("//a[text() = 'Link']").click
       expect(browser.body).to include("Hello world")
     end
+
+    context "on the click test page" do
+      before do
+        browser.go_to("/click_test")
+      end
+
+      after do
+        browser.resize(width: 1024, height: 768)
+        browser.reset
+      end
+
+      it "clicks elements scrolled into view" 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}").scroll_into_view.click
+          expect(log.text).to eq(instruction)
+        end
+      end
+
+      it "clicks an element inside an svg" do
+        expect { browser.at_css("#myrect").click }.not_to raise_error
+      end
+    end
   end
 
   describe "#scroll_by" do
@@ -43,30 +74,20 @@
         browser.evaluate("[window.scrollX, window.scrollY]")
       ).to eq([10, 20])
     end
-  end
-
-  context "with smooth scrolling", :launch do
-    let(:smooth_browser) do
-      defaults = Ferrum::Browser::Options::Chrome.options.except("disable-smooth-scrolling")
-      Ferrum::Browser.new(ignore_default_browser_options: true, browser_options: defaults.merge("no-sandbox" => nil))
-    end
 
-    before do
-      smooth_browser.go_to(base_url("/long_page"))
-      smooth_browser.resize(width: 10, height: 10)
-      smooth_browser.execute("document.documentElement.style.scrollBehavior = 'smooth'")
-    end
-
-    after { smooth_browser.quit }
+    context "with smooth scrolling", :launch do
+      before do
+        smooth_browser.go_to(base_url("/long_page"))
+        smooth_browser.resize(width: 10, height: 10)
+        smooth_browser.execute("document.documentElement.style.scrollBehavior = 'smooth'")
+      end
 
-    it "scrolls by instantly" do
-      smooth_browser.mouse.scroll_by(30, 70)
-      expect(smooth_browser.evaluate("[window.scrollX, window.scrollY]")).to eq([30, 70])
-    end
+      after { smooth_browser.quit }
 
-    it "scrolls to instantly" do
-      smooth_browser.mouse.scroll_to(200, 100)
-      expect(smooth_browser.evaluate("[window.scrollX, window.scrollY]")).to eq([200, 100])
+      it "scrolls instantly" do
+        smooth_browser.mouse.scroll_by(30, 70)
+        expect(smooth_browser.evaluate("[window.scrollX, window.scrollY]")).to eq([30, 70])
+      end
     end
   end
 
@@ -79,6 +100,21 @@
         browser.evaluate("[window.scrollX, window.scrollY]")
       ).to eq([200, 100])
     end
+
+    context "with smooth scrolling", :launch do
+      before do
+        smooth_browser.go_to(base_url("/long_page"))
+        smooth_browser.resize(width: 10, height: 10)
+        smooth_browser.execute("document.documentElement.style.scrollBehavior = 'smooth'")
+      end
+
+      after { smooth_browser.quit }
+
+      it "scrolls instantly" do
+        smooth_browser.mouse.scroll_to(200, 100)
+        expect(smooth_browser.evaluate("[window.scrollX, window.scrollY]")).to eq([200, 100])
+      end
+    end
   end
 
   describe "#move" do
@@ -164,30 +200,4 @@
       ])
     end
   end
-
-  context "mouse support" do
-    before do
-      browser.go_to("/click_test")
-    end
-
-    after do
-      browser.resize(width: 1024, height: 768)
-      browser.reset
-    end
-
-    it "clicks elements scrolled into view" 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}").scroll_into_view.click
-        expect(log.text).to eq(instruction)
-      end
-    end
-
-    it "can click an element inside an svg" do
-      expect { browser.at_css("#myrect").click }.not_to raise_error
-    end
-  end
 end
diff --git a/spec/network/error_spec.rb b/spec/network/error_spec.rb
index fff40208..869e8fe0 100644
--- a/spec/network/error_spec.rb
+++ b/spec/network/error_spec.rb
@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 describe Ferrum::Network::Error do
-  it "#canceled?" do
-    page.go_to("/with_ajax_connection_canceled")
+  describe "#canceled?" do
+    it "returns true for a canceled request" do
+      page.go_to("/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
-    Ferrum::Utils::Attempt.with_retry(errors: RuntimeError, max: 10, wait: 0.1) do
-      page.at_xpath("//h1[text() = 'Canceled']") || raise("Node not found")
-    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
+      expect(network.idle?).to be_truthy
+      expect(last_exchange.error.canceled?).to be_truthy
+    end
   end
 end
diff --git a/spec/network/exchange_spec.rb b/spec/network/exchange_spec.rb
index 1e92c083..95ec41b2 100644
--- a/spec/network/exchange_spec.rb
+++ b/spec/network/exchange_spec.rb
@@ -26,7 +26,7 @@
   end
 
   describe "#intercepted_request" do
-    it "returns request" do
+    it "returns the intercepted request" do
       request_id = nil
       network.intercept
       page.on(:request) do |r|
@@ -70,7 +70,7 @@
   end
 
   describe "#request" do
-    it "returns request" do
+    it "returns the request" do
       page.go_to
 
       expect(last_exchange.request).to be
@@ -79,7 +79,7 @@
   end
 
   describe "#response" do
-    it "returns request" do
+    it "returns the response" do
       page.go_to
 
       expect(last_exchange.response).to be
@@ -88,6 +88,13 @@
   end
 
   describe "#error" do
+    it "captures failed request errors" do
+      page.go_to("/with_ajax_fail")
+      page.network.wait_for_idle!
+
+      expect(last_exchange.error).to be
+    end
+
     it "captures refused connection errors" do
       page.go_to("/with_ajax_connection_refused")
       expect(page.at_xpath("//h1[text() = 'Error']")).to be
diff --git a/spec/network/response_spec.rb b/spec/network/response_spec.rb
index 0987a306..e30ddfac 100644
--- a/spec/network/response_spec.rb
+++ b/spec/network/response_spec.rb
@@ -93,17 +93,8 @@
     end
   end
 
-  describe "#error" do
-    it "captures errors" do
-      page.go_to("/with_ajax_fail")
-      page.network.wait_for_idle!
-
-      expect(last_exchange.error).to be
-    end
-  end
-
   describe "#redirect?" do
-    it "captures errors" do
+    it "returns true for a redirect response" do
       page.go_to("/redirect_again")
 
       expect(page.body).to include("You landed")
@@ -129,7 +120,7 @@
   end
 
   describe "#to_h" do
-    it "must return #params" do
+    it "returns #params" do
       page.go_to("/with_js")
 
       expect(last_exchange.response.to_h).to eq(last_exchange.response.params)
diff --git a/spec/network_spec.rb b/spec/network_spec.rb
index 2a57740c..90076a0a 100644
--- a/spec/network_spec.rb
+++ b/spec/network_spec.rb
@@ -135,51 +135,63 @@
     end
   end
 
-  it "#total_connections" do
-    expect(network.total_connections).to eq(0)
+  describe "#total_connections" do
+    it "counts every connection of the page" do
+      expect(network.total_connections).to eq(0)
 
-    page.go_to("/with_ajax_connection_refused")
-    network.wait_for_idle
+      page.go_to("/with_ajax_connection_refused")
+      network.wait_for_idle
 
-    expect(network.total_connections).to eq(3)
+      expect(network.total_connections).to eq(3)
+    end
   end
 
-  it "#finished_connections" do
-    expect(network.finished_connections).to eq(0)
+  describe "#finished_connections" do
+    it "counts the finished connections" do
+      expect(network.finished_connections).to eq(0)
 
-    page.go_to("/with_ajax_connection_refused")
-    network.wait_for_idle
+      page.go_to("/with_ajax_connection_refused")
+      network.wait_for_idle
 
-    expect(network.finished_connections).to eq(3)
+      expect(network.finished_connections).to eq(3)
+    end
   end
 
-  it "#pending_connections" do
-    expect(network.pending_connections).to eq(0)
+  describe "#pending_connections" do
+    it "counts the pending connections" do
+      expect(network.pending_connections).to eq(0)
 
-    page.go_to("/with_slow_ajax_connection")
-    expect(network.pending_connections).to eq(1)
+      page.go_to("/with_slow_ajax_connection")
+      expect(network.pending_connections).to eq(1)
 
-    network.wait_for_idle
-    expect(network.pending_connections).to eq(0)
+      network.wait_for_idle
+      expect(network.pending_connections).to eq(0)
+    end
   end
 
-  it "#request" do
-    page.go_to("/with_js")
+  describe "#request" do
+    it "returns the main document request" do
+      page.go_to("/with_js")
 
-    expect(network.request.url).to eq(base_url("/with_js"))
+      expect(network.request.url).to eq(base_url("/with_js"))
+    end
   end
 
-  it "#response" do
-    page.go_to("/with_js")
+  describe "#response" do
+    it "returns the main document response" do
+      page.go_to("/with_js")
 
-    expect(network.response.url).to eq(base_url("/with_js"))
-    expect(network.response.status).to eq(200)
+      expect(network.response.url).to eq(base_url("/with_js"))
+      expect(network.response.status).to eq(200)
+    end
   end
 
-  it "#status" do
-    page.go_to("/arbitrary_path/404/missing")
+  describe "#status" do
+    it "returns the main document status" do
+      page.go_to("/arbitrary_path/404/missing")
 
-    expect(network.status).to eq(404)
+      expect(network.status).to eq(404)
+    end
   end
 
   describe "#clear" do
@@ -420,40 +432,36 @@
       expect(frame.body).to include("hello")
     end
 
-    context "with :resource_type argument" do
-      it "raises an error with wrong type" do
-        expect { network.intercept(resource_type: :BlaBla) }.to raise_error(ArgumentError)
+    it "raises an error for an unknown :resource_type" do
+      expect { network.intercept(resource_type: :BlaBla) }.to raise_error(ArgumentError)
+    end
+
+    it "intercepts only the given :resource_type" do
+      network.intercept(resource_type: :Document)
+      page.on(:request) do |request|
+        request.respond(body: "<h1>hello</h1>")
       end
 
-      it "intercepts only given type" do
-        network.intercept(resource_type: :Document)
-        page.on(:request) do |request|
-          request.respond(body: "<h1>hello</h1>")
-        end
+      page.go_to("/non_existing")
 
-        page.go_to("/non_existing")
+      expect(network.status).to eq(200)
+      expect(page.body).to include("hello")
+    end
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("hello")
-      end
+    it "raises an error for an unknown :request_stage" do
+      expect { network.intercept(request_stage: :BlaBla) }.to raise_error(ArgumentError)
     end
 
-    context "with :request_stage argument" do
-      it "raises an error with wrong stage" do
-        expect { network.intercept(request_stage: :BlaBla) }.to raise_error(ArgumentError)
+    it "intercepts only the given :request_stage" do
+      network.intercept(request_stage: :Response)
+      page.on(:request) do |request|
+        request.respond(body: "<h1>hello</h1>")
       end
 
-      it "intercepts only given stage" do
-        network.intercept(request_stage: :Response)
-        page.on(:request) do |request|
-          request.respond(body: "<h1>hello</h1>")
-        end
-
-        page.go_to("/index")
+      page.go_to("/index")
 
-        expect(network.status).to eq(200)
-        expect(page.body).to include("hello")
-      end
+      expect(network.status).to eq(200)
+      expect(page.body).to include("hello")
     end
 
     it "supports custom responses" do
@@ -469,50 +477,6 @@
     end
   end
 
-  describe "#on(:response)" do
-    it "yields the exchange once its response is fully loaded" do
-      exchanges = []
-      page.on(:response) { |exchange, _index, _total| exchanges << exchange }
-
-      page.go_to("/foo")
-
-      expect(exchanges.size).to eq(1)
-      expect(exchanges.first.response.loaded?).to eq(true)
-      expect(exchanges.first.response.body).to eq("Another World")
-    end
-
-    it "fires once per exchange that finishes loading" do
-      exchanges = []
-      page.on(:response) { |exchange, _index, _total| exchanges << exchange }
-
-      page.go_to("/with_js")
-
-      expect(exchanges.map(&:url)).to match_array(traffic.map(&:url))
-    end
-
-    it "does not fire for requests that fail to load" do
-      exchanges = []
-      page.on(:response) { |exchange, _index, _total| exchanges << exchange }
-
-      page.go_to("/with_ajax_connection_refused")
-      network.wait_for_idle
-
-      expect(traffic.size).to eq(3)
-      expect(exchanges.size).to eq(2)
-      expect(exchanges).not_to include(traffic.find(&:error))
-    end
-
-    it "does not require request interception to be set up" do
-      expect(page.subscribed?("Fetch.requestPaused")).to eq(false)
-
-      exchange = nil
-      page.on(:response) { |e, _index, _total| exchange = e }
-      page.go_to("/foo")
-
-      expect(exchange).to be
-    end
-  end
-
   describe "#authorize" do
     it "raises error when authorize is without block" do
       expect do
@@ -594,13 +558,15 @@
     end
   end
 
-  it "#emulate_network_conditions" do
-    page.network.emulate_network_conditions(latency: 500)
+  describe "#emulate_network_conditions" do
+    it "delays requests by the given latency" do
+      page.network.emulate_network_conditions(latency: 500)
 
-    start = Ferrum::Utils::ElapsedTime.monotonic_time
-    page.go_to("/with_js")
+      start = Ferrum::Utils::ElapsedTime.monotonic_time
+      page.go_to("/with_js")
 
-    expect(Ferrum::Utils::ElapsedTime.elapsed_time(start)).to be >= 0.5
+      expect(Ferrum::Utils::ElapsedTime.elapsed_time(start)).to be >= 0.5
+    end
   end
 
   describe "#emulate" do
@@ -728,14 +694,16 @@
     end
   end
 
-  it "#offline_mode" do
-    page.network.offline_mode
+  describe "#offline_mode" do
+    it "fails requests while offline" do
+      page.network.offline_mode
 
-    expect { page.go_to("/with_js") }.to raise_error(
-      Ferrum::StatusError,
-      %r{Request to http://.*/with_js failed \(net::ERR_INTERNET_DISCONNECTED\)}
-    )
+      expect { page.go_to("/with_js") }.to raise_error(
+        Ferrum::StatusError,
+        %r{Request to http://.*/with_js failed \(net::ERR_INTERNET_DISCONNECTED\)}
+      )
 
-    expect(page.at_css("body").text.downcase).to match("no internet")
+      expect(page.at_css("body").text.downcase).to match("no internet")
+    end
   end
 end
diff --git a/spec/node_spec.rb b/spec/node_spec.rb
index 2d2e83a3..2fd98fca 100644
--- a/spec/node_spec.rb
+++ b/spec/node_spec.rb
@@ -158,10 +158,10 @@
       end
     end
 
-    context "can double click" do
+    context "with mode: :double" do
       before { page.go_to("/double_click_test") }
 
-      it "double clicks properly" do
+      it "double-clicks the node" do
         log = browser.at_css("#log")
 
         instructions = %w[one four one two three]
@@ -171,6 +171,82 @@
         end
       end
     end
+
+    it "raises NodeNotFoundError for a node from before a refresh" do
+      browser.go_to("/index")
+      shallow_node = browser.at_xpath(".//a")
+
+      browser.refresh
+      expect { shallow_node.click }.to raise_error(Ferrum::NodeNotFoundError)
+
+      node = browser.at_xpath(".//a")
+      expect { node.click }.not_to raise_error
+    end
+
+    it "finishes a form submission that opens an inline PDF" do
+      page.go_to("/inline_pdf")
+      page.at_css("button").click
+
+      expect(page.url).to eq(base_url("/inline.pdf"))
+      expect(page.network.response.content_type).to eq("application/pdf")
+    end
+
+    it "keeps waiting for a loading frame when another one is removed" do
+      page.go_to("/removed_iframe")
+      page.at_css("button").click
+
+      expect(page.evaluate("document.querySelector('iframe').contentWindow.location.pathname"))
+        .to eq("/show_cookies/set_cookie_slow")
+    end
+
+    it "waits for a navigation it starts after removing a loaded frame" do
+      page.go_to("/remove_iframe_and_navigate")
+      page.at_css("button").click
+
+      expect(page.evaluate("location.pathname")).to eq("/slow")
+    end
+
+    it "clicks a node in a frame with padding" do
+      page.go_to
+      page.execute <<-JS
+      document.body.innerHTML += "<iframe src='/click_test' name='padded_frame' style='padding:100px;'>"
+      JS
+      sleep 0.5
+      frame = page.at_xpath("//iframe[@name = 'padded_frame']").frame
+
+      log = frame.at_css("#log")
+      frame.at_css("#one").scroll_into_view.click
+      expect(log.text).to eq("one")
+    end
+
+    it "clicks a node in a frame nested in a frame" do
+      page.go_to
+
+      # The padding on the frame here is to differ the sizes of the two
+      # frames, ensuring that their offsets are being calculated separately.
+      # 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.
+      page.execute <<-JS
+      document.body.innerHTML += "<iframe src='/nested_frame_test' name='outer_frame' style='padding:200px'>"
+      JS
+
+      sleep 0.5
+
+      inner_frame = page.frame_by(name: "inner_frame")
+      log = inner_frame.at_css("#log")
+      inner_frame.at_css("#one").scroll_into_view.click
+      expect(log.text).to eq("one")
+    end
+
+    it "does not block when its handler attaches a lazy iframe" do
+      page.go_to("/lazy_iframe")
+
+      expect { page.at_css("#add_iframe").click }.not_to raise_error
+
+      states = page.frames.reject(&:main?).map(&:state)
+      expect(states).to eq(%i[stopped_loading stopped_loading stopped_loading])
+    end
   end
 
   describe "#at_xpath" do
@@ -270,23 +346,17 @@
       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
+    it "returns the first option text when no option is selected" do
+      expect(browser.at_xpath("//*[@id='form_title']").selected.map(&:text)).to eq(["Mrs"])
     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
+    it "returns an empty array without selected options" do
+      expect(browser.at_xpath("//*[@id='form_tendency']").selected.map(&:text)).to eq([])
     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
+    it "raises JavaScriptError for an element that isn't a <select>" do
+      expect { browser.at_xpath("//*[@id='customer_name']").selected.map(&:text) }
+        .to raise_exception(Ferrum::JavaScriptError, /Element is not a <select> element/)
     end
   end
 
@@ -299,77 +369,63 @@
       expect(browser.at_xpath("//*[@id='form_title']").select("Miss").selected.map(&:text)).to eq(["Miss"])
     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
+    def expect_select_to_clear(options)
+      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
 
-    context "when option with provided text does not exist" do
-      include_examples "clears selected options with no exception", "Gotcha"
+    it "clears selected options for a text that doesn't exist" do
+      expect_select_to_clear("Gotcha")
     end
 
-    context "when provided empty array" do
-      include_examples "clears selected options with no exception", []
+    it "clears selected options for an empty array" do
+      expect_select_to_clear([])
     end
 
-    context "when provided empty string" do
-      include_examples "clears selected options with no exception", ""
+    it "clears selected options for an empty string" do
+      expect_select_to_clear("")
     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
+    it "picks only the existing options when one of the texts doesn't exist" 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
+    it "picks options of a multiple select by an 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 of a multiple select by strings" do
+      expect(browser.at_xpath("//*[@id='form_languages']").select("SQL", "Ruby").selected.map(&:text))
+        .to eq(%w[Ruby SQL])
     end
 
-    context "when selector is not <select>" do
-      it "raises JavaScriptError with proper message" do
-        expect { browser.at_xpath("//*[@id='customer_name']").select("Ruby") }
-          .to raise_exception(Ferrum::JavaScriptError, /Element is not a <select> element/)
-      end
+    it "raises JavaScriptError for an element that isn't a <select>" do
+      expect { browser.at_xpath("//*[@id='customer_name']").select("Ruby") }
+        .to raise_exception(Ferrum::JavaScriptError, /Element is not a <select> element/)
     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
+    it "picks a disabled option" do
+      expect(browser.at_xpath("//*[@id='form_title']").select(["Other"]).selected.map(&:text)).to eq(["Other"])
     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
+    it "picks an option by its text with by: :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 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 an option of a select with an empty option" 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
+    it "picks the empty option by an empty value" do
+      expect(browser.at_xpath("//select[@id='empty_option']").select("").selected.map(&:value)).to eq([""])
+    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 the empty option by an empty text" do
+      expect(browser.at_xpath("//select[@id='empty_option']").select("", by: :text).selected.map(&:text))
+        .to eq([""])
     end
 
     it "picks option within frame" do
@@ -436,12 +492,12 @@
       browser.go_to("/form")
     end
 
-    context "with hidden input" do
-      it { expect(browser.at_css("#hidden_input").focusable?).to eq(false) }
+    it "returns false for a hidden input" do
+      expect(browser.at_css("#hidden_input").focusable?).to eq(false)
     end
 
-    context "with regular input" do
-      it { expect(browser.at_css("#form_name").focusable?).to eq(true) }
+    it "returns true for a regular input" do
+      expect(browser.at_css("#form_name").focusable?).to eq(true)
     end
 
     it "leaves the node focused" do
@@ -477,6 +533,17 @@
     it "returns nil for an ignored element" do
       expect(browser.at_css("#hidden").axnode).to be_nil
     end
+
+    it "returns the AXNode of a node in an iframe" do
+      browser.go_to("/accessibility_iframe")
+      frame_node = browser.page.at_css("iframe").frame.at_css("#child_btn")
+
+      ax = frame_node.axnode
+
+      expect(ax).to be_a(Ferrum::Accessibility::AXNode)
+      expect(ax.role).to eq("button")
+      expect(ax.name).to eq("Frame button")
+    end
   end
 
   describe "#remove" do
@@ -515,28 +582,6 @@
     end
   end
 
-  context "with whitespace" do
-    before do
-      browser.go_to("/filter_text_test")
-    end
-
-    it "gets text" do
-      expect(browser.at_css("#foo").text).to eq "foo"
-    end
-
-    it "gets inner text with stripped whitespace" do
-      expect(browser.at_css("#bar").inner_text).to eq "bar"
-    end
-
-    it "keeps non-breaking spaces in inner text" do
-      expect(browser.at_css("#baz").inner_text).to eq "\u00a0baz \u00a0 \u00a0"
-    end
-
-    it "keeps all whitespace in text" do
-      expect(browser.at_css("#qux").text).to eq " \u00a0 \u3000 qux  \u3000 \u00a0 \u3000  "
-    end
-  end
-
   describe "#property" do
     before do
       browser.go_to("/attributes_properties")
@@ -611,6 +656,27 @@
         expect(browser.at_css("tspan").text).to eq("svg foo")
       end
     end
+
+    it "returns the text with surrounding whitespace stripped" do
+      browser.go_to("/filter_text_test")
+
+      expect(browser.at_css("#foo").text).to eq "foo"
+    end
+
+    it "keeps all whitespace in the text" do
+      browser.go_to("/filter_text_test")
+
+      expect(browser.at_css("#qux").text).to eq " \u00a0 \u3000 qux  \u3000 \u00a0 \u3000  "
+    end
+
+    it "raises NodeNotFoundError for a node from a previous page" do
+      browser.go_to("/index")
+      node = browser.at_xpath(".//a")
+
+      browser.execute "window.location = 'about:blank'"
+
+      expect { node.text }.to raise_error(Ferrum::NodeNotFoundError)
+    end
   end
 
   describe "#inner_text" do
@@ -620,6 +686,18 @@
 
       expect(el.inner_text).to eq("Foo\nBar")
     end
+
+    it "returns the inner text with stripped whitespace" do
+      browser.go_to("/filter_text_test")
+
+      expect(browser.at_css("#bar").inner_text).to eq "bar"
+    end
+
+    it "keeps non-breaking spaces in the inner text" do
+      browser.go_to("/filter_text_test")
+
+      expect(browser.at_css("#baz").inner_text).to eq "\u00a0baz \u00a0 \u00a0"
+    end
   end
 
   describe "#type" do
@@ -966,25 +1044,36 @@
     end
   end
 
-  context "with disappearing node" do
-    it "raises an error if the element was on a previous page" do
-      browser.go_to("/index")
-      node = browser.at_xpath(".//a")
+  describe "#evaluate" do
+    before { browser.go_to("/index") }
 
-      browser.execute "window.location = 'about:blank'"
+    it "binds this to the node" do
+      expect(browser.at_xpath(".//a").evaluate("this.getAttribute('href')")).to eq("js_redirect")
+    end
 
-      expect { node.text }.to raise_error(Ferrum::NodeNotFoundError)
+    it "accepts named arguments" do
+      expect(browser.at_xpath(".//a").evaluate("this.getAttribute(name)", name: "href")).to eq("js_redirect")
     end
 
-    it "works for a new node after refresh" do
-      browser.go_to("/index")
-      shallow_node = browser.at_xpath(".//a")
+    it "resolves nodes returned by a function declaration" do
+      expect(browser.at_xpath(".//a").evaluate("function() { return this.parentNode }")).to be_a(Ferrum::Node)
+    end
+  end
 
-      browser.refresh
-      expect { shallow_node.click }.to raise_error(Ferrum::NodeNotFoundError)
+  describe "#execute" do
+    before { browser.go_to("/index") }
 
+    it "calls a named function" do
+      browser.execute("function setup() { window.ran = true }")
+
+      expect(browser.evaluate("window.ran")).to be(true)
+    end
+
+    it "runs statements" do
       node = browser.at_xpath(".//a")
-      expect { node.click }.not_to raise_error
+      node.execute("this.dataset.touched = value", value: "yes")
+
+      expect(node.evaluate("this.dataset.touched")).to eq("yes")
     end
   end
 end
diff --git a/spec/page/frames_spec.rb b/spec/page/frames_spec.rb
new file mode 100644
index 00000000..9e88413b
--- /dev/null
+++ b/spec/page/frames_spec.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+describe Ferrum::Page::Frames do
+  describe "#frame_by" do
+    it "returns nil for an unknown frame without waiting for it" do
+      page.go_to
+
+      frame = page.frame_by(name: "omg")
+
+      expect(frame).to be_nil
+    end
+  end
+end
diff --git a/spec/page/screencast_spec.rb b/spec/page/screencast_spec.rb
index 4e3cff75..73c75ecd 100644
--- a/spec/page/screencast_spec.rb
+++ b/spec/page/screencast_spec.rb
@@ -48,22 +48,20 @@
   end
 
   describe "#stop_screencast" do
-    context "when the page content continually changes" do
-      it "stops screencasting frames when the page has finished rendering" do
-        browser.go_to "/animation"
-
-        count = 0
-        browser.start_screencast(format: format) do |data|
-          Base64.decode64(data)
-          count += 1
-        end
-        sleep 2
-        expect(count).to be > 50
-        browser.stop_screencast
-        sleep 2 # wait for events on the fly to land
+    it "stops screencasting frames of a continually changing page" do
+      browser.go_to "/animation"
 
-        expect { sleep 2 }.not_to(change { count })
+      count = 0
+      browser.start_screencast(format: format) do |data|
+        Base64.decode64(data)
+        count += 1
       end
+      sleep 2
+      expect(count).to be > 50
+      browser.stop_screencast
+      sleep 2 # wait for events on the fly to land
+
+      expect { sleep 2 }.not_to(change { count })
     end
   end
 end
diff --git a/spec/page/screenshot_spec.rb b/spec/page/screenshot_spec.rb
index f4a920fb..4ffde462 100644
--- a/spec/page/screenshot_spec.rb
+++ b/spec/page/screenshot_spec.rb
@@ -6,129 +6,105 @@
 require "ferrum/rgba"
 
 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("/long_page")
+  describe "#screenshot" do
+    let(:format) { :png }
+    let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
+    let(:device_pixel_ratio) { browser.device_pixel_ratio }
 
-      create_screenshot(path: file)
+    it "returns the number of bytes saved" do
+      browser.go_to("/simple")
 
-      File.open(file, "rb") do |f|
-        expect(ImageSize.new(f.read).size).to eq(browser.viewport_size.map { |s| s * device_pixel_ratio })
-      end
+      expect(browser.screenshot(path: file)).to eq(File.size(file))
+    end
 
-      create_screenshot(path: file, full: true)
+    after do
+      FileUtils.rm_f(["#{PROJECT_ROOT}/spec/tmp/screenshot.png", "#{PROJECT_ROOT}/spec/tmp/screenshot.jpeg"])
+    end
 
-      File.open(file, "rb") do |f|
-        size = browser.evaluate("[document.documentElement.clientWidth, document.documentElement.clientHeight]")
-        expect(ImageSize.new(f.read).size).to eq(size.map { |s| s * device_pixel_ratio })
+    def create_screenshot(encoding: :binary, format: :png, **options)
+      path = "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}"
+      if encoding == :base64
+        File.binwrite(path, Base64.decode64(browser.screenshot(format: format, encoding: :base64, **options)))
+      else
+        browser.screenshot(path: path, **options)
       end
+      path
     end
 
-    it "supports screenshotting the entire window when documentElement has no height" do
-      browser.go_to("/fixed_positioning")
-
-      create_screenshot(path: file, full: true)
-
-      File.open(file, "rb") do |f|
-        expect(ImageSize.new(f.read).size).to eq(browser.viewport_size.map { |s| s * device_pixel_ratio })
-      end
+    def image_size(path)
+      File.open(path, "rb") { |f| ImageSize.new(f.read).size }
     end
 
-    it "supports screenshotting just the selected element" do
-      browser.go_to("/long_page")
+    def element_size(selector)
+      browser.evaluate(<<~JS, selector: selector)
+        (() => {
+          const rect = document.querySelector(selector).getBoundingClientRect();
+          return [rect.width, rect.height];
+        })()
+      JS
+    end
 
-      create_screenshot(path: file, selector: "#penultimate")
+    def document_size
+      browser.evaluate("[document.documentElement.clientWidth, document.documentElement.clientHeight]")
+    end
 
-      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.map { |s| s * device_pixel_ratio })
-      end
+    def scaled(size)
+      size.map { |s| s * device_pixel_ratio }
     end
 
-    it "ignores :selector and :area in #save_screenshot if full: true" do
+    def expect_page_outside_viewport_screenshot(**variant)
       browser.go_to("/long_page")
-      expect(browser.page).to receive(:warn).with(/Ignoring :selector or :area/)
 
-      create_screenshot(path: file, full: true, selector: "#penultimate")
+      expect(image_size(create_screenshot(**variant))).to eq(scaled(browser.viewport_size))
 
-      File.open(file, "rb") do |f|
-        size = browser.evaluate("[document.documentElement.clientWidth, document.documentElement.clientHeight]")
-        expect(ImageSize.new(f.read).size).to eq(size.map { |s| s * device_pixel_ratio })
-      end
+      path = create_screenshot(**variant, full: true)
+      expect(image_size(path)).to eq(scaled(document_size))
     end
 
-    it "ignores :area in #save_screenshot if selector is set" do
-      browser.go_to("/long_page")
-      expect(browser.page).to receive(:warn).with(/Ignoring :area/)
+    def expect_window_without_document_height_screenshot(**variant)
+      browser.go_to("/fixed_positioning")
 
-      create_screenshot(path: file, selector: "#penultimate", area: { x: 0, y: 0, width: 200, height: 100 })
+      path = create_screenshot(**variant, full: true)
 
-      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.map { |s| s * device_pixel_ratio })
-      end
+      expect(image_size(path)).to eq(scaled(browser.viewport_size))
     end
 
-    it "resets element positions after" do
+    def expect_selected_element_screenshot(**variant)
       browser.go_to("/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
 
-  shared_examples "when scale is set" do
-    it "changes image dimensions" do
-      browser.go_to("/zoom_test")
+      path = create_screenshot(**variant, selector: "#penultimate")
 
-      black_pixels_count = lambda { |file|
-        img = ChunkyPNG::Image.from_file(file)
-        img.pixels.inject(0) { |i, p| p > 255 ? i + 1 : i }
-      }
+      expect(image_size(path)).to eq(scaled(element_size("#penultimate")))
+    end
 
-      create_screenshot(path: file)
-      before = black_pixels_count[file]
+    def expect_full_screenshot_ignoring_selector(**variant)
+      browser.go_to("/long_page")
+      expect(browser.page).to receive(:warn).with(/Ignoring :selector or :area/)
 
-      create_screenshot(path: file, scale: scale)
-      after = black_pixels_count[file]
+      path = create_screenshot(**variant, full: true, selector: "#penultimate")
 
-      expect((after.to_f / before).round(2)).to eq(scale**2)
+      expect(image_size(path)).to eq(scaled(document_size))
     end
-  end
 
-  describe "#screenshot" do
-    let(:format) { :png }
-    let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
-    let(:device_pixel_ratio) { browser.device_pixel_ratio }
+    def expect_selector_screenshot_ignoring_area(**variant)
+      browser.go_to("/long_page")
+      expect(browser.page).to receive(:warn).with(/Ignoring :area/)
 
-    it "returns the number of bytes saved" do
-      browser.go_to("/simple")
+      path = create_screenshot(**variant, selector: "#penultimate", area: { x: 0, y: 0, width: 200, height: 100 })
 
-      expect(browser.screenshot(path: file)).to eq(File.size(file))
+      expect(image_size(path)).to eq(scaled(element_size("#penultimate")))
     end
 
-    def create_screenshot(**options)
-      browser.screenshot(**options)
-    end
+    def expect_scaled_screenshot(scale)
+      browser.go_to("/zoom_test")
+      black_pixels_count = lambda { |path|
+        ChunkyPNG::Image.from_file(path).pixels.inject(0) { |i, p| p > 255 ? i + 1 : i }
+      }
 
-    after do
-      FileUtils.rm_f("#{PROJECT_ROOT}/spec/tmp/screenshot.png")
+      before = black_pixels_count[create_screenshot]
+      after = black_pixels_count[create_screenshot(scale: scale)]
+
+      expect((after.to_f / before).round(2)).to eq(scale**2)
     end
 
     it "supports screenshotting the page" do
@@ -189,182 +165,220 @@ def create_screenshot(**options)
       end
     end
 
-    include_examples "screenshot screen"
+    it "supports screenshotting the whole of a page that goes outside the viewport" do
+      expect_page_outside_viewport_screenshot
+    end
 
-    context "with fullscreen" do
-      it "supports screenshotting of fullscreen" do
-        browser.go_to("/custom_html_size")
-        expect(browser.viewport_size).to eq([1024, 681])
+    it "supports screenshotting the entire window when documentElement has no height" do
+      expect_window_without_document_height_screenshot
+    end
 
-        browser.screenshot(path: file, full: true)
+    it "supports screenshotting just the selected element" do
+      expect_selected_element_screenshot
+    end
 
-        File.open(file, "rb") do |f|
-          expect(ImageSize.new(f.read).size).to eq([1280, 1024].map { |s| s * device_pixel_ratio })
-        end
-        expect(browser.viewport_size).to eq([1024, 681])
-      end
+    it "ignores :selector and :area in #save_screenshot if full: true" do
+      expect_full_screenshot_ignoring_selector
+    end
 
-      it "keeps current viewport" do
-        browser.go_to
-        browser.resize(width: 800, height: 200)
+    it "ignores :area in #save_screenshot if selector is set" do
+      expect_selector_screenshot_ignoring_area
+    end
 
-        browser.screenshot(path: file, full: true)
+    it "resets element positions after" do
+      browser.go_to("/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
 
-        expect(File.exist?(file)).to be(true)
-        expect(browser.viewport_size).to eq([800, 200])
-      end
+    it "supports screenshotting the whole of a page that goes outside the viewport as base64 png" do
+      expect_page_outside_viewport_screenshot(encoding: :base64)
+    end
 
-      it "keeps previous viewport when exception is raised" do
-        browser.go_to("/custom_html_size")
-        browser.resize(width: 100, height: 100)
-
-        allow(browser.page).to receive(:command).and_call_original
-        expect(browser.page).to receive(:command)
-          .with("Page.captureScreenshot",
-                timeout: Ferrum::Page::Screenshot::DEFAULT_RENDER_TIMEOUT,
-                format: "png", clip: { x: 0, y: 0, width: 1280, height: 1024, scale: 1.0 },
-                captureBeyondViewport: true)
-          .and_raise(StandardError)
-        expect { browser.screenshot(path: file, full: true) }
-          .to raise_exception(StandardError)
-
-        # Fix Ruby 3 `and_call_original` bug
-        RSpec::Mocks.space.proxy_for(browser.page).reset
-
-        expect(File.exist?(file)).not_to be
-        expect(browser.viewport_size).to eq([100, 100])
-      end
+    it "supports screenshotting the entire window when documentElement has no height as base64 png" do
+      expect_window_without_document_height_screenshot(encoding: :base64)
+    end
 
-      it "does not mutate window state (no native macOS fullscreen transition)" do
-        browser.go_to("/long_page")
+    it "supports screenshotting just the selected element as base64 png" do
+      expect_selected_element_screenshot(encoding: :base64)
+    end
 
-        client = browser.page.client
-        commands = []
-        allow(client).to receive(:command).and_wrap_original do |m, name, **opts|
-          commands << [name, opts]
-          m.call(name, **opts)
-        end
+    it "ignores :selector and :area in #save_screenshot if full: true as base64 png" do
+      expect_full_screenshot_ignoring_selector(encoding: :base64)
+    end
 
-        browser.screenshot(path: file, full: true)
+    it "ignores :area in #save_screenshot if selector is set as base64 png" do
+      expect_selector_screenshot_ignoring_area(encoding: :base64)
+    end
 
-        # Fix Ruby 3 `and_call_original` bug
-        RSpec::Mocks.space.proxy_for(client).reset
+    it "supports screenshotting the whole of a page that goes outside the viewport as base64 jpeg" do
+      expect_page_outside_viewport_screenshot(encoding: :base64, format: :jpeg)
+    end
 
-        bounds_calls = commands.select { |(name, _)| name == "Browser.setWindowBounds" }
-        expect(bounds_calls).to be_empty
-      end
+    it "supports screenshotting the entire window when documentElement has no height as base64 jpeg" do
+      expect_window_without_document_height_screenshot(encoding: :base64, format: :jpeg)
+    end
 
-      it "forwards captureBeyondViewport: true to Page.captureScreenshot" do
-        browser.go_to("/long_page")
+    it "supports screenshotting just the selected element as base64 jpeg" do
+      expect_selected_element_screenshot(encoding: :base64, format: :jpeg)
+    end
 
-        client = browser.page.client
-        capture_opts = nil
-        allow(client).to receive(:command).and_wrap_original do |m, name, **opts|
-          capture_opts = opts if name == "Page.captureScreenshot"
-          m.call(name, **opts)
-        end
+    it "ignores :selector and :area in #save_screenshot if full: true as base64 jpeg" do
+      expect_full_screenshot_ignoring_selector(encoding: :base64, format: :jpeg)
+    end
 
-        browser.screenshot(path: file, full: true)
+    it "ignores :area in #save_screenshot if selector is set as base64 jpeg" do
+      expect_selector_screenshot_ignoring_area(encoding: :base64, format: :jpeg)
+    end
 
-        # Fix Ruby 3 `and_call_original` bug
-        RSpec::Mocks.space.proxy_for(client).reset
+    it "changes image dimensions with :scale above 1" do
+      expect_scaled_screenshot(2)
+    end
 
-        expect(capture_opts).to include(captureBeyondViewport: true)
-      end
+    it "changes image dimensions with :scale below 1" do
+      expect_scaled_screenshot(0.5)
     end
 
-    context "with area screenshot" do
-      it "supports screenshotting of an area" do
-        browser.go_to("/custom_html_size")
-        expect(browser.viewport_size).to eq([1024, 681])
+    it "supports screenshotting with full: true" do
+      browser.go_to("/custom_html_size")
+      expect(browser.viewport_size).to eq([1024, 681])
 
-        browser.screenshot(path: file, area: { x: 0, y: 0, width: 300, height: 200 })
+      browser.screenshot(path: file, full: true)
 
-        File.open(file, "rb") do |f|
-          expect(ImageSize.new(f.read).size).to eq([300, 200].map { |s| s * device_pixel_ratio })
-        end
-        expect(browser.viewport_size).to eq([1024, 681])
+      File.open(file, "rb") do |f|
+        expect(ImageSize.new(f.read).size).to eq([1280, 1024].map { |s| s * device_pixel_ratio })
       end
+      expect(browser.viewport_size).to eq([1024, 681])
+    end
 
-      it "keeps current viewport" do
-        browser.go_to
-        browser.set_viewport(width: 800, height: 200)
+    it "keeps the current viewport with full: true" do
+      browser.go_to
+      browser.resize(width: 800, height: 200)
 
-        browser.screenshot(path: file, area: { x: 0, y: 0, width: 300, height: 200 })
+      browser.screenshot(path: file, full: true)
 
-        expect(File.exist?(file)).to be(true)
-        expect(browser.viewport_size).to eq([800, 200])
-      end
+      expect(File.exist?(file)).to be(true)
+      expect(browser.viewport_size).to eq([800, 200])
     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: 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
+    it "keeps the previous viewport with full: true when an exception is raised" do
+      browser.go_to("/custom_html_size")
+      browser.resize(width: 100, height: 100)
+
+      allow(browser.page).to receive(:command).and_call_original
+      expect(browser.page).to receive(:command)
+        .with("Page.captureScreenshot",
+              timeout: Ferrum::Page::Screenshot::DEFAULT_RENDER_TIMEOUT,
+              format: "png", clip: { x: 0, y: 0, width: 1280, height: 1024, scale: 1.0 },
+              captureBeyondViewport: true)
+        .and_raise(StandardError)
+      expect { browser.screenshot(path: file, full: true) }
+        .to raise_exception(StandardError)
+
+      # Fix Ruby 3 `and_call_original` bug
+      RSpec::Mocks.space.proxy_for(browser.page).reset
+
+      expect(File.exist?(file)).not_to be
+      expect(browser.viewport_size).to eq([100, 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")
+    it "does not mutate window state with full: true (no native macOS fullscreen transition)" do
+      browser.go_to("/long_page")
+
+      client = browser.page.client
+      commands = []
+      allow(client).to receive(:command).and_wrap_original do |m, name, **opts|
+        commands << [name, opts]
+        m.call(name, **opts)
       end
-    end
 
-    context "zoom in" do
-      let(:scale) { 2 }
-      include_examples "when scale is set"
-    end
+      browser.screenshot(path: file, full: true)
+
+      # Fix Ruby 3 `and_call_original` bug
+      RSpec::Mocks.space.proxy_for(client).reset
 
-    context "zoom out" do
-      let(:scale) { 0.5 }
-      include_examples "when scale is set"
+      bounds_calls = commands.select { |(name, _)| name == "Browser.setWindowBounds" }
+      expect(bounds_calls).to be_empty
     end
 
-    context "when encoding is base64" do
-      let(:file) { "#{PROJECT_ROOT}/spec/tmp/screenshot.#{format}" }
+    it "forwards captureBeyondViewport: true to Page.captureScreenshot with full: true" do
+      browser.go_to("/long_page")
 
-      def create_screenshot(path:, **options)
-        image = browser.screenshot(format: format, encoding: :base64, **options)
-        File.binwrite(path, Base64.decode64(image))
+      client = browser.page.client
+      capture_opts = nil
+      allow(client).to receive(:command).and_wrap_original do |m, name, **opts|
+        capture_opts = opts if name == "Page.captureScreenshot"
+        m.call(name, **opts)
       end
 
-      it "defaults to base64 when path isn't set" do
-        browser.go_to
+      browser.screenshot(path: file, full: true)
 
-        screenshot = browser.screenshot(format: format)
+      # Fix Ruby 3 `and_call_original` bug
+      RSpec::Mocks.space.proxy_for(client).reset
 
-        expect(screenshot.length).to be > 100
-      end
+      expect(capture_opts).to include(captureBeyondViewport: true)
+    end
 
-      it "supports screenshotting the page in base64" do
-        browser.go_to
+    it "supports screenshotting of an area" do
+      browser.go_to("/custom_html_size")
+      expect(browser.viewport_size).to eq([1024, 681])
 
-        screenshot = browser.screenshot(encoding: :base64)
+      browser.screenshot(path: file, area: { x: 0, y: 0, width: 300, height: 200 })
 
-        expect(screenshot.length).to be > 100
+      File.open(file, "rb") do |f|
+        expect(ImageSize.new(f.read).size).to eq([300, 200].map { |s| s * device_pixel_ratio })
       end
+      expect(browser.viewport_size).to eq([1024, 681])
+    end
+
+    it "keeps the current viewport with :area" do
+      browser.go_to
+      browser.set_viewport(width: 800, height: 200)
 
-      context "with png" do
-        let(:format) { :png }
-        after { FileUtils.rm_f(file) }
+      browser.screenshot(path: file, area: { x: 0, y: 0, width: 300, height: 200 })
 
-        include_examples "screenshot screen"
-      end
+      expect(File.exist?(file)).to be(true)
+      expect(browser.viewport_size).to eq([800, 200])
+    end
 
-      context "with jpeg" do
-        let(:format) { :jpeg }
-        after { FileUtils.rm_f(file) }
+    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
 
-        include_examples "screenshot screen"
-      end
+    it "raises ArgumentError for a wrong :background_color" do
+      browser.go_to
+      expect do
+        browser.screenshot(path: file, background_color: "#FFF")
+      end.to raise_exception(ArgumentError, "Accept Ferrum::RGBA class only")
+    end
+
+    it "defaults to base64 when path isn't set" do
+      browser.go_to
+
+      screenshot = browser.screenshot(format: format)
+
+      expect(screenshot.length).to be > 100
+    end
+
+    it "supports screenshotting the page in base64" do
+      browser.go_to
+
+      screenshot = browser.screenshot(encoding: :base64)
+
+      expect(screenshot.length).to be > 100
     end
   end
 
@@ -382,83 +396,79 @@ def create_screenshot(path:, **options)
       expect(browser.pdf(path: file)).to eq(File.size(file))
     end
 
-    context "when :paper_width and :paper_height are set" do
-      it "changes pdf size" do
-        browser.go_to("/long_page")
+    it "changes pdf size with :paper_width and :paper_height" do
+      browser.go_to("/long_page")
 
-        browser.pdf(path: file, paper_width: 1.0, paper_height: 1.0)
+      browser.pdf(path: file, paper_width: 1.0, paper_height: 1.0)
 
-        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
+      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
 
-    context "when format is passed" do
-      it "changes pdf size to A0" do
-        browser.go_to("/long_page")
+    it "changes pdf size to A0 with :format" do
+      browser.go_to("/long_page")
 
-        browser.pdf(path: file, format: :A0)
+      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(1)).to eq(33.1)
-        end
+      reader = PDF::Reader.new(file)
+      reader.pages.each do |page|
+        bbox = page.attributes[:MediaBox]
+        width = (bbox[2] - bbox[0]) / 72
+        expect(width.round(1)).to eq(33.1)
       end
+    end
 
-      it "specifying format and paperWidth will cause exception" do
-        browser.go_to("/long_page")
+    it "raises ArgumentError with both :format and :paper_width" do
+      browser.go_to("/long_page")
 
-        expect do
-          browser.pdf(path: file, format: :A0, paper_width: 1.0)
-        end.to raise_error(ArgumentError)
-      end
+      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("/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 }
-        }
-        allow(browser.page).to receive(:command).with("IO.close", handle: "1").and_return({})
-
-        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
+    it "converts options to Page.printToPDF parameters" do
+      browser.go_to("/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 }
+      }
+      allow(browser.page).to receive(:command).with("IO.close", handle: "1").and_return({})
+
+      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
 
diff --git a/spec/page/tracing_spec.rb b/spec/page/tracing_spec.rb
index 891c81ae..73b9f8fb 100644
--- a/spec/page/tracing_spec.rb
+++ b/spec/page/tracing_spec.rb
@@ -13,6 +13,14 @@
   end
 
   describe "#record" do
+    def force_repaints
+      page.go_to("/grid")
+      3.times do
+        sleep 0.1
+        page.evaluate("document.body.style.backgroundColor = document.body.style.backgroundColor ? '' : 'red'")
+      end
+    end
+
     it "outputs a trace to file" do
       page.tracing.record(path: file_path) { page.go_to }
 
@@ -92,29 +100,19 @@
       expect(content["traceEvents"].any?).to eq(true)
     end
 
-    context "with screenshots enabled" do
-      def force_repaints
-        page.go_to("/grid")
-        3.times do
-          sleep 0.1
-          page.evaluate("document.body.style.backgroundColor = document.body.style.backgroundColor ? '' : 'red'")
-        end
-      end
-
-      it "fills file with screenshot data" do
-        page.tracing.record(path: file_path, screenshots: true) { force_repaints }
+    it "fills file with screenshot data when screenshots are enabled" do
+      page.tracing.record(path: file_path, screenshots: true) { force_repaints }
 
-        expect(File.exist?(file_path)).to be(true)
-        expect(content["traceEvents"].any? { |o| o["name"] == "Screenshot" }).to eq(true)
-      end
+      expect(File.exist?(file_path)).to be(true)
+      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) { force_repaints }
+    it "returns a buffer with screenshot data when screenshots are enabled" do
+      trace = page.tracing.record(screenshots: true) { force_repaints }
 
-        expect(File.exist?(file_path)).to be(false)
-        content = JSON.parse(trace)
-        expect(content["traceEvents"].any? { |o| o["name"] == "Screenshot" }).to eq(true)
-      end
+      expect(File.exist?(file_path)).to be(false)
+      content = JSON.parse(trace)
+      expect(content["traceEvents"].any? { |o| o["name"] == "Screenshot" }).to eq(true)
     end
 
     it "waits for promise fill with timeout when it provided" do
diff --git a/spec/page_spec.rb b/spec/page_spec.rb
index a14cdbd3..e0a9dfb2 100644
--- a/spec/page_spec.rb
+++ b/spec/page_spec.rb
@@ -13,6 +13,22 @@
         page.timeout = 4
         expect { page.go_to("/really_slow") }.not_to raise_error
       end
+
+      it "does not block on a lazy iframe" do
+        expect { page.go_to("/lazy_iframe") }.not_to raise_error
+
+        states = page.frames.reject(&:main?).map(&:state)
+        expect(states).to eq(%i[stopped_loading stopped_loading])
+      end
+
+      it "loads in-viewport lazy iframes" do
+        page.go_to("/lazy_iframe")
+        frame = page.frame_by(name: "lazy_in_viewport")
+
+        states = page.frames.reject(&:main?).map(&:state)
+        expect(frame.body).to include("slow page")
+        expect(states).to eq(%i[stopped_loading stopped_loading])
+      end
     end
 
     context "with failing response" do
@@ -202,7 +218,7 @@
   end
 
   describe "#bypass_csp" do
-    it "can bypass csp headers" do
+    it "bypasses CSP headers" do
       page.go_to("/csp")
       page.add_script_tag(content: "window.__injected = 42")
       expect(page.evaluate("window.__injected")).to be_nil
@@ -286,90 +302,159 @@ def is_mobile?
       page.evaluate("'ontouchstart' in window || navigator.maxTouchPoints > 0")
     end
 
-    context "when mobile is true" do
-      it "enables touch/mobile emulation without changing the window size" do
-        page.go_to("/")
+    it "enables touch/mobile emulation with mobile: true without changing the window size" do
+      page.go_to("/")
 
-        expect do
-          page.set_viewport(mobile: true)
-          page.reload
-        end.to change { is_mobile? }.to(true)
-      end
+      expect do
+        page.set_viewport(mobile: true)
+        page.reload
+      end.to change { is_mobile? }.to(true)
     end
 
-    context "when mobile is false" do
-      it "does not enable touch/mobile emulation" do
-        page.go_to("/")
+    it "does not enable touch/mobile emulation with mobile: false" do
+      page.go_to("/")
 
-        expect do
-          page.set_viewport(mobile: false)
-          page.reload
-        end.not_to(change { is_mobile? })
-      end
+      expect do
+        page.set_viewport(mobile: false)
+        page.reload
+      end.not_to(change { is_mobile? })
     end
 
-    context "when mobile is not given" do
-      it "keeps the pointer type set with --blink-settings", :launch do
-        browser = Ferrum::Browser.new(browser_options: { "blink-settings" => "primaryPointerType=2,availablePointerTypes=2" })
-        browser.go_to(base_url)
+    it "keeps the pointer type set with --blink-settings when mobile is not given", :launch do
+      browser = Ferrum::Browser.new(browser_options: { "blink-settings" => "primaryPointerType=2,availablePointerTypes=2" })
+      browser.go_to(base_url)
 
-        expect do
-          browser.set_viewport(width: 500, height: 300)
-        end.not_to(change { browser.evaluate("matchMedia('(pointer: coarse)').matches") }.from(true))
-      ensure
-        browser&.quit
-      end
+      expect do
+        browser.set_viewport(width: 500, height: 300)
+      end.not_to(change { browser.evaluate("matchMedia('(pointer: coarse)').matches") }.from(true))
+    ensure
+      browser&.quit
     end
 
-    context "when mobile was true before" do
-      it "disables touch/mobile emulation again" do
-        page.go_to("/")
-        page.set_viewport(mobile: true)
-        page.reload
+    it "disables touch/mobile emulation with mobile: false after mobile: true" do
+      page.go_to("/")
+      page.set_viewport(mobile: true)
+      page.reload
 
-        expect do
-          page.set_viewport(mobile: false)
-          page.reload
-        end.to change { is_mobile? }.from(true).to(false)
-      end
+      expect do
+        page.set_viewport(mobile: false)
+        page.reload
+      end.to change { is_mobile? }.from(true).to(false)
     end
   end
 
   describe "#on" do
-    it "subscribes to an event" do
-      message = nil
+    context "with a CDP event" do
+      it "subscribes to the event" do
+        message = nil
 
-      page.on("Runtime.consoleAPICalled") do |params|
-        message = params.dig("args", 0, "value")
+        page.on("Runtime.consoleAPICalled") do |params|
+          message = params.dig("args", 0, "value")
+        end
+
+        page.evaluate("console.log('hello')")
+        wait_for { message }.to eq("hello")
       end
+    end
 
-      page.evaluate("console.log('hello')")
-      wait_for { message }.to eq("hello")
+    context "with :response" do
+      it "yields the exchange once its response is fully loaded" do
+        exchanges = []
+        page.on(:response) { |exchange, _index, _total| exchanges << exchange }
+
+        page.go_to("/foo")
+
+        expect(exchanges.size).to eq(1)
+        expect(exchanges.first.response.loaded?).to eq(true)
+        expect(exchanges.first.response.body).to eq("Another World")
+      end
+
+      it "fires once per exchange that finishes loading" do
+        exchanges = []
+        page.on(:response) { |exchange, _index, _total| exchanges << exchange }
+
+        page.go_to("/with_js")
+
+        expect(exchanges.map(&:url)).to match_array(traffic.map(&:url))
+      end
+
+      it "does not fire for requests that fail to load" do
+        exchanges = []
+        page.on(:response) { |exchange, _index, _total| exchanges << exchange }
+
+        page.go_to("/with_ajax_connection_refused")
+        network.wait_for_idle
+
+        expect(traffic.size).to eq(3)
+        expect(exchanges.size).to eq(2)
+        expect(exchanges).not_to include(traffic.find(&:error))
+      end
+
+      it "does not require request interception to be set up" do
+        expect(page.subscribed?("Fetch.requestPaused")).to eq(false)
+
+        exchange = nil
+        page.on(:response) { |e, _index, _total| exchange = e }
+        page.go_to("/foo")
+
+        expect(exchange).to be
+      end
+    end
+
+    context "with :console" do
+      it "yields new messages" do
+        messages = []
+        page.on(:console) { |message| messages << message.text }
+
+        page.go_to("/console_log")
+        page.execute(%(console.warn("later")))
+
+        wait_for { messages }.to eq(["Hello world", "later"])
+      end
     end
   end
 
   describe "#off" do
-    it "unsubscribes a specific event handler" do
-      message_a = nil
-      message_b = nil
+    context "with a CDP event" do
+      it "unsubscribes a specific event handler" do
+        message_a = nil
+        message_b = nil
 
-      handler = page.on("Runtime.consoleAPICalled") do |params|
-        message_a = params.dig("args", 0, "value")
-      end
+        handler = page.on("Runtime.consoleAPICalled") do |params|
+          message_a = params.dig("args", 0, "value")
+        end
 
-      page.on("Runtime.consoleAPICalled") do |params|
-        message_b = params.dig("args", 0, "value")
+        page.on("Runtime.consoleAPICalled") do |params|
+          message_b = params.dig("args", 0, "value")
+        end
+
+        page.evaluate("console.log('hello')")
+        wait_for { message_a }.to eq("hello")
+        wait_for { message_b }.to eq("hello")
+
+        page.off("Runtime.consoleAPICalled", handler)
+        page.evaluate("console.log('goodbye')")
+
+        expect(message_a).to eq("hello")
+        wait_for { message_b }.to eq("goodbye")
       end
+    end
+
+    context "with :console" do
+      it "stops yielding console messages" do
+        messages = []
+        id = page.on(:console) { |message| messages << message.text }
 
-      page.evaluate("console.log('hello')")
-      wait_for { message_a }.to eq("hello")
-      wait_for { message_b }.to eq("hello")
+        page.go_to
+        page.execute(%(console.log("first")))
+        wait_for { messages }.to eq(["first"])
 
-      page.off("Runtime.consoleAPICalled", handler)
-      page.evaluate("console.log('goodbye')")
+        page.off(:console, id)
+        page.execute(%(console.log("second")))
+        wait_for { page.console.size }.to eq(2)
 
-      expect(message_a).to eq("hello")
-      wait_for { message_b }.to eq("goodbye")
+        expect(messages).to eq(["first"])
+      end
     end
   end
 end
diff --git a/spec/rgba_spec.rb b/spec/rgba_spec.rb
index 2b3f88d6..30fdf09d 100644
--- a/spec/rgba_spec.rb
+++ b/spec/rgba_spec.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 describe Ferrum::RGBA do
-  describe "#new" do
+  describe ".new" do
     it "raises ArgumentError for Integer value of alpha" do
       expect do
         Ferrum::RGBA.new(0, 0, 0, 0)
@@ -40,7 +40,9 @@
   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 }) }
+    it "returns the channels as a hash" do
+      expect(Ferrum::RGBA.new(0, 0, 0, 0.0).to_h).to eq({ r: 0, g: 0, b: 0, a: 0.0 })
+      expect(Ferrum::RGBA.new(255, 255, 255, 1.0).to_h).to eq({ r: 255, g: 255, b: 255, a: 1.0 })
+    end
   end
 end
diff --git a/spec/support/global_helpers.rb b/spec/support/global_helpers.rb
index 6cebfc60..175ae0e2 100644
--- a/spec/support/global_helpers.rb
+++ b/spec/support/global_helpers.rb
@@ -31,6 +31,20 @@ def last_exchange
     traffic.last
   end
 
+  def wait_for_target(&block)
+    start = Ferrum::Utils::ElapsedTime.monotonic_time
+    target = nil
+
+    until target
+      target = browser.targets.values.find(&block)
+      raise Ferrum::TimeoutError if Ferrum::Utils::ElapsedTime.timeout?(start, browser.timeout)
+
+      sleep 0.05
+    end
+
+    target
+  end
+
   def reset
     @browser.reset
     @page = nil
diff --git a/spec/target_spec.rb b/spec/target_spec.rb
new file mode 100644
index 00000000..a7e36939
--- /dev/null
+++ b/spec/target_spec.rb
@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+describe Ferrum::Target do
+  describe "#worker" do
+    it "raises for a service worker that isn't attached" do
+      page.go_to
+      page.execute(%(await navigator.serviceWorker.register("/sw.js")), timeout: 5)
+      target = wait_for_target(&:service_worker?)
+      wait_for { target.session_id }.to be_nil
+
+      expect { target.worker }.to raise_error(Ferrum::NoSuchTargetError, /attach_target/)
+    end
+  end
+end
diff --git a/spec/unit/accessibility/ax_node_spec.rb b/spec/unit/accessibility/ax_node_spec.rb
index d41ab5be..2a505a2d 100644
--- a/spec/unit/accessibility/ax_node_spec.rb
+++ b/spec/unit/accessibility/ax_node_spec.rb
@@ -22,67 +22,110 @@
 
   subject(:ax_node) { described_class.new(params) }
 
-  it "exposes role, name, description and value" do
-    expect(ax_node.role).to eq("button")
-    expect(ax_node.name).to eq("Send form")
-    expect(ax_node.description).to eq("Sends the form")
-    expect(ax_node.value).to eq("Go")
+  let(:bare_node) { described_class.new({ "nodeId" => "1", "ignored" => true }) }
+
+  describe "#role" do
+    it "returns the role" do
+      expect(ax_node.role).to eq("button")
+    end
+
+    it "returns nil without a role" do
+      expect(bare_node.role).to be_nil
+    end
+  end
+
+  describe "#name" do
+    it "returns the name" do
+      expect(ax_node.name).to eq("Send form")
+    end
+
+    it "returns nil without a name" do
+      expect(bare_node.name).to be_nil
+    end
+  end
+
+  describe "#description" do
+    it "returns the description" do
+      expect(ax_node.description).to eq("Sends the form")
+    end
+
+    it "returns nil without a description" do
+      expect(bare_node.description).to be_nil
+    end
+  end
+
+  describe "#value" do
+    it "returns the value" do
+      expect(ax_node.value).to eq("Go")
+    end
+
+    it "returns nil without a value" do
+      expect(bare_node.value).to be_nil
+    end
+  end
+
+  describe "#properties" do
+    it "flattens properties into a name => value hash" do
+      expect(ax_node.properties).to eq("focusable" => true, "required" => true)
+    end
+
+    it "returns an empty hash without properties" do
+      expect(bare_node.properties).to eq({})
+    end
+
+    it "returns a frozen hash" do
+      expect { ax_node.properties["focusable"] = false }.to raise_error(FrozenError)
+    end
+  end
+
+  describe "#ignored?" do
+    it "returns whether the node is ignored" do
+      expect(ax_node.ignored?).to be(false)
+      expect(bare_node.ignored?).to be(true)
+    end
   end
 
-  it "flattens properties into a name => value hash" do
-    expect(ax_node.properties).to eq("focusable" => true, "required" => true)
+  describe "#ignored_reasons" do
+    it "returns nil without ignored reasons" do
+      expect(bare_node.ignored_reasons).to be_nil
+    end
   end
 
-  it "exposes identity and tree fields" do
-    expect(ax_node.node_id).to eq("7")
-    expect(ax_node.backend_dom_node_id).to eq(42)
-    expect(ax_node.child_ids).to eq(%w[8 9])
-    expect(ax_node.ignored?).to be(false)
-    expect(ax_node.to_h).to eq(params)
+  describe "#node_id" do
+    it "returns the node id" do
+      expect(ax_node.node_id).to eq("7")
+    end
   end
 
-  it "tolerates missing keys" do
-    node = described_class.new({ "nodeId" => "1", "ignored" => true })
-    expect(node.role).to be_nil
-    expect(node.name).to be_nil
-    expect(node.description).to be_nil
-    expect(node.value).to be_nil
-    expect(node.properties).to eq({})
-    expect(node.ignored?).to be(true)
-    expect(node.ignored_reasons).to be_nil
+  describe "#backend_dom_node_id" do
+    it "returns the backend DOM node id" do
+      expect(ax_node.backend_dom_node_id).to eq(42)
+    end
   end
 
-  describe "immutability (deep freeze)" do
-    let(:mutable_params) do
-      {
-        "nodeId" => "10",
-        "ignored" => false,
-        "role" => { "type" => "role", "value" => "slider" },
-        "childIds" => %w[11 12],
-        "properties" => [
-          { "name" => "focusable", "value" => { "type" => "booleanOrUndefined", "value" => true } }
-        ]
-      }
+  describe "#child_ids" do
+    it "returns the child ids" do
+      expect(ax_node.child_ids).to eq(%w[8 9])
     end
 
-    subject(:frozen_node) { described_class.new(mutable_params) }
+    it "returns a frozen array" do
+      expect { ax_node.child_ids << "x" }.to raise_error(FrozenError)
+    end
+  end
 
-    it "raises FrozenError when mutating child_ids" do
-      expect { frozen_node.child_ids << "x" }.to raise_error(FrozenError)
+  describe "#to_h" do
+    it "returns the params" do
+      expect(ax_node.to_h).to eq(params)
     end
 
-    it "raises FrozenError when mutating the properties array from to_h" do
-      expect { frozen_node.to_h["properties"] << {} }.to raise_error(FrozenError)
+    it "returns a deeply frozen hash" do
+      expect { ax_node.to_h["properties"] << {} }.to raise_error(FrozenError)
     end
 
     it "freezes hash keys, not just values" do
-      key = frozen_node.to_h.keys.find { |k| k == "nodeId" }
+      key = ax_node.to_h.keys.find { |k| k == "nodeId" }
       expect(key).not_to be_nil
       expect(key).to be_frozen
     end
-
-    it "raises FrozenError when mutating the memoized properties hash" do
-      expect { frozen_node.properties["focusable"] = false }.to raise_error(FrozenError)
-    end
   end
 end
diff --git a/spec/unit/process/killer_spec.rb b/spec/unit/browser/process/killer_spec.rb
similarity index 80%
rename from spec/unit/process/killer_spec.rb
rename to spec/unit/browser/process/killer_spec.rb
index 1dcd8f77..da3b594a 100644
--- a/spec/unit/process/killer_spec.rb
+++ b/spec/unit/browser/process/killer_spec.rb
@@ -159,4 +159,36 @@ def reaped?(pid)
       expect(described_class.process_group_alive?(pid)).to be false
     end
   end
+
+  describe ".kill", if: Ferrum::Utils::Platform.mri? && !Ferrum::Utils::Platform.windows? do
+    it "kills the whole process group, not just the leader, when a group member ignores TERM" do
+      child_pid_path = File.join(Dir.tmpdir, "ferrum-process-spec-child-pid-#{Process.pid}")
+
+      script = <<~RUBY
+        pid = fork do
+          trap("TERM", "IGNORE")
+          sleep 30
+        end
+        Process.detach(pid)
+        File.write(#{child_pid_path.inspect}, pid.to_s)
+        sleep 30
+      RUBY
+      leader_pid = Process.spawn(RbConfig.ruby, "-e", script, pgroup: true)
+
+      begin
+        start = Ferrum::Utils::ElapsedTime.monotonic_time
+        sleep(0.05) until File.size?(child_pid_path) || Ferrum::Utils::ElapsedTime.timeout?(start, 5)
+        child_pid = File.read(child_pid_path).to_i
+
+        # A leader that dies promptly on TERM must not short-circuit the
+        # escalation to KILL for the rest of its process group.
+        Ferrum::Browser::Process::Killer.kill(leader_pid)
+        sleep(0.2)
+
+        expect { Process.kill(0, child_pid) }.to raise_error(Errno::ESRCH)
+      ensure
+        File.delete(child_pid_path) if child_pid && File.exist?(child_pid_path)
+      end
+    end
+  end
 end
diff --git a/spec/unit/process_spec.rb b/spec/unit/browser/process_spec.rb
similarity index 56%
rename from spec/unit/process_spec.rb
rename to spec/unit/browser/process_spec.rb
index 30cff906..e7621393 100644
--- a/spec/unit/process_spec.rb
+++ b/spec/unit/browser/process_spec.rb
@@ -5,15 +5,15 @@
 
   let(:client) { double.as_null_object.tap { |client| allow(client).to receive(:command).and_return(client) } }
 
-  unless Ferrum::Utils::Platform.windows?
-    it "forcibly kills the child if it does not respond to SIGTERM" do
+  describe "#stop", skip: Ferrum::Utils::Platform.windows? do
+    it "kills the child forcibly 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::Client).to receive(:new).and_return(client)
 
       allow_any_instance_of(Ferrum::Browser::Process).to receive(:parse_ws_url)
 
-      subject.send(:start)
+      subject
 
       expect(Process).to receive(:kill).with("TERM", -5678).ordered
       expect(Process).to receive(:kill).with("KILL", -5678).ordered
@@ -28,7 +28,7 @@
 
       allow_any_instance_of(Ferrum::Browser::Process).to receive(:parse_ws_url)
 
-      subject.send(:start)
+      subject
 
       allow(Process).to receive(:kill).with("TERM", -5678).and_raise(Errno::EPERM)
       expect(Process).to receive(:kill).with("TERM", 5678).ordered
@@ -46,7 +46,7 @@
 
       allow_any_instance_of(Ferrum::Browser::Process).to receive(:parse_ws_url)
 
-      subject.send(:start)
+      subject
 
       allow(Process).to receive(:kill).with("TERM", -5678).and_raise(Errno::ESRCH)
       expect(Process).to receive(:kill).with("TERM", 5678).ordered
@@ -55,58 +55,29 @@
 
       subject.quit
     end
-
-    it "kills the whole process group, not just the leader, when a group member ignores TERM", if: Ferrum::Utils::Platform.mri? do
-      child_pid_path = File.join(Dir.tmpdir, "ferrum-process-spec-child-pid-#{Process.pid}")
-
-      script = <<~RUBY
-        pid = fork do
-          trap("TERM", "IGNORE")
-          sleep 30
-        end
-        Process.detach(pid)
-        File.write(#{child_pid_path.inspect}, pid.to_s)
-        sleep 30
-      RUBY
-      leader_pid = Process.spawn(RbConfig.ruby, "-e", script, pgroup: true)
-
-      begin
-        start = Ferrum::Utils::ElapsedTime.monotonic_time
-        sleep(0.05) until File.size?(child_pid_path) || Ferrum::Utils::ElapsedTime.timeout?(start, 5)
-        child_pid = File.read(child_pid_path).to_i
-
-        # A leader that dies promptly on TERM must not short-circuit the
-        # escalation to KILL for the rest of its process group.
-        Ferrum::Browser::Process::Killer.kill(leader_pid)
-        sleep(0.2)
-
-        expect { Process.kill(0, child_pid) }.to raise_error(Errno::ESRCH)
-      ensure
-        File.delete(child_pid_path) if child_pid && File.exist?(child_pid_path)
-      end
-    end
   end
 
-  context "when spawning Chrome itself" do
+  describe "#start" do
     it "uses the requested :host instead of the address Chrome reports" do
-      subject = described_class.new(Ferrum::Browser::Options.new(host: "ferrum.localhost", port: 6001))
-      subject.output.pipe do |io|
-        io.write("DevTools listening on ws://127.0.0.1:6001/devtools/browser/" \
-                 "11111111-1111-1111-1111-111111111111\n")
+      process = described_class.new(Ferrum::Browser::Options.new(host: "ferrum.localhost", port: 6001))
+      allow(Process).to receive(:spawn) do |*, options|
+        options[:out].write("DevTools listening on ws://127.0.0.1:6001/devtools/browser/" \
+                            "11111111-1111-1111-1111-111111111111\n")
+        5678
       end
+      allow(Process).to receive(:wait).and_return(nil)
+      allow(Process).to receive(:kill)
 
-      subject.send(:parse_ws_url)
+      process.start
 
-      expect(subject.host).to eq("ferrum.localhost")
-      expect(subject.port).to eq(6001)
-      expect(subject.ws_url.host).to eq("ferrum.localhost")
+      expect(process.host).to eq("ferrum.localhost")
+      expect(process.port).to eq(6001)
+      expect(process.ws_url.host).to eq("ferrum.localhost")
+    ensure
+      process.stop
     end
-  end
-
-  context "env variables" do
-    subject { Ferrum::Browser.new(env: { "LD_PRELOAD" => "some.so" }) }
 
-    it "passes through env" do
+    it "passes env through to the browser process" do
       allow(Process).to receive(:wait).and_return(nil)
       allow(Ferrum::Client).to receive(:new).and_return(client)
 
@@ -114,8 +85,8 @@
 
       allow_any_instance_of(Ferrum::Browser::Process).to receive(:parse_ws_url)
 
-      subject.send(:start)
-      subject.quit
+      browser = Ferrum::Browser.new(env: { "LD_PRELOAD" => "some.so" })
+      browser.quit
     end
   end
 end
diff --git a/spec/unit/browser_spec.rb b/spec/unit/browser_spec.rb
index e6a4e3ea..a195f843 100644
--- a/spec/unit/browser_spec.rb
+++ b/spec/unit/browser_spec.rb
@@ -4,62 +4,66 @@
 require "logger"
 
 describe Ferrum::Browser do
-  it "logs requests and responses with native Logger" do
-    custom_logger = Class.new do
-      def initialize(logger)
-        @logger = logger
-      end
+  describe ".new" 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
+        def puts(*args)
+          @logger << args
+        end
       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("document.documentElement?.outerHTML")
+      expect(file_log).to include("<html><head></head><body></body></html>")
+    ensure
+      FileUtils.rm_f(file_path)
+      browser.quit
     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("document.documentElement?.outerHTML")
-    expect(file_log).to include("<html><head></head><body></body></html>")
-  ensure
-    FileUtils.rm_f(file_path)
-    browser.quit
-  end
 
-  it "logs requests and responses" do
-    logger = StringIO.new
-    browser = Ferrum::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("document.documentElement?.outerHTML")
-    expect(logger.string).to include("<html><head></head><body></body></html>")
-  ensure
-    browser.quit
-  end
+      expect(logger.string).to include("document.documentElement?.outerHTML")
+      expect(logger.string).to include("<html><head></head><body></body></html>")
+    ensure
+      browser.quit
+    end
 
-  it "shows command line options passed" do
-    browser = Ferrum::Browser.new(browser_options: { "blink-settings" => "imagesEnabled=false" })
+    it "passes browser_options to the command line" 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")
-  ensure
-    browser.quit
+      expect(arguments).to include("--blink-settings=imagesEnabled=false")
+    ensure
+      browser.quit
+    end
   end
 
-  it "restarts a browser whose previous start died after the client was built" do
-    browser = Ferrum::Browser.new
+  describe "#restart" do
+    it "restarts a browser whose previous start died after the client was built" do
+      browser = Ferrum::Browser.new
 
-    error = StandardError.new
-    allow(Ferrum::Contexts).to receive(:new).and_raise(error)
-    expect { browser.restart }.to raise_error(error)
+      error = StandardError.new
+      allow(Ferrum::Contexts).to receive(:new).and_raise(error)
+      expect { browser.restart }.to raise_error(error)
 
-    allow(Ferrum::Contexts).to receive(:new).and_call_original
+      allow(Ferrum::Contexts).to receive(:new).and_call_original
 
-    expect { browser.restart }.not_to raise_error
-    expect(browser.contexts).not_to be_nil
-  ensure
-    browser&.quit
+      expect { browser.restart }.not_to raise_error
+      expect(browser.contexts).not_to be_nil
+    ensure
+      browser&.quit
+    end
   end
 end
diff --git a/spec/unit/frame/script_spec.rb b/spec/unit/frame/script_spec.rb
index eabe1ba8..05b57592 100644
--- a/spec/unit/frame/script_spec.rb
+++ b/spec/unit/frame/script_spec.rb
@@ -5,6 +5,46 @@ def script(source)
     described_class.new(source)
   end
 
+  describe ".new" do
+    [
+      "function() {",
+      "function() { return 1",
+      "function(a, b",
+      "function(a, b) }",
+      "() =>",
+      "(a, b) =>",
+      "=> 1",
+      "}}}",
+      ")))",
+      "]]]",
+      "{[(",
+      "'unterminated",
+      "\"unterminated",
+      "`unterminated",
+      "`unterminated ${",
+      "`${`${`${",
+      "/unterminated",
+      "/[unterminated",
+      "a /* unterminated",
+      "\\",
+      "@#%^&",
+      "\u0000",
+      "😀 => 😀",
+      "function café(é) { return é }",
+      "a" * 10_000,
+      "(" * 1_000,
+      "function() { #{'{' * 500}#{'}' * 500} }",
+      "#{'`${' * 200}#{'}`' * 200}"
+    ].each do |source|
+      it "reads #{source[0, 30].inspect} without raising" do
+        result = script(source)
+
+        expect { [result.code, result.declaration?, result.awaits?] }
+          .not_to raise_error
+      end
+    end
+  end
+
   describe "#declaration?" do
     {
       "function() { return 1 }" => true,
@@ -88,6 +128,29 @@ def script(source)
         expect(script(source).declaration?).to be(expected)
       end
     end
+
+    {
+      "function() {" => false,
+      "function() { return 1" => false,
+      "function(a, b) }" => false,
+      "}}}" => false,
+      "'unterminated" => false
+    }.each do |source, expected|
+      it "doesn't treat #{source.inspect} as a declaration" do
+        expect(script(source).declaration?).to be(expected)
+      end
+    end
+
+    it "reads a declaration after non-ASCII text" do
+      result = script("/* ü */ function(é, b) { return 'ä' } // ö")
+
+      expect(result.declaration?).to be(true)
+      expect(result.code).to eq("function(é, b) { return 'ä' }")
+    end
+
+    it "reads an ASCII string in another encoding" do
+      expect(script("(a) => a".b).declaration?).to be(true)
+    end
   end
 
   describe "#code" do
@@ -132,6 +195,51 @@ def script(source)
 
       expect(script(source).code).to eq("const a = 1;\nconst b = { c: '}' };\nreturn a + b.c")
     end
+
+    {
+      "\"é\" + 1" => "\"é\" + 1",
+      "// café\n1 + 1" => "1 + 1",
+      "/* ü */ document.title // ä" => "document.title",
+      "'日本語' // コメント" => "'日本語'",
+      "`😀 ${a}` // 😀" => "`😀 ${a}`"
+    }.each do |source, expected|
+      it "reads the code of #{source.inspect}" do
+        expect(script(source).code).to eq(expected)
+      end
+    end
+
+    it "leaves a script that isn't UTF-8 as it is" do
+      source = "(a) => 'é'".encode("UTF-16LE")
+
+      expect([script(source).code, script(source).declaration?]).to eq([source, false])
+    end
+
+    it "leaves a script with invalid bytes as it is" do
+      source = "1 + \xFF".dup.force_encoding("UTF-8")
+      result = script(source)
+
+      expect(result.code.bytes).to eq(source.bytes)
+      expect([result.declaration?, result.awaits?]).to eq([false, false])
+    end
+
+    {
+      "a / b / c" => "a / b / c",
+      "(a) / 2 // half" => "(a) / 2",
+      "a[0] / 2 // half" => "a[0] / 2",
+      "x = /ab+c/i // regexp" => "x = /ab+c/i",
+      "return /a/ // regexp" => "return /a/",
+      "typeof /a/" => "typeof /a/",
+      "[/a/, /b/]" => "[/a/, /b/]",
+      "a ? /x/ : /y/" => "a ? /x/ : /y/",
+      "s.replace(/'/g, '\"') // quote" => "s.replace(/'/g, '\"')",
+      "s.match(/[/]/) // slash" => "s.match(/[/]/)",
+      "s.split(/\\//) // escaped" => "s.split(/\\//)",
+      "1 / 2 / '//' // comment" => "1 / 2 / '//'"
+    }.each do |source, expected|
+      it "reads #{source.inspect}" do
+        expect(script(source).code).to eq(expected)
+      end
+    end
   end
 
   describe "#awaits?" do
@@ -193,116 +301,4 @@ def script(source)
       end
     end
   end
-
-  describe "broken input" do
-    [
-      "function() {",
-      "function() { return 1",
-      "function(a, b",
-      "function(a, b) }",
-      "() =>",
-      "(a, b) =>",
-      "=> 1",
-      "}}}",
-      ")))",
-      "]]]",
-      "{[(",
-      "'unterminated",
-      "\"unterminated",
-      "`unterminated",
-      "`unterminated ${",
-      "`${`${`${",
-      "/unterminated",
-      "/[unterminated",
-      "a /* unterminated",
-      "\\",
-      "@#%^&",
-      "\u0000",
-      "😀 => 😀",
-      "function café(é) { return é }",
-      "a" * 10_000,
-      "(" * 1_000,
-      "function() { #{'{' * 500}#{'}' * 500} }",
-      "#{'`${' * 200}#{'}`' * 200}"
-    ].each do |source|
-      it "reads #{source[0, 30].inspect} without raising" do
-        result = script(source)
-
-        expect { [result.code, result.declaration?, result.awaits?] }
-          .not_to raise_error
-      end
-    end
-
-    {
-      "function() {" => false,
-      "function() { return 1" => false,
-      "function(a, b) }" => false,
-      "}}}" => false,
-      "'unterminated" => false
-    }.each do |source, expected|
-      it "doesn't treat #{source.inspect} as a declaration" do
-        expect(script(source).declaration?).to be(expected)
-      end
-    end
-  end
-
-  describe "non-ASCII scripts" do
-    {
-      "\"é\" + 1" => "\"é\" + 1",
-      "// café\n1 + 1" => "1 + 1",
-      "/* ü */ document.title // ä" => "document.title",
-      "'日本語' // コメント" => "'日本語'",
-      "`😀 ${a}` // 😀" => "`😀 ${a}`"
-    }.each do |source, expected|
-      it "reads the code of #{source.inspect}" do
-        expect(script(source).code).to eq(expected)
-      end
-    end
-
-    it "reads a declaration after non-ASCII text" do
-      result = script("/* ü */ function(é, b) { return 'ä' } // ö")
-
-      expect(result.declaration?).to be(true)
-      expect(result.code).to eq("function(é, b) { return 'ä' }")
-    end
-
-    it "reads an ASCII string in another encoding" do
-      expect(script("(a) => a".b).declaration?).to be(true)
-    end
-
-    it "leaves a script that isn't UTF-8 as it is" do
-      source = "(a) => 'é'".encode("UTF-16LE")
-
-      expect([script(source).code, script(source).declaration?]).to eq([source, false])
-    end
-
-    it "leaves a script with invalid bytes as it is" do
-      source = "1 + \xFF".dup.force_encoding("UTF-8")
-      result = script(source)
-
-      expect(result.code.bytes).to eq(source.bytes)
-      expect([result.declaration?, result.awaits?]).to eq([false, false])
-    end
-  end
-
-  describe "division and regular expressions" do
-    {
-      "a / b / c" => "a / b / c",
-      "(a) / 2 // half" => "(a) / 2",
-      "a[0] / 2 // half" => "a[0] / 2",
-      "x = /ab+c/i // regexp" => "x = /ab+c/i",
-      "return /a/ // regexp" => "return /a/",
-      "typeof /a/" => "typeof /a/",
-      "[/a/, /b/]" => "[/a/, /b/]",
-      "a ? /x/ : /y/" => "a ? /x/ : /y/",
-      "s.replace(/'/g, '\"') // quote" => "s.replace(/'/g, '\"')",
-      "s.match(/[/]/) // slash" => "s.match(/[/]/)",
-      "s.split(/\\//) // escaped" => "s.split(/\\//)",
-      "1 / 2 / '//' // comment" => "1 / 2 / '//'"
-    }.each do |source, expected|
-      it "reads #{source.inspect}" do
-        expect(script(source).code).to eq(expected)
-      end
-    end
-  end
 end
diff --git a/spec/worker_spec.rb b/spec/worker_spec.rb
index 9b025c11..94cd84cf 100644
--- a/spec/worker_spec.rb
+++ b/spec/worker_spec.rb
@@ -1,39 +1,7 @@
 # frozen_string_literal: true
 
 describe Ferrum::Worker do
-  def wait_for_target(&block)
-    start = Ferrum::Utils::ElapsedTime.monotonic_time
-    target = nil
-
-    until target
-      target = browser.targets.values.find(&block)
-      raise Ferrum::TimeoutError if Ferrum::Utils::ElapsedTime.timeout?(start, browser.timeout)
-
-      sleep 0.05
-    end
-
-    target
-  end
-
-  describe "dedicated workers" do
-    it "is discovered, connected to, and reachable through Context#workers" do
-      page.go_to
-
-      page.execute <<~JS
-        new Worker(URL.createObjectURL(new Blob(
-          ["self.onmessage = () => self.postMessage(1 + 1)"],
-          { type: "application/javascript" }
-        )))
-      JS
-
-      target = wait_for_target(&:worker?)
-
-      expect(target.url).to start_with("blob:")
-      expect(target.connected?).to eq(true)
-      expect(browser.workers).to contain_exactly(target.worker)
-      expect(target.worker.evaluate("1 + 1")).to eq(2)
-    end
-
+  describe "#console" do
     it "collects its console messages" do
       page.go_to
 
@@ -50,85 +18,5 @@ def wait_for_target(&block)
       wait_for { worker.console.map(&:text) }.to eq(["from worker"])
       expect(worker.console.first).to be_warning
     end
-
-    it "is left out of Context#workers once detached" do
-      page.go_to
-
-      page.execute <<~JS
-        new Worker(URL.createObjectURL(new Blob(
-          ["self.onmessage = () => {}"],
-          { type: "application/javascript" }
-        )))
-      JS
-
-      target = wait_for_target(&:worker?)
-      wait_for { browser.workers }.to contain_exactly(target.worker)
-      page.command("Target.detachFromTarget", sessionId: target.session_id)
-
-      wait_for { browser.workers }.to be_empty
-    end
-  end
-
-  describe "shared workers" do
-    it "is discovered, connected to, and reachable through Context#workers" do
-      page.go_to
-
-      page.execute <<~JS
-        new SharedWorker(URL.createObjectURL(new Blob(
-          ["self.onconnect = () => {}"],
-          { type: "application/javascript" }
-        )))
-      JS
-
-      target = wait_for_target(&:shared_worker?)
-
-      expect(target.connected?).to eq(true)
-      expect(browser.workers).to contain_exactly(target.worker)
-      expect(target.worker.evaluate("1 + 1")).to eq(2)
-    end
-  end
-
-  describe "service workers" do
-    it "discovers registered service workers without connecting to them" do
-      page.go_to
-      page.evaluate(%(await navigator.serviceWorker.register("/sw.js")), timeout: 5)
-
-      target = wait_for_target(&:service_worker?)
-
-      expect(target.url).to end_with("/sw.js")
-      expect(target.connected?).to eq(false)
-      expect(browser.service_workers).to contain_exactly(target)
-    end
-
-    it "detaches from them so Chrome can terminate them" do
-      page.go_to
-      page.execute(%(await navigator.serviceWorker.register("/sw.js")), timeout: 5)
-      target = wait_for_target(&:service_worker?)
-
-      wait_for do
-        browser.client.command("Target.getTargets")["targetInfos"]
-               .select { |info| info["type"] == "service_worker" }.map { |info| info["attached"] }
-      end.to eq([false])
-      expect(target.session_id).to be_nil
-    end
-
-    it "raises when connected to without attaching first" do
-      page.go_to
-      page.execute(%(await navigator.serviceWorker.register("/sw.js")), timeout: 5)
-      target = wait_for_target(&:service_worker?)
-      wait_for { target.session_id }.to be_nil
-
-      expect { target.worker }.to raise_error(Ferrum::NoSuchTargetError, /attach_target/)
-    end
-
-    it "connects on demand through Context#attach_target, keeping it alive" do
-      page.go_to
-      page.evaluate(%(await navigator.serviceWorker.register("/sw.js")), timeout: 5)
-
-      target = wait_for_target(&:service_worker?)
-      browser.attach_target(target.id)
-
-      expect(target.worker.evaluate("1 + 1")).to eq(2)
-    end
   end
 end