ruby_raider 3.9.0 → 3.10.0

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)
@@ -263,20 +285,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 +313,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 +334,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 +356,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 +375,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

data/spec/integration/generators/invoke_generators_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'open3'
+require_relative '../spec_helper'
+
+describe InvokeGenerators do
+  after { FileUtils.rm_rf(Dir.glob('case_*')) }
+
+  context 'with option values in a different case' do
+    it 'accepts framework:Cucumber and automation:Selenium' do
+      described_class.generate_framework(framework: 'Cucumber', automation: 'Selenium', name: 'case_mixed')
+      expect(File).to exist('case_mixed/cucumber.yml')
+    end
+
+    it 'accepts upper-case values' do
+      described_class.generate_framework(framework: 'RSPEC', automation: 'WATIR', name: 'case_upper')
+      expect(File).to exist('case_upper/.rspec')
+    end
+
+    it 'accepts symbols' do
+      described_class.generate_framework(framework: :rspec, automation: :selenium, name: 'case_symbol')
+      expect(File).to exist('case_symbol/.rspec')
+    end
+  end
+
+  context 'with raider new and capitalised options' do
+    it 'generates the project and exits zero' do
+      root = File.expand_path('../../..', __dir__)
+      _out, status = Open3.capture2e('ruby', "#{root}/bin/raider", 'new', 'case_cli', '-p', 'framework:Cucumber',
+                                     'automation:Selenium')
+      expect(status.exitstatus).to eq(0)
+      expect(File).to exist('case_cli/cucumber.yml')
+    end
+  end
+
+  context 'with invalid values' do
+    it 'raises a Thor::Error for an unknown framework' do
+      expect { described_class.generate_framework(framework: 'minitest', automation: 'selenium', name: 'case_bad') }
+        .to raise_error(Thor::Error, /Invalid framework "minitest"/)
+    end
+
+    it 'sends an invalid ci to stderr and exits non-zero' do
+      root = File.expand_path('../../..', __dir__)
+      _out, err, status = Open3.capture3('ruby', "#{root}/bin/raider", 'new', 'case_bad_ci', '-p',
+                                         'framework:rspec', 'automation:selenium', 'ci:gitlab')
+      expect(status.exitstatus).to eq(1)
+      expect(err).to include('ci must be github or azure')
+      expect(File).not_to exist('case_bad_ci')
+    end
+  end
+end

data/spec/integration/scaffolding_e2e_spec.rb

@@ -23,11 +23,7 @@ end
 
 # End-to-end scaffolding tests that verify the scaffold command creates the right
 # files with the right content across all automation × framework combinations.
-describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
-
-  WEB_AUTOMATIONS = %w[selenium watir].freeze
-  TEST_FRAMEWORKS = %w[rspec cucumber].freeze
-
+describe 'Scaffolding E2E' do
   def self.scaffold_style(framework)
     case framework
     when 'rspec'    then :spec
@@ -36,7 +32,7 @@ describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
   end
 
   # Build a minimal mock project that the scaffolding system can detect.
-  def self.build_mock_project(automation, framework) # rubocop:disable Metrics/MethodLength
+  def self.build_mock_project(automation, framework)
     dir = File.expand_path("tmp_scaffold_e2e_#{framework}_#{automation}")
     FileUtils.rm_rf(dir)
     FileUtils.mkdir_p("#{dir}/page_objects/pages")
@@ -61,7 +57,7 @@ describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
     when 'rspec'    then gems << "gem 'rspec'"
     when 'cucumber' then gems << "gem 'cucumber'"
     end
-    File.write("#{dir}/Gemfile", gems.join("\n") + "\n")
+    File.write("#{dir}/Gemfile", "#{gems.join("\n")}\n")
     File.write("#{dir}/config/config.yml", "browser: chrome\nurl: http://localhost:3000\n")
     File.write("#{dir}/page_objects/abstract/page.rb", "class Page; end\n")
     File.write("#{dir}/page_objects/abstract/component.rb", "class Component; end\n")
@@ -91,7 +87,7 @@ describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
     end
 
     it 'includes url method (config has url)' do
-      expect(page_content).to include("def url(_page)")
+      expect(page_content).to include('def url(_page)')
       expect(page_content).to include("'checkout'")
     end
   end
@@ -326,11 +322,11 @@ describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
   # Test matrix: automation × framework
   # ══════════════════════════════════════════════
 
-  WEB_AUTOMATIONS.each do |automation|
-    TEST_FRAMEWORKS.each do |framework|
+  %w[selenium watir].each do |automation|
+    %w[rspec cucumber].each do |framework|
       style = scaffold_style(framework)
 
-      context "with #{framework} and #{automation}" do # rubocop:disable RSpec/ContextWording
+      context "with #{framework} and #{automation}" do
         let(:scaffold) { ScaffoldingCommands }
 
         # Use absolute path so Dir.chdir is safe regardless of current CWD
@@ -367,6 +363,9 @@ describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
             end
           end
 
+          # Page content validation
+          let(:page_content) { File.read('page_objects/pages/checkout.rb') }
+
           it 'creates page object' do
             expect(Pathname.new('page_objects/pages/checkout.rb')).to be_file
           end
@@ -389,9 +388,6 @@ describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
             end
           end
 
-          # Page content validation
-          let(:page_content) { File.read('page_objects/pages/checkout.rb') }
-
           include_examples 'valid scaffolded page'
           include_examples "#{automation} scaffolded page"
 
@@ -459,16 +455,10 @@ describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
 
           it 'generates multiple scaffolds at once' do
             scaffold.new.invoke(:scaffold, nil, %w[search filter])
-            expect(Pathname.new('page_objects/pages/search.rb')).to be_file
-            expect(Pathname.new('page_objects/pages/filter.rb')).to be_file
-
-            if style == :spec
-              expect(Pathname.new('spec/search_page_spec.rb')).to be_file
-              expect(Pathname.new('spec/filter_page_spec.rb')).to be_file
-            else
-              expect(Pathname.new('features/search.feature')).to be_file
-              expect(Pathname.new('features/filter.feature')).to be_file
+            files = %w[search filter].flat_map do |name|
+              ["page_objects/pages/#{name}.rb", style == :spec ? "spec/#{name}_page_spec.rb" : "features/#{name}.feature"]
             end
+            expect(files.reject { |file| File.file?(file) }).to be_empty
           end
         end
 
@@ -496,7 +486,6 @@ describe 'Scaffolding E2E' do # rubocop:disable RSpec/DescribeClass
             expect(Pathname.new('page_objects/pages/checkout.rb')).to be_file
           end
         end
-
       end
     end
   end

data/spec/scaffolding/scaffold_project_detector_spec.rb

@@ -33,7 +33,6 @@ RSpec.describe ScaffoldProjectDetector do
     it 'reports selenium?' do
       expect(described_class.selenium?).to be true
     end
-
   end
 
   context 'with watir project' do

data/spec/scaffolding/scaffolding_features_spec.rb

@@ -104,5 +104,4 @@ RSpec.describe 'Scaffolding features' do
       expect(Pathname.new('spec/dashboard_page_spec.rb')).to be_file
     end
   end
-
 end

data/spec/system/selenium_spec.rb

@@ -35,5 +35,4 @@ describe 'Selenium based frameworks' do
   context 'with cucumber' do
     include_examples 'runs tests successfully', 'cucumber'
   end
-
 end

data/spec/system/watir_spec.rb

@@ -35,5 +35,4 @@ describe 'Watir based frameworks' do
   context 'with cucumber' do
     include_examples 'runs tests successfully', 'cucumber'
   end
-
 end