ruby_raider 3.8.0 → 3.10.0

data/spec/integration/content/azure_content_spec.rb

@@ -3,6 +3,7 @@
 require 'yaml'
 require 'fileutils'
 require_relative 'content_helper'
+require_relative '../../../lib/ruby_raider/ffmpeg'
 
 # UseRubyVersion@0 versionSpec '3.4' resolves against the hosted tool cache, which lists Ruby 3.4.x
 # (3.2, 3.3, 3.4, 4.0): https://github.com/actions/runner-images/blob/main/images/ubuntu/Ubuntu2404-Readme.md
@@ -47,6 +48,33 @@ describe 'Azure Pipelines content' do
         )
       end
 
+      it 'caches the ffmpeg dir keyed on the ffmpeg version and Gemfile.lock, then installs ffmpeg, before the tests' do
+        steps = yml['jobs'][0]['steps']
+        cache = steps.index { |s| s['task'] == 'Cache@2' }
+        install = steps.index { |s| s['script'] == 'bundle exec raider u video install' }
+        tests = steps.index { |s| s['script'] == run_command }
+        expect([cache, install, tests]).to all(be_an(Integer))
+        expect(cache).to be < install
+        expect(install).to be < tests
+        expect(steps[cache]['inputs']).to eq(
+          'key' => "raider-ffmpeg-#{RubyRaider::Ffmpeg::MANIFEST[:version]} | \"$(Agent.OS)\" | Gemfile.lock",
+          'path' => '$(RAIDER_CACHE_DIR)'
+        )
+      end
+
+      it 'caches RAIDER_CACHE_DIR in the pipeline workspace and keeps the ffmpeg install from failing the build' do
+        install = yml['jobs'][0]['steps'].find { |s| s['script'] == 'bundle exec raider u video install' }
+        expect(install['continueOnError']).to be(true)
+        expect(yml['variables']['RAIDER_CACHE_DIR']).to eq('$(Pipeline.Workspace)/.cache/raider')
+      end
+
+      it 'adds no cache or install step to the comment and gate jobs' do
+        yml['jobs'][1..].each do |job|
+          expect(job['steps'].map { |s| s['task'] || s['script'] })
+            .not_to include('Cache@2', 'bundle exec raider u video install')
+        end
+      end
+
       it 'passes exactly the Raider settings to the test step' do
         step = yml['jobs'][0]['steps'].find { |s| s['script'] == run_command }
         expect(step['env']).to eq('RAIDER_TOKEN' => '$(RAIDER_TOKEN)', 'RAIDER_ENDPOINT' => '$(RAIDER_ENDPOINT)',
@@ -54,16 +82,32 @@ describe 'Azure Pipelines content' do
         expect(yml['variables']['HEADLESS']).to eq('true')
       end
 
-      it 'has a raider_comment job for pull requests' do
+      it 'has a raider_comment job for pull requests that waits for the gate job but runs even when it is skipped' do
         comment = yml['jobs'][1]
         expect(comment['job']).to eq('raider_comment')
-        expect(comment['dependsOn']).to eq('tests')
+        expect(comment['dependsOn']).to eq(%w[tests raider_gate])
         expect(comment['condition']).to eq("and(always(), eq(variables['Build.Reason'], 'PullRequest'))")
         last = comment['steps'].last
         expect(last['script']).to eq('bundle exec raider-reporter comment')
         expect(last['env']).to include('SYSTEM_ACCESSTOKEN' => '$(System.AccessToken)')
       end
 
+      it 'has a raider_gate job that runs only when RAIDER_GATE is 1' do
+        gate = yml['jobs'][2]
+        expect(yml['jobs'].size).to eq(3)
+        expect(gate['job']).to eq('raider_gate')
+        expect(gate['dependsOn']).to eq('tests')
+        expect(gate['condition']).to eq("and(always(), eq(variables['RAIDER_GATE'], '1'))")
+      end
+
+      it 'sets up Ruby in the raider_gate job and runs the gate with the token env' do
+        gate = yml['jobs'][2]
+        expect(gate['steps'].first).to eq('task' => 'UseRubyVersion@0', 'inputs' => { 'versionSpec' => '3.4' })
+        expect(gate['steps'].filter_map { |s| s['script'] }).to eq(['bundle install', 'bundle exec raider-reporter gate'])
+        expect(gate['steps'].last['env']).to eq('RAIDER_TOKEN' => '$(RAIDER_TOKEN)', 'RAIDER_ENDPOINT' => '$(RAIDER_ENDPOINT)',
+                                                'SYSTEM_ACCESSTOKEN' => '$(System.AccessToken)')
+      end
+
       it 'has triggers, pool and the self-hosted hint' do
         expect(yml['trigger']['branches']['include']).to include('main', 'master')
         expect(yml['pr']['branches']['include']).to include('*')
@@ -84,8 +128,9 @@ describe 'Azure Pipelines content' do
         readme = read_generated(name, 'Readme.md')
         expect(readme).to include('## Azure Pipelines', 'RAIDER_TOKEN', 'Contribute to pull requests',
                                   'pool: { name: Default }', 'Build validation branch policy',
-                                  'same stage')
+                                  'same stage', 'raider_gate', 'RAIDER_GATE=1', 'RAIDER_SHARD_TOTAL', 'RAIDER_SHARD_INDEX')
         expect(readme).not_to match(/GitHub Actions/i)
