ruby_raider 3.13.0 → 4.0.0

data/spec/runtime/actionability_spec.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/ruby_raider/runtime'
+require_relative 'support/fake_bridge'
+
+RSpec.describe 'Raider::Actionability' do
+  let(:bridge) { Raider::Spec::FakeBridge.new }
+  let(:element) { Selenium::WebDriver::Element.new(bridge, 'e1') }
+  let(:overlay) { { 'check' => 'events', 'covering' => { 'element' => '<div class="overlay">', 'x' => 412, 'y' => 300 } } }
+
+  before do
+    Raider.reset
+    Raider::Actionability.reset_notice
+    allow($stderr).to receive(:puts)
+  end
+
+  after { Raider.reset }
+
+  it 'makes no script call when actionability is off' do
+    Raider.actionability = false
+    Raider::Actionability.ensure(element, :click, force: false)
+    expect(bridge.script_calls).to be_empty
+  end
+
+  it 'makes no script call but one tag_name command when forced' do
+    bridge.answer(:element_tag_name, 'div')
+    Raider::Actionability.ensure(element, :click, force: true)
+    expect([bridge.script_calls, bridge.calls]).to eq([[], [[:element_tag_name, 'e1']]])
+  end
+
+  it 'polls until the check returns nil' do
+    bridge.script_results.push({ 'check' => 'visible' }, { 'check' => 'visible' }, nil)
+    Raider::Actionability.ensure(element, :click, force: false)
+    expect(bridge.script_calls.size).to eq(3)
+  end
+
+  it 'pauses briefly and re-checks at once after a first stable poll' do
+    first = { 'check' => 'stable', 'first' => true }
+    bridge.script_results.push(first, nil)
+    allow(Raider::Actionability).to receive(:sleep)
+    Raider::Actionability.ensure(element, :click, force: false)
+    expect(Raider::Actionability).to have_received(:sleep).with(0.02).once
+    expect(bridge.script_calls.size).to eq(2)
+  end
+
+  it 'passes the script and the action checks to the browser' do
+    bridge.script_results.push(nil)
+    Raider::Actionability.ensure(element, :submit, force: false)
+    expect(bridge.script_calls.first).to eq([Raider::Actionability::SCRIPT, element, %w[visible enabled inert]])
+  end
+
+  it 'raises NotActionable naming the covering element' do
+    Raider.timeout = 0.3
+    bridge.script_results.concat([overlay] * 20)
+    expect { Raider::Actionability.ensure(element, :click, force: false) }
+      .to raise_error(Raider::NotActionable, /receive events; `<div class="overlay">` covers it at \(412, 300\)/)
+  end
+
+  it 'returns zero when actionability is off or forced' do
+    Raider.actionability = false
+    off = Raider::Actionability.ensure(element, :click, force: false)
+    Raider.actionability = true
+    bridge.answer(:element_tag_name, 'div')
+    expect([off, Raider::Actionability.ensure(element, :click, force: true)]).to eq([0, 0])
+  end
+
+  it 'returns the number of not-ready polls on the web' do
+    bridge.script_results.push({ 'check' => 'visible' }, { 'check' => 'enabled' }, nil)
+    expect(Raider::Actionability.ensure(element, :click, force: false)).to eq(2)
+  end
+
+  it 'does not count the first stable poll as not ready' do
+    bridge.script_results.push({ 'check' => 'stable', 'first' => true }, nil)
+    allow(Raider::Actionability).to receive(:sleep)
+    expect(Raider::Actionability.ensure(element, :click, force: false)).to eq(0)
+  end
+
+  describe 'on an Appium native context' do
+    let(:context) { 'NATIVE_APP' }
+    let(:appium) do
+      name = context
+      Class.new(Raider::Spec::FakeBridge) { define_method(:current_context) { name } }.new
+    end
+
+    def native = @native ||= Selenium::WebDriver::Element.new(appium, 'e1')
+
+    def ensure_native(action, **opts)
+      Raider::Actionability.ensure(native, action, force: false, **opts)
+    end
+
+    it 'polls until displayed and enabled, then returns the not-ready count without a script call' do
+      appium.answer(:element_displayed?, false, false, true).answer(:element_enabled?, false, true)
+      expect(ensure_native(:click)).to eq(3)
+      expect(appium.script_calls).to be_empty
+    end
+
+    it 'returns zero when ready at once' do
+      appium.answer(:element_displayed?, true).answer(:element_enabled?, true)
+      expect(ensure_native(:click)).to eq(0)
+    end
+
+    %i[click send_keys clear].each do |action|
+      it "raises NotActionable to be visible for a hidden element on #{action}" do
+        Raider.timeout = 0.3
+        appium.answer(:element_displayed?, false).answer(:element_enabled?, true)
+        expect { ensure_native(action) }.to raise_error(Raider::NotActionable, /waited 0\.[34]\d?s for .* to be visible/)
+      end
+
+      it "raises NotActionable to be enabled for a disabled element on #{action}" do
+        Raider.timeout = 0.3
+        appium.answer(:element_displayed?, true).answer(:element_enabled?, false)
+        expect { ensure_native(action) }.to raise_error(Raider::NotActionable, /waited 0\.[34]\d?s for .* to be enabled/)
+      end
+    end
+
+    it 'makes no check call for submit' do
+      allow(native).to receive(:displayed?)
+      allow(native).to receive(:enabled?)
+      expect(ensure_native(:submit)).to eq(0)
+      expect(native).not_to have_received(:displayed?)
+      expect(native).not_to have_received(:enabled?)
+      expect([appium.script_calls, appium.calls]).to eq([[], []])
+    end
+
+    it 'raises a stale element at once rather than waiting out the timeout' do
+      Raider.timeout = 5
+      allow(native).to receive(:displayed?).and_raise(Selenium::WebDriver::Error::StaleElementReferenceError)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      expect { ensure_native(:click) }.to raise_error(Selenium::WebDriver::Error::StaleElementReferenceError)
+      expect(Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).to be < 1
+      expect(native).to have_received(:displayed?).once
+    end
+
+    it 'reports the elapsed wait of the gate, not the configured timeout' do
+      Raider.timeout = 5
+      appium.answer(:element_displayed?, false)
+      error = nil
+      Raider::Wait.until(timeout: 0.2) do
+        ensure_native(:click)
+      rescue Raider::NotActionable => e
+        error = e
+      end
+      expect(error.message).to match(/waited 0\.[23]\d?s for/)
+    end
+
+    it 'raises KeyError for an action with no native table entry' do
+      expect { ensure_native(:hover) }.to raise_error(KeyError)
+    end
+
+    it 'makes one displayed call and no enabled call when forced' do
+      allow(native).to receive(:displayed?).and_return(true)
+      allow(native).to receive(:enabled?)
+      expect(Raider::Actionability.ensure(native, :click, force: true)).to eq(0)
+      expect(native).to have_received(:displayed?).once
+      expect(native).not_to have_received(:enabled?)
+    end
+
+    it 'raises on a stale element when forced' do
+      appium.answer(:element_displayed?, Selenium::WebDriver::Error::StaleElementReferenceError)
+      expect { Raider::Actionability.ensure(native, :click, force: true) }
+        .to raise_error(Selenium::WebDriver::Error::StaleElementReferenceError)
+    end
+
+    it 'makes no displayed or enabled call when actionability is off' do
+      Raider.actionability = false
+      allow(native).to receive(:displayed?)
+      allow(native).to receive(:enabled?)
+      expect(ensure_native(:click)).to eq(0)
+      expect(native).not_to have_received(:displayed?)
+      expect(native).not_to have_received(:enabled?)
+    end
+
+    it 'asks for the context once per action' do
+      appium.answer(:element_displayed?, true).answer(:element_enabled?, true)
+      allow(appium).to receive(:current_context).and_call_original
+      ensure_native(:click)
+      expect(appium).to have_received(:current_context).once
+    end
+
+    context 'when the context is a webview' do
+      let(:context) { 'WEBVIEW_1' }
+
+      it 'uses the script path as before' do
+        appium.script_results.push({ 'check' => 'visible' }, nil)
+        expect(ensure_native(:click)).to eq(1)
+        expect(appium.script_calls.size).to eq(2)
+      end
+    end
+  end
+
+  it 'prints the notice once' do
+    bridge.script_results.push(nil, nil)
+    2.times { Raider::Actionability.ensure(element, :click, force: false) }
+    expect($stderr).to have_received(:puts).with(/actionability on/).once
+  end
+
+  it 'prints no notice with RAIDER_QUIET=1' do
+    bridge.script_results.push(nil)
+    old = ENV.fetch('RAIDER_QUIET', nil)
+    ENV['RAIDER_QUIET'] = '1'
+    Raider::Actionability.ensure(element, :click, force: false)
+    expect($stderr).not_to have_received(:puts)
+  ensure
+    old ? ENV['RAIDER_QUIET'] = old : ENV.delete('RAIDER_QUIET')
+  end
+end

