ruby_raider 3.13.0 → 4.0.0

data/spec/integration/end_to_end_spec.rb

@@ -13,7 +13,7 @@ require_relative 'trace_page_server'
 # These tests:
 # 1. Generate a complete project
 # 2. Install dependencies (bundle install)
-# 3. Run the generated tests (rspec/cucumber)
+# 3. Run the generated tests (rspec)
 # 4. Verify tests pass
 #
 # This ensures the template system produces working, executable test frameworks
@@ -94,21 +94,6 @@ describe 'End-to-End Project Generation and Execution' do
     result
   end
 
-  # Helper to run Cucumber tests
-  def run_cucumber(project_name)
-    puts "\n🥒 Running Cucumber tests in #{project_name}..."
-    result = run_in_project(project_name, 'HEADLESS=true bundle exec cucumber features/ --format pretty', timeout: 120)
-
-    puts result[:stdout] if result[:stdout].length.positive?
-
-    unless result[:success]
-      puts '❌ Cucumber tests failed:'
-      puts result[:stderr] if result[:stderr].length.positive?
-    end
-
-    result
-  end
-
   # Shared example for RSpec-based projects
   shared_examples 'executable rspec project' do |project_name|
     let(:project) { project_name }
@@ -117,10 +102,10 @@ describe 'End-to-End Project Generation and Execution' do
       expect(bundle_install(project)).to be true
     end
 
-    it 'resolves raider_reporter 0.10+ from RubyGems and ships the raider-reporter executable', :aggregate_failures do
+    it 'resolves raider_reporter 1.x from RubyGems and ships the raider-reporter executable', :aggregate_failures do
       skip 'Bundle install failed' unless bundle_install(project)
 
-      expect(File.read(File.join(project, 'Gemfile.lock'))).to match(/^    raider_reporter \(0\.1\d\.\d+\)$/)
+      expect(File.read(File.join(project, 'Gemfile.lock'))).to match(/^    raider_reporter \(1\.\d+\.\d+\)$/)
       result = run_in_project(project, 'bundle exec raider-reporter --help', timeout: 60)
       expect(result[:exit_code]).to eq(0), "STDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
       expect(result[:stdout] + result[:stderr]).to include('raider-reporter comment')
@@ -157,116 +142,6 @@ describe 'End-to-End Project Generation and Execution' do
     end
   end
 