+        expect(readme).to include('`RAIDER_CACHE_DIR` to `$(Pipeline.Workspace)/.cache/raider`')
       end
     end
   end

data/spec/integration/content/ci_content_spec.rb

@@ -2,6 +2,7 @@
 
 require 'yaml'
 require_relative 'content_helper'
+require_relative '../../../lib/ruby_raider/ffmpeg'
 
 describe 'CI pipeline content' do
   shared_examples 'valid github pipeline' do |project_name|
@@ -92,7 +93,7 @@ describe 'CI pipeline content' do
 
     it 'uploads raider-results as an artifact even on failure in every job' do
       uploads = steps.select { |step| step['uses'] == 'actions/upload-artifact@v4' }
-      expect(uploads.size).to eq(YAML.safe_load(pipeline)['jobs'].except('raider-comment').size)
+      expect(uploads.size).to eq(YAML.safe_load(pipeline)['jobs'].except('raider-comment', 'raider-gate').size)
       uploads.each do |upload|
         expect(upload['with']['path']).to eq('raider-results/')
         expect(upload['if']).to eq('always()')
@@ -107,15 +108,16 @@ describe 'CI pipeline content' do
     let(:job) { jobs['raider-comment'] }
 
     it 'is a valid workflow with exactly the expected jobs' do
-      expect(jobs.keys).to match_array(test_jobs + ['raider-comment'])
+      expect(jobs.keys).to match_array(test_jobs + %w[raider-comment raider-gate])
     end
 
-    it 'needs every test job' do
-      expect(job['needs']).to match_array(test_jobs)
+    it 'needs every test job and the gate job, so the comment carries the final gate line' do
+      expect(job['needs']).to match_array(test_jobs + %w[raider-gate])
     end
 
-    it 'runs always, on pull requests only' do
+    it 'runs always, on pull requests only, so a skipped or failed gate job does not skip it' do
       expect(job['if']).to eq("always() && github.event_name == 'pull_request'")
+      expect(job['if']).to start_with('always()')
       expect(job['runs-on']).to eq('ubuntu-latest')
     end
 
@@ -151,62 +153,170 @@ describe 'CI pipeline content' do
     end
   end
 
