ruby_raider 3.11.0 → 3.12.0

data/spec/integration/generators/cucumber_generator_spec.rb

@@ -61,4 +61,40 @@ describe CucumberGenerator do
     include_examples 'creates cucumber files', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}", 'login'
     include_examples 'creates factories for web projects', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::WATIR}", 'login'
   end
+
+  describe 'without example tests' do
+    %w[selenium ios cross_platform].each do |automation|
+      context "with cucumber and #{automation}" do
+        let(:name) { ensure_project(framework: 'cucumber', automation:, examples: false) }
+
+        it 'creates no feature files' do
+          expect(Dir.glob("#{name}/features/**/*.feature")).to be_empty
+        end
+
+        it 'keeps an empty step_definitions folder' do
+          expect(Dir.children("#{name}/features/step_definitions")).to eq(['.keep'])
+        end
+
+        it 'creates the support files' do
+          expect(Dir.children("#{name}/features/support")).to contain_exactly('env.rb', 'world.rb')
+        end
+
+        it 'creates the cucumber.yml file' do
+          expect(File).to exist("#{name}/cucumber.yml")
+        end
+
+        it 'creates no user factory' do
+          expect(File).not_to exist("#{name}/models/user_factory.rb")
+        end
+      end
+    end
+
+    it 'creates no accessibility example' do
+      InvokeGenerators.generate_framework(framework: 'cucumber', automation: 'selenium', name: 'skeleton_axe_cucumber',
+                                          examples: false, accessibility: true)
+      expect(Dir.glob('skeleton_axe_cucumber/features/**/accessibility*')).to be_empty
+    ensure
+      FileUtils.rm_rf('skeleton_axe_cucumber')
+    end
+  end
 end

data/spec/integration/generators/helpers_generator_spec.rb

@@ -32,6 +32,18 @@ describe HelpersGenerator do
     it 'creates a browser helper file' do
       expect(File).to exist("#{name}/helpers/browser_helper.rb")
     end
+
+    it 'does not create the wait helper or the element wrapper' do
+      expect(File).not_to exist("#{name}/helpers/wait_helper.rb")
+      expect(File).not_to exist("#{name}/helpers/raider_element.rb")
+    end
+  end
+
+  shared_examples 'creates the wait helper' do |name|
+    it 'creates the wait helper and the element wrapper' do
+      expect(File).to exist("#{name}/helpers/wait_helper.rb")
+      expect(File).to exist("#{name}/helpers/raider_element.rb")
+    end
   end
 
   shared_examples 'creates rspec helpers' do |name|
@@ -56,6 +68,7 @@ describe HelpersGenerator do
     include_examples 'creates common helpers', "#{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}"
     include_examples 'creates rspec helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
   end
 
@@ -70,6 +83,7 @@ describe HelpersGenerator do
     include_examples 'creates common helpers', "#{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}"
     include_examples 'creates cucumber helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
   end
 
@@ -84,6 +98,7 @@ describe HelpersGenerator do
     include_examples 'creates common helpers', "#{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}"
     include_examples 'creates rspec helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::ANDROID}"
   end
 
@@ -91,6 +106,7 @@ describe HelpersGenerator do
     include_examples 'creates common helpers', "#{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}"
     include_examples 'creates rspec helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::IOS}"
   end
 
@@ -98,6 +114,7 @@ describe HelpersGenerator do
     include_examples 'creates common helpers', "#{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}"
     include_examples 'creates cucumber helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::ANDROID}"
   end
 
@@ -105,6 +122,7 @@ describe HelpersGenerator do
     include_examples 'creates common helpers', "#{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}"
     include_examples 'creates cucumber helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::IOS}"
   end
 
@@ -112,6 +130,7 @@ describe HelpersGenerator do
     include_examples 'creates common helpers', "#{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}"
     include_examples 'creates rspec helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'creates cross platform helpers', "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}"
   end
