ruby_raider 3.9.0 → 3.11.0

data/spec/integration/content/readme_content_spec.rb

@@ -3,6 +3,57 @@
 require_relative 'content_helper'
 
 describe 'Generated Readme content' do
+  FRAMEWORKS.product(AUTOMATION_TYPES).each do |framework, automation|
+    context "with #{framework} and #{automation}, the Video replay section" do
+      subject(:section) { readme[/^### Video replay\n.*?(?=^##)/m]&.gsub(/\s+/, ' ') }
+
+      let(:readme) { read_generated("#{framework}_#{automation}", 'Readme.md') }
+      let(:web) { %w[selenium watir].include?(automation) }
+
+      it 'exists and covers the defaults, VIDEO=off, the install commands and the cache' do
+        expect(section).not_to be_nil
+        expect(section).to include('only for failing tests', 'VIDEO=off', 'raider u video install',
+                                   'raider u video status', '~/.cache/raider', 'RAIDER_FFMPEG_PATH',
+                                   'RAIDER_CACHE_DIR', 'raider-results/attachments/')
+      end
+
+      it 'says that video needs RAIDER_FFMPEG_PATH until the ffmpeg release is published' do
+        expect(section).to include('ffmpeg-7.1', 'not published yet')
+      end
+
+      it 'names the right video format and how to turn video off for this project' do
+        if web
+          expect(section).to include('video.webm', 'raider u video off', 'raider u video on', 'video:')
+        elsif %w[android ios].include?(automation)
+          expect(section).to include('video.mp4', 'raider u video off', 'creates `config/config.yml`')
+          expect(section).not_to include('no `config/config.yml`')
+        else
+          expect(section).to include('video.mp4', 'raider u video off')
+        end
+      end
+
+      it 'says where mobile recording needs ffmpeg and how long it records' do
+        limits = { 'ios' => ['1800 s'], 'android' => ['180 s'], 'cross_platform' => ['1800 s', '180 s'] }
+        if web
+          expect(section).not_to include('Appium server host')
+        else
+          expect(section).to include('`ffmpeg` on the Appium server host', 'iOS', 'longer than 180 s',
+                                     'time_limit', *limits.fetch(automation))
+          expect(section).not_to include('do not use ffmpeg')
+        end
+      end
+
+      it 'lists the known limits of web recording' do
+        if web
+          expect(section).to include('after each page load, click and text change', 'next frame',
+                                     'one recorded driver per process')
+        else
+          expect(section).not_to include('next frame')
+        end
+      end
+    end
+  end
+
   AUTOMATION_TYPES.each do |automation|
     context "with rspec and #{automation}" do
       subject(:readme) { read_generated("#{FrameworkIndex::RSPEC}_#{automation}", 'Readme.md') }
@@ -61,4 +112,32 @@ describe 'Generated Readme content' do
       end
     end
   end
+
+  FRAMEWORKS.product(AUTOMATION_TYPES).each do |framework, automation|
+    context "with #{framework} and #{automation}, the login reuse section" do
+      subject(:readme) { read_generated("#{framework}_#{automation}", 'Readme.md') }
+
+      if %w[selenium watir].include?(automation)
+        it 'documents the tags, other roles, max_age, the env switch and the secrets warning' do
+          section = readme[/^## Reusing the login\n.*?(?=^##)/m].gsub(/\s+/, ' ')
+          expect(section).to include('`:logged_in`', '`@logged_in`', "SessionState.new(driver, name: 'admin')",
+                                     'browser.driver', 'login_state', 'max_age', 'RAIDER_LOGIN_STATE=off',
+                                     'RAIDER_LOGIN_STATE=refresh', '.raider/auth/', 'git-ignored',
+                                     'live session tokens', 'must not be committed, cached or uploaded')
+        end
+
+        it 'is its own ## section, straight after the Quality gate and before any CI section' do
+          heading = readme.index("\n## Reusing the login\n")
+          gate = readme.index("\n### Quality gate\n")
+          expect(gate).to be < heading
+          expect(readme[(gate + 1)...heading]).not_to match(/\n##/)
+          expect(readme[(heading + 1)..][/\n## .*/]).to be_nil.or match(/\A\n## (CI|Azure Pipelines)\z/)
+        end
+      else
+        it 'does not mention login reuse' do
+          expect(readme).not_to include('Reusing the login', 'RAIDER_LOGIN_STATE', '.raider/auth/')
+        end
+      end
+    end
+  end
 end

data/spec/integration/content/rspec_reporter_content_spec.rb

@@ -18,8 +18,8 @@ describe 'RSpec projects without Allure' do
         expect(File).not_to exist(File.join(project_name, 'allure-results'))
       end
 
-      it 'pins raider_reporter 0.9' do
-        expect(read_generated(project_name, 'Gemfile')).to include("gem 'raider_reporter', '~> 0.9'")
+      it 'pins raider_reporter 0.10' do
+        expect(read_generated(project_name, 'Gemfile')).to include("gem 'raider_reporter', '~> 0.10'")
       end
     end
   end

data/spec/integration/content/syntax_validation_spec.rb

@@ -24,6 +24,21 @@ describe 'Ruby syntax validation' do
             expect(content).to have_frozen_string_literal
           end
         end
+
+        login_reuse_files = %w[helpers/session_state.rb]
+        login_reuse_files += if framework == 'rspec'
+                               %w[helpers/spec_helper.rb]
+                             else
+                               %w[features/support/env.rb features/step_definitions/login_steps.rb]
+                             end
+
+        login_reuse_files.each do |relative|
+          it "#{relative} is generated as valid Ruby with frozen_string_literal" do
+            content = File.read(File.join(project_name, relative))
+            expect(content).to have_valid_ruby_syntax
+            expect(content).to have_frozen_string_literal
+          end
+        end
       end
     end
   end

data/spec/integration/content/test_content_spec.rb

@@ -111,8 +111,29 @@ describe 'Test file content' do
       expect(config).to include('default:')
     end
 
-    it 'uses the pretty formatter, with the reporter activated from env.rb' do
-      expect(config.strip).to eq('default: --format pretty --publish-quiet --retry 0')
+    it 'uses the pretty and rerun formatters, with the reporter activated from env.rb' do
+      expect(config.strip).to eq('default: --format pretty --format rerun --out rerun.txt --publish-quiet --retry 0')
+    end
+  end
+
+  shared_examples 'logged in example' do |project_name|
+    it 'adds a :logged_in example that reuses the saved login and keeps the login example' do
+      spec = read_generated(project_name, 'spec/login_page_spec.rb')
+      expect(spec).to include("describe 'Account', :logged_in", 'opens the account page with the saved login',
+                              "describe 'Login' do", 'can successfully log in')
+    end
+  end
+
+  shared_examples 'logged in scenario' do |project_name|
+    it 'adds a @logged_in scenario and keeps the login scenario' do
+      feature = read_generated(project_name, 'features/login.feature')
+      expect(feature).to include("@logged_in\nScenario: A logged-in user opens the account page",
+                                 "Given I'm a registered user\n", 'Scenario: A user can login')
+    end
+
+    it 'defines the step that picks the user without logging in' do
+      steps = read_generated(project_name, 'features/step_definitions/login_steps.rb')
+      expect(steps).to include(%q(Given("I'm a {user}") do |user|))
     end
   end
 
@@ -122,12 +143,14 @@ describe 'Test file content' do
     name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
     include_examples 'valid rspec spec', name
     include_examples 'selenium rspec spec', name
+    include_examples 'logged in example', name
   end
 
   context 'with rspec and watir' do
     name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::WATIR}"
     include_examples 'valid rspec spec', name
     include_examples 'watir rspec spec', name
+    include_examples 'logged in example', name
   end
 
   # --- Cucumber contexts ---
@@ -138,6 +161,7 @@ describe 'Test file content' do
     include_examples 'valid cucumber env', name
     include_examples 'valid cucumber world', name
     include_examples 'valid cucumber config', name
+    include_examples 'logged in scenario', name
   end
 
   context 'with cucumber and watir' do
@@ -146,6 +170,6 @@ describe 'Test file content' do
     include_examples 'valid cucumber env', name
     include_examples 'valid cucumber world', name
     include_examples 'valid cucumber config', name
+    include_examples 'logged in scenario', name
   end
-
 end

data/spec/integration/end_to_end_features_spec.rb

@@ -242,7 +242,6 @@ describe 'End-to-End Feature Validation' do
         end
       end
     end
-
   end
 
   # --- Feature: GitHub Actions CI ---
@@ -264,5 +263,4 @@ describe 'End-to-End Feature Validation' do
       expect(content).to include('rspec')
     end
   end
-
 end

data/spec/integration/end_to_end_spec.rb

@@ -4,6 +4,8 @@ require_relative 'spec_helper'
 require 'timeout'
 require 'open3'
 require 'json'
+require 'erb'
+require 'tmpdir'
 
 # End-to-end integration tests that verify generated projects actually work
 # These tests:
@@ -15,7 +17,7 @@ require 'json'
 # This ensures the template system produces working, executable test frameworks
 describe 'End-to-End Project Generation and Execution' do
   # Helper to run commands in a generated project directory
-  def run_in_project(project_name, command, timeout: 300)
+  def run_in_project(project_name, command, timeout: 300, env: {})
     result = {
       success: false,
       stdout: '',
@@ -26,7 +28,7 @@ describe 'End-to-End Project Generation and Execution' do
     Dir.chdir(project_name) do
       Bundler.with_unbundled_env do
         Timeout.timeout(timeout) do
-          stdout, stderr, status = Open3.capture3(command)
+          stdout, stderr, status = Open3.capture3(env, command)
           result[:stdout] = stdout
           result[:stderr] = stderr
           result[:exit_code] = status.exitstatus
@@ -49,6 +51,15 @@ describe 'End-to-End Project Generation and Execution' do
     gemfile = File.join(project_name, 'Gemfile')
     root = File.expand_path('../..', __dir__)
     File.write(gemfile, File.read(gemfile).sub(/^gem 'ruby_raider'.*$/, "gem 'ruby_raider', path: '#{root}'"))
+    use_local_raider_reporter(gemfile)
+  end
+
+  # Set RAIDER_REPORTER_PATH to a raider_reporter checkout to resolve a release that is not on RubyGems yet.
+  def use_local_raider_reporter(gemfile)
+    path = ENV.fetch('RAIDER_REPORTER_PATH', nil)
+    return unless path
+
+    File.write(gemfile, File.read(gemfile).sub(/^gem 'raider_reporter'.*$/, "gem 'raider_reporter', path: '#{path}'"))
   end
 
   # Helper to install dependencies
@@ -104,10 +115,10 @@ describe 'End-to-End Project Generation and Execution' do
       expect(bundle_install(project)).to be true
     end
 
-    it 'resolves raider_reporter 0.9 from RubyGems and ships the raider-reporter executable', :aggregate_failures do
+    it 'resolves raider_reporter 0.10+ 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\.9\.\d+\)$/)
+      expect(File.read(File.join(project, 'Gemfile.lock'))).to match(/^    raider_reporter \(0\.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')
@@ -163,11 +174,11 @@ describe 'End-to-End Project Generation and Execution' do
                                   "STDERR: #{result[:stderr]}"
     end
 
-    it 'resolves raider_reporter 0.9 from RubyGems and requires its Cucumber plugin', :aggregate_failures do
+    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\.9\.\d+\)$/)
+      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
 
@@ -182,6 +193,17 @@ describe 'End-to-End Project Generation and Execution' do
       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)
@@ -211,7 +233,7 @@ describe 'End-to-End Project Generation and Execution' do
   # 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'))
+    FileUtils.rm_rf([File.join(project, 'raider-results'), File.join(project, 'rerun.txt')])
     run_cucumber(project)
   ensure
     remove_failing_cucumber_scenario(project)
@@ -247,6 +269,29 @@ describe 'End-to-End Project Generation and Execution' do
   context 'Web Automation Frameworks' do
     describe 'Selenium + RSpec' do
       include_examples 'executable rspec project', 'rspec_selenium'
+
+      it 'saves the login once and reuses it', :aggregate_failures, :slow do
+        skip 'Bundle install failed' unless bundle_install('rspec_selenium')
+
+        state_file = File.join('rspec_selenium', '.raider', 'auth', 'user.json')
+        FileUtils.rm_rf(File.join('rspec_selenium', '.raider'))
+        first = run_in_project('rspec_selenium', 'bundle exec rspec spec/', env: { 'HEADLESS' => 'true' })
+        failed = ->(run, index) { "Run #{index} failed.\nSTDOUT: #{run[:stdout]}\nSTDERR: #{run[:stderr]}" }
+        raise failed.call(first, 1) unless first[:exit_code].zero? # show run 1's output, not a missing state file
+
+        expect(File).to exist(state_file)
+        saved = JSON.parse(File.read(state_file))
+        second = run_in_project('rspec_selenium', 'bundle exec rspec spec/', env: { 'HEADLESS' => 'true' })
+        expect(second[:exit_code]).to eq(0), failed.call(second, 2)
+        expect(File.stat(state_file).mode & 0o777).to eq(0o600)
+        expect(saved).to include('format' => 1, 'origin' => 'https://raider-test-site.onrender.com')
+        expect(JSON.parse(File.read(state_file))['saved_at']).to eq(saved['saved_at'])
+        cookie_values = saved['cookies'].map { |cookie| cookie['value'].to_s }
+        expect(cookie_values.reject(&:empty?)).not_to be_empty
+        output = [first, second].map { |run| run[:stdout] + run[:stderr] }.join
+        # Short values like "1" or "en" can appear in any output; a leaked token is long.
+        cookie_values.select { |value| value.length >= 8 }.each { |value| expect(output).not_to include(value) }
+      end
     end
 
     describe 'Watir + RSpec' do
@@ -263,20 +308,22 @@ describe 'End-to-End Project Generation and Execution' do
   end
 
   # Recorded Azure Pipelines env of a push (IndividualCI) build, see raider_reporter's CiDetector specs
-  AZURE_PUSH_ENV = {
-    'TF_BUILD' => 'True',
-    'SYSTEM_COLLECTIONURI' => 'https://dev.azure.com/raider-test/',
-    'SYSTEM_TEAMPROJECT' => 'My Project',
-    'SYSTEM_TEAMPROJECTID' => '6ce954b1-ce1f-45d1-b94d-e6bf2464ba2c',
-    'BUILD_REPOSITORY_NAME' => 'web tests',
-    'BUILD_REPOSITORY_ID' => '1c2bd1a0-3f63-4d93-9c3c-2b4f2b1d8f11',
-    'BUILD_REPOSITORY_PROVIDER' => 'TfsGit',
-    'BUILD_BUILDID' => '42',
-    'SYSTEM_JOBDISPLAYNAME' => 'tests',
-    'BUILD_REASON' => 'IndividualCI',
-    'BUILD_SOURCEBRANCH' => 'refs/heads/release/1.2',
-    'BUILD_SOURCEVERSION' => 'abc'
-  }.freeze
+  def azure_push_env
+    {
+      'TF_BUILD' => 'True',
+      'SYSTEM_COLLECTIONURI' => 'https://dev.azure.com/raider-test/',
+      'SYSTEM_TEAMPROJECT' => 'My Project',
+      'SYSTEM_TEAMPROJECTID' => '6ce954b1-ce1f-45d1-b94d-e6bf2464ba2c',
+      'BUILD_REPOSITORY_NAME' => 'web tests',
+      'BUILD_REPOSITORY_ID' => '1c2bd1a0-3f63-4d93-9c3c-2b4f2b1d8f11',
+      'BUILD_REPOSITORY_PROVIDER' => 'TfsGit',
+      'BUILD_BUILDID' => '42',
+      'SYSTEM_JOBDISPLAYNAME' => 'tests',
+      'BUILD_REASON' => 'IndividualCI',
+      'BUILD_SOURCEBRANCH' => 'refs/heads/release/1.2',
+      'BUILD_SOURCEVERSION' => 'abc'
+    }.freeze
+  end
 
   # Generates a ci: azure web project (the shared before(:all) only builds the default github ones)
   def generate_azure_project(framework)
@@ -289,7 +336,7 @@ describe 'End-to-End Project Generation and Execution' do
   end
 
   def azure_env_prefix
-    "GITHUB_ACTIONS= HEADLESS=true #{AZURE_PUSH_ENV.map { |k, v| "#{k}='#{v}'" }.join(' ')}"
+    "GITHUB_ACTIONS= HEADLESS=true #{azure_push_env.map { |k, v| "#{k}='#{v}'" }.join(' ')}"
   end
 
   def expect_azure_ci_block(project)
@@ -310,12 +357,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.9', :aggregate_failures do
+      it 'ships azure-pipelines.yml and resolves raider_reporter 0.10+', :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\.9\.\d+\)$/)
+        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
@@ -332,11 +379,11 @@ describe 'End-to-End Project Generation and Execution' do
     describe 'Selenium + Cucumber' do
       let(:project) { generate_azure_project('cucumber') }
 
-      it 'ships azure-pipelines.yml and resolves raider_reporter 0.9', :aggregate_failures do
+      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\.9\.\d+\)$/)
+        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
@@ -351,6 +398,208 @@ describe 'End-to-End Project Generation and Execution' do
     end
   end
 
+  # Failure video replay against real browsers. Needs an ffmpeg with libvpx (RAIDER_FFMPEG_PATH), because the
+  # RaiderHQ ffmpeg release has no checksums yet. Skipped when it, or the browser, is missing. Firefox can be
+  # pointed at a specific binary with FIREFOX_BINARY.
+  context 'Failure video replay', :slow, :video do
+    let(:ffmpeg_path) { ENV.fetch('RAIDER_FFMPEG_PATH', '') }
+    let(:cache_dir) { Dir.mktmpdir('raider-cache') }
+
+    after { FileUtils.rm_rf(cache_dir) }
+
+    def skip_unless_video_prerequisites(browser)
+      skip 'RAIDER_FFMPEG_PATH is not set to an executable ffmpeg with libvpx' unless
+        File.file?(ffmpeg_path) && File.executable?(ffmpeg_path)
+      skip "#{browser} is not installed" unless browser_installed?(browser)
+    end
+
+    def browser_installed?(browser)
+      if browser == 'firefox'
+        ENV['FIREFOX_BINARY'] ? File.executable?(ENV['FIREFOX_BINARY']) : app_or_command?('Firefox', 'firefox')
+      else
+        app_or_command?('Google Chrome', 'google-chrome') || app_or_command?('Chromium', 'chromium')
+      end
+    end
+
+    def app_or_command?(app, command)
+      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
+    def generate_video_project(framework, automation)
+      name = "video_#{framework}_#{automation}"
+      unless LazyProjectGenerator::GENERATED.include?(name)
+        generate_framework(framework:, automation:, name:)
+        LazyProjectGenerator::GENERATED.add(name)
+        use_local_ruby_raider(name)
+        expect(run_in_project(name, 'bundle install --quiet', timeout: 300)[:success]).to be(true)
+      end
+      FileUtils.rm_rf(File.join(name, 'raider-results'))
+      name
+    end
+
+    def video_env(overrides = {})
+      { 'HEADLESS' => 'true', 'RAIDER_FFMPEG_PATH' => ffmpeg_path, 'RAIDER_CACHE_DIR' => cache_dir,
+        'RAIDER_TOKEN' => nil, 'RAIDER_ENDPOINT' => nil, 'VIDEO' => nil }.merge(overrides)
+    end
+
+    def page_url
+      "data:text/html,#{ERB::Util.url_encode('<h1 id="title">Video</h1><input id="name"><button id="go">Go</button>')}"
+    end
+
+    def add_rspec_video_spec(project)
+      File.write(File.join(project, 'spec/video_replay_spec.rb'), <<~SPEC)
+        # frozen_string_literal: true
+
+        require_relative '../helpers/spec_helper'
+
+        describe 'Video replay' do
+          it 'passes after driving the page' do
+            driver.navigate.to('#{page_url}')
+            driver.find_element(id: 'name').send_keys('ok')
+            expect(driver.find_element(id: 'title').text).to eq('Video')
+          end
+
+          it 'fails after driving the page' do
+            driver.navigate.to('#{page_url}')
+            driver.find_element(id: 'name').send_keys('broken')
+            driver.find_element(id: 'go').click
+            expect(driver.find_element(id: 'title').text).to eq('deliberate video failure')
+          end
+        end
+      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 results(project)
+      JSON.parse(File.read(File.join(project, 'raider-results', 'run.json')))['results']
+    end
+
+    def video_files(project)
+      Dir.glob(File.join(project, 'raider-results', '**', '*.{webm,mp4}'))
+    end
+
+    def video_attachments(result)
+      result['attachments'].select { |attachment| attachment['name'] == 'video' }
+    end
+
+    def expect_video_for_failure_only(project, failing_name, run)
+      by_status = results(project).group_by { |r| r['status'] }
+      expect(by_status.keys).to match_array(%w[passed failed]), "STDOUT: #{run[:stdout]}\nSTDERR: #{run[:stderr]}"
+      failing = by_status['failed'].find { |r| r['full_name'].include?(failing_name) }
+      expect(failing).not_to be_nil, "No failing result named #{failing_name}"
+      expect(video_attachments(failing).size).to eq(1)
+      expect(video_attachments(failing).first['content_type']).to eq('video/webm')
+      by_status.fetch('passed', []).each { |r| expect(video_attachments(r)).to be_empty }
+      videos = video_files(project)
+      expect(videos.size).to eq(1)
+      expect(videos.first).to end_with('video.webm')
+      expect(File.size(videos.first)).to be_positive
+      expect(File.read(File.join(project, 'raider-results', 'index.html'))).to include('<video')
+    end
+
+    describe 'Selenium + RSpec on headless Chrome' do
+      let(:project) { 'video_rspec_selenium' }
+      let(:command) { 'bundle exec rspec spec/video_replay_spec.rb' }
+
+      before do
+        skip_unless_video_prerequisites('chrome')
+        generate_video_project('rspec', 'selenium')
+        add_rspec_video_spec(project)
+      end
+
+      after { FileUtils.rm_f(File.join(project, 'spec/video_replay_spec.rb')) }
+
+      it 'attaches video.webm to the failing example only and plays it in index.html', :aggregate_failures do
+        result = run_in_project(project, command, env: video_env)
+        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, 'fails after driving the page', result)
+      end
+
+      it 'writes no video with VIDEO=off', :aggregate_failures do
+        result = run_in_project(project, command, env: video_env('VIDEO' => 'off'))
+        expect(result[:exit_code]).to eq(1), "STDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
+        expect(video_files(project)).to be_empty
+        expect(results(project).flat_map { |r| video_attachments(r) }).to be_empty
+        expect(result[:stderr]).not_to include('[video]')
+      end
+
+      it 'runs unchanged with one [video] line and no download when no ffmpeg is usable', :aggregate_failures do
+        off = run_in_project(project, command, env: video_env('VIDEO' => 'off'))
+        FileUtils.rm_rf(File.join(project, 'raider-results'))
+        result = run_in_project(project, command, env: video_env('RAIDER_FFMPEG_PATH' => nil))
+
+        expect(result[:exit_code]).to eq(off[:exit_code]), "STDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
+        video_lines = result[:stderr].lines.grep(/\[video\]/)
+        expect(video_lines.size).to eq(1), "STDERR: #{result[:stderr]}"
+        # Decided at the first driver/recorder call, before any capture or fetch: the placeholder
+        # manifest has no checksum, so nothing is captured or downloaded.
+        expect(video_lines.first).to include('no ffmpeg available for this platform yet')
+        expect(video_files(project)).to be_empty
+        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
+
   # Mobile and Visual frameworks require external services, so we only verify structure
   context 'Mobile Automation Frameworks (structure validation only)' do
     describe 'iOS + RSpec' do