+  shared_examples 'github raider-gate job' do |project_name, file, test_jobs|
+    subject(:pipeline) { read_generated(project_name, ".github/workflows/#{file}") }
+
+    let(:jobs) { YAML.safe_load(pipeline)['jobs'] }
+    let(:gate_job) { jobs['raider-gate'] }
+
+    it 'needs every test job and runs always when RAIDER_GATE is 1, on push and pull requests' do
+      expect(gate_job['needs']).to match_array(test_jobs)
+      expect(gate_job['if']).to eq("always() && vars.RAIDER_GATE == '1'")
+      expect(gate_job['runs-on']).to eq('ubuntu-latest')
+    end
+
+    it 'can read the code and write statuses only' do
+      expect(gate_job['permissions']).to eq('contents' => 'read', 'statuses' => 'write')
+    end
+
+    it 'checks out, sets up the same Ruby as the test jobs and runs the gate' do
+      steps = gate_job['steps']
+      expect(steps[0]).to eq('uses' => 'actions/checkout@v4')
+      test_ruby = jobs.values_at(*test_jobs).flat_map { |j| j['steps'] }
+                      .find { |step| step['uses'] == 'ruby/setup-ruby@v1' }['with']['ruby-version']
+      expect(steps[1]).to eq('uses' => 'ruby/setup-ruby@v1', 'with' => { 'ruby-version' => test_ruby, 'bundler-cache' => true })
+      expect(steps[2]).to eq('name' => 'Wait for the Raider quality gate',
+                             'run' => 'bundle exec raider-reporter gate',
+                             'env' => { 'RAIDER_TOKEN' => '${{ secrets.RAIDER_TOKEN }}',
+                                        'RAIDER_ENDPOINT' => '${{ vars.RAIDER_ENDPOINT }}',
+                                        'GITHUB_TOKEN' => '${{ secrets.GITHUB_TOKEN }}' })
+      expect(steps.size).to eq(3)
+    end
+  end
+
+  shared_examples 'github appium shards' do |project_name, runner, shards|
+    subject(:pipeline) { read_generated(project_name, '.github/workflows/appium_pipeline.yml') }
+
+    let(:jobs) { YAML.safe_load(pipeline)['jobs'] }
+
+    def test_step(job, runner)
+      job['steps'].find { |step| step['run'].to_s.include?(runner) || step['with'].to_h['script'].to_s.include?(runner) }
+    end
+
+    if shards
+      it 'gives each platform job its own shard of two, so the gate waits for both' do
+        shards.each do |job_name, index|
+          expect(test_step(jobs[job_name], runner)['env'])
+            .to include('RAIDER_SHARD_INDEX' => index, 'RAIDER_SHARD_TOTAL' => '2')
+        end
+      end
+    else
+      it 'sets no shard env for a single platform' do
+        jobs.except('raider-comment', 'raider-gate').each_value do |job|
+          expect(test_step(job, runner)['env'].keys).not_to include('RAIDER_SHARD_INDEX', 'RAIDER_SHARD_TOTAL')
+        end
+      end
+    end
+  end
+
+  shared_examples 'github ffmpeg cache' do |project_name, file, test_jobs, runner = 'rspec'|
+    subject(:pipeline) { read_generated(project_name, ".github/workflows/#{file}") }
+
+    let(:jobs) { YAML.safe_load(pipeline)['jobs'] }
+
+    test_jobs.each do |job_name|
+      it "caches ~/.cache/raider keyed on the ffmpeg version and Gemfile.lock, then installs ffmpeg, before the tests in #{job_name}" do
+        steps = jobs[job_name]['steps']
+        cache = steps.index { |step| step['uses'] == 'actions/cache@v4' }
+        install = steps.index { |step| step['run'] == 'bundle exec raider u video install' }
+        tests = steps.index do |step|
+          step['run'].to_s.include?(runner) || step['with'].to_h['script'].to_s.include?(runner)
+        end
+        expect([cache, install, tests]).to all(be_an(Integer))
+        expect(cache).to be < install
+        expect(install).to be < tests
+        expect(steps[cache]['with']).to eq(
+          'path' => '~/.cache/raider',
+          'key' => "raider-ffmpeg-#{RubyRaider::Ffmpeg::MANIFEST[:version]}-${{ runner.os }}-${{ hashFiles('**/Gemfile.lock') }}"
+        )
+      end
+
+      it "keeps the ffmpeg install step from failing #{job_name}, since video is optional" do
+        install = jobs[job_name]['steps'].find { |step| step['run'] == 'bundle exec raider u video install' }
+        expect(install['continue-on-error']).to be(true)
+      end
+    end
+
+    it 'adds no cache or install step to the comment and gate jobs' do
+      jobs.slice('raider-comment', 'raider-gate').each_value do |job|
+        expect(job['steps'].map { |step| step['run'] || step['uses'] })
+          .not_to include('actions/cache@v4', 'bundle exec raider u video install')
+      end
+    end
+  end
+
   context 'with rspec and selenium' do
     name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
