ruby_raider 3.12.0 → 3.13.0

data/spec/integration/end_to_end_spec.rb

@@ -6,6 +6,8 @@ require 'open3'
 require 'json'
 require 'erb'
 require 'tmpdir'
+require_relative 'trace_format_checker'
+require_relative 'trace_page_server'
 
 # End-to-end integration tests that verify generated projects actually work
 # These tests:
@@ -265,11 +267,30 @@ describe 'End-to-End Project Generation and Execution' do
     FileUtils.rm_f(File.join(project, 'features/step_definitions/reporter_failure_steps.rb'))
   end
 
+  # Runs the project's own RuboCop with the gems its bundle resolved (newer than this gem's dev bundle).
+  # It runs from a copy outside this repo, as a user's project would: inside it RuboCop would also read
+  # this repo's .rubocop.yml, gemspec and .ruby-version.
+  def expect_project_rubocop_clean(project)
+    skip 'Bundle install failed' unless bundle_install(project)
+
+    Dir.mktmpdir('raider_rubocop') do |tmp|
+      copy = File.join(tmp, project)
+      FileUtils.cp_r(project, copy)
+      puts run_in_project(copy, 'bundle exec rubocop -V', timeout: 60)[:stdout]
+      result = run_in_project(copy, 'bundle exec rubocop --cache false', timeout: 180)
+      expect(result[:exit_code]).to eq(0), "STDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
+    end
+  end
+
   # Test Web Frameworks (these can run without external services)
   context 'Web Automation Frameworks' do
     describe 'Selenium + RSpec' do
       include_examples 'executable rspec project', 'rspec_selenium'
 
+      it 'passes its own RuboCop with its bundled gems', :slow do
+        expect_project_rubocop_clean('rspec_selenium')
+      end
+
       it 'saves the login once and reuses it', :aggregate_failures, :slow do
         skip 'Bundle install failed' unless bundle_install('rspec_selenium')
 
@@ -300,6 +321,10 @@ describe 'End-to-End Project Generation and Execution' do
 
     describe 'Selenium + Cucumber' do
       include_examples 'executable cucumber project', 'cucumber_selenium'
+
+      it 'passes its own RuboCop with its bundled gems', :slow do
+        expect_project_rubocop_clean('cucumber_selenium')
+      end
     end
 
     describe 'Watir + Cucumber' do
@@ -432,6 +457,36 @@ describe 'End-to-End Project Generation and Execution' do
     end
   end
 
+  # Browser e2e helpers shared by the failure video and the trace replay contexts
+  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 results(project)
+    JSON.parse(File.read(File.join(project, 'raider-results', 'run.json')))['results']
+  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.
@@ -447,31 +502,6 @@ describe 'End-to-End Project Generation and Execution' do
       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)
@@ -539,10 +569,6 @@ describe 'End-to-End Project Generation and Execution' do
       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
@@ -634,6 +660,366 @@ describe 'End-to-End Project Generation and Execution' do
     end
   end
 
