ruby_raider 3.11.0 → 3.12.0

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/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/syntax_validation_spec.rb

@@ -31,6 +31,8 @@ describe 'Ruby syntax validation' do
                              else
                                %w[features/support/env.rb features/step_definitions/login_steps.rb]
                              end
+        # The glob above runs at load time, before the projects exist, so new helpers are listed here.
+        login_reuse_files += %w[helpers/wait_helper.rb helpers/raider_element.rb] if automation == 'selenium'
 
         login_reuse_files.each do |relative|
           it "#{relative} is generated as valid Ruby with frozen_string_literal" do
@@ -41,5 +43,26 @@ describe 'Ruby syntax validation' do
         end
       end
     end
+
+    # Mobile projects get the mobile branch of the wait helper templates.
+    %w[android ios cross_platform].each do |automation|
+      context "with #{framework} and #{automation}" do
+        project_name = "#{framework}_#{automation}"
+
+        %w[helpers/wait_helper.rb helpers/raider_element.rb].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
+
+        it 'helpers/wait_helper.rb has the mobile gestures and no web-only methods' do
+          content = File.read(File.join(project_name, '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
   end
 end

data/spec/integration/content/test_content_spec.rb

@@ -173,3 +173,60 @@ 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); 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).
+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

data/spec/integration/end_to_end_spec.rb

@@ -398,6 +398,40 @@ describe 'End-to-End Project Generation and Execution' do
     end
   end
 
+  # An empty skeleton (examples: false) still passes its run, so its CI is green until tests are added
+  def generate_skeleton_project(framework)
+    name = "skeleton_e2e_#{framework}_selenium"
+    unless LazyProjectGenerator::GENERATED.include?(name)
+      generate_framework(framework:, automation: 'selenium', name:, examples: false)
+      LazyProjectGenerator::GENERATED.add(name)
+    end
+    name
+  end
+
+  context 'Empty skeleton projects (examples: false)' do
+    it 'runs bundle exec rspec on a selenium rspec skeleton with 0 examples', :aggregate_failures do
+      project = generate_skeleton_project('rspec')
+      skip 'Bundle install failed' unless bundle_install(project)
+
+      ['rspec', 'rspec spec/'].each do |command|
+        result = run_in_project(project, "bundle exec #{command}", timeout: 120)
+        expect(result[:exit_code]).to eq(0), "#{command}\nSTDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
+        expect(result[:stdout]).to include('0 examples, 0 failures')
+      end
+    end
+
+    it 'runs bundle exec cucumber on a selenium cucumber skeleton with 0 scenarios', :aggregate_failures do
+      project = generate_skeleton_project('cucumber')
+      skip 'Bundle install failed' unless bundle_install(project)
+
+      ['cucumber', 'cucumber features'].each do |command|
+        result = run_in_project(project, "bundle exec #{command}", timeout: 120)
+        expect(result[:exit_code]).to eq(0), "#{command}\nSTDOUT: #{result[:stdout]}\nSTDERR: #{result[:stderr]}"
+        expect(result[:stdout]).to include('0 scenarios')
+      end
+    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.
@@ -683,38 +717,26 @@ describe 'End-to-End Project Generation and Execution' do
 
   # Verify template system performance (caching working)
   context 'Template System Performance' do
-    it 'benefits from template caching on second generation' do
+    it 'compiles each partial once and reuses it on the second generation' do
       require_relative '../../lib/generators/generator'
 
-      # Clear cache
       Generator.clear_template_cache
+      compiled = []
+      allow_any_instance_of(TemplateRenderer::PartialCache).to(
+        receive(:compile_template).and_wrap_original { |original, *args| compiled << args.first && original.call(*args) }
+      )
 