+    include_examples 'github ffmpeg cache', name, 'test_pipeline.yml', %w[build]
     include_examples 'valid github pipeline', name
     include_examples 'github rspec pipeline', name
     include_examples 'github triggers', name, 'test_pipeline.yml'
     include_examples 'github raider wiring', name, 'test_pipeline.yml'
     include_examples 'github raider-comment job', name, 'test_pipeline.yml', %w[build]
+    include_examples 'github raider-gate job', name, 'test_pipeline.yml', %w[build]
     include_examples 'github without allure steps', name
   end
 
   context 'with cucumber and selenium' do
     name = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
+    include_examples 'github ffmpeg cache', name, 'test_pipeline.yml', %w[build], 'cucumber'
     include_examples 'valid github pipeline', name
     include_examples 'github cucumber pipeline', name
     include_examples 'github triggers', name, 'test_pipeline.yml'
     include_examples 'github raider wiring', name, 'test_pipeline.yml', 'cucumber'
     include_examples 'github raider-comment job', name, 'test_pipeline.yml', %w[build]
+    include_examples 'github raider-gate job', name, 'test_pipeline.yml', %w[build]
     include_examples 'github without allure steps', name
   end
 
   context 'with rspec and watir' do
     name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::WATIR}"
+    include_examples 'github ffmpeg cache', name, 'test_pipeline.yml', %w[build]
     include_examples 'valid github pipeline', name
     include_examples 'github rspec pipeline', name
     include_examples 'github triggers', name, 'test_pipeline.yml'
     include_examples 'github raider wiring', name, 'test_pipeline.yml'
     include_examples 'github raider-comment job', name, 'test_pipeline.yml', %w[build]
+    include_examples 'github raider-gate job', name, 'test_pipeline.yml', %w[build]
     include_examples 'github without allure steps', name
   end
 
   context 'with cucumber and watir' do
     name = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
+    include_examples 'github ffmpeg cache', name, 'test_pipeline.yml', %w[build], 'cucumber'
     include_examples 'valid github pipeline', name
     include_examples 'github cucumber pipeline', name
     include_examples 'github triggers', name, 'test_pipeline.yml'
     include_examples 'github raider wiring', name, 'test_pipeline.yml', 'cucumber'
     include_examples 'github raider-comment job', name, 'test_pipeline.yml', %w[build]
+    include_examples 'github raider-gate job', name, 'test_pipeline.yml', %w[build]
     include_examples 'github without allure steps', name
   end
 
   appium_jobs = { 'android' => %w[android-tests], 'ios' => %w[ios-tests],
                   'cross_platform' => %w[ios-tests android-tests] }
 
+  appium_shards = { 'cross_platform' => { 'ios-tests' => '1', 'android-tests' => '2' } }
+
   appium_jobs.each do |automation, test_jobs|
     context "with rspec and #{automation}" do
       name = "#{FrameworkIndex::RSPEC}_#{automation}"
+      include_examples 'github appium shards', name, 'rspec', appium_shards[automation]
+      include_examples 'github ffmpeg cache', name, 'appium_pipeline.yml', test_jobs
       include_examples 'github raider-comment job', name, 'appium_pipeline.yml', test_jobs
+      include_examples 'github raider-gate job', name, 'appium_pipeline.yml', test_jobs
       include_examples 'github triggers', name, 'appium_pipeline.yml'
       include_examples 'github raider wiring', name, 'appium_pipeline.yml'
     end
 
     context "with cucumber and #{automation}" do
       name = "#{FrameworkIndex::CUCUMBER}_#{automation}"
+      include_examples 'github appium shards', name, 'cucumber', appium_shards[automation]
+      include_examples 'github ffmpeg cache', name, 'appium_pipeline.yml', test_jobs, 'cucumber'
       include_examples 'github triggers', name, 'appium_pipeline.yml'
       include_examples 'github raider wiring', name, 'appium_pipeline.yml', 'cucumber'
       include_examples 'github raider-comment job', name, 'appium_pipeline.yml', test_jobs
+      include_examples 'github raider-gate job', name, 'appium_pipeline.yml', test_jobs
     end
   end
 end

data/spec/integration/content/common_content_spec.rb

@@ -133,6 +133,10 @@ describe 'Common file content' do
     it 'includes raider-results' do
       expect(gitignore).to include('raider-results')
     end
