ruby_raider 3.11.0 → 3.12.1

data/spec/integration/commands/utility_commands_spec.rb

@@ -110,4 +110,12 @@ describe UtilityCommands do
       expect(config.dig('browser_arguments', 'firefox')).to eq([])
     end
   end
+
+  # Generated drivers connect to appium_lib's default, http://127.0.0.1:4723, with no base path.
+  it 'starts Appium on the default path the generated drivers connect to' do
+    command = utility.new
+    allow(command).to receive(:system)
+    command.start_appium
+    expect(command).to have_received(:system).with('appium')
+  end
 end

data/spec/integration/content/config_content_spec.rb

@@ -111,6 +111,23 @@ describe 'Config file content' do
     end
   end
 
+  # appium_lib connects to http://127.0.0.1:4723 and ignores a url capability, so none is generated.
+  %w[rspec cucumber].product(%w[android ios cross_platform]).each do |framework, automation|
+    it "has no unused url capability or /wd/hub path in #{framework} #{automation} capabilities" do
+      caps = read_generated("#{framework}_#{automation}", 'config/capabilities.yml')
+      local = caps.split(/^browserstack:/).first
+      expect(local).not_to match(/^\s*url:/)
+      expect(local).not_to include('/wd/hub')
+    end
+
+    it "parses as YAML, BrowserStack block included, in #{framework} #{automation} capabilities" do
+      caps = YAML.safe_load(read_generated("#{framework}_#{automation}", 'config/capabilities.yml'))
+      browserstack = caps.fetch('browserstack')
+      expect(browserstack).to have_key('app')
+      expect(browserstack['app'].to_s).not_to start_with('app:')
+    end
+  end
+
   %w[android ios cross_platform].each do |automation|
     it "has no login_state in the #{automation} config" do
       Dir.glob(File.join("#{FrameworkIndex::RSPEC}_#{automation}", 'config', '*.yml')).each do |file|
@@ -119,3 +136,30 @@ describe 'Config file content' do
     end
   end
 end
+
+describe 'Config timeout wiring' do
+  %w[rspec cucumber].each do |framework|
+    # Single-platform Appium projects have no config.yml; WaitHelper falls back to its default of 10.
+    %w[selenium cross_platform].each do |automation|
+      it "sets timeout 10 in #{framework} #{automation}" do
+        config = YAML.safe_load(read_generated("#{framework}_#{automation}", 'config/config.yml'), permitted_classes: [Symbol])
+        expect(config['timeout']).to eq(10)
+      end
+    end
+  end
+
+  it 'describes the selenium timeout as an action and eventually wait' do
+    expect(read_generated('rspec_selenium', 'config/config.yml'))
+      .to include('# seconds that actions and eventually wait before failing')
+  end
+
+  it 'describes the mobile timeout as an action and eventually wait' do
+    expect(read_generated('rspec_cross_platform', 'config/config.yml'))
+      .to include('timeout: 10 # seconds that actions and eventually wait before failing')
+  end
+
+  it 'leaves the watir timeout comment unchanged' do
+    expect(read_generated('rspec_watir', 'config/config.yml'))
+      .to include('timeout: 10 # seconds — used for implicit waits and max wait time')
+  end
+end

data/spec/integration/content/content_helper.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../spec_helper'
+require_relative '../frozen_string_literal_matcher'
 
 module ContentHelper
   def read_generated(project, relative_path)
@@ -12,11 +13,6 @@ module ContentHelper
   end
 end
 
-RSpec::Matchers.define :have_frozen_string_literal do
-  match { |content| content.include?('# frozen_string_literal: true') }
-  failure_message { 'expected file to contain frozen_string_literal magic comment' }
-end
-
 RSpec::Matchers.define :have_valid_ruby_syntax do
   match do |content|
     RubyVM::InstructionSequence.compile(content)

data/spec/integration/content/helper_content_spec.rb

@@ -398,3 +398,82 @@ describe 'Helper file content' do
     end
   end
 end
