ruby_raider 3.4.0 → 3.6.0

data/spec/integration/content/azure_content_spec.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+require_relative 'content_helper'
+
+# 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
+describe 'Azure Pipelines content' do
+  combos = FRAMEWORKS.product(%w[selenium watir], [false, true])
+
+  before(:all) do # rubocop:disable RSpec/BeforeAfterAll
+    combos.each do |framework, automation, axe|
+      name = "azurec_#{framework}_#{automation}#{'_axe' if axe}"
+      next if File.exist?(name)
+
+      InvokeGenerators.generate_framework(automation:, framework:, name:, accessibility: axe, ci: 'azure')
+    end
+  end
+
+  after(:all) { FileUtils.rm_rf(Dir.glob('azurec_*')) } # rubocop:disable RSpec/BeforeAfterAll
+
+  combos.each do |framework, automation, axe|
+    context "with #{framework}, #{automation}#{', axe' if axe}" do
+      let(:name) { "azurec_#{framework}_#{automation}#{'_axe' if axe}" }
+      let(:raw) { read_generated(name, 'azure-pipelines.yml') }
+      let(:yml) { YAML.safe_load(raw) }
+      let(:run_command) do
+        if framework == 'cucumber'
+          'bundle exec cucumber features/ --format pretty'
+        else
+          'bundle exec rspec spec/ --format documentation'
+        end
+      end
+
+      it 'has a tests job with ruby, bundle install, run command and an always-published artifact' do
+        tests = yml['jobs'][0]
+        expect(tests['job']).to eq('tests')
+        steps = tests['steps']
+        expect(steps.first).to eq('task' => 'UseRubyVersion@0', 'inputs' => { 'versionSpec' => '3.4' })
+        expect(steps.map { |s| s['script'] }).to include('bundle install', run_command)
+        publish = steps.find { |s| s['task'] == 'PublishPipelineArtifact@1' }
+        expect(publish['condition']).to eq('always()')
+        expect(publish['inputs']).to eq(
+          'targetPath' => 'raider-results',
+          'artifact' => 'raider-results-$(System.JobPositionInPhase)-$(System.JobAttempt)'
+        )
+      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)')
+        expect(yml['variables']['HEADLESS']).to eq('true')
+      end
+
+      it 'has a raider_comment job for pull requests' do
+        comment = yml['jobs'][1]
+        expect(comment['job']).to eq('raider_comment')
+        expect(comment['dependsOn']).to eq('tests')
+        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 triggers, pool and the self-hosted hint' do
+        expect(yml['trigger']['branches']['include']).to include('main', 'master')
+        expect(yml['pr']['branches']['include']).to include('*')
+        expect(yml['pool']).to eq('vmImage' => 'ubuntu-latest')
+        expect(raw).to include('# Self-hosted agent? Replace vmImage with: pool: { name: Default }')
+      end
+
+      it 'explains that Azure Repos ignores pr: directly above the pr block' do
+        expect(raw).to include('# Azure Repos ignores pr: — add this pipeline as a Build validation branch policy ' \
+                               "so pull request builds (and the Raider comment) run.\npr:")
+      end
+
+      it 'has no Allure' do
+        expect(raw).not_to match(/allure/i)
+      end
+
+      it 'documents Azure Pipelines in the README and no GitHub Actions setup' 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')
+        expect(readme).not_to match(/GitHub Actions/i)
+      end
+    end
+  end
+
+  context 'with a mobile project and ci azure' do
+    let(:readme) { read_generated('azurec_mobile', 'Readme.md') }
+
+    before(:all) do # rubocop:disable RSpec/BeforeAfterAll
+      InvokeGenerators.generate_framework(automation: 'ios', framework: 'rspec', name: 'azurec_mobile', ci: 'azure')
+    end
+
+    it 'says the template is not available and does not mention azure-pipelines.yml' do
+      expect(readme).to include('## CI', 'Azure Pipelines template for mobile projects is not available yet. ' \
+                                         'Use GitHub Actions (`ci:github`)')
+      expect(readme).not_to include('azure-pipelines.yml', '## Azure Pipelines')
+    end
+  end
+
+  it 'does not generate azure-pipelines.yml for default projects' do
+    expect(File).not_to exist("#{project('rspec', 'selenium')}/azure-pipelines.yml")
+  end
+end

data/spec/integration/content/ci_content_spec.rb

@@ -62,13 +62,13 @@ describe 'CI pipeline content' do
     end
   end
 
-  shared_examples 'github raider wiring' do |project_name, file|
+  shared_examples 'github raider wiring' do |project_name, file, runner = 'rspec'|
     subject(:pipeline) { read_generated(project_name, ".github/workflows/#{file}") }
 
     let(:steps) { YAML.safe_load(pipeline)['jobs'].values.flat_map { |job| job['steps'] } }
 
     let(:test_steps) do