data/spec/integration/generators/azure_generator_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'fileutils'
+require 'open3'
 require 'yaml'
 require_relative '../../../lib/generators/infrastructure/azure_generator'
 require_relative '../spec_helper'
@@ -63,10 +64,10 @@ describe AzureGenerator do
   end
 
   context 'with an invalid ci' do
-    it 'raises an ArgumentError and generates nothing' do
+    it 'raises a Thor::Error and generates nothing' do
       expect do
         InvokeGenerators.generate_framework(automation: 'selenium', framework: 'rspec', name: 'azure_bad', ci: 'gitlab')
-      end.to raise_error(ArgumentError, 'ci must be github or azure')
+      end.to raise_error(Thor::Error, 'ci must be github or azure')
       expect(File).not_to exist('azure_bad')
     end
   end
@@ -74,10 +75,10 @@ describe AzureGenerator do
   context 'with raider new and ci:gitlab' do
     it 'prints the error, generates nothing and exits non-zero' do
       root = File.expand_path('../../..', __dir__)
-      out = IO.popen(['ruby', "#{root}/bin/raider", 'new', 'azure_cli_bad', '-p', 'framework:rspec',
-                      'automation:selenium', 'ci:gitlab', { err: %i[child out] }], &:read)
-      expect($CHILD_STATUS.exitstatus).not_to eq(0)
-      expect(out).to include('Invalid parameters: ci must be github or azure')
+      out, status = Open3.capture2e('ruby', "#{root}/bin/raider", 'new', 'azure_cli_bad', '-p', 'framework:rspec',
+                                    'automation:selenium', 'ci:gitlab')
+      expect(status.exitstatus).not_to eq(0)
+      expect(out).to include('ci must be github or azure')
       expect(File).not_to exist('azure_cli_bad')
     end
   end

data/spec/integration/generators/common_generator_spec.rb

@@ -18,7 +18,7 @@ describe CommonGenerator do
     end
   end
 
-shared_examples 'creates a config file' do |name|
+  shared_examples 'creates a config file' do |name|
     it 'creates a config file' do
       expect(File).to exist("#{name}/config/config.yml")
     end