+
+describe 'Auto-waiting helper wiring' do
+  %w[selenium ios android cross_platform].each do |automation|
+    context "with rspec and #{automation}" do
+      it 'includes WaitHelper in the spec helper' do
+        helper = read_generated("#{FrameworkIndex::RSPEC}_#{automation}", 'helpers/spec_helper.rb')
+        expect(helper).to include("require_relative 'wait_helper'", 'config.include(WaitHelper)')
+      end
+    end
+  end
+
+  %w[ios android cross_platform].each do |automation|
+    %w[rspec cucumber].each do |framework|
+      it "does not pass a wait to appium_lib in #{framework} #{automation}" do
+        driver = read_generated("#{framework}_#{automation}", 'helpers/driver_helper.rb')
+        expect(driver).not_to match(/\bwait:/)
+      end
+    end
+  end
+
+  %w[rspec cucumber].each do |framework|
+    it "returns the new driver without a redundant assignment in #{framework} selenium" do
+      driver = read_generated("#{framework}_selenium", 'helpers/driver_helper.rb')
+      expect(driver).to include("    Selenium::WebDriver.for(browser.to_sym, **arguments)\n  end")
+      expect(driver).not_to include('driver = Selenium::WebDriver.for')
+    end
+
+    it "leaves no implicit wait in #{framework} selenium" do
+      driver = read_generated("#{framework}_selenium", 'helpers/driver_helper.rb')
+      expect(driver).not_to include('implicit_wait')
+    end
+
+    it "keeps Watir untouched in #{framework} watir" do
+      project = "#{framework}_watir"
+      expect(File.exist?(File.join(project, 'helpers/wait_helper.rb'))).to be(false)
+      expect(read_generated(project, 'helpers/browser_helper.rb')).to include('Watir.default_timeout')
+      files = Dir.glob(File.join(project, '**/*.rb')).map { |f| File.read(f) }
+      expect(files.grep(/WaitHelper/)).to be_empty
+    end
+  end
+
+  describe 'without example tests' do
+    %w[selenium ios cross_platform].each do |automation|
+      context "with rspec and #{automation}" do
+        subject(:helper) { read_generated(ensure_project(framework: 'rspec', automation:, examples: false), 'helpers/spec_helper.rb') }
+
+        it 'names no example class or hook' do
+          expect(helper).not_to match(/Login|Account|logged_in|model_factory/)
+        end
+
+        it 'has valid Ruby syntax' do
+          expect(helper).to have_valid_ruby_syntax
+        end
+      end
+
+      context "with cucumber and #{automation}" do
+        let(:name) { ensure_project(framework: 'cucumber', automation:, examples: false) }
+
+        it 'names no example class or hook in the env and the World' do
+          %w[env.rb world.rb].each do |file|
+            expect(read_generated(name, "features/support/#{file}")).not_to match(/Login|Account|logged_in|factory/)
+          end
+        end
+
+        it 'has a valid env and World' do
+          %w[env.rb world.rb].each do |file|
+            expect(read_generated(name, "features/support/#{file}")).to have_valid_ruby_syntax
+          end
+        end
+      end
+    end
+
+    it 'keeps the session state require in the selenium rspec spec helper' do
+      helper = read_generated(ensure_project(framework: 'rspec', automation: 'selenium', examples: false),
+                              'helpers/spec_helper.rb')
+      expect(helper).to include("require_relative 'session_state'")
+    end
+  end
+end

data/spec/integration/content/page_content_spec.rb

@@ -36,12 +36,16 @@ describe 'Page object content' do
   shared_examples 'selenium login page' do |project_name|
     subject(:login) { read_generated(project_name, 'page_objects/pages/login.rb') }
 
-    it 'uses find_element for elements' do
-      expect(login).to include('driver.find_element')
+    it 'returns locator hashes from the element methods' do
+      expect(login).to include("{ id: 'loginFrm_loginname' }", "{ id: 'loginFrm_password' }",
+                               %q({ xpath: "//button[@title='Login']" }))
+      expect(login).not_to include('driver.find_element')
     end
 
-    it 'uses send_keys for input' do
-      expect(login).to include('send_keys')
+    it 'logs in through the wait helper' do
+      expect(login).to include('send_keys(username_field, username)', 'send_keys(password_field, password)',
+                               'click(login_button)')
+      expect(login).not_to include('.send_keys', '.click')
     end
 
     it 'has private element methods' do
@@ -167,3 +171,70 @@ describe 'Page object content' do
     include_examples 'watir abstract page', name
   end
 end