-      steps.select { |step| step['run'].to_s.include?('rspec') || step['with'].to_h['script'].to_s.include?('rspec') }
+      steps.select { |step| step['run'].to_s.include?(runner) || step['with'].to_h['script'].to_s.include?(runner) }
     end
 
     it 'passes Raider settings to every test step' do
@@ -128,29 +128,19 @@ describe 'CI pipeline content' do
     end
   end
 
-  shared_examples 'github without raider-comment job' do |project_name, file|
-    subject(:pipeline) { read_generated(project_name, ".github/workflows/#{file}") }
-
-    it 'has no raider-comment job' do
-      expect(pipeline).not_to include('raider-comment')
-      expect(pipeline).not_to include('raider-reporter')
-    end
-  end
-
-  shared_examples 'github without raider wiring' do |project_name, file|
-    subject(:pipeline) { read_generated(project_name, ".github/workflows/#{file}") }
+  shared_examples 'github allure steps' do |project_name|
+    subject(:pipeline) { read_generated(project_name, '.github/workflows/test_pipeline.yml') }
 
-    it 'has no Raider settings or artifact' do
-      expect(pipeline).not_to include('RAIDER_')
-      expect(pipeline).not_to include('raider-results')
+    it 'keeps the Allure steps' do
+      expect(pipeline).to include('simple-elf/allure-report-action', 'peaceiris/actions-gh-pages')
     end
   end
 
-  shared_examples 'github allure steps' do |project_name|
+  shared_examples 'github without allure steps' do |project_name|
     subject(:pipeline) { read_generated(project_name, '.github/workflows/test_pipeline.yml') }
 
-    it 'keeps the Allure steps' do
-      expect(pipeline).to include('simple-elf/allure-report-action', 'peaceiris/actions-gh-pages')
+    it 'has no Allure report or gh-pages steps' do
+      expect(pipeline).not_to match(/allure|gh-pages/i)
     end
   end
 
@@ -169,9 +159,9 @@ describe 'CI pipeline content' do
     include_examples 'valid github pipeline', name
     include_examples 'github cucumber pipeline', name
     include_examples 'github triggers', name, 'test_pipeline.yml'
-    include_examples 'github without raider wiring', name, 'test_pipeline.yml'
-    include_examples 'github without raider-comment job', name, 'test_pipeline.yml'
-    include_examples 'github allure steps', name
+    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 without allure steps', name
   end
 
   context 'with rspec and watir' do
@@ -184,6 +174,16 @@ describe 'CI pipeline content' do
     include_examples 'github allure steps', name
   end
 
+  context 'with cucumber and watir' do
+    name = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
+    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 without allure steps', name
+  end
+
   appium_jobs = { 'android' => %w[android-tests], 'ios' => %w[ios-tests],
                   'cross_platform' => %w[ios-tests android-tests] }
 
@@ -198,8 +198,8 @@ describe 'CI pipeline content' do
     context "with cucumber and #{automation}" do
       name = "#{FrameworkIndex::CUCUMBER}_#{automation}"
       include_examples 'github triggers', name, 'appium_pipeline.yml'
-      include_examples 'github without raider wiring', name, 'appium_pipeline.yml'
-      include_examples 'github without raider-comment job', 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
     end
   end
 end

data/spec/integration/content/common_content_spec.rb

@@ -122,16 +122,16 @@ describe 'Common file content' do
   shared_examples 'non-rspec gitignore' do |project_name|
     subject(:gitignore) { read_generated(project_name, '.gitignore') }
 
-    it 'includes allure-results' do
-      expect(gitignore).to include('allure-results')
+    it 'does not include allure-results' do
+      expect(gitignore).not_to include('allure-results')
     end
 
     it 'does not include spec/examples.txt' do
       expect(gitignore).not_to include('spec/examples.txt')
     end
 
-    it 'does not include raider-results' do
-      expect(gitignore).not_to include('raider-results')
+    it 'includes raider-results' do
+      expect(gitignore).to include('raider-results')
     end
   end
 