data/spec/runtime/actionable_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/ruby_raider/runtime'
+require_relative 'support/fake_bridge'
+
+RSpec.describe 'Raider::Actionable' do
+  let(:bridge) { Raider::Spec::FakeBridge.new }
+  let(:element) { Selenium::WebDriver::Element.new(bridge, 'e1') }
+  let(:keys) { Selenium::WebDriver::Keys.encode(['a', :enter]) }
+
+  before do
+    Raider.reset
+    Raider::Actionability.reset_notice
+    allow($stderr).to receive(:puts)
+  end
+
+  after { Raider.reset }
+
+  it 'is prepended to Selenium::WebDriver::Element' do
+    expect(Selenium::WebDriver::Element.ancestors.first).to eq(Raider::Actionable)
+  end
+
+  it 'defines only the four action methods and the send_key alias' do
+    expect(Raider::Actionable.instance_methods(false)).to contain_exactly(:click, :send_keys, :send_key, :clear, :submit)
+  end
+
+  it 'polls the script until it passes, then clicks' do
+    bridge.script_results.push({ 'check' => 'visible' }, nil)
+    element.click
+    expect([bridge.script_calls.size, bridge.calls.last]).to eq([2, [:click_element, 'e1']])
+  end
+
+  it 'clicks after one tag_name command when forced' do
+    bridge.answer(:element_tag_name, 'div')
+    element.click(force: true)
+    expect([bridge.script_calls, bridge.calls]).to eq([[], [[:element_tag_name, 'e1'], [:click_element, 'e1']]])
+  end
+
+  it 'sends the keys Selenium would send' do
+    bridge.script_results.push(nil)
+    element.send_keys('a', :enter)
+    expect(bridge.calls.last).to eq([:send_keys_to_element, 'e1', keys])
+  end
+
+  it 'gates the send_key alias too' do
+    bridge.script_results.push(nil)
+    element.send_key('a')
+    expect([bridge.script_calls.size, bridge.calls.last]).to eq([1, [:send_keys_to_element, 'e1', Selenium::WebDriver::Keys.encode(['a'])]])
+  end
+
+  it 'sends keys when forced without leaking the keyword' do
+    bridge.answer(:element_tag_name, 'div')
+    element.send_keys('a', :enter, force: true)
+    expect(bridge.calls.last).to eq([:send_keys_to_element, 'e1', keys])
+  end
+
+  it 'clears after the check' do
+    bridge.script_results.push(nil)
+    element.clear
+    expect([bridge.script_calls.size, bridge.calls.last]).to eq([1, [:clear_element, 'e1']])
+  end
+
+  it 'submits after the check' do
+    bridge.script_results.push(nil)
+    element.submit
+    expect([bridge.script_calls.size, bridge.calls.last]).to eq([1, [:submit_element, 'e1']])
+  end
+
+  it 'makes no script call when actionability is off' do
+    Raider.actionability = false
+    element.click
+    expect([bridge.script_calls, bridge.calls]).to eq([[], [[:click_element, 'e1']]])
+  end
+
+  it 'raises a stale element at once without acting' do
+    stale = Class.new(Raider::Spec::FakeBridge) do
+      def execute_script(*) = raise(Selenium::WebDriver::Error::StaleElementReferenceError, 'stale')
+    end.new
+    expect { Selenium::WebDriver::Element.new(stale, 'e1').click }
+      .to raise_error(Selenium::WebDriver::Error::StaleElementReferenceError)
+    expect(stale.calls).to be_empty
+  end
+
+  it 'lets a script timeout from the page propagate' do
+    hung = Class.new(Raider::Spec::FakeBridge) do
+      def execute_script(*) = raise(Selenium::WebDriver::Error::ScriptTimeoutError, 'hung')
+    end.new
+    expect { Selenium::WebDriver::Element.new(hung, 'e1').click }
+      .to raise_error(Selenium::WebDriver::Error::ScriptTimeoutError)
+  end
+
+  it 'gates subclasses such as the Appium element' do
+    appium_like = Class.new(Selenium::WebDriver::Element)
+    stub_const('AppiumLikeElement', appium_like)
+    bridge.script_results.push(nil)
+    appium_like.new(bridge, 'e1').click
+    expect([bridge.script_calls.size, bridge.calls.last]).to eq([1, [:click_element, 'e1']])
+  end
+
+  describe 'on an Appium native context' do
+    let(:appium) { Class.new(Raider::Spec::FakeBridge) { def current_context = 'NATIVE_APP' }.new }
+    let(:native) { Selenium::WebDriver::Element.new(appium, 'e1') }
+
+    before { appium.answer(:element_displayed?, false, true).answer(:element_enabled?, false, true) }
+
+    it 'polls displayed and enabled, then clicks without a script call' do
+      native.click
+      expect(appium.calls).to include([:click_element, 'e1'])
+      expect(appium.script_calls).to be_empty
+    end
+
+    it 'clicks after one displayed call when forced' do
+      allow(native).to receive(:displayed?).and_return(false)
+      native.click(force: true)
+      expect(native).to have_received(:displayed?).once
+      expect(appium.calls).to include([:click_element, 'e1'])
+    end
+
+    it 'sends keys once ready' do
+      native.send_keys('a')
+      expect(appium.calls).to include([:send_keys_to_element, 'e1', ['a']])
+    end
+  end
+end