-  # Shared example for Cucumber-based projects
-  shared_examples 'executable cucumber project' do |project_name|
-    let(:project) { project_name }
-
-    it 'installs dependencies successfully' do
-      expect(bundle_install(project)).to be true
-    end
-
-    it 'runs generated Cucumber tests successfully', :slow do
-      skip 'Bundle install failed' unless bundle_install(project)
-
-      result = run_cucumber(project)
-
-      expect(result[:success]).to be(true),
-                                  "Cucumber tests failed with exit code #{result[:exit_code]}.\n" \
-                                  "STDOUT: #{result[:stdout]}\n" \
-                                  "STDERR: #{result[:stderr]}"
-    end
-
-    it 'resolves raider_reporter 0.10+ from RubyGems and requires its Cucumber plugin', :aggregate_failures do
-      skip 'Bundle install failed' unless bundle_install(project)
-
-      lockfile = File.read(File.join(project, 'Gemfile.lock'))
-      expect(lockfile).to match(/^    raider_reporter \(0\.1\d\.\d+\)$/)
-      expect(File.read(File.join(project, 'features/support/env.rb'))).to include("require 'raider_reporter/cucumber'")
-    end
-
-    it 'prints pretty output and keeps the exit status of a failing Cucumber run', :aggregate_failures, :slow do
-      skip 'Bundle install failed' unless bundle_install(project)
-
-      result = run_cucumber_with_failure(project)
-
-      expect(result[:stdout]).to include('Feature: Reporter failure')
-      expect(result[:stdout]).to include('Scenario: A deliberately failing scenario')
-      expect(result[:stdout]).to match(/\d+ scenarios? \(\d+ failed/)
-      expect(result[:exit_code]).to eq(1)
-    end
-
-    it 'writes rerun.txt listing only the failing scenario', :aggregate_failures, :slow do
-      skip 'Bundle install failed' unless bundle_install(project)
-
-      result = run_cucumber_with_failure(project)
-
-      expect(result[:exit_code]).to eq(1)
-      rerun = File.join(project, 'rerun.txt')
-      expect(File).to exist(rerun)
-      expect(File.read(rerun).strip).to eq('features/reporter_failure.feature:3')
-    end
-
-    it 'writes raider-results/run.json listing every scenario with a failing scenario screenshot',
-       :aggregate_failures, :slow do
-      skip 'Bundle install failed' unless bundle_install(project)
-
-      result = run_cucumber_with_failure(project)
-      summary = result[:stdout].match(/(\d+) scenarios? \((?:(\d+) failed)?/)
-      expect(summary).not_to be_nil, "No Cucumber summary line.\nSTDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
-
-      run = JSON.parse(File.read(File.join(project, 'raider-results', 'run.json')))
-      expect(run['schema_version']).to eq(1)
-      expect(run['results'].size).to eq(summary[1].to_i)
-      expect(run['results'].count { |r| r['status'] == 'failed' }).to eq(summary[2].to_i)
-
-      failing = run['results'].find { |r| r['full_name'] == 'Reporter failure: A deliberately failing scenario' }
-      expect(failing).not_to be_nil, "Scenario missing from run.json: #{run['results'].map { |r| r['full_name'] }}"
-      expect(failing['status']).to eq('failed')
-      expect(failing['file_path']).to eq('features/reporter_failure.feature')
-      expect(failing['failure']['message']).to start_with(
-        'Then the reporter records this failure (features/reporter_failure.feature:5)'
-      )
-      screenshot = failing['attachments'].find { |a| a['name'] == 'screenshot' }
-      expect(screenshot).not_to be_nil, "No screenshot attachment: #{failing['attachments']}"
-      expect(screenshot['content_type']).to eq('image/png')
-    end
-  end
-
-  # Runs the project's features plus a deliberately failing scenario, then removes that scenario again
-  def run_cucumber_with_failure(project)
-    add_failing_cucumber_scenario(project)
-    FileUtils.rm_rf([File.join(project, 'raider-results'), File.join(project, 'rerun.txt')])
-    run_cucumber(project)
-  ensure
-    remove_failing_cucumber_scenario(project)
-  end
-
-  # Adds a scenario that always fails at its last step, after the browser has been started
-  def add_failing_cucumber_scenario(project)
-    File.write(File.join(project, 'features/reporter_failure.feature'), <<~FEATURE)
-      Feature: Reporter failure
-
-      Scenario: A deliberately failing scenario
-          Given the reporter has a started scenario
-          Then the reporter records this failure
-    FEATURE
-    File.write(File.join(project, 'features/step_definitions/reporter_failure_steps.rb'), <<~STEPS)
-      # frozen_string_literal: true
-
-      Given('the reporter has a started scenario') {}
-
-      Then('the reporter records this failure') do
-        raise 'deliberate failure for raider_reporter'
-      end
-    STEPS
-  end
-
-  # Keeps the deliberate failure from leaking into the other examples that share the project
-  def remove_failing_cucumber_scenario(project)
-    FileUtils.rm_f(File.join(project, 'features/reporter_failure.feature'))
-    FileUtils.rm_f(File.join(project, 'features/step_definitions/reporter_failure_steps.rb'))
-  end
-
   # Runs the project's own RuboCop with the gems its bundle resolved (newer than this gem's dev bundle).
   # It runs from a copy outside this repo, as a user's project would: inside it RuboCop would also read
   # this repo's .rubocop.yml, gemspec and .ruby-version.
@@ -291,6 +166,13 @@ describe 'End-to-End Project Generation and Execution' do
         expect_project_rubocop_clean('rspec_selenium')
       end
 
+      it 'prints the actionability notice once per run', :slow do
+        skip 'Bundle install failed' unless bundle_install('rspec_selenium')
+
+        result = run_rspec('rspec_selenium')
+        expect(result[:stderr].scan('[raider] actionability on').size).to eq(1), "STDERR: #{result[:stderr]}"
+      end
+
       it 'saves the login once and reuses it', :aggregate_failures, :slow do
         skip 'Bundle install failed' unless bundle_install('rspec_selenium')
 
@@ -314,22 +196,6 @@ describe 'End-to-End Project Generation and Execution' do
         cookie_values.select { |value| value.length >= 8 }.each { |value| expect(output).not_to include(value) }
       end
     end
-
-    describe 'Watir + RSpec' do
-      include_examples 'executable rspec project', 'rspec_watir'
-    end
-
-    describe 'Selenium + Cucumber' do
-      include_examples 'executable cucumber project', 'cucumber_selenium'
-
-      it 'passes its own RuboCop with its bundled gems', :slow do
-        expect_project_rubocop_clean('cucumber_selenium')
-      end
-    end
-
-    describe 'Watir + Cucumber' do
-      include_examples 'executable cucumber project', 'cucumber_watir'
-    end
   end
 
   # Recorded Azure Pipelines env of a push (IndividualCI) build, see raider_reporter's CiDetector specs
@@ -382,12 +248,12 @@ describe 'End-to-End Project Generation and Execution' do
     describe 'Selenium + RSpec' do
       let(:project) { generate_azure_project('rspec') }
 
-      it 'ships azure-pipelines.yml and resolves raider_reporter 0.10+', :aggregate_failures do
+      it 'ships azure-pipelines.yml and resolves raider_reporter 1.x', :aggregate_failures do
         expect(File).to exist(File.join(project, 'azure-pipelines.yml'))
         expect(File).not_to exist(File.join(project, '.github/workflows'))
         skip 'Bundle install failed' unless bundle_install(project)
 
-        expect(File.read(File.join(project, 'Gemfile.lock'))).to match(/^    raider_reporter \(0\.1\d\.\d+\)$/)
+        expect(File.read(File.join(project, 'Gemfile.lock'))).to match(/^    raider_reporter \(1\.\d+\.\d+\)$/)
       end
 
       it 'records provider azure_pipelines and an azure_pipelines: build key in run.json', :aggregate_failures, :slow do
@@ -400,27 +266,6 @@ describe 'End-to-End Project Generation and Execution' do
         expect_azure_ci_block(project)
       end
     end
-
-    describe 'Selenium + Cucumber' do
-      let(:project) { generate_azure_project('cucumber') }
-
-      it 'ships azure-pipelines.yml and resolves raider_reporter 0.10+', :aggregate_failures do
-        expect(File).to exist(File.join(project, 'azure-pipelines.yml'))
-        skip 'Bundle install failed' unless bundle_install(project)
-
-        expect(File.read(File.join(project, 'Gemfile.lock'))).to match(/^    raider_reporter \(0\.1\d\.\d+\)$/)
-      end
-
-      it 'records provider azure_pipelines and an azure_pipelines: build key in run.json', :aggregate_failures, :slow do
-        skip 'Bundle install failed' unless bundle_install(project)
-
-        FileUtils.rm_rf(File.join(project, 'raider-results'))
-        result = run_in_project(project, "#{azure_env_prefix} bundle exec cucumber features/ --format pretty",
-                                timeout: 120)
-        expect(result[:success]).to be(true), "STDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
-        expect_azure_ci_block(project)
-      end
-    end
   end
 
   # An empty skeleton (examples: false) still passes its run, so its CI is green until tests are added
@@ -444,17 +289,6 @@ describe 'End-to-End Project Generation and Execution' do
         expect(result[:stdout]).to include('0 examples, 0 failures')
       end
     end
-
-    it 'runs bundle exec cucumber on a selenium cucumber skeleton with 0 scenarios', :aggregate_failures do
-      project = generate_skeleton_project('cucumber')
-      skip 'Bundle install failed' unless bundle_install(project)
-
-      ['cucumber', 'cucumber features'].each do |command|
-        result = run_in_project(project, "bundle exec #{command}", timeout: 120)
-        expect(result[:exit_code]).to eq(0), "#{command}\nSTDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
-        expect(result[:stdout]).to include('0 scenarios')
-      end
-    end
   end
 
   # Browser e2e helpers shared by the failure video and the trace replay contexts
@@ -470,7 +304,7 @@ describe 'End-to-End Project Generation and Execution' do
     File.directory?("/Applications/#{app}.app") || system("command -v #{command} > /dev/null 2>&1")
   end
 
-  # A separate project, so the default projects keep resolving raider_reporter 0.10+ from RubyGems
+  # A separate project, so the default projects keep resolving raider_reporter 1.x from RubyGems
   def generate_video_project(framework, automation)
     name = "video_#{framework}_#{automation}"
     unless LazyProjectGenerator::GENERATED.include?(name)
@@ -534,41 +368,6 @@ describe 'End-to-End Project Generation and Execution' do
       SPEC
     end
 
-    def add_cucumber_video_feature(project, firefox_binary)
-      File.write(File.join(project, 'features/video_replay.feature'), <<~FEATURE)
-        Feature: Video replay
-
-        Scenario: A passing scenario
-            Given the video page is open
-            Then the video page title is "Video"
-
-        Scenario: A failing scenario
-            Given the video page is open
-            Then the video page title is "deliberate video failure"
-      FEATURE
-      File.write(File.join(project, 'features/step_definitions/video_replay_steps.rb'), <<~STEPS)
-        # frozen_string_literal: true
-
-        Given('the video page is open') do
-          browser.goto('#{page_url}')
-          browser.text_field(id: 'name').set('typed')
-          browser.button(id: 'go').click
-        end
-
-        Then('the video page title is {string}') do |title|
-          raise "expected title \#{title}" unless browser.h1(id: 'title').text == title
-        end
-      STEPS
-      config = File.join(project, 'config/config.yml')
-      File.write(config, File.read(config).sub(/^browser: .*$/, 'browser: firefox'))
-      # Test setup only: the generated templates do not read FIREFOX_BINARY.
-      File.write(File.join(project, 'features/support/zz_firefox_binary.rb'), <<~RUBY) if firefox_binary
-        # frozen_string_literal: true
-
-        Selenium::WebDriver::Firefox.path = ENV['FIREFOX_BINARY'] if ENV['FIREFOX_BINARY']
-      RUBY
-    end
-
     def video_files(project)
       Dir.glob(File.join(project, 'raider-results', '**', '*.{webm,mp4}'))
     end
@@ -634,34 +433,10 @@ describe 'End-to-End Project Generation and Execution' do
         expect(Dir.glob(File.join(cache_dir, '**', '*'))).to be_empty
       end
     end
-
-    describe 'Watir + Cucumber on headless Firefox' do
-      let(:project) { 'video_cucumber_watir' }
-      let(:firefox_binary) { ENV.fetch('FIREFOX_BINARY', nil) }
-
-      before do
-        skip_unless_video_prerequisites('firefox')
-        generate_video_project('cucumber', 'watir')
-        add_cucumber_video_feature(project, firefox_binary)
-      end
-
-      after do
-        FileUtils.rm_f(File.join(project, 'features/video_replay.feature'))
-        FileUtils.rm_f(File.join(project, 'features/step_definitions/video_replay_steps.rb'))
-      end
-
-      it 'attaches video.webm to the failing scenario only and plays it in index.html', :aggregate_failures do
-        result = run_in_project(project, 'bundle exec cucumber features/video_replay.feature',
-                                env: video_env('FIREFOX_BINARY' => firefox_binary), timeout: 240)
-        expect(result[:exit_code]).to eq(1), "STDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
-        expect(result[:stderr]).not_to include('[video]')
-        expect_video_for_failure_only(project, 'A failing scenario', result)
-      end
-    end
   end
 
   # Trace replay against headless Chrome, and one example on headless Firefox. The page is served over HTTP from this process (never file://), so
-  # WebDriver BiDi reports real network and console entries. raider_reporter ~> 0.12 resolves from RubyGems, or
+  # WebDriver BiDi reports real network and console entries. raider_reporter ~> 1.0 resolves from RubyGems, or
   # from a checkout at RAIDER_REPORTER_PATH. The example with video on also needs RAIDER_FFMPEG_PATH.
   # Set TRACE_FIXTURE_DIR to keep the failing RSpec example's trace.zip (and an unzipped copy) there.
   context 'Trace replay', :slow do
@@ -686,8 +461,8 @@ describe 'End-to-End Project Generation and Execution' do
     def skip_unless_trace_prerequisites(project, browser = 'chrome')
       skip "#{browser == 'chrome' ? 'Google Chrome' : 'Firefox'} is not installed" unless browser_installed?(browser)
       version = run_in_project(project, %(bundle exec ruby -e "require 'raider_reporter/version'; print RaiderReporter::VERSION"))
-      skip "the bundle does not resolve raider_reporter ~> 0.12 (set RAIDER_REPORTER_PATH): #{version[:stderr].lines.last}" unless
-        version[:success] && Gem::Version.new(version[:stdout]) >= Gem::Version.new('0.12')
+      skip "the bundle does not resolve raider_reporter ~> 1.0 (set RAIDER_REPORTER_PATH): #{version[:stderr].lines.last}" unless
+        version[:success] && Gem::Version.new(version[:stdout]) >= Gem::Version.new('1.0')
     end
 
     def trace_env(overrides = {})
@@ -747,7 +522,7 @@ describe 'End-to-End Project Generation and Execution' do
       'passes after driving the page'
     end
 
-    # Drives the page through the generated WaitHelper, so the trace has action steps.
+    # Drives the page with plain Selenium and the runtime's matchers, so the trace has action steps.
     # Each example prints the driver's webSocketUrl, which is set only while tracing is on.
     def add_rspec_trace_spec(project)
       File.write(File.join(project, 'spec/trace_replay_spec.rb'), <<~SPEC)
@@ -757,21 +532,23 @@ describe 'End-to-End Project Generation and Execution' do
 
         describe 'Trace replay' do
           it '#{failing}' do
-            driver.navigate.to('#{server.url}')
+            driver.navigate.to('#{server.url}start')
             puts "TRACE_E2E_WEBSOCKET=\#{driver.capabilities[:web_socket_url].inspect}"
-            send_keys({ id: 'pw' }, '#{secrets[0]}')
-            send_keys({ id: 'pw2' }, '#{secrets[1]}')
-            find_element(id: 'name').send_keys('#{plain_value}')
-            click({ id: 'go' })
-            eventually(timeout: 5) { expect(text(id: 'status')).to eq('answered by /api') }
-            eventually(timeout: 1) { expect(text(id: 'title')).to eq('deliberate trace failure') }
+            driver.find_element(id: 'pw').send_keys('#{secrets[0]}')
+            driver.find_element(id: 'pw2').send_keys('#{secrets[1]}')
+            form = driver.find_element(id: 'form')
+            form.find_element(id: 'name').send_keys('#{plain_value}')
+            driver.find_element(id: 'go').click
+            expect { driver.find_element(id: 'status') }.to have_text('answered by /api', wait: 5)
+            expect { driver.find_element(id: 'status').text }.to eq('answered by /api')
+            expect { driver.find_element(id: 'title') }.to have_text('deliberate trace failure', wait: 1)
           end
 
           it '#{passing}' do
             driver.navigate.to('#{server.url}')
             puts "TRACE_E2E_WEBSOCKET=\#{driver.capabilities[:web_socket_url].inspect}"
-            send_keys({ id: 'name' }, 'ok')
-            eventually { expect(text(id: 'title')).to eq('Trace') }
+            driver.find_element(id: 'name').send_keys('ok')
+            expect { driver.find_element(id: 'title') }.to have_text('Trace')
           end
         end
       SPEC
@@ -782,6 +559,19 @@ describe 'End-to-End Project Generation and Execution' do
       trace_zip(project, trace_attachments(result).first)
     end
 
+    # Locators as id strategies, the chained find as within, the password steps masked, and no 3.x step shapes.
+    def expect_runtime_steps(steps)
+      by_id = ->(step) { step['locator'].is_a?(Hash) && step['locator']['strategy'] == 'id' && step['locator']['selector'].is_a?(String) }
+      expect(steps.select { |step| step['action'] == 'click' }).to all(satisfy(&by_id)).and(be_any)
+      expect(steps.select { |step| step['action'] == 'click' }.first['source']['file']).to end_with('spec/trace_replay_spec.rb')
+      typed = steps.select { |step| step['action'] == 'send_keys' }
+      expect(typed).to all(satisfy(&by_id))
+      expect(typed.last['locator']['within']).to be_a(Array).and(be_any)
+      expect(typed.first(2)).to all(include('value' => nil, 'secret' => true))
+      expect(steps.map { |step| step['kind'] }).not_to include('group')
+      expect(steps.map { |step| step['action'] }).not_to include('cucumber_step')
+    end
+
     def steps_of(path)
       TraceFormatChecker.read(path).first['steps']
     end
@@ -824,6 +614,16 @@ describe 'End-to-End Project Generation and Execution' do
         expect(trace['console']).to include(include('level' => 'error', 'text' => a_string_including('trace e2e error')))
       end
 
+      # /start redirects to /: two entries, one per hop, both credited to the navigate step.
+      def expect_redirect_hops(trace)
+        navigate = trace['steps'].find { |step| step['kind'] == 'navigate' }
+        start = trace['network'].find { |entry| entry['url'].to_s.end_with?('/start') }
+        page = trace['network'].find { |entry| entry['url'] == server.url }
+        expect(start).to include('status' => 302, 'step_index' => navigate['index'])
+        expect(page).to include('status' => 200, 'step_index' => navigate['index'])
+        expect(page['duration_ms']).to be >= (TracePageServer::PAGE_DELAY * 1000) - 50
+      end
+
       # The same-origin stylesheet inlined as <style>, and the page's <script> gone.
       def expect_sanitised_snapshots(path, names)
         entries = zip_entries(path)
@@ -847,12 +647,14 @@ describe 'End-to-End Project Generation and Execution' do
         expect(trace_attachments(result_named(project, passing))).to be_empty
         expect(trace_files(project).size).to eq(1)
         expect_valid_trace(path)
+        expect_runtime_steps(steps_of(path))
 
         trace, names = TraceFormatChecker.read(path)
         expect(trace['capabilities']).to include('network' => true, 'console' => true)
         expect_steps(trace['steps'])
         expect_jpeg_screenshots(path, names)
         expect_network_and_console(trace)
+        expect_redirect_hops(trace)
         expect_sanitised_snapshots(path, names)
       end
 
@@ -871,7 +673,7 @@ describe 'End-to-End Project Generation and Execution' do
       end
 
       it 'writes no trace and no web_socket_url with TRACE=off', :aggregate_failures do
-        run = run_in_project(project, command, env: trace_env('TRACE' => 'off'))
+        run = run_in_project(project, command, env: trace_env('TRACE' => 'off', 'BIDI' => 'off'))
         expect_run(run)
         expect(run[:stdout].scan(/^TRACE_E2E_WEBSOCKET=(.*)$/).flatten).to eq(%w[nil nil])
         expect(results(project).flat_map { |result| trace_attachments(result) }).to be_empty
@@ -954,6 +756,7 @@ describe 'End-to-End Project Generation and Execution' do
         expect_run(run)
         path = failing_trace(result_named(project, failing))
         expect_valid_trace(path)
+        expect_runtime_steps(steps_of(path))
 
         trace, names = TraceFormatChecker.read(path)
         expect(trace['browser']).to include('name' => 'firefox')
@@ -965,57 +768,286 @@ describe 'End-to-End Project Generation and Execution' do
       end
     end
 
-    describe 'Selenium + Cucumber on headless Chrome' do
-      let(:project) { 'video_cucumber_selenium' }
+    # mock_request / block_request through WebDriver BiDi, on a page that fetches /api/* and a cross-origin URL
+    # that exists nowhere (so it only answers when mocked). Chrome by default; Edge and Firefox run only when
+    # RAIDER_E2E_BROWSERS (comma separated) lists them.
+    describe 'Network mocking' do
+      let(:project) { 'video_rspec_selenium' }
+      let(:original_config) { File.read(config) }
 
-      before do
-        generate_video_project('cucumber', 'selenium')
-        skip_unless_trace_prerequisites(project)
-        add_cucumber_trace_feature(project)
+      def config
+        File.join(project, 'config/config.yml')
       end
 
-      after do
-        FileUtils.rm_f(File.join(project, 'features/trace_replay.feature'))
-        FileUtils.rm_f(File.join(project, 'features/step_definitions/trace_replay_steps.rb'))
+      def spec_path
+        File.join(project, 'spec/network_mocking_spec.rb')
       end
 
-      def add_cucumber_trace_feature(project)
-        File.write(File.join(project, 'features/trace_replay.feature'), <<~FEATURE)
-          Feature: Trace replay
+      def opted_in?(browser)
+        ENV.fetch('RAIDER_E2E_BROWSERS', '').split(',').map(&:strip).include?(browser)
+      end
+
+      def skip_unless_mocking_prerequisites(browser)
+        skip "set RAIDER_E2E_BROWSERS=#{browser} to run network mocking on #{browser}" unless browser == 'chrome' || opted_in?(browser)
+        skip 'Microsoft Edge is not installed' if browser == 'edge' && !File.directory?('/Applications/Microsoft Edge.app')
+        skip_unless_trace_prerequisites(project, browser == 'firefox' ? 'firefox' : 'chrome')
+      end
 
-          Scenario: A failing traced scenario
-              Given the trace page is open
-              When I type a name on the trace page
-              Then the trace page title is "deliberate trace failure"
-        FEATURE
-        File.write(File.join(project, 'features/step_definitions/trace_replay_steps.rb'), <<~STEPS)
+      def write_spec(body)
+        File.write(spec_path, <<~SPEC)
           # frozen_string_literal: true
 
-          Given('the trace page is open') do
-            driver.navigate.to('#{server.url}')
+          require_relative '../helpers/spec_helper'
+
+          describe 'Network mocking' do
+          #{body.lines.map { |line| line.strip.empty? ? line : "  #{line}" }.join}
           end
+        SPEC
+      end
+
+      def mocking_run(overrides = {})
+        run_in_project(project, 'bundle exec rspec spec/network_mocking_spec.rb', env: trace_env(overrides), timeout: 240)
+      end
 
-          When('I type a name on the trace page') do
-            send_keys({ id: 'name' }, '#{plain_value}')
-            click({ id: 'go' })
+      def mock_example(browser)
+        write_spec(<<~BODY)
+          it 'mocks, blocks, edits and removes' do
+            driver.navigate.to('#{server.url}mock')
+            users = mock_request('#{server.url}api/users', json: { users: ['ana'] })
+            block_request('**/api/fail')
+            mock_request('**/api/echo') { { continue: { headers: { 'x-raider' => 'yes' } } } }
+            mock_request('http://mock.raider.test/api/cors', json: { ok: true })
+            driver.find_element(id: 'users').click
+            expect { driver.find_element(id: 'users-out') }.to have_text('ana', wait: 5)
+            driver.find_element(id: 'fail').click
+            expect { driver.find_element(id: 'fail-out') }.to have_text('request failed', wait: 5)
+            driver.find_element(id: 'echo').click
+            expect { driver.find_element(id: 'echo-out') }.to have_text('echo yes', wait: 5)
+            driver.find_element(id: 'cors').click
+            expect { driver.find_element(id: 'cors-out') }.to have_text('cors true', wait: 5)
+            expect { users.calls.size }.to eq(1)
+            expect { users.called? }.to be(true)
+            remove_mock(users)
+            driver.find_element(id: 'users').click
+            expect { driver.find_element(id: 'users-out') }.to have_text('real', wait: 5)
+            expect { users.calls.size }.to eq(1)
+            puts 'NETWORK_MOCKING_#{browser.upcase}_DONE'
           end
+        BODY
+      end
+
+      def switch_browser(name)
+        # The generated config carries browser arguments for chrome and firefox only.
+        edge_args = "  edge:\n    - no-sandbox\n"
+        File.write(config, original_config.sub(/^browser: .*$/, "browser: #{name}").sub(/^  firefox:/, "#{edge_args}  firefox:"))
+      end
+
+      # Skips when the browser is unavailable or not opted in; otherwise points the config at it.
+      def use_browser(name)
+        skip_unless_mocking_prerequisites(name)
+        original_config
+        switch_browser(name)
+      end
+
+      before { generate_video_project('rspec', 'selenium') }
 
-          Then('the trace page title is {string}') do |title|
-            eventually(timeout: 1) { expect(text(id: 'title')).to eq(title) }
+      after do
+        File.write(config, original_config) if File.exist?(config)
+        FileUtils.rm_f(spec_path)
+      end
+
+      %w[chrome edge firefox].each do |name|
+        it "mocks, blocks, edits headers and removes a mock on headless #{name}", :aggregate_failures do
+          use_browser(name)
+          mock_example(name)
+          run = mocking_run('TRACE' => 'off')
+          expect_run(run, exit_code: 0)
+          expect(run[:stdout]).to include("NETWORK_MOCKING_#{name.upcase}_DONE")
+        end
+      end
+
+      def write_failing_spec
+        write_spec(<<~BODY)
+          it 'fails after mocking' do
+            driver.navigate.to('#{server.url}mock')
+            mock_request('#{server.url}api/users', json: { users: ['ana'] })
+            block_request('#{server.url}api/fail')
+            driver.find_element(id: 'users').click
+            expect { driver.find_element(id: 'users-out') }.to have_text('ana', wait: 5)
+            driver.find_element(id: 'fail').click
+            expect { driver.find_element(id: 'fail-out') }.to have_text('request failed', wait: 5)
+            expect { driver.find_element(id: 'users-out') }.to have_text('deliberate mocking failure', wait: 1)
           end
-        STEPS
+        BODY
       end
 
-      it 'attaches a trace.zip with Gherkin step groups to the failing scenario', :aggregate_failures do
-        run = run_in_project(project, 'bundle exec cucumber features/trace_replay.feature', env: trace_env, timeout: 240)
-        expect_run(run)
-        attachments = trace_attachments(result_named(project, 'A failing traced scenario'))
-        expect(attachments.size).to eq(1)
-        expect(attachments.first).to include('content_type' => 'application/vnd.raider.trace+zip', 'attempt' => 1)
-        path = trace_zip(project, attachments.first)
+      it 'keeps mocked entries in the failing example trace', :aggregate_failures do
+        use_browser('chrome')
+        write_failing_spec
+        expect_run(mocking_run)
+        path = failing_trace(result_named(project, 'fails after mocking'))
+        keep_fixture(path)
         expect_valid_trace(path)
-        groups = TraceFormatChecker.read(path).first['steps'].select { |step| step['action'] == 'cucumber_step' }
-        expect(groups).to include(include('kind' => 'group', 'name' => a_string_including('the trace page is open')))
+        network = TraceFormatChecker.read(path).first['network']
+        users = network.find { |entry| entry['url'].to_s.end_with?('/api/users') }
+        failed = network.find { |entry| entry['url'].to_s.end_with?('/api/fail') }
+        expect(users).to include('mocked' => 'fulfilled', 'status' => 200)
+        expect(failed).to include('mocked' => 'failed')
+      end
+
+      it 'fails the example with MockError when a block raises', :aggregate_failures do
+        use_browser('chrome')
+        write_spec(<<~BODY)
+          it 'has a raising block' do
+            driver.navigate.to('#{server.url}mock')
+            mock_request('#{server.url}api/users') { raise 'boom from the block' }
+            driver.find_element(id: 'users').click
+            expect { driver.find_element(id: 'users-out') }.to have_text('users failed', wait: 5)
+          end
+        BODY
+        run = mocking_run('TRACE' => 'off')
+        expect(run[:exit_code]).to eq(1), "STDOUT: #{run[:stdout]}\nSTDERR: #{run[:stderr]}"
+        expect(run[:stdout]).to include('NetworkHelper::MockError', 'boom from the block')
+      end
+    end
+  end
+
+  # match_screenshot against real browsers, on a fixed data: page (no server, no animation). Chrome by default; Edge and
+  # Firefox run only when RAIDER_E2E_BROWSERS (comma separated) lists them. The generated spec recolours the page
+  # when SHOT_VARIANT=changed. raider_reporter comes from RubyGems (no `comparison` method yet), so the images are
+  # attached and one warning is printed; the report's comparisons field is not asserted here.
+  context 'Screenshot comparison', :slow do
+    let(:cache_dir) { Dir.mktmpdir('raider-cache') }
+    let(:baseline) { "screenshots/baselines/#{browser_name}/home.png" }
+    let(:original_config) { File.read(config_path) }
+
+    after do
+      File.write(config_path, original_config) if File.exist?(config_path)
+      FileUtils.rm_rf(File.join(project, 'screenshots'))
+      FileUtils.rm_f(File.join(project, 'spec/screenshot_comparison_spec.rb'))
+      FileUtils.rm_rf(cache_dir)
+    end
+
+    def config_path
+      File.join(project, 'config/config.yml')
+    end
+
+    def shot_page
+      html = '<body style="margin:0;font-family:monospace"><h1 id="title">Screenshot</h1><p>Fixed content</p></body>'
+      "data:text/html,#{ERB::Util.url_encode(html)}"
+    end
+
+    def recolour
+      "document.documentElement.style.background = 'rgb(200, 0, 0)'; document.body.style.background = 'rgb(200, 0, 0)'"
+    end
+
+    def shot_env(overrides = {})
+      ci = %w[CI GITHUB_ACTIONS GITLAB_CI JENKINS_URL BUILDKITE CIRCLECI TF_BUILD TRAVIS].to_h { |key| [key, nil] }
+      ci.merge('HEADLESS' => 'true', 'VIDEO' => 'off', 'TRACE' => 'off', 'RAIDER_CACHE_DIR' => cache_dir,
+               'RAIDER_TOKEN' => nil, 'RAIDER_ENDPOINT' => nil, 'SCREENSHOTS' => nil, 'SHOT_VARIANT' => nil).merge(overrides)
+    end
+
+    def use_browser(name)
+      opted_in = ENV.fetch('RAIDER_E2E_BROWSERS', '').split(',').map(&:strip).include?(name)
+      skip "set RAIDER_E2E_BROWSERS=#{name} to run screenshot comparison on #{name}" unless name == 'chrome' || opted_in
+      skip 'Microsoft Edge is not installed' if name == 'edge' && !File.directory?('/Applications/Microsoft Edge.app')
+      skip "#{name} is not installed" unless name == 'edge' || browser_installed?(name == 'firefox' ? 'firefox' : 'chrome')
+      @browser_name = name
+      original_config
+      edge_args = "  edge:\n    - no-sandbox\n"
+      File.write(config_path, original_config.sub(/^browser: .*$/, "browser: #{name}").sub(/^  firefox:/, "#{edge_args}  firefox:"))
+    end
+
+    attr_reader :browser_name
+
+    def attachment_names(project)
+      results(project).flat_map { |result| result['attachments'].map { |attachment| attachment['name'] } }
+    end
+
+    def comparison_names(project)
+      attachment_names(project).grep(/\Acomparison:/)
+    end
+
+    def baseline_path
+      File.join(project, baseline)
+    end
+
+    def write_rspec_spec
+      File.write(File.join(project, 'spec/screenshot_comparison_spec.rb'), <<~SPEC)
+        # frozen_string_literal: true
+
+        require_relative '../helpers/spec_helper'
+
+        describe 'Screenshot comparison' do
+          it 'matches home' do
+            driver.navigate.to('#{shot_page}')
+            driver.execute_script("#{recolour}") if ENV['SHOT_VARIANT'] == 'changed'
+            match_screenshot('home')
+          end
+        end
+      SPEC
+    end
+
+    # Every failure message in run.json, as text.
+    def failure_text(project)
+      results(project).to_json
+    end
+
+    def expect_ok(run)
+      expect(run[:exit_code]).to eq(0), "STDOUT: #{run[:stdout]}\nSTDERR: #{run[:stderr]}"
+    end
+
+    def expect_failed(run)
+      expect(run[:exit_code]).to eq(1), "STDOUT: #{run[:stdout]}\nSTDERR: #{run[:stderr]}"
+    end
+
+    # The five runs of the plan, in order; each block is one run of the generated test.
+    def walk_through(command)
+      run = proc do |overrides = {}|
+        FileUtils.rm_rf(File.join(project, 'raider-results'))
+        run_in_project(project, command, env: shot_env(overrides), timeout: 300)
+      end
+
+      expect_ok(run.call) # 1: creates the baseline
+      expect(File).to exist(baseline_path)
+      expect(File.binread(baseline_path)).to start_with("\x89PNG".b)
+      first_bytes = File.binread(baseline_path)
+
+      expect_ok(run.call) # 2: matches
+      expect(comparison_names(project)).to be_empty
+
+      different = run.call('SHOT_VARIANT' => 'changed') # 3: differs
+      expect_failed(different)
+      expect(comparison_names(project)).to include('comparison:home:expected', 'comparison:home:actual', 'comparison:home:diff')
+      expect(failure_text(project)).to include(baseline)
+      expect(File.binread(baseline_path)).to eq(first_bytes)
+      expect(different[:stderr].scan('[screenshots] this raider_reporter has no comparison method').size).to be <= 1
+
+      FileUtils.rm_f(baseline_path) # 4: CI without a baseline
+      missing = run.call('CI' => '1')
+      expect_failed(missing)
+      expect(File).not_to exist(baseline_path)
+      expect(failure_text(project)).to include('no baseline')
+
+      expect_ok(run.call('SCREENSHOTS' => 'update')) # 5: update rewrites
+      expect(File).to exist(baseline_path)
+      expect_ok(run.call('SHOT_VARIANT' => 'changed', 'SCREENSHOTS' => 'update'))
+      expect(File.binread(baseline_path)).not_to eq(first_bytes)
+    end
+
+    %w[chrome edge firefox].each do |name|
+      describe "Selenium + RSpec on headless #{name}" do
+        let(:project) { 'video_rspec_selenium' }
+
+        before do
+          generate_video_project('rspec', 'selenium')
+          use_browser(name)
+          write_rspec_spec
+        end
+
+        it 'creates, matches, fails with images, refuses on CI and updates', :aggregate_failures do
+          walk_through('bundle exec rspec spec/screenshot_comparison_spec.rb')
+        end
       end
     end
   end
@@ -1035,19 +1067,6 @@ describe 'End-to-End Project Generation and Execution' do
       end
     end
 
-    describe 'iOS + Cucumber' do
-      it 'generates valid project structure' do
-        expect(File).to exist('cucumber_ios/features/support/env.rb')
-        expect(File).to exist('cucumber_ios/Gemfile')
-        expect(File).to exist('cucumber_ios/features')
-      end
-
-      it 'has valid Ruby syntax in generated files' do
-        result = run_in_project('cucumber_ios', 'ruby -c features/support/env.rb')
-        expect(result[:success]).to be true
-      end
-    end
-
     describe 'Android + RSpec' do
       it 'generates valid project structure' do
         expect(File).to exist('rspec_android/helpers/spec_helper.rb')
@@ -1061,19 +1080,6 @@ describe 'End-to-End Project Generation and Execution' do
       end
     end
 
-    describe 'Android + Cucumber' do
-      it 'generates valid project structure' do
-        expect(File).to exist('cucumber_android/features/support/env.rb')
-        expect(File).to exist('cucumber_android/Gemfile')
-        expect(File).to exist('cucumber_android/features')
-      end
-
-      it 'has valid Ruby syntax in generated files' do
-        result = run_in_project('cucumber_android', 'ruby -c features/support/env.rb')
-        expect(result[:success]).to be true
-      end
-    end
-
     describe 'Cross-Platform + RSpec' do
       it 'generates valid project structure' do
         expect(File).to exist('rspec_cross_platform/helpers/appium_helper.rb')
@@ -1086,19 +1092,6 @@ describe 'End-to-End Project Generation and Execution' do
         expect(result[:success]).to be true
       end
     end
-
-    describe 'Cross-Platform + Cucumber' do
-      it 'generates valid project structure' do
-        expect(File).to exist('cucumber_cross_platform/helpers/appium_helper.rb')
-        expect(File).to exist('cucumber_cross_platform/Gemfile')
-        expect(File).to exist('cucumber_cross_platform/features')
-      end
-
-      it 'has valid Ruby syntax in generated files' do
-        result = run_in_project('cucumber_cross_platform', 'ruby -c features/support/env.rb')
-        expect(result[:success]).to be true
-      end
-    end
   end
 
   # Verify template system performance (caching working)