+
+    it 'includes rerun.txt' do
+      expect(gitignore).to include('rerun.txt')
+    end
   end
 
   # --- Spec helper retry config (C4) ---
@@ -187,6 +191,10 @@ describe 'Common file content' do
     it 'includes --retry flag' do
       expect(cucumber_yml).to include('--retry')
     end
+
+    it 'writes failed scenarios to rerun.txt for Re-run Failed' do
+      expect(cucumber_yml).to include('--format rerun --out rerun.txt')
+    end
   end
 
   # --- RSpec contexts ---

data/spec/integration/content/config_content_spec.rb

@@ -51,12 +51,21 @@ describe 'Config file content' do
     end
   end
 
+  shared_examples 'video config' do |project_name|
+    subject(:config) { YAML.safe_load(read_generated(project_name, 'config/config.yml'), permitted_classes: [Symbol]) }
+
+    it 'has video enabled at 5 fps and 1280 px max width' do
+      expect(config['video']).to eq('enabled' => true, 'fps' => 5, 'max_width' => 1280)
+    end
+  end
+
   # --- Web config per automation ---
 
   context 'with rspec and selenium' do
     name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
     include_examples 'valid web config', name
     include_examples 'selenium config with timeout', name
+    include_examples 'video config', name
   end
 
   context 'with rspec and watir' do
@@ -73,6 +82,11 @@ describe 'Config file content' do
 
   # --- Mobile config ---
 
+  # Single-platform Appium projects have no config.yml; VideoHelper falls back to its defaults.
+  context 'with rspec and cross platform' do
+    include_examples 'video config', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
+  end
+
   context 'with rspec and appium android' do
     subject(:caps) { read_generated("#{FrameworkIndex::RSPEC}_#{AutomationIndex::ANDROID}", 'config/capabilities.yml') }
 

data/spec/integration/content/cucumber_reporter_content_spec.rb

@@ -36,7 +36,7 @@ describe 'Cucumber raider_reporter wiring' do
 
       it 'quits the driver in an ensure of the After block, without a redundant begin' do
         quit = %w[android ios cross_platform].include?(automation) ? 'driver.quit_driver' : quit_call