data/spec/integration/content/cucumber_reporter_content_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'content_helper'
+
+describe 'Cucumber raider_reporter wiring' do
+  screenshot_calls = {
+    'selenium' => 'driver.save_screenshot(screenshot_path)',
+    'watir' => 'browser.screenshot.save(screenshot_path)'
+  }
+
+  AUTOMATION_TYPES.each do |automation|
+    context "with cucumber and #{automation}" do
+      let(:project_name) { "#{FrameworkIndex::CUCUMBER}_#{automation}" }
+      let(:env) { read_generated(project_name, 'features/support/env.rb') }
+      let(:screenshot_call) { screenshot_calls.fetch(automation, 'driver.screenshot(screenshot_path)') }
+      let(:hook) { env[/^\s*After do.*\z/m] }
+      let(:quit_call) { automation == 'watir' ? 'browser.quit' : 'driver.quit' }
+
+      it 'activates the reporter by requiring raider_reporter/cucumber' do
+        expect(env).to include("require 'raider_reporter/cucumber'")
+      end
+
+      it 'does not reference the allure helper' do
+        expect(env).not_to match(/AllureHelper|allure_helper/)
+      end
+
+      it 'takes the screenshot only for failed scenarios, inside the guard block' do
+        guarded = /if scenario\.failed\?\n\s+Dir\.mktmpdir do \|temp_folder\|\n(?<body>.*?)\n\s+end\n\s+end\nensure/m
+        expect(hook.match(guarded)[:body]).to include(screenshot_call)
+      end
+
+      it 'uses a fixed file name in the tmpdir, never the scenario name' do
+        expect(env).to include("screenshot_path = File.join(temp_folder, 'screenshot.png')")
+        expect(hook).not_to include('scenario.name')
+      end
+
+      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).not_to match(/^\s+begin$/)
+      end
+
+      it 'attaches the screenshot path before quitting the driver' do
+        attach = "RaiderReporter.attach('screenshot', screenshot_path, type: :png)"
+        expect(env).to include(attach)
+        expect(env.index(screenshot_call)).to be < env.index(attach)
+        expect(env.index(attach)).to be < env.index(/driver\.quit|browser\.quit/, env.index(attach))
+      end
+
+      it 'does not generate the allure helper' do
+        expect(File).not_to exist(File.join(project_name, 'helpers/allure_helper.rb'))
+      end
+
+      it 'does not mention Allure in any generated file' do
+        files = Dir.glob("#{project_name}/**/*", File::FNM_DOTMATCH).select { |f| File.file?(f) }
+        expect(files.select { |f| File.read(f).match?(/allure/i) }).to be_empty
+      end
+
+      it 'does not create an allure-results folder' do
+        expect(File).not_to exist(File.join(project_name, 'allure-results'))
+      end
+    end
+  end
+end

data/spec/integration/content/gemfile_content_spec.rb

@@ -58,8 +58,8 @@ describe 'Gemfile content' do
       expect(gemfile).to include("gem 'cucumber'")
     end
 
-    it 'includes allure-cucumber' do
-      expect(gemfile).to include("gem 'allure-cucumber'")
+    it 'does not include allure-cucumber' do
+      expect(gemfile).not_to include('allure')
     end
 
     it 'includes rspec as cucumber dependency' do
@@ -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.3'")
+          expect(gemfile).to include("gem 'raider_reporter', '~> 0.5'")
         end
 
         it 'keeps allure gems' do
@@ -142,12 +142,12 @@ describe 'Gemfile content' do
       context "with cucumber and #{automation}" do
         let(:gemfile) { read_generated("#{FrameworkIndex::CUCUMBER}_#{automation}", 'Gemfile') }
 
-        it 'does not include raider_reporter' do
-          expect(gemfile).not_to include('raider_reporter')
+        it 'includes raider_reporter' do
+          expect(gemfile).to include("gem 'raider_reporter', '~> 0.5'")
         end
 
-        it 'keeps allure-cucumber' do
-          expect(gemfile).to include("gem 'allure-cucumber', '2.28.0'")
+        it 'drops allure-cucumber' do
+          expect(gemfile).not_to include('allure')
         end
 
         it 'pins ruby_raider to the generator major.minor' do

data/spec/integration/content/helper_content_spec.rb

@@ -221,13 +221,11 @@ describe 'Helper file content' do
     name = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
     it_behaves_like 'valid driver helper', name
     it_behaves_like 'selenium driver helper', name
-    it_behaves_like 'valid allure helper', name
   end
 
   context 'with cucumber and watir' do
     name = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
     it_behaves_like 'valid browser helper', name
-    it_behaves_like 'valid allure helper', name
   end
 
   # --- Mobile contexts (with AppiumRecorder) ---
@@ -255,10 +253,8 @@ describe 'Helper file content' do
     end
 
     context "with cucumber and #{automation}" do
-      it 'has no raider reporter wiring' do
-        project = "#{FrameworkIndex::CUCUMBER}_#{automation}"
-        files = Dir.glob("#{project}/**/*", File::FNM_DOTMATCH).select { |f| File.file?(f) }
-        expect(files.select { |f| File.read(f).match?(/raider_reporter|RaiderReporter/) }).to be_empty
+      it 'does not generate the allure helper' do
+        expect(File).not_to exist("#{FrameworkIndex::CUCUMBER}_#{automation}/helpers/allure_helper.rb")
       end
     end
   end

data/spec/integration/content/readme_content_spec.rb

@@ -22,9 +22,19 @@ describe 'Generated Readme content' do
     end
 
     context "with cucumber and #{automation}" do