-      # First generation (cache miss)
-      start_time = Time.now
-      settings1 = create_settings(framework: 'rspec', automation: 'selenium')
-      settings1[:name] = 'test_cache_1'
-      generate_framework(settings1)
-      first_duration = Time.now - start_time
-
-      # Second generation (cache hit)
-      start_time = Time.now
-      settings2 = create_settings(framework: 'rspec', automation: 'selenium')
-      settings2[:name] = 'test_cache_2'
-      generate_framework(settings2)
-      second_duration = Time.now - start_time
-
-      # Second generation should be faster (or similar if I/O dominates)
-      # At minimum, cache should not slow things down
-      expect(second_duration).to be <= (first_duration * 1.2)
-
-      # Cleanup
-      FileUtils.rm_rf('test_cache_1')
-      FileUtils.rm_rf('test_cache_2')
-
-      # Verify cache has entries
-      stats = Generator.template_cache_stats
-      expect(stats[:size]).to be > 0
-      puts "\n📊 Template cache: #{stats[:size]} entries, ~#{stats[:memory_estimate] / 1024}KB"
+      %w[test_cache_1 test_cache_2].map do |name|
+        before = compiled.size
+        generate_framework(create_settings(framework: 'rspec', automation: 'selenium').merge(name:))
+        compiled.size - before
+      end => [first, second]
+
+      expect(first).to be_positive
+      expect(second).to eq(0)
+      expect(Generator.template_cache_stats[:size]).to be_positive
+    ensure
+      FileUtils.rm_rf(%w[test_cache_1 test_cache_2])
     end
   end
 end

data/spec/integration/generators/automation_generator_spec.rb

@@ -71,4 +71,54 @@ describe AutomationGenerator do
   context 'with cucumber and appium cross platform' do
     include_examples 'creates mobile automation framework', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::CROSS_PLATFORM}"
   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
+        let(:name) { ensure_project(framework:, automation:, examples: false) }
+
+        it 'creates no example pages' do
+          expect(Dir.glob("#{name}/page_objects/pages/*.rb")).to be_empty
+        end
+
+        it 'keeps the pages folder with a .keep' do
+          expect(File).to exist("#{name}/page_objects/pages/.keep")
+        end
+
+        it 'creates the abstract page' do
+          expect(File).to exist("#{name}/page_objects/abstract/page.rb")
+        end
+
+        it 'gives the abstract page no header component' do
+          expect(File.read("#{name}/page_objects/abstract/page.rb")).not_to include('Header')
+        end
+
+        it 'creates no models' do
+          expect(File).not_to exist("#{name}/models")
+        end
+      end
+    end
+
+    context 'with a web project' do
+      let(:name) { ensure_project(framework: 'rspec', automation: 'selenium', examples: false) }
+
+      it 'creates the abstract component' do
+        expect(File).to exist("#{name}/page_objects/abstract/component.rb")
+      end
+
+      it 'keeps the components folder with a .keep and no example component' do
+        expect(Dir.children("#{name}/page_objects/components")).to eq(['.keep'])
+      end
+    end
+
+    context 'with watir' do
+      it 'still creates the examples, because the Watir templates are frozen' do
+        InvokeGenerators.generate_framework(framework: 'rspec', automation: 'watir', name: 'skeleton_watir',
+                                            examples: false)
+        expect(File).to exist('skeleton_watir/page_objects/pages/login.rb')
+      ensure
+        FileUtils.rm_rf('skeleton_watir')
+      end
+    end
+  end
 end

data/spec/integration/generators/common_generator_spec.rb

@@ -107,4 +107,24 @@ describe CommonGenerator do
     include_examples 'creates a config file', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'creates a gitignore file', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
   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
+        let(:name) { ensure_project(framework:, automation:, examples: false) }
+        let(:ci_file) { automation == 'selenium' ? 'test_pipeline.yml' : 'appium_pipeline.yml' }
+
+        it 'creates the README, Gemfile, Rakefile and CI file' do
+          %W[Readme.md Gemfile Rakefile .github/workflows/#{ci_file}].each do |file|
+            expect(File).to exist("#{name}/#{file}")
+          end
+        end
+
+        it 'creates the settings' do
+          settings = automation == 'ios' ? 'config/capabilities.yml' : 'config/config.yml'
+          expect(File).to exist("#{name}/#{settings}")
+        end
+      end
+    end
+  end
 end

data/spec/integration/generators/config_features_spec.rb

@@ -35,9 +35,9 @@ describe 'Config features for generated projects' do
       expect(config['driver_options']).to be_nil
     end
 
-    it 'generates driver_helper with timeout from config' do
+    it 'generates driver_helper without an implicit wait' do
       helper = File.read('config_selenium_test/helpers/driver_helper.rb')
-      expect(helper).to include("config.fetch('timeout', 10)")
+      expect(helper).not_to include('implicit_wait')
     end
 
     it 'generates spec_helper with viewport-aware window setup' do