@@ -120,7 +139,26 @@ describe HelpersGenerator do
     include_examples 'creates common helpers', "#{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}"
     include_examples 'creates cucumber helpers', "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::CROSS_PLATFORM}"
     include_examples 'creates cross platform helpers', "#{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 the wait helper and RaiderElement' do
+          expect(File).to exist("#{name}/helpers/wait_helper.rb")
+          expect(File).to exist("#{name}/helpers/raider_element.rb")
+        end
+      end
+    end
+
+    it 'keeps the session state for web' do
+      name = ensure_project(framework: 'rspec', automation: 'selenium', examples: false)
+      expect(File).to exist("#{name}/helpers/session_state.rb")
+    end
+  end
 end

data/spec/integration/generators/invoke_generators_spec.rb

@@ -49,4 +49,74 @@ describe InvokeGenerators do
       expect(File).not_to exist('case_bad_ci')
     end
   end
+
+  describe '.collect_flags' do
+    it 'adds no_examples when examples is false' do
+      expect(described_class.collect_flags(automation: 'selenium', examples: false)).to include('no_examples')
+    end
+
+    it 'keeps the examples by default' do
+      expect(described_class.collect_flags(automation: 'selenium')).not_to include('no_examples')
+    end
+
+    it 'keeps the examples for watir, whose templates are frozen' do
+      expect(described_class.collect_flags(automation: 'watir', examples: false)).not_to include('no_examples')
+    end
+  end
+
+  context 'with the Watir deprecation notice' do
+    let(:notice) do
+      'Watir is deprecated and will be removed in the next major version of ruby_raider; new projects should use Selenium.'
+    end
+
+    it 'prints it for watir' do
+      expect { described_class.generate_framework(framework: 'rspec', automation: 'watir', name: 'case_dep') }
+        .to output(/#{Regexp.escape(notice)}/).to_stdout
+    end
+
+    it 'does not print it for selenium' do
+      expect { described_class.generate_framework(framework: 'rspec', automation: 'selenium', name: 'case_nodep') }
+        .not_to output(/Watir is deprecated/).to_stdout
+    end
+
+    it 'still prints it for raider new with automation:watir' do
+      root = File.expand_path('../../..', __dir__)
+      out, status = Open3.capture2e('ruby', "#{root}/bin/raider", 'new', 'case_cli_watir', '-p',
+                                    'framework:rspec', 'automation:watir')
+      expect(status.success?).to be(true)
+      expect(out).to include(notice)
+      expect(File).to exist('case_cli_watir/.rspec')
+    end
+  end
+
+  context 'with examples false for watir' do
+    it 'says the examples are kept' do
+      expect { described_class.generate_framework(framework: 'rspec', automation: 'watir', name: 'case_watir', examples: false) }
+        .to output(/Watir projects always include the example tests/).to_stdout
+    end
+  end
+end
+
+describe 'Projects named like a generator option' do
+  after { FileUtils.rm_rf(%w[no_examples watir selenium]) }
+
+  it 'keeps the example tests in a project named no_examples' do
+    InvokeGenerators.generate_framework(automation: 'selenium', framework: 'rspec', name: 'no_examples')
+    expect(File).to exist('no_examples/spec/login_page_spec.rb')
+    expect(File).to exist('no_examples/page_objects/pages/login.rb')
+  end
+
+  it 'gives a Selenium project named watir the wait helper it wires in' do
+    InvokeGenerators.generate_framework(automation: 'selenium', framework: 'cucumber', name: 'watir')
+    expect(File).to exist('watir/helpers/wait_helper.rb')
+    expect(File.read('watir/features/support/env.rb')).not_to include('Watir')
+    expect(File.read('watir/page_objects/abstract/page.rb')).to include('include WaitHelper')
+  end
+
+  it 'keeps a Watir project named selenium on Watir' do
+    InvokeGenerators.generate_framework(automation: 'watir', framework: 'rspec', name: 'selenium')
+    expect(File).not_to exist('selenium/helpers/wait_helper.rb')
+    expect(File.read('selenium/page_objects/abstract/page.rb')).to include('browser.element')
+    expect(File.read('selenium/page_objects/abstract/page.rb')).not_to include('find_element')
+  end
 end

data/spec/integration/generators/rspec_generator_spec.rb

@@ -46,4 +46,24 @@ describe RspecGenerator do
     include_examples 'creates rspec files examples',
                      "#{FrameworkIndex::RSPEC}_#{AutomationIndex::CROSS_PLATFORM}", 'pdp'
   end
+
+  describe 'without example tests' do
+    %w[selenium ios cross_platform].each do |automation|
+      context "with rspec and #{automation}" do
+        let(:name) { ensure_project(framework: 'rspec', automation:, examples: false) }
+
+        it 'creates an empty spec folder' do
+          expect(Dir.children("#{name}/spec")).to eq(['.keep'])
+        end
+      end
+    end
+
+    it 'creates no accessibility example' do
+      InvokeGenerators.generate_framework(framework: 'rspec', automation: 'selenium', name: 'skeleton_axe_rspec',
+                                          examples: false, accessibility: true)
+      expect(Dir.children('skeleton_axe_rspec/spec')).to eq(['.keep'])
+    ensure
+      FileUtils.rm_rf('skeleton_axe_rspec')
+    end
+  end
 end

data/spec/integration/helpers/session_state_spec.rb

@@ -2,6 +2,7 @@
 
 require 'erb'
 require 'json'
+require 'timeout'
 require 'selenium-webdriver'
 require 'time'
 require 'tmpdir'
@@ -409,6 +410,51 @@ describe 'SessionState' do
       expect(Time.iso8601(saved['saved_at'])).to be > before
     end
 
+    it 'lets concurrent callers restore a fresh login at the same time' do
+      write_state('cookies' => [saved_cookie('session')])
+      arrived = Queue.new
+      checked = Queue.new
+      threads = Array.new(2) do
+        Thread.new do
+          valid = lambda do
+            arrived << 1
+            Timeout.timeout(2) { sleep 0.01 until arrived.size == 2 }
+            checked << 1
+          end
+          SessionState.new(SessionStateSpec::FakeDriver.new(cookies:)).reuse(valid:) { raise 'logged in' }
+        end
+      end
+      threads.each(&:join)
+      expect(checked.size).to eq(2)
+    end
+
+    it 'restores a login another worker saved meanwhile, without a fallback warning' do
+      write_state('cookies' => [saved_cookie('session')])
+      checks = 0
+      valid = lambda do
+        checks += 1
+        write_state('cookies' => [saved_cookie('session')], 'saved_at' => Time.now.utc.iso8601) if checks == 1
+        checks > 1
+      end
+      logins = 0
+      expect { state.reuse(valid:) { logins += 1 } }.not_to output.to_stderr
+      expect([logins, checks]).to eq([0, 2])
+    end
+
+    it 'warns once when the second restore after a peer save is also invalid' do
+      write_state('cookies' => [saved_cookie('session')])
+      checks = 0
+      valid = lambda do
+        checks += 1
+        write_state('cookies' => [saved_cookie('session')], 'saved_at' => Time.now.utc.iso8601) if checks == 1
+        false
+      end
+      logins = 0
+      expect { state.reuse(valid:) { logins += 1 } }
+        .to output(/\A\[login_state\] login restored from \S+ is no longer valid, logging in again\n\z/).to_stderr
+      expect(logins).to eq(1)
+    end
+
     it 'serializes concurrent callers on the lock' do
       count = 0
       drivers = Array.new(2) { SessionStateSpec::FakeDriver.new(cookies:) }

data/spec/integration/helpers/wait_helper_mobile_spec.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require_relative 'wait_helper_support'
+
+# The mobile render loads into App, so its WaitHelper and RaiderElement never meet the web
+# render's top-level ones when both spec files run in one process.
+module WaitHelperMobileSpec
+  module App; end
+  WaitHelperSpec.load_templates(mobile: true, into: App)
+
+  class Page
+    include App::WaitHelper
+
+    attr_reader :driver
+
+    def initialize(driver)
+      @driver = driver
+    end
+  end
+
+  RSpec.describe 'WaitHelper on mobile' do
+    let(:driver) { WaitHelperSpec::FakeDriver.new(device: :ios) }
+    let(:android) { WaitHelperSpec::FakeDriver.new(device: :android) }
+    let(:page) { Page.new(driver) }
+    let(:per_os) { { ios: { accessibility_id: 'ios-card' }, android: { accessibility_id: 'android-card' } } }
+
+    def element(**state) = WaitHelperSpec::FakeElement.new(**state)
+    def clock = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    def screen_area = { left: 0, top: 20, width: 390, height: 800 }
+
+    describe '#tap and #click' do
+      it 'click once the element is visible, enabled and stable' do
+        %i[tap click].each do |name|
+          target = element(rects: [[0, 0, 10, 10], [5, 5, 10, 10], [5, 5, 10, 10]])
+          driver.script({ accessibility_id: name.to_s }, nil, element(displayed: false), element(enabled: false), target)
+          expect(page.public_send(name, { accessibility_id: name.to_s }, timeout: 2)).to eq(target)
+          expect(target.log).to eq([[:click]])
+        end
+      end
+    end
+
+    describe 'tap with a block' do
+      it 'is Object#tap on a RaiderElement: yields and returns the wrapper without clicking' do
+        card = element
+        driver.script({ accessibility_id: 'card' }, card)
+        wrapper = page.find_element(accessibility_id: 'card')
+        seen = nil
+        expect(wrapper.tap { |yielded| seen = yielded }).to be(wrapper)
+        expect([seen, card.log]).to eq([wrapper, []])
+      end
+
+      it 'is Object#tap on the mixin: yields self without looking anything up' do
+        seen = nil
+        expect(page.tap { |yielded| seen = yielded }).to be(page)
+        expect(page.tap(&:driver)).to be(page)
+        expect([seen, driver.finds, driver.scripts]).to eq([page, [], []])
+      end
+
+      it 'still clicks without a block' do
+        card = element
+        driver.script({ id: 'x' }, card)
+        page.tap({ id: 'x' }, timeout: 1)
+        page.tap(id: 'x')
+        page.find_element(id: 'x').tap
+        expect(card.log).to eq([[:click]] * 3)
+      end
+    end
+
+    describe '#swipe' do
+      it 'uses mobile: swipe on iOS' do
+        card = element
+        driver.script({ accessibility_id: 'card' }, card)
+        expect(page.swipe('left', { accessibility_id: 'card' }, timeout: 1)).to eq(card)
+        expect(driver.scripts).to eq([['mobile: swipe', { direction: 'left', element: card.id }]])
+      end
+
+      it 'uses mobile: swipeGesture on Android' do
+        card = element
+        android.script({ accessibility_id: 'card' }, card)
+        Page.new(android).swipe('left', { accessibility_id: 'card' }, timeout: 1)
+        expect(android.scripts)
+          .to eq([['mobile: swipeGesture', { elementId: card.id, direction: 'left', percent: 0.75 }]])
+      end
+
+      it 'waits for the element to be visible first' do
+        card = element
+        driver.script({ accessibility_id: 'card' }, nil, element(displayed: false), card)
+        page.swipe('up', { accessibility_id: 'card' }, timeout: 1)
+        expect([driver.finds.size, driver.scripts.size]).to eq([3, 1])
+      end
+
+      it 'swipes the whole screen without a locator' do
+        expect(page.swipe('up')).to be_nil
+        Page.new(android).swipe('up')
+        expect(driver.scripts).to eq([['mobile: swipe', { direction: 'up' }]])
+        expect(android.scripts).to eq([['mobile: swipeGesture', { **screen_area, direction: 'up', percent: 0.75 }]])
+      end
+
+      it 'rejects a direction other than up, down, left or right' do
+        expect { page.swipe('sideways') }.to raise_error(ArgumentError, /up, down, left or right/)
+        expect(driver.scripts).to be_empty
+      end
+    end
+
+    describe '#scroll' do
+      it 'scrolls the screen without a locator' do
+        page.scroll('down')
+        Page.new(android).scroll('down')
+        expect(driver.scripts).to eq([['mobile: scroll', { direction: 'down' }]])
+        expect(android.scripts).to eq([['mobile: scrollGesture', { **screen_area, direction: 'down', percent: 0.75 }]])
+      end
+
+      it 'scrolls a container' do
+        list = element
+        android.script({ id: 'list' }, list)
+        Page.new(android).scroll('up', { id: 'list' }, timeout: 1)
+        expect(android.scripts).to eq([['mobile: scrollGesture', { elementId: list.id, direction: 'up', percent: 0.75 }]])
+      end
+    end
+
+    describe 'an unknown device' do
+      it 'raises NotImplementedError naming it, before waiting' do
+        windows = WaitHelperSpec::FakeDriver.new(device: :windows)
+        started = clock
+        expect { Page.new(windows).swipe('left', { id: 'never' }, timeout: 2) }
+          .to raise_error(NotImplementedError, /windows/)
+        expect { Page.new(windows).scroll('down') }.to raise_error(NotImplementedError, /windows/)
+        expect(clock - started).to be < 0.5
+      end
+    end
+
+    describe '#scroll_to' do
+      it 'returns a RaiderElement once the element turns visible after 2 scrolls' do
+        footer = element
+        driver.script({ accessibility_id: 'footer' }, nil, element(displayed: false), footer)
+        found = page.scroll_to({ accessibility_id: 'footer' }, timeout: 2)
+        expect(found).to be_a(App::RaiderElement).and eq(footer)
+        expect(driver.scripts).to eq([['mobile: scroll', { direction: 'down' }]] * 2)
+      end
+
+      it 'scrolls in the given direction' do
+        driver.script({ accessibility_id: 'header' }, nil, element)
+        page.scroll_to({ accessibility_id: 'header' }, direction: 'up', timeout: 2)
+        expect(driver.scripts).to eq([['mobile: scroll', { direction: 'up' }]])
+      end
+
+      it 'stops after max_scrolls scrolls and says so' do
+        started = clock
+        expect { page.scroll_to({ accessibility_id: 'footer' }, max_scrolls: 3, timeout: 5) }
+          .to raise_error(App::WaitHelper::TimeoutError) { |error|
+            expect(error.message).to include('to be visible').and include('after 3 scrolls')
+          }
+        expect(driver.scripts.size).to eq(3)
+        expect(driver.finds.size).to eq(4)
+        expect(clock - started).to be < 2
+      end
+
+      it 'also stops at the timeout, naming the scrolls so far' do
+        expect { page.scroll_to({ accessibility_id: 'footer' }, timeout: 0) }
+          .to raise_error(App::WaitHelper::TimeoutError, /after 0 scrolls/)
+        expect(driver.scripts).to be_empty
+      end
+    end
+
+    describe 'per-OS locators' do
+      it 'resolve on tap and swipe' do
+        card = element
+        android.script({ accessibility_id: 'android-card' }, card)
+        mobile = Page.new(android)
+        mobile.tap(per_os, timeout: 1)
+        mobile.swipe('right', per_os, timeout: 1)
+        expect(android.finds.uniq).to eq([{ accessibility_id: 'android-card' }])
+        expect([card.log, android.scripts.size]).to eq([[[:click]], 1])
+      end
+
+      it 'resolve on a nested find_element' do
+        row = element
+        list = element.script({ accessibility_id: 'ios-row' }, row)
+        driver.script({ accessibility_id: 'ios-card' }, list)
+        found = page.find_element(per_os).find_element({ ios: { accessibility_id: 'ios-row' }, android: { id: 'row' } })
+        expect(found).to eq(row)
+      end
+    end
+
+    describe 'RaiderElement' do
+      it 'has the mobile set without the locator' do
+        card = element
+        driver.script({ accessibility_id: 'card' }, card)
+        wrapper = page.find_element(accessibility_id: 'card')
+        expect(wrapper.tap.swipe('left').scroll('down').scroll_to).to be(wrapper)
+        expect(card.log).to eq([[:click]])
+        expect(driver.scripts).to eq([['mobile: swipe', { direction: 'left', element: card.id }],
+                                      ['mobile: scroll', { direction: 'down', element: card.id }]])
+      end
+
+      it 'adds exactly the planned public methods' do
+        expect(App::RaiderElement.public_instance_methods(false).sort)
+          .to eq(%i[== attribute clear click displayed? enabled? eql? find_element find_elements hash native scroll
+                    scroll_to selected? send_keys swipe tap text])
+      end
+    end
+
+    describe 'the choke point' do
+      let(:actions) { [] }
+
+      before do
+        driver.script({ id: 'x' }, element.script({ css: 'y' }, element).script_many({ css: 'y' }, [element]))
+        allow_any_instance_of(App::WaitHelper::Waiter).to receive(:perform_action).and_wrap_original do |original, *args, **options, &block|
+          actions << args.first
+          original.call(*args, **options, &block)
+        end
+      end
+
+      def calls(locator)
+        { find_element: [locator], find_elements: [locator], click: [locator], tap: [locator], clear: [locator],
+          text: [locator], displayed?: [locator], enabled?: [locator], selected?: [locator],
+          send_keys: [locator, 'a'], attribute: [locator, 'name'], swipe: ['left', locator],
+          scroll: ['down', locator], scroll_to: [locator] }
+      end
+
+      it 'is called once per mixin method, with the method name' do
+        calls({ id: 'x' }).each do |name, args|
+          actions.clear
+          page.public_send(name, *args, timeout: 1)
+          expect(actions).to eq([name])
+        end
+      end
+
+      it 'is called once for a whole-screen gesture' do
+        %i[swipe scroll].each do |name|
+          actions.clear
+          page.public_send(name, 'up')
+          expect(actions).to eq([name])
+        end
+      end
+
+      it 'is called once per wrapper method, with the method name' do
+        wrapper = page.find_element(id: 'x')
+        calls({ css: 'y' }).each do |name, args|
+          args = args.reject { |arg| arg.is_a?(Hash) } unless %i[find_element find_elements].include?(name)
+          actions.clear
+          wrapper.public_send(name, *args, timeout: 1)
+          expect(actions).to eq([name])
+        end
+      end
+    end
+
+    describe 'footprint' do
+      it 'adds exactly the mobile API, with no private methods and nothing named wait' do
+        expect(App::WaitHelper.public_instance_methods(false).sort)
+          .to eq(%i[attribute clear click displayed? enabled? eventually find_element find_elements scroll scroll_to
+                    selected? send_keys swipe tap text])
+        expect(App::WaitHelper.private_instance_methods(false)).to be_empty
+        expect(page.respond_to?(:wait, true)).to be(false)
+      end
+    end
+
+    describe '#eventually' do
+      it 'retries the block as on web' do
+        tries = 0
+        expect(page.eventually(timeout: 1) { expect(tries += 1).to eq(2) }).to be(true)
+      end
+
+      it 'retries a nested timeout: until its own deadline, as on web' do
+        started = clock
+        expect { page.eventually(timeout: 0.6) { page.text({ accessibility_id: 'never' }, timeout: 0.2) } }
+          .to raise_error(App::WaitHelper::TimeoutError, /\A\(still failing after 0.6s\)/)
+        expect(clock - started).to be_between(0.5, 1.0)
+      end
+
+      it 'raises at once for a stale find_elements member used as a parent' do
+        row = element.script({ accessibility_id: 'cell' }, element)
+        driver.script_many({ accessibility_id: 'row' }, [row])
+        member = page.find_elements(accessibility_id: 'row').first
+        row.go_stale
+        expect { member.find_element(accessibility_id: 'cell', timeout: 2) }
+          .to raise_error(Selenium::WebDriver::Error::StaleElementReferenceError, /find_elements again/)
+      end
+    end
+  end
+end