-        expect(hook).to match(/^\s*After do \|scenario\|\n.*\n^ensure\n\s+#{Regexp.escape(quit)}\nend/m)
+        expect(hook).to match(/^\s*After do \|scenario\|\n.*\n^ensure\n.*\n\s+#{Regexp.escape(quit)}\nend/m)
         expect(hook).not_to match(/^\s+begin$/)
       end
 
@@ -47,6 +47,27 @@ describe 'Cucumber raider_reporter wiring' do
         expect(env.index(attach)).to be < env.index(/driver\.quit|browser\.quit/, env.index(attach))
       end
 
+      context 'with video recording' do
+        target = automation == 'watir' ? 'browser' : 'driver'
+        video_type = %w[selenium watir].include?(automation) ? ':webm' : ':mp4'
+
+        it 'requires video_helper' do
+          expect(env).to include("require_relative '../../helpers/video_helper'")
+        end
+
+        it 'starts the recorder in Before' do
+          expect(env[/^Before do.*?^end$/m]).to include("@video_recorder = VideoHelper.recorder_for(#{target})", '@video_recorder.start')
+        end
+
+        it 'stops with keep: scenario.failed? before quitting, attaches the path and cleans up in the ensure' do
+          expect(hook).to include('video_path = @video_recorder&.stop(keep: scenario.failed?)')
+          expect(hook).to include("RaiderReporter.attach('video', video_path, type: #{video_type}) if video_path")
+          expect(hook.index('@video_recorder&.stop')).to be < hook.index("RaiderReporter.attach('video'")
+          expect(hook.index("RaiderReporter.attach('video'")).to be < hook.index(/^ensure/)
+          expect(hook.index(/^ensure/)).to be < hook.index('@video_recorder&.cleanup')
+        end
+      end
+
       it 'does not generate the allure helper' do
         expect(File).not_to exist(File.join(project_name, 'helpers/allure_helper.rb'))
       end

data/spec/integration/content/gemfile_content_spec.rb

@@ -127,7 +127,7 @@ describe 'Gemfile content' do
         let(:gemfile) { read_generated("#{FrameworkIndex::RSPEC}_#{automation}", 'Gemfile') }
 
         it 'includes raider_reporter' do
-          expect(gemfile).to include("gem 'raider_reporter', '~> 0.8'")
+          expect(gemfile).to include("gem 'raider_reporter', '~> 0.10'")
         end
 
         it 'has no allure gems' do
@@ -143,7 +143,7 @@ describe 'Gemfile content' do
         let(:gemfile) { read_generated("#{FrameworkIndex::CUCUMBER}_#{automation}", 'Gemfile') }
 
         it 'includes raider_reporter' do
-          expect(gemfile).to include("gem 'raider_reporter', '~> 0.8'")
+          expect(gemfile).to include("gem 'raider_reporter', '~> 0.10'")
         end
 
         it 'drops allure-cucumber' do
@@ -156,5 +156,4 @@ describe 'Gemfile content' do
       end
     end
   end
-
 end

data/spec/integration/content/helper_content_spec.rb

@@ -139,6 +139,43 @@ describe 'Helper file content' do
     end
   end
 
+  shared_examples 'video spec helper wiring' do |project_name, recorder_target, video_type|
+    subject(:helper) { read_generated(project_name, 'helpers/spec_helper.rb') }
+
+    let(:before_hook) { helper[/config\.before\(:each\) do.*?^    end$/m] }
+    let(:after_hook) { helper[/config\.after\(:each\).*\z/m] }
+
+    it 'requires video_helper' do
+      expect(helper).to include("require_relative 'video_helper'")
+    end
+
+    it 'starts a recorder in before(:each), after the viewport resize or driver start' do
+      start = "@video_recorder = VideoHelper.recorder_for(#{recorder_target})"
+      expect(before_hook).to include(start, '@video_recorder.start')
+      setup = before_hook[/driver\.start_driver|\.window\.maximize/]
+      expect(before_hook.index(setup)).to be < before_hook.index(start)
+      expect(before_hook.index(start)).to be < before_hook.index('@video_recorder.start')
+    end
+
+    it 'attaches "video" only when example.exception && VideoHelper.final_attempt?(example)' do
+      expect(after_hook).to match(/example\.exception\s*(\?|&&)\s*VideoHelper\.final_attempt\?\(example\)/)
+      expect(after_hook).to include("RaiderReporter.attach('video', video_path, type: #{video_type}) if video_path")
+    end
+
+    it 'stops and attaches, then cleans up and quits the driver in the ensure, so the browser closes if an attach raises' do
+      order = [after_hook.index('@video_recorder&.stop(keep: keep_video)'), after_hook.index("RaiderReporter.attach('video'"),
+               after_hook.index("\n    ensure\n"), after_hook.index('@video_recorder&.cleanup'),
+               after_hook.index(/driver\.quit|browser\.quit/)]
+      expect(order).to all(be_an(Integer)).and eq(order.compact.sort)
+      expect(after_hook.scan(/driver\.quit|browser\.quit/).size).to eq(1)
+      expect(after_hook[order[2]..]).to match(/\n      @video_recorder&\.cleanup\n      (driver|browser)\.quit(_driver)?\n    end\n/)
+    end
+
+    it 'keeps the screenshot attachment' do
+      expect(after_hook).to include("RaiderReporter.attach('screenshot', screenshot_path, type: :png)")
+    end
+  end
+
   shared_examples 'selenium spec helper' do |project_name|
     subject(:helper) { read_generated(project_name, 'helpers/spec_helper.rb') }
 
@@ -171,6 +208,113 @@ describe 'Helper file content' do
     end
   end
 
+  # --- Video helper ---
+
+  shared_examples 'valid video helper' do |project_name|
+    subject(:helper) { read_generated(project_name, 'helpers/video_helper.rb') }
+
+    it 'has frozen_string_literal' do
+      expect(helper).to have_frozen_string_literal
+    end
+
+    it 'has valid Ruby syntax' do
+      expect(helper).to have_valid_ruby_syntax
+    end
+
+    it 'defines VideoHelper with enabled?, recorder_for and disable!' do
+      expect(helper).to match(/module VideoHelper/)
+      expect(helper).to match(/def enabled\?/)
+      expect(helper).to match(/def recorder_for\(/)
+      expect(helper).to match(/def disable!\(/)
+    end
+
+    it 'has no ScreenCaptureRecorder and no CdpRecorder' do
+      expect(helper).not_to include('ScreenCaptureRecorder')
+      expect(helper).not_to include('CdpRecorder')
+    end
+  end
+
+  shared_examples 'web video helper' do |project_name|
+    subject(:helper) { read_generated(project_name, 'helpers/video_helper.rb') }
+
+    it 'defines a FrameRecorder and a Selenium FrameListener' do
+      expect(helper).to include('class FrameRecorder')
+      expect(helper).to include('class FrameListener < Selenium::WebDriver::Support::AbstractEventListener')
+    end
+
+    it 'captures only after navigate, click and change_value_of' do
+      hooks = helper.scan(/def ((?:after|before)_\w+)/).flatten
+      expect(hooks).to contain_exactly('after_navigate_to', 'after_click', 'after_change_value_of')
+    end
+
+    it 'encodes WebM with libvpx' do
+      expect(helper).to include("'libvpx'", 'video.webm')
+    end
+
+    it 'loads ffmpeg lazily from the ruby_raider gem' do
+      expect(helper).to include("require 'ruby_raider/ffmpeg'")
+      expect(helper).not_to match(/^require 'ruby_raider/)
+    end
+
+    it 'has no AppiumRecorder' do
+      expect(helper).not_to include('AppiumRecorder')
+    end
+  end
+
+  shared_examples 'mobile video helper' do |project_name|
+    subject(:helper) { read_generated(project_name, 'helpers/video_helper.rb') }
+
+    it 'defines an AppiumRecorder writing mp4' do
+      expect(helper).to include('class AppiumRecorder', 'start_recording_screen', 'video.mp4')
+    end
+
+    it 'has no FrameRecorder or listener' do
+      expect(helper).not_to include('FrameRecorder')
+      expect(helper).not_to include('AbstractEventListener')
+    end
+
+    it 'does not provision ffmpeg on this machine (Appium records on its own host)' do
+      expect(helper).not_to include('ruby_raider/ffmpeg', 'Ffmpeg.ensure!', 'ffmpeg_path')
+    end
+  end
+
+  shared_examples 'video listener wiring' do |project_name, helper_file|
+    subject(:helper) { read_generated(project_name, "helpers/#{helper_file}") }
+
+    it 'requires video_helper' do
+      expect(helper).to include("require_relative 'video_helper'")
+    end
+
+    it 'passes VideoHelper.listener only when it is not nil' do
+      expect(helper).to include('VideoHelper.listener')
+      expect(helper).to match(/\[:listener\] = listener if listener/)
+    end
+  end
+
+  context 'with rspec and selenium video' do
+    name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
+    it_behaves_like 'valid video helper', name
+    it_behaves_like 'web video helper', name
+    it_behaves_like 'video listener wiring', name, 'driver_helper.rb'
+  end
+
+  context 'with cucumber and watir video' do
+    name = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
+    it_behaves_like 'valid video helper', name
+    it_behaves_like 'web video helper', name
+    it_behaves_like 'video listener wiring', name, 'browser_helper.rb'
+  end
+
+  context 'with rspec and ios video' do
+    name = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::IOS}"
+    it_behaves_like 'valid video helper', name
+    it_behaves_like 'mobile video helper', name
+
+    it 'does not wire a listener into the appium driver helper' do
+      expect(read_generated(name, 'helpers/driver_helper.rb')).not_to include('listener')
+    end
+  end
+
   # --- RSpec + automation contexts ---
 
   context 'with rspec and selenium' do
@@ -211,6 +355,8 @@ describe 'Helper file content' do
         'watir' => 'browser.screenshot.save(screenshot_path)'
       }.fetch(automation, 'driver.screenshot(screenshot_path)')
       it_behaves_like 'raider reporter spec helper', name, screenshot_call
+      it_behaves_like 'video spec helper wiring', name, automation == 'watir' ? 'browser' : 'driver',
+                      %w[selenium watir].include?(automation) ? ':webm' : ':mp4'
     end
 
     context "with cucumber and #{automation}" do

data/spec/integration/content/page_content_spec.rb

@@ -166,5 +166,4 @@ describe 'Page object content' do
     include_examples 'valid abstract page', name
     include_examples 'watir abstract page', name
   end
-
 end