data/spec/runtime/browser/actionability_script_browser_spec.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../../lib/ruby_raider/runtime'
+require_relative '../support/browser'
+
+RSpec.describe 'Raider actionability script in a real browser', :browser do
+  let(:driver) { Raider::Spec::Browser.driver }
+  let(:click) { Raider::Actionability::CHECKS[:click] }
+  let(:send_keys) { Raider::Actionability::CHECKS[:send_keys] }
+
+  before { Raider::Spec::Browser.open('actionability.html') }
+
+  after(:all) { Raider::Spec::Browser.quit } # rubocop:disable RSpec/BeforeAfterAll
+
+  def element(id)
+    driver.find_element(id: id)
+  end
+
+  def run(id, checks)
+    driver.execute_script(Raider::Actionability::SCRIPT, element(id), checks)
+  end
+
+  # Stable needs a previous poll to compare with, so poll twice like the gate does.
+  def settled(id, checks)
+    run(id, checks)
+    run(id, checks)
+  end
+
+  it 'passes a plain button once it has been polled twice' do
+    expect(run('plain', click)).to eq('check' => 'stable', 'first' => true)
+    expect(run('plain', click)).to be_nil
+  end
+
+  it 'fails visible for display: none and visibility: hidden' do
+    expect(run('hidden-display', click)).to eq('check' => 'visible')
+    expect(run('hidden-visibility', click)).to eq('check' => 'visible')
+  end
+
+  it 'scrolls an off-screen button into view and passes' do
+    expect(settled('far', click)).to be_nil
+  end
+
+  it 'reports the overlay covering a button with integer coordinates' do
+    result = settled('covered', click)
+    expect(result['check']).to eq('events')
+    expect(result['covering']['element']).to eq('div#overlay')
+    expect(result['covering']['x']).to be_a(Integer)
+    expect(result['covering']['y']).to be_a(Integer)
+  end
+
+  it 'reports the sticky header covering a button after the script scrolls' do
+    result = settled('under-header', click)
+    expect(result['check']).to eq('events')
+    expect(result['covering']['element']).to eq('header#top')
+  end
+
+  it 'fails enabled for a disabled button and a button in a disabled fieldset' do
+    expect(run('disabled', click)).to eq('check' => 'enabled')
+    expect(run('in-fieldset', click)).to eq('check' => 'enabled')
+  end
+
+  it 'treats the first legend of a disabled fieldset as enabled' do
+    expect(settled('legend-button', click)).to be_nil
+  end
+
+  it 'fails editable for a readonly input and passes a writable one and contenteditable' do
+    expect(run('readonly', send_keys)).to eq('check' => 'editable')
+    expect(run('writable', send_keys)).to be_nil
+    expect(run('area', send_keys)).to be_nil
+    expect(run('editable', send_keys)).to be_nil
+  end
+
+  it 'passes editable for a button and the body, which keys such as Enter and Escape target' do
+    expect(run('plain', send_keys)).to be_nil
+    expect(driver.execute_script(Raider::Actionability::SCRIPT, driver.find_element(tag_name: 'body'), send_keys)).to be_nil
+  end
+
+  it 'fails inert inside an [inert] region' do
+    expect(run('in-inert', click)).to eq('check' => 'inert')
+  end
+
+  it 'fails inert outside an open modal dialog and passes inside it' do
+    driver.execute_script("document.getElementById('dlg').showModal()")
+    expect(run('outside-dialog', click)).to eq('check' => 'inert')
+    expect(settled('in-dialog', click)).to be_nil
+  end
+
+  it 'reports a moving button as not stable on consecutive polls' do
+    expect(run('moving', click)).to eq('check' => 'stable', 'first' => true)
+    sleep 0.1
+    expect(run('moving', click)).to eq('check' => 'stable')
+    sleep 0.1
+    expect(run('moving', click)).to eq('check' => 'stable')
+  end
+
+  it 'reports an element moving vertically in a scrollable page as not stable' do
+    expect(run('bouncer', click)).to eq('check' => 'stable', 'first' => true)
+    sleep 0.1
+    expect(run('bouncer', click)).to eq('check' => 'stable')
+    sleep 0.1
+    expect(run('bouncer', click)).to eq('check' => 'stable')
+  end
+
+  it 'passes a static button on the second poll' do
+    run('plain', click)
+    sleep 0.1
+    expect(run('plain', click)).to be_nil
+  end
+
+  it 'passes editable for a select' do
+    expect(run('choices', send_keys)).to be_nil
+  end
+
+  it 'fails visible for a file input inside a display: none container, except when typing a path' do
+    expect(run('file-hidden', %w[visible])).to eq('check' => 'visible')
+    expect(run('file-hidden', click)).to eq('check' => 'visible')
+    expect(run('file-hidden', send_keys)).to be_nil
+  end
+
+  it 'fails visible for a zero-sized button' do
+    expect(run('zero', click)).to eq('check' => 'visible')
+  end
+
+  it 'scrolls a button clipped inside an overflow container into view' do
+    expect(settled('deep', click)).to be_nil
+  end
+
+  it 'passes inert for a button in a shadow root inside the open modal dialog' do
+    driver.execute_script("document.getElementById('dlg').showModal()")
+    button = driver.execute_script("return document.getElementById('shadow-host').shadowRoot.getElementById('shadow-button')")
+    driver.execute_script(Raider::Actionability::SCRIPT, button, click)
+    expect(driver.execute_script(Raider::Actionability::SCRIPT, button, click)).to be_nil
+  end
+
+  it 'skips stable and events for an option' do
+    expect(run('opt-a', click)).to be_nil
+  end
+
+  it 'passes visible for a file input with an empty rect' do
+    expect(run('file', %w[visible])).to be_nil
+  end
+
+  it 'keeps the previous rect in a WeakMap and not on the element' do
+    run('plain', click)
+    expect(driver.execute_script('return typeof window.__raiderRects')).to eq('object')
+    expect(driver.execute_script("return '__raiderRect' in document.getElementById('plain')")).to be(false)
+    expect(driver.execute_script('return window.__raider === undefined')).to be(true)
+  end
+end