+  # Trace replay against headless Chrome, and one example on headless Firefox. The page is served over HTTP from this process (never file://), so
+  # WebDriver BiDi reports real network and console entries. raider_reporter ~> 0.12 resolves from RubyGems, or
+  # from a checkout at RAIDER_REPORTER_PATH. The example with video on also needs RAIDER_FFMPEG_PATH.
+  # Set TRACE_FIXTURE_DIR to keep the failing RSpec example's trace.zip (and an unzipped copy) there.
+  context 'Trace replay', :slow do
+    let!(:server) { TracePageServer.new }
+    let(:cache_dir) { Dir.mktmpdir('raider-cache') }
+
+    after do
+      server.stop
+      FileUtils.rm_rf(cache_dir)
+    end
+
+    # Typed into the secret fields; neither may reach the zip.
+    def secrets
+      %w[hunter2 s3cr3t]
+    end
+
+    # Typed into a plain field; it is kept as the step's value.
+    def plain_value
+      'plain-trace-name'
+    end
+
+    def skip_unless_trace_prerequisites(project, browser = 'chrome')
+      skip "#{browser == 'chrome' ? 'Google Chrome' : 'Firefox'} is not installed" unless browser_installed?(browser)
+      version = run_in_project(project, %(bundle exec ruby -e "require 'raider_reporter/version'; print RaiderReporter::VERSION"))
+      skip "the bundle does not resolve raider_reporter ~> 0.12 (set RAIDER_REPORTER_PATH): #{version[:stderr].lines.last}" unless
+        version[:success] && Gem::Version.new(version[:stdout]) >= Gem::Version.new('0.12')
+    end
+
+    def trace_env(overrides = {})
+      { 'HEADLESS' => 'true', 'VIDEO' => 'off', 'TRACE' => nil, 'RAIDER_CACHE_DIR' => cache_dir,
+        'RAIDER_TOKEN' => nil, 'RAIDER_ENDPOINT' => nil }.merge(overrides)
+    end
+
+    def trace_attachments(result)
+      result['attachments'].select { |attachment| attachment['name'] == 'trace' }
+    end
+
+    def trace_files(project)
+      Dir.glob(File.join(project, 'raider-results', '**', '*trace.zip'))
+    end
+
+    def trace_zip(project, attachment)
+      File.join(project, 'raider-results', attachment['path'])
+    end
+
+    # { entry name => bytes } for every entry of the zip.
+    def zip_entries(path)
+      Zip::File.open(path) { |zip| zip.entries.to_h { |entry| [entry.name, entry.get_input_stream.read] } }
+    end
+
+    def result_named(project, name)
+      results(project).find { |result| result['full_name'].include?(name) }
+    end
+
+    def expect_run(result, exit_code: 1)
+      expect(result[:exit_code]).to eq(exit_code), "STDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
+      expect(result[:stderr]).not_to include('[trace]')
+    end
+
+    def expect_valid_trace(path)
+      expect(TraceFormatChecker.problems(path)).to be_empty
+    end
+
+    def keep_fixture(path)
+      dir = ENV.fetch('TRACE_FIXTURE_DIR', nil)
+      return unless dir
+
+      FileUtils.rm_rf(File.join(dir, 'unzipped'))
+      FileUtils.mkdir_p(File.join(dir, 'unzipped'))
+      FileUtils.cp(path, File.join(dir, 'trace.zip'))
+      zip_entries(path).each do |name, bytes|
+        FileUtils.mkdir_p(File.dirname(File.join(dir, 'unzipped', name)))
+        File.binwrite(File.join(dir, 'unzipped', name), bytes)
+      end
+    end
+
+    # The RSpec examples' names, spec file and readers, shared by the Chrome and Firefox examples.
+    def failing
+      'fails after driving the page'
+    end
+
+    def passing
+      'passes after driving the page'
+    end
+
+    # Drives the page through the generated WaitHelper, so the trace has action steps.
+    # Each example prints the driver's webSocketUrl, which is set only while tracing is on.
+    def add_rspec_trace_spec(project)
+      File.write(File.join(project, 'spec/trace_replay_spec.rb'), <<~SPEC)
+        # frozen_string_literal: true
+
+        require_relative '../helpers/spec_helper'
+
+        describe 'Trace replay' do
+          it '#{failing}' do
+            driver.navigate.to('#{server.url}')
+            puts "TRACE_E2E_WEBSOCKET=\#{driver.capabilities[:web_socket_url].inspect}"
+            send_keys({ id: 'pw' }, '#{secrets[0]}')
+            send_keys({ id: 'pw2' }, '#{secrets[1]}')
+            find_element(id: 'name').send_keys('#{plain_value}')
+            click({ id: 'go' })
+            eventually(timeout: 5) { expect(text(id: 'status')).to eq('answered by /api') }
+            eventually(timeout: 1) { expect(text(id: 'title')).to eq('deliberate trace failure') }
+          end
+
+          it '#{passing}' do
+            driver.navigate.to('#{server.url}')
+            puts "TRACE_E2E_WEBSOCKET=\#{driver.capabilities[:web_socket_url].inspect}"
+            send_keys({ id: 'name' }, 'ok')
+            eventually { expect(text(id: 'title')).to eq('Trace') }
+          end
+        end
+      SPEC
+    end
+
+    def failing_trace(result)
+      expect(trace_attachments(result).size).to eq(1)
+      trace_zip(project, trace_attachments(result).first)
+    end
+
+    def steps_of(path)
+      TraceFormatChecker.read(path).first['steps']
+    end
+
+    # BiDi screenshots, so window_handle worked as the browsing context id: .jpg entries that are JPEGs.
+    def expect_jpeg_screenshots(path, names)
+      screenshots = names.grep(%r{\Asteps/\d{4}\.(jpg|png)\z})
+      expect(screenshots).not_to be_empty
+      expect(screenshots).to all(end_with('.jpg'))
+      entries = zip_entries(path)
+      screenshots.each { |name| expect(entries[name].byteslice(0, 2).bytes).to eq([0xFF, 0xD8]), name }
+    end
+
+    describe 'Selenium + RSpec on headless Chrome' do
+      let(:project) { 'video_rspec_selenium' }
+      let(:command) { 'bundle exec rspec spec/trace_replay_spec.rb' }
+
+      before do
+        generate_video_project('rspec', 'selenium')
+        skip_unless_trace_prerequisites(project)
+        add_rspec_trace_spec(project)
+      end
+
+      after { FileUtils.rm_f(File.join(project, 'spec/trace_replay_spec.rb')) }
+
+      # A navigate step (Selenium sends get through BiDi with web_socket_url set), and action steps whose
+      # elements have a label and a rect.
+      def expect_steps(steps)
+        expect(steps.map { |step| step['kind'] }).to include('navigate')
+        actions = steps.select { |step| %w[click send_keys].include?(step['action']) }
+        expect(actions.size).to eq(4)
+        expect(actions).to all(include('element' => include('label' => a_kind_of(String)), 'rect' => a_kind_of(Hash)))
+      end
+
+      def expect_network_and_console(trace)
+        api = trace['network'].find { |entry| entry['url'].to_s.end_with?('/api') }
+        expect(api).to include('method' => 'GET', 'status' => 200, 'mime_type' => 'application/json')
+        expect(api['bytes']).to be_positive
+        expect(api['duration_ms']).to be >= (TracePageServer::API_DELAY * 1000) - 50
+        expect(trace['console']).to include(include('level' => 'error', 'text' => a_string_including('trace e2e error')))
+      end
+
+      # The same-origin stylesheet inlined as <style>, and the page's <script> gone.
+      def expect_sanitised_snapshots(path, names)
+        entries = zip_entries(path)
+        snapshots = names.grep(%r{\Asteps/\d{4}\.html\z}).map { |name| entries[name] }
+        expect(snapshots).not_to be_empty
+        expect(snapshots).to all(match(/<style[^>]*>[^<]*#{Regexp.escape(TracePageServer::CSS_RULE)}/))
+        expect(snapshots).to all(satisfy { |html| !html.match?(/<script/i) })
+      end
+
+      it 'attaches one trace.zip to the failing example only, valid against raider-trace v1, with network and console',
+         :aggregate_failures do
+        run = run_in_project(project, command, env: trace_env)
+        expect_run(run)
+        failed = result_named(project, failing)
+        attachment = trace_attachments(failed).first
+        path = failing_trace(failed)
+        keep_fixture(path)
+
+        expect(run[:stdout]).to include('TRACE_E2E_WEBSOCKET="ws://')
+        expect(attachment).to include('content_type' => 'application/vnd.raider.trace+zip', 'attempt' => 1)
+        expect(trace_attachments(result_named(project, passing))).to be_empty
+        expect(trace_files(project).size).to eq(1)
+        expect_valid_trace(path)
+
+        trace, names = TraceFormatChecker.read(path)
+        expect(trace['capabilities']).to include('network' => true, 'console' => true)
+        expect_steps(trace['steps'])
+        expect_jpeg_screenshots(path, names)
+        expect_network_and_console(trace)
+        expect_sanitised_snapshots(path, names)
+      end
+
+      it 'masks the typed password', :aggregate_failures do
+        run = run_in_project(project, command, env: trace_env)
+        expect_run(run)
+        path = failing_trace(result_named(project, failing))
+
+        zip_entries(path).each do |name, bytes|
+          secrets.each { |secret| expect(bytes.b).not_to include(secret.b), "#{secret} is in #{name}" }
+        end
+        typed = steps_of(path).select { |step| step['action'] == 'send_keys' }
+        expect(typed.size).to eq(3)
+        expect(typed.first(2)).to all(include('value' => nil, 'secret' => true))
+        expect(typed.last).to include('value' => plain_value, 'secret' => false)
+      end
+
+      it 'writes no trace and no web_socket_url with TRACE=off', :aggregate_failures do
+        run = run_in_project(project, command, env: trace_env('TRACE' => 'off'))
+        expect_run(run)
+        expect(run[:stdout].scan(/^TRACE_E2E_WEBSOCKET=(.*)$/).flatten).to eq(%w[nil nil])
+        expect(results(project).flat_map { |result| trace_attachments(result) }).to be_empty
+        expect(trace_files(project)).to be_empty
+      end
+
+      it 'keeps traces for passing examples too with TRACE=on', :aggregate_failures do
+        run = run_in_project(project, command, env: trace_env('TRACE' => 'on'))
+        expect_run(run)
+        [failing, passing].each do |name|
+          attachments = trace_attachments(result_named(project, name))
+          expect(attachments.size).to eq(1), "#{name} has #{attachments.size} traces"
+          expect_valid_trace(trace_zip(project, attachments.first)) if attachments.one?
+        end
+        expect(trace_files(project).size).to eq(2)
+      end
+
+      # Spec §2 Cost: tracing on failing tests (the default) costs under 15% of the wall-clock time.
+      # One warm-up run, then the modes interleaved, three runs each, compared by their medians.
+      # Opt-in: CI runs the integration specs on every PR, and runner jitter is the size of the margin.
+      it 'keeps the suite within 15% of its TRACE=off wall-clock time' do
+        skip 'set TRACE_OVERHEAD=1 to measure trace overhead' unless ENV['TRACE_OVERHEAD']
+
+        run_in_project(project, command, env: trace_env)
+        times = Hash.new { |hash, key| hash[key] = [] }
+        3.times do
+          { 'off' => 'off', 'default' => nil }.each do |mode, value|
+            started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            expect_run(run_in_project(project, command, env: trace_env('TRACE' => value)))
+            times[mode] << (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started)
+          end
+        end
+        off, traced = times.values_at('off', 'default').map { |runs| runs.sort[1] }
+        overhead = (traced - off) / off
+        puts format("\n[trace overhead] TRACE=off %<off>s, default %<default>s, medians %<o>.2fs vs %<t>.2fs: %<p>+.1f%%",
+                    off: times['off'].map { |time| time.round(2) }, default: times['default'].map { |time| time.round(2) },
+                    o: off, t: traced, p: overhead * 100)
+        expect(overhead).to be < 0.15
+      end
+
+      it 'attaches video.webm and trace.zip to the failing example with video on', :aggregate_failures do
+        ffmpeg = ENV.fetch('RAIDER_FFMPEG_PATH', '')
+        skip 'RAIDER_FFMPEG_PATH is not set to an executable ffmpeg with libvpx' unless
+          File.file?(ffmpeg) && File.executable?(ffmpeg)
+
+        run = run_in_project(project, command, env: trace_env('VIDEO' => nil, 'RAIDER_FFMPEG_PATH' => ffmpeg))
+        expect_run(run)
+        expect(run[:stderr]).not_to include('[video]')
+        attachments = result_named(project, failing)['attachments']
+        expect(attachments.map { |attachment| attachment['content_type'] })
+          .to include('video/webm', 'application/vnd.raider.trace+zip')
+        expect(attachments.map { |attachment| File.basename(attachment['path']) })
+          .to include(a_string_ending_with('video.webm'), a_string_ending_with('trace.zip'))
+        expect_valid_trace(failing_trace(result_named(project, failing)))
+      end
+    end
+
+    # The same RSpec project with config.yml set to firefox; Selenium Manager fetches geckodriver.
+    describe 'Selenium + RSpec on headless Firefox' do
+      let(:project) { 'video_rspec_selenium' }
+      let(:config) { File.join(project, 'config/config.yml') }
+      # Read before the switch to firefox and written back after, so the Chrome examples keep chrome.
+      let(:original_config) { File.read(config) }
+
+      before do
+        generate_video_project('rspec', 'selenium')
+        skip_unless_trace_prerequisites(project, 'firefox')
+        File.write(config, original_config.sub(/^browser: .*$/, 'browser: firefox'))
+        add_rspec_trace_spec(project)
+      end
+
+      after do
+        File.write(config, original_config) if File.exist?(config)
+        FileUtils.rm_f(File.join(project, 'spec/trace_replay_spec.rb'))
+      end
+
+      it 'attaches a trace.zip valid against raider-trace v1, with network, console and BiDi JPEG screenshots',
+         :aggregate_failures do
+        run = run_in_project(project, 'bundle exec rspec spec/trace_replay_spec.rb', env: trace_env, timeout: 240)
+        expect_run(run)
+        path = failing_trace(result_named(project, failing))
+        expect_valid_trace(path)
+
+        trace, names = TraceFormatChecker.read(path)
+        expect(trace['browser']).to include('name' => 'firefox')
+        expect(trace['capabilities']).to include('network' => true, 'console' => true)
+        expect_jpeg_screenshots(path, names)
+        api = trace['network'].find { |entry| entry['url'].to_s.end_with?('/api') }
+        expect(api).to include('status' => 200)
+        expect(api && api['duration_ms']).to be_a(Integer).and be_positive
+      end
+    end
+
+    describe 'Selenium + Cucumber on headless Chrome' do
+      let(:project) { 'video_cucumber_selenium' }
+
+      before do
+        generate_video_project('cucumber', 'selenium')
+        skip_unless_trace_prerequisites(project)
+        add_cucumber_trace_feature(project)
+      end
+
+      after do
+        FileUtils.rm_f(File.join(project, 'features/trace_replay.feature'))
+        FileUtils.rm_f(File.join(project, 'features/step_definitions/trace_replay_steps.rb'))
+      end
+
+      def add_cucumber_trace_feature(project)
+        File.write(File.join(project, 'features/trace_replay.feature'), <<~FEATURE)
+          Feature: Trace replay
+
+          Scenario: A failing traced scenario
+              Given the trace page is open
+              When I type a name on the trace page
+              Then the trace page title is "deliberate trace failure"
+        FEATURE
+        File.write(File.join(project, 'features/step_definitions/trace_replay_steps.rb'), <<~STEPS)
+          # frozen_string_literal: true
+
+          Given('the trace page is open') do
+            driver.navigate.to('#{server.url}')
+          end
+
+          When('I type a name on the trace page') do
+            send_keys({ id: 'name' }, '#{plain_value}')
+            click({ id: 'go' })
+          end
+
+          Then('the trace page title is {string}') do |title|
+            eventually(timeout: 1) { expect(text(id: 'title')).to eq(title) }
+          end
+        STEPS
+      end
+
+      it 'attaches a trace.zip with Gherkin step groups to the failing scenario', :aggregate_failures do
+        run = run_in_project(project, 'bundle exec cucumber features/trace_replay.feature', env: trace_env, timeout: 240)
+        expect_run(run)
+        attachments = trace_attachments(result_named(project, 'A failing traced scenario'))
+        expect(attachments.size).to eq(1)
+        expect(attachments.first).to include('content_type' => 'application/vnd.raider.trace+zip', 'attempt' => 1)
+        path = trace_zip(project, attachments.first)
+        expect_valid_trace(path)
+        groups = TraceFormatChecker.read(path).first['steps'].select { |step| step['action'] == 'cucumber_step' }
+        expect(groups).to include(include('kind' => 'group', 'name' => a_string_including('the trace page is open')))
+      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/frozen_string_literal_matcher.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rspec/expectations'
+
+# Ruby only reads the magic comment in the comment block before the first line of code. Ruby would
+# accept it indented, but the generated project's RuboCop (Layout/CommentIndentation) would not.
+RSpec::Matchers.define :have_frozen_string_literal do
+  match do |content|
+    leading_comments = content.lines.take_while { |line| line.strip.empty? || line.start_with?('#') }
+    leading_comments.any? { |line| line.chomp == '# frozen_string_literal: true' }
+  end
+  failure_message { 'expected an unindented frozen_string_literal magic comment before the first line of code' }
+end

data/spec/integration/generators/helpers_generator_spec.rb

@@ -46,6 +46,18 @@ describe HelpersGenerator do
     end
   end
 
+  shared_examples 'creates the trace helper' do |name|
+    it 'creates the trace helper' do
+      expect(File).to exist("#{name}/helpers/trace_helper.rb")
+    end
+  end
+
+  shared_examples 'skips the trace helper' do |name|
+    it 'does not create the trace helper' do
+      expect(File).not_to exist("#{name}/helpers/trace_helper.rb")
+    end
+  end
+
   shared_examples 'creates rspec helpers' do |name|
     it 'creates a spec helper file' do
       expect(File).to exist("#{name}/helpers/spec_helper.rb")
@@ -66,6 +78,7 @@ describe HelpersGenerator do
 
   context 'with rspec and selenium' do
     include_examples 'creates common helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
+    include_examples 'creates the trace helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
     include_examples 'creates a session state helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
     include_examples 'creates selenium helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
     include_examples 'creates the wait helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
@@ -74,6 +87,7 @@ describe HelpersGenerator do
 
   context 'with rspec and watir' do
     include_examples 'creates common helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::WATIR}"
+    include_examples 'skips the trace helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::WATIR}"
     include_examples 'creates a session state helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::WATIR}"
     include_examples 'creates watir helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::WATIR}"
     include_examples 'creates rspec helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::WATIR}"
@@ -81,6 +95,7 @@ describe HelpersGenerator do
 
   context 'with cucumber and selenium' do
     include_examples 'creates common helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
+    include_examples 'creates the trace helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
     include_examples 'creates a session state helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
     include_examples 'creates selenium helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
     include_examples 'creates the wait helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
@@ -89,6 +104,7 @@ describe HelpersGenerator do
 
   context 'with cucumber and watir' do
     include_examples 'creates common helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
+    include_examples 'skips the trace helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
     include_examples 'creates a session state helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
     include_examples 'creates watir helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
     include_examples 'creates cucumber helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}"
@@ -96,6 +112,7 @@ describe HelpersGenerator do
 
   context 'with rspec and appium android' do
     include_examples 'creates common helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::ANDROID}"
+    include_examples 'skips the trace helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::ANDROID}"
     include_examples 'skips the session state helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::ANDROID}"
     include_examples 'creates selenium helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::ANDROID}"
     include_examples 'creates the wait helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::ANDROID}"
@@ -104,6 +121,7 @@ describe HelpersGenerator do
 
   context 'with rspec and appium ios' do
     include_examples 'creates common helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::IOS}"
+    include_examples 'skips the trace helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::IOS}"
     include_examples 'skips the session state helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::IOS}"
     include_examples 'creates selenium helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::IOS}"
     include_examples 'creates the wait helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::IOS}"
@@ -112,6 +130,7 @@ describe HelpersGenerator do
 
   context 'with cucumber and appium android' do
     include_examples 'creates common helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::ANDROID}"
+    include_examples 'skips the trace helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::ANDROID}"
     include_examples 'skips the session state helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::ANDROID}"
     include_examples 'creates selenium helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::ANDROID}"
     include_examples 'creates the wait helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::ANDROID}"
@@ -120,6 +139,7 @@ describe HelpersGenerator do
 
   context 'with cucumber and appium ios' do
     include_examples 'creates common helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::IOS}"
+    include_examples 'skips the trace helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::IOS}"
     include_examples 'skips the session state helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::IOS}"
     include_examples 'creates selenium helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::IOS}"
     include_examples 'creates the wait helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::IOS}"
@@ -128,6 +148,7 @@ describe HelpersGenerator do
 
   context 'with rspec and appium cross platform' do
     include_examples 'creates common helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
+    include_examples 'skips the trace helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'skips the session state helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'creates selenium helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'creates the wait helper', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
@@ -137,6 +158,7 @@ describe HelpersGenerator do
 
   context 'with cucumber and appium cross platform' do
     include_examples 'creates common helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::CROSS_PLATFORM}"
+    include_examples 'skips the trace helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'skips the session state helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'creates selenium helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'creates the wait helper', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::CROSS_PLATFORM}"
@@ -153,6 +175,10 @@ describe HelpersGenerator do
           expect(File).to exist("#{name}/helpers/wait_helper.rb")
           expect(File).to exist("#{name}/helpers/raider_element.rb")
         end
+
+        it "#{automation == 'selenium' ? 'creates' : 'skips'} the trace helper" do
+          expect(File.exist?("#{name}/helpers/trace_helper.rb")).to eq(automation == 'selenium')
+        end
       end
     end