-      it 'has no Reporting section' do
-        readme = read_generated("#{FrameworkIndex::CUCUMBER}_#{automation}", 'Readme.md')
-        expect(readme).not_to include('RAIDER_TOKEN')
+      subject(:readme) { read_generated("#{FrameworkIndex::CUCUMBER}_#{automation}", 'Readme.md') }
+
+      it 'has a Reporting section' do
+        expect(readme).to include('## Reporting')
+      end
+
+      it 'documents local results, upload settings, plugin mode and the raider_reporter README' do
+        expect(readme).to include('raider-results/', 'RAIDER_TOKEN', 'RAIDER_ENDPOINT', 'features/support/env.rb',
+                                  'https://github.com/RaiderHQ/raider_reporter')
+      end
+
+      it 'does not mention Allure' do
+        expect(readme).not_to match(/allure/i)
       end
     end
   end

data/spec/integration/content/test_content_spec.rb

@@ -110,6 +110,10 @@ describe 'Test file content' do
     it 'has default profile' 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')
+    end
   end
 
   # --- RSpec contexts ---

data/spec/integration/end_to_end_spec.rb

@@ -84,7 +84,7 @@ describe 'End-to-End Project Generation and Execution' do
   # Helper to run Cucumber tests
   def run_cucumber(project_name)
     puts "\n🥒 Running Cucumber tests in #{project_name}..."
-    result = run_in_project(project_name, 'bundle exec cucumber features/ --format pretty', timeout: 120)
+    result = run_in_project(project_name, 'HEADLESS=true bundle exec cucumber features/ --format pretty', timeout: 120)
 
     puts result[:stdout] if result[:stdout].length.positive?
 
@@ -104,10 +104,10 @@ describe 'End-to-End Project Generation and Execution' do
       expect(bundle_install(project)).to be true
     end
 
-    it 'resolves raider_reporter 0.3 from RubyGems and ships the raider-reporter executable', :aggregate_failures do
+    it 'resolves raider_reporter 0.5 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\.3\.\d+\)$/)
+      expect(File.read(File.join(project, 'Gemfile.lock'))).to match(/^    raider_reporter \(0\.5\.\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')
@@ -162,6 +162,85 @@ describe 'End-to-End Project Generation and Execution' do
                                   "STDOUT: #{result[:stdout]}\n" \
                                   "STDERR: #{result[:stderr]}"
     end
+
+    it 'resolves raider_reporter 0.5 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\.5\.\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 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'))
+    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
 
   # Test Web Frameworks (these can run without external services)
@@ -183,6 +262,95 @@ describe 'End-to-End Project Generation and Execution' do
     end
   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
+
+  # Generates a ci: azure web project (the shared before(:all) only builds the default github ones)
+  def generate_azure_project(framework)
+    name = "azure_#{framework}_selenium"
+    unless LazyProjectGenerator::GENERATED.include?(name)
+      generate_framework(framework:, automation: 'selenium', name:, ci: 'azure')
+      LazyProjectGenerator::GENERATED.add(name)
+    end
+    name
+  end
+
+  def azure_env_prefix
+    "GITHUB_ACTIONS= HEADLESS=true #{AZURE_PUSH_ENV.map { |k, v| "#{k}='#{v}'" }.join(' ')}"
+  end
+
+  def expect_azure_ci_block(project)
+    run = JSON.parse(File.read(File.join(project, 'raider-results', 'run.json')))
+    ci = run.dig('run', 'ci') || run['ci']
+    expect(ci).not_to be_nil, "No ci block in run.json: #{run.keys}"
+    expect(ci['provider']).to eq('azure_pipelines')
+    expect(ci['build_key']).to start_with('azure_pipelines:')
+    expect(ci['build_key']).to eq(
+      'azure_pipelines:dev.azure.com/raider-test/6ce954b1-ce1f-45d1-b94d-e6bf2464ba2c/' \
+      '1c2bd1a0-3f63-4d93-9c3c-2b4f2b1d8f11:42:1'
+    )
+    expect(ci['build_url']).to eq('https://dev.azure.com/raider-test/My%20Project/_build/results?buildId=42')
+    puts "\nrun.json ci block: #{JSON.pretty_generate(ci)}"
+  end
+
+  context 'Azure Pipelines projects (ci: azure)' do
+    describe 'Selenium + RSpec' do
+      let(:project) { generate_azure_project('rspec') }
+
+      it 'ships azure-pipelines.yml and resolves raider_reporter 0.5', :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\.5\.\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 rspec spec/ --format documentation",
+                                timeout: 120)
+        expect(result[:success]).to be(true), "STDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
+        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.5', :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\.5\.\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
+
   # Mobile and Visual frameworks require external services, so we only verify structure
   context 'Mobile Automation Frameworks (structure validation only)' do
     describe 'iOS + RSpec' do