data/spec/runtime/browser/actionable_browser_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../../lib/ruby_raider/runtime'
+require_relative '../support/browser'
+
+RSpec.describe 'Raider::Actionable in a real browser', :browser do
+  let(:driver) { Raider::Spec::Browser.driver }
+
+  before do
+    Raider.reset
+    Raider.timeout = 1
+    Raider::Spec::Browser.open('actionability.html')
+  end
+
+  after { Raider.reset }
+
+  after(:all) { Raider::Spec::Browser.quit } # rubocop:disable RSpec/BeforeAfterAll
+
+  def element(id)
+    driver.find_element(id: id)
+  end
+
+  it 'refuses to click a button the overlay covers' do
+    expect { element('covered').click }
+      .to raise_error(Raider::NotActionable, /receive events; `div#overlay` covers it/)
+  end
+
+  it 'skips the checks with force: true and leaves the covered click to Selenium' do
+    expect { element('covered').click(force: true) }
+      .to raise_error(Selenium::WebDriver::Error::ElementClickInterceptedError)
+  end
+
+  it 'scrolls to and clicks an off-screen button' do
+    element('far').click
+    expect(element('far').attribute('data-clicked')).to eq('1')
+  end
+
+  it 'refuses a button in a disabled fieldset' do
+    expect { element('in-fieldset').click }.to raise_error(Raider::NotActionable, /to be enabled/)
+  end
+
+  it 'refuses a button inside a closed details' do
+    expect { element('in-details').click }.to raise_error(Raider::NotActionable, /to be visible/)
+  end
+
+  it 'names the sticky header covering a button' do
+    expect { element('under-header').click }.to raise_error(Raider::NotActionable, /`header#top` covers it/)
+  end
+
+  it 'refuses to type into a readonly input' do
+    expect { element('readonly').send_keys('x') }.to raise_error(Raider::NotActionable, /to be editable/)
+  end
+
+  it 'types into a contenteditable element' do
+    element('editable').send_keys('hello')
+    expect(element('editable').text).to include('hello')
+  end
+
+  it 'clicks a button clipped inside an overflow container' do
+    element('deep').click
+    expect(element('deep').attribute('data-clicked')).to eq('1')
+  end
+
+  it 'sends keys to the body' do
+    expect { driver.find_element(tag_name: 'body').send_keys(:escape) }.not_to raise_error
+  end
+
+  it 'refuses a moving button' do
+    expect { element('moving').click }.to raise_error(Raider::NotActionable, /to be stable/)
+  end
+
+  it 'lets Selenium select an option by text' do
+    Selenium::WebDriver::Support::Select.new(element('choices')).select_by(:text, 'Blue')
+    expect(element('choices').attribute('value')).to eq('blue')
+  end
+
+  it 'leaves the covered click to Selenium when actionability is off' do
+    Raider.actionability = false
+    expect { element('covered').click }.to raise_error(Selenium::WebDriver::Error::ElementClickInterceptedError)
+  end
+
+  it 'costs under 50 ms per first click on distinct visible buttons', :slow do
+    mean_ms = lambda do
+      Raider::Spec::Browser.open('actionability.html')
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      10.times { |index| element("m#{index}").click }
+      (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) / 10 * 1000
+    end
+    Raider.actionability = true
+    on_mean = mean_ms.call
+    Raider.actionability = false
+    off_mean = mean_ms.call
+    puts format('actionability on %<on>.1f ms, off %<off>.1f ms, difference %<diff>.1f ms per first click',
+                on: on_mean, off: off_mean, diff: on_mean - off_mean)
+    expect(on_mean - off_mean).to be < 50
+  end
+end