+
+describe 'Page WaitHelper wiring' do
+  %w[rspec cucumber].each do |framework|
+    %w[selenium ios android cross_platform].each do |automation|
+      it "includes WaitHelper in #{framework} #{automation}" do
+        page = read_generated("#{framework}_#{automation}", 'page_objects/abstract/page.rb')
+        expect(page).to include("require_relative '../../helpers/wait_helper'", 'include WaitHelper')
+      end
+    end
+
+    it "does not include WaitHelper in #{framework} watir" do
+      expect(read_generated("#{framework}_watir", 'page_objects/abstract/page.rb')).not_to include('WaitHelper')
+    end
+  end
+end
+
+describe 'Abstract page layout' do
+  %w[rspec cucumber].each do |framework|
+    %w[selenium ios android cross_platform].each do |automation|
+      [true, false].each do |examples|
+        it "has no blank line before the class end in #{framework} #{automation}#{' (skeleton)' unless examples}" do
+          page = read_generated(ensure_project(framework:, automation:, examples:), 'page_objects/abstract/page.rb')
+          expect(page).not_to match(/\n\n\s*end\s*\z/)
+        end
+      end
+    end
+  end
+end
+
+describe 'Example pages on the wait helper' do
+  %w[rspec cucumber].each do |framework|
+    it "finds the header through the wait helper in #{framework} selenium" do
+      page = read_generated("#{framework}_selenium", 'page_objects/abstract/page.rb')
+      expect(page).to include("Header.new(find_element(css: '.welcome-msg'))")
+      expect(page).not_to include('driver.find_element')
+    end
+
+    %w[ios android cross_platform].each do |automation|
+      context "with #{framework} and #{automation}" do
+        let(:home) { read_generated("#{framework}_#{automation}", 'page_objects/pages/home.rb') }
+        let(:pdp) { read_generated("#{framework}_#{automation}", 'page_objects/pages/pdp.rb') }
+
+        it 'taps the first product and reads the add to cart text through the wait helper' do
+          expect(home).to include('tap(first_product)')
+          expect(pdp).to include('text(add_to_cart_button)')
+          expect(home + pdp).not_to include('driver.wait', 'driver.find_element')
+        end
+
+        it 'returns locator hashes from the element methods' do
+          if automation == 'cross_platform'
+            expect(home).to include("{ ios: { accessibility_id: 'product-item-1' },")
+            expect(pdp).to include("{ ios: { accessibility_id: 'add-to-cart-button' },")
+            expect(home + pdp).not_to include('element(ios:')
+          else
+            expect(home).to include("{ accessibility_id: 'product-item-1' }")
+            expect(pdp).to include("{ accessibility_id: 'add-to-cart-button' }")
+          end
+        end
+
+        it 'has valid Ruby syntax' do
+          expect(home).to have_valid_ruby_syntax
+          expect(pdp).to have_valid_ruby_syntax
+        end
+      end
+    end
+  end
+end

data/spec/integration/content/readme_content_spec.rb

@@ -126,12 +126,12 @@ describe 'Generated Readme content' do
                                      'live session tokens', 'must not be committed, cached or uploaded')
         end
 
-        it 'is its own ## section, straight after the Quality gate and before any CI section' do
+        it 'is its own ## section, straight before Reporting, so Sponsors does not nest under it' do
           heading = readme.index("\n## Reusing the login\n")
-          gate = readme.index("\n### Quality gate\n")
-          expect(gate).to be < heading
-          expect(readme[(gate + 1)...heading]).not_to match(/\n##/)
-          expect(readme[(heading + 1)..][/\n## .*/]).to be_nil.or match(/\A\n## (CI|Azure Pipelines)\z/)
+          expect(heading).not_to be_nil
+          expect(readme[(heading + 1)..][/\n## .*/]).to eq("\n## Reporting")
+          sponsors = readme.index("\n### Sponsors") || readme.size
+          expect(readme[0...sponsors].scan(/\n## .*/).last).not_to eq("\n## Reusing the login")
         end
       else
         it 'does not mention login reuse' do
@@ -141,3 +141,124 @@ describe 'Generated Readme content' do
     end
   end
 end
+
+describe 'Generated Readme: How the framework works' do
+  def section_of(readme)
+    readme[/^## How the framework works\n.*?(?=^## )/m]
+  end
+
+  FRAMEWORKS.each do |framework|
+    context "with #{framework} and selenium" do
+      subject(:readme) { read_generated("#{framework}_selenium", 'Readme.md') }
+
+      it 'sits between Getting Started and Reusing the login' do
+        works = readme.index("\n## How the framework works\n")
+        expect(works).not_to be_nil
+        expect(readme.index("\n## Getting Started\n")).to be < works
+        expect(readme.index("\n## Reusing the login\n")).to be > works
+      end
+
+      it 'covers the web wait helper, chaining, .native, absence checks and how to remove it' do
+        section = section_of(readme)
+        expect(section).to include('### Removing the wait helper', '.native',
+                                   "find_element(css: '.form').find_element(id: 'email')",
+                                   'select_by', 'hover', 'drag_and_drop', 'eventually', 'timeout: 0',
+                                   'find_elements', 'config/config.yml', '[Reporting](#reporting)',
+                                   '[Reusing the login](#reusing-the-login)', 'parallel_tests', 'HEADLESS',
+                                   framework == 'rspec' ? 'RETRY_COUNT' : '--retry 2')
+        expect(section).not_to include('scroll_to', 'swipe')
+      end
+
+      it 'explains that the waits inside eventually stretch to its time and are retried' do
+        eventually = section_of(readme)[/^### eventually\n.*?(?=^### )/m]
+        expect(eventually).to include('a wait inside it that timed out', 'whatever is left of the block',
+                                      '`timeout: 2` gets 2 seconds per try', '(still failing after 10s)')
+      end
+
+      it 'replaces eventually with a true/false Wait block and points at the generators that check' do
+        removal = section_of(readme)[/^### Removing the wait helper\n.*/m]
+        expect(removal).to include('a plain `expect`, or `Selenium::WebDriver::Wait.new(timeout: 10).until { condition }`',
+                                   'a block that returns true or false', '`raider g page` and `raider g component`')
+        expect(removal).not_to include('raider g spec')
+      end
+
+      it 'lists the five steps to remove the wait helper' do
+        removal = section_of(readme)[/^### Removing the wait helper\n.*/m]
+        expect(removal).to include('helpers/wait_helper.rb', 'helpers/raider_element.rb', 'include WaitHelper',
+                                   'driver.find_element(**', 'Selenium::WebDriver::Wait.new', 'implicit_wait',
+                                   'raider g')
+        expect(removal.scan(/^\d\. /).size).to eq(5)
+      end
+    end
+
+    %w[ios android cross_platform].each do |automation|
+      context "with #{framework} and #{automation}" do
+        subject(:readme) { read_generated("#{framework}_#{automation}", 'Readme.md') }
+
+        it 'sits between Getting Started and Reporting' do
+          works = readme.index("\n## How the framework works\n")
+          expect(works).not_to be_nil
+          expect(readme.index("\n## Getting Started\n")).to be < works
+          expect(readme.index("\n## Reporting\n")).to be > works
+        end
+
+        it 'covers the mobile method set, per-OS locators, Appium setup and how to remove the wait helper' do
+          section = section_of(readme)
+          expect(section).to include('swipe', 'scroll_to', 'tap', 'capabilities.yml', 'raider u start_appium',
+                                     '### Removing the wait helper', '.native', '[Reporting](#reporting)',
+                                     'timeout: 15', 'http://127.0.0.1:4723')
+          expect(section).not_to include('select_by', 'hover', 'drag_and_drop', 'Reusing the login', '/wd/hub')
+          expect(section).to include('ios: {') if automation == 'cross_platform'
+        end
+
+        it 'says the device capabilities sit under appium:options' do
+          settings = section_of(readme)[/^### Settings\n.*?(?=^### )/m]
+          expect(settings).to include('under `appium:options`')
+          expect(settings).to include('under the `ios:` and `android:` parts') if automation == 'cross_platform'
+        end
+      end
+    end
+
+    it "marks the #{framework} watir Readme as deprecated and not the selenium one" do
+      watir = read_generated("#{framework}_watir", 'Readme.md')
+      expect(watir).to include('> **Deprecated:** Watir is deprecated', 'only available through `-p automation:watir`',
+                               'https://github.com/RaiderHQ/ruby_raider#migrating-from-watir')
+      expect(read_generated("#{framework}_selenium", 'Readme.md')).not_to include('**Deprecated:**')
+    end
+
+    it "has no such section for #{framework} and watir" do
+      expect(read_generated("#{framework}_watir", 'Readme.md')).not_to include('How the framework works')
+    end
+  end
+
+  describe 'without example tests' do
+    %w[rspec cucumber].product(%w[selenium ios cross_platform]).each do |framework, automation|
+      context "with #{framework} and #{automation}" do
+        subject(:readme) { read_generated(ensure_project(framework:, automation:, examples: false), 'Readme.md') }
+
+        it 'still explains how the framework works' do
+          expect(readme).to include('## How the framework works', '### The wait helper and RaiderElement')
+        end
+
+        it 'points at no example file' do
+          expect(readme).not_to match(/login\.rb|account\.rb|header\.rb|home\.rb|pdp\.rb|users\.yml|model_factory|
+                                       user_factory|login_page_spec|pdp_page_spec|login\.feature|home\.feature|
+                                       login_steps|home_steps|account\ example|files\ in\ this\ project/x)
+        end
+
+        it 'says it has no example tests and how it grows with scaffolding' do
+          expect(readme).to include('generated without example tests', 'raider g scaffold checkout')
+        end
+      end
+    end
+
+    %w[rspec cucumber].each do |framework|
+      it "shows how to add the login hook for the project's own login page in #{framework}" do
+        readme = read_generated(ensure_project(framework:, automation: 'selenium', examples: false), 'Readme.md')
+        section = readme[/^## Reusing the login\n.*?(?=^## )/m]
+        hook = framework == 'rspec' ? 'config.before(:each, :logged_in) do' : "Before('@logged_in') do"
+        expect(section).to include(hook, 'SessionState.new(driver).reuse(')
+      end
+    end
+  end
+end

data/spec/integration/content/rubocop_content_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rubocop'
+require 'stringio'
+require 'tmpdir'
+require_relative 'content_helper'
+
+RUBOCOP_WEB_AUTOMATIONS = %w[selenium watir].freeze
+
+# Every generated project must pass the RuboCop it ships: its own .rubocop.yml, run in-process with
+# this gem's bundle. The project is linted from a copy outside this repo, so RuboCop resolves the
+# target Ruby the way a user's fresh project does (no TargetRubyVersion, so its 2.7 default) instead
+# of picking up this repo's .ruby-version or gemspec. The end-to-end spec repeats the check with the
+# project's own resolved gems.
+describe 'Generated projects pass their own RuboCop' do
+  def rubocop_report(project_name)
+    Dir.mktmpdir('raider_rubocop') do |tmp|
+      dir = File.join(tmp, File.basename(project_name))
+      FileUtils.cp_r(project_name, dir)
+      with_project_root(dir) { yield lint(dir), target_ruby(dir) }
+    end
+  end
+
+  def with_project_root(dir)
+    RuboCop::ConfigFinder.project_root = dir
+    yield
+  ensure
+    RuboCop::ConfigFinder.project_root = nil
+  end
+
+  def target_ruby(dir)
+    RuboCop::TargetRuby.new(RuboCop::ConfigLoader.configuration_from_file(File.join(dir, '.rubocop.yml'))).version
+  end
+
+  def lint(dir)
+    report, exit_code = capture_rubocop_json(['--config', File.join(dir, '.rubocop.yml'), '--cache', 'false',
+                                              '--format', 'json', dir])
+    offenses = report.fetch('files').flat_map do |file|
+      path = file.fetch('path').delete_prefix("#{dir}/")
+      file.fetch('offenses').map do |offense|
+        "#{path}:#{offense.dig('location', 'line')}: #{offense.fetch('cop_name')}: #{offense.fetch('message')}"
+      end
+    end
+    { offenses: offenses, inspected: report.fetch('summary').fetch('inspected_file_count'), exit_code: exit_code }
+  end
+
+  def capture_rubocop_json(args)
+    original = $stdout
+    $stdout = StringIO.new
+    exit_code = RuboCop::CLI.new.run(args)
+    [JSON.parse($stdout.string), exit_code]
+  ensure
+    $stdout = original
+  end
+
+  def expect_no_offenses(project_name)
+    expect(File).to exist(File.join(project_name, '.rubocop.yml'))
+    rubocop_report(project_name) do |summary, target|
+      offenses = summary.fetch(:offenses)
+      expect(target).to eq(RuboCop::TargetRuby::DEFAULT_VERSION)
+      expect(summary.fetch(:inspected)).to be_positive, "#{project_name}: RuboCop inspected no files"
+      expect(offenses).to be_empty, "#{project_name} has #{offenses.size} RuboCop offenses:\n#{offenses.join("\n")}"
+      expect(summary.fetch(:exit_code)).to eq(0)
+    end
+  end
+
+  FRAMEWORKS.each do |framework|
+    AUTOMATION_TYPES.each do |automation|
+      { 'with examples' => true, 'without examples' => false }.each do |label, examples|
+        it "has no offenses for #{framework} and #{automation} (#{label})" do
+          expect_no_offenses(ensure_project(framework:, automation:, examples:))
+        end
+      end
+    end
+
+    RUBOCOP_WEB_AUTOMATIONS.each do |automation|
+      it "has no offenses for #{framework} and #{automation} with accessibility" do
+        name = "rubocop_axe_#{framework}_#{automation}"
+        InvokeGenerators.generate_framework(automation:, framework:, name:, accessibility: true)
+        expect_no_offenses(name)
+      ensure
+        FileUtils.rm_rf(name)
+      end
+    end
+  end
+end

data/spec/integration/content/syntax_validation_spec.rb

@@ -2,43 +2,46 @@
 
 require_relative 'content_helper'
 
-SYNTAX_WEB_AUTOMATIONS = %w[selenium watir].freeze
-SYNTAX_ALL_FRAMEWORKS = %w[cucumber rspec].freeze
+SYNTAX_MOBILE_AUTOMATIONS = %w[android ios cross_platform].freeze
 
+# Projects are generated by spec_helper's before(:all), so the file list is read inside the
+# examples (after generation), never when this file loads.
 describe 'Ruby syntax validation' do
-  SYNTAX_ALL_FRAMEWORKS.each do |framework|
-    SYNTAX_WEB_AUTOMATIONS.each do |automation|
-      context "with #{framework} and #{automation}" do
-        project_name = "#{framework}_#{automation}"
-
-        Dir.glob("#{project_name}/**/*.rb").each do |file|
-          relative = file.sub("#{project_name}/", '')
+  def generated_ruby_files(project_name)
+    Dir.glob('**/*.rb', base: project_name).sort
+  end
 
-          it "#{relative} has valid Ruby syntax" do
-            content = File.read(file)
-            expect(content).to have_valid_ruby_syntax
-          end
+  def syntax_error_for(content)
+    RubyVM::InstructionSequence.compile(content)
+    nil
+  rescue SyntaxError => e
+    e.message
+  end
 
-          it "#{relative} has frozen_string_literal" do
-            content = File.read(file)
-            expect(content).to have_frozen_string_literal
+  FRAMEWORKS.each do |framework|
+    AUTOMATION_TYPES.each do |automation|
+      { 'with examples' => true, 'without examples' => false }.each do |label, examples|
+        it "generates only valid Ruby with frozen_string_literal for #{framework} and #{automation} (#{label})" do
+          project_name = ensure_project(framework:, automation:, examples:)
+          files = generated_ruby_files(project_name)
+
+          expect(files).not_to be_empty
+          aggregate_failures do
+            files.each do |relative|
+              content = File.read(File.join(project_name, relative))
+              expect(syntax_error_for(content)).to be_nil, "#{project_name}/#{relative} has a syntax error"
+              expect(content).to have_frozen_string_literal, "#{project_name}/#{relative} lacks frozen_string_literal"
+            end
           end
         end
+      end
+    end
 
-        login_reuse_files = %w[helpers/session_state.rb]
-        login_reuse_files += if framework == 'rspec'
-                               %w[helpers/spec_helper.rb]
-                             else
-                               %w[features/support/env.rb features/step_definitions/login_steps.rb]
-                             end
-
-        login_reuse_files.each do |relative|
-          it "#{relative} is generated as valid Ruby with frozen_string_literal" do
-            content = File.read(File.join(project_name, relative))
-            expect(content).to have_valid_ruby_syntax
-            expect(content).to have_frozen_string_literal
-          end
-        end
+    SYNTAX_MOBILE_AUTOMATIONS.each do |automation|
+      it "#{framework}_#{automation} wait_helper has the mobile gestures and no web-only methods" do
+        content = File.read(File.join(ensure_project(framework:, automation:), 'helpers/wait_helper.rb'))
+        expect(content).to include("'mobile: swipeGesture'").and include('def scroll_to(')
+        expect(content).not_to include('def drag_and_drop(')
       end
     end
   end

data/spec/integration/content/test_content_spec.rb

@@ -173,3 +173,63 @@ describe 'Test file content' do
     include_examples 'logged in scenario', name
   end
 end
+
+describe 'Cucumber world WaitHelper wiring' do
+  %w[selenium ios android cross_platform].each do |automation|
+    it "makes WaitHelper available to steps in #{automation}" do
+      world = read_generated("cucumber_#{automation}", 'features/support/world.rb')
+      expect(world).to include("require_relative '../../helpers/wait_helper'", 'World(WaitHelper)')
+    end
+  end
+
+  it 'leaves the watir world without WaitHelper' do
+    expect(read_generated('cucumber_watir', 'features/support/world.rb')).not_to include('WaitHelper')
+  end
+end
+
+describe 'Example tests on the wait helper' do
+  it 'wraps every assertion of the selenium rspec spec in eventually' do
+    spec = read_generated('rspec_selenium', 'spec/login_page_spec.rb')
+    expect(spec.scan('eventually { expect(').size).to eq(3)
+    expect(spec.scan(/^ +expect\(/)).to be_empty
+  end
+
+  it "wraps the selenium cucumber Then step's assertion in eventually" do
+    steps = read_generated('cucumber_selenium', 'features/step_definitions/login_steps.rb')
+    expect(steps).to include('eventually { expect(account_page.header.customer_name).to eq ')
+  end
+
+  %w[ios android cross_platform].each do |automation|
+    it "wraps the #{automation} rspec assertion in eventually" do
+      spec = read_generated("rspec_#{automation}", 'spec/pdp_page_spec.rb')
+      expect(spec).to include("eventually { expect(pdp_page.add_to_cart_text).to eq 'Add to Cart' }")
+    end
+
+    it "wraps the #{automation} cucumber Then step's assertion in eventually" do
+      steps = read_generated("cucumber_#{automation}", 'features/step_definitions/home_steps.rb')
+      expect(steps).to include("eventually { expect(pdp_page.add_to_cart_text).to eq 'Add to Cart' }")
+    end
+  end
+end
+
+# The Watir output must stay as master generated it (1274a66), plus the 3.12.1 lint fixes; the snapshots in
+# spec/fixtures/watir_master were generated from that commit's lib.
+# To regenerate: `git archive 1274a66 lib` into a scratch dir, generate rspec and cucumber Watir projects there,
+# then apply only the Readme deprecation-line delta (the `> **Deprecated:**` line under the heading block) and
+# the 3.12.1 changes: RuboCop lint fixes (page.rb loses its extra blank lines, login_steps.rb ends with a newline)
+# plus the frozen_string_literal comments the syntax spec requires (Style/FrozenStringLiteralComment is disabled
+# in the generated .rubocop.yml, so RuboCop does not ask for them) on the Watir page, world and user_factory files.
+describe 'Watir example output' do
+  snapshots = File.expand_path('../../fixtures/watir_master', __dir__)
+
+  { 'rspec_watir' => %w[page_objects/pages/login.rb page_objects/abstract/page.rb spec/login_page_spec.rb Readme.md],
+    'cucumber_watir' => %w[page_objects/pages/login.rb page_objects/abstract/page.rb
+                           features/step_definitions/login_steps.rb Readme.md] }.each do |project, files|
+    files.each do |file|
+      it "keeps #{project}/#{file} as master generates it" do
+        expected = File.read(File.join(snapshots, project, "#{file}.snapshot"))
+        expect(read_generated(project, file)).to eq(expected)
+      end
+    end
+  end
+end