ruby_raider 3.13.0 → 4.0.0

data/spec/runtime/role_query_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/ruby_raider/runtime'
+require_relative 'support/fake_bridge'
+
+RSpec.describe 'Raider::RoleQuery' do
+  let(:bridge) { Raider::Spec::FakeBridge.new }
+  let(:elements) { %w[a b] }
+  let(:missing) { Selenium::WebDriver::Error::JavascriptError.new('ReferenceError: window.__raider is undefined') }
+
+  it 'queries once when the engine is already installed' do
+    bridge.script_results << elements
+    expect(Raider::RoleQuery.run(bridge, nil, 'button', {})).to eq(elements)
+    expect(bridge.script_calls.length).to eq(1)
+    expect(bridge.script_calls.first.first).to eq(Raider::RoleFinder::QUERY)
+  end
+
+  it 'installs the engine once and re-runs the query when it is missing' do
+    bridge.script_results.push(missing, elements)
+    expect(Raider::RoleQuery.run(bridge, nil, 'button', {})).to eq(elements)
+    expect(bridge.script_calls.length).to eq(2)
+    expect(bridge.script_calls.last.first).to start_with(Raider::RoleFinder::ENGINE)
+    expect(bridge.script_calls.last.first).to end_with(Raider::RoleFinder::QUERY)
+  end
+
+  it 'installs the engine on the Chromium-style missing-engine error' do
+    bridge.script_results.push(Selenium::WebDriver::Error::JavascriptError.new('javascript error: __raider not installed'),
+                               elements)
+    expect(Raider::RoleQuery.run(bridge, nil, 'button', {})).to eq(elements)
+    expect(bridge.script_calls.length).to eq(2)
+  end
+
+  it 'guards the query so a missing engine throws a fixed message' do
+    expect(Raider::RoleFinder::QUERY).to include('__raider not installed')
+  end
+
+  it 'does not retry beyond the install run' do
+    bridge.script_results.push(missing, missing)
+    expect { Raider::RoleQuery.run(bridge, nil, 'button', {}) }
+      .to raise_error(Selenium::WebDriver::Error::JavascriptError)
+    expect(bridge.script_calls.length).to eq(2)
+  end
+
+  it 'propagates an unrelated JavascriptError' do
+    bridge.script_results << Selenium::WebDriver::Error::JavascriptError.new('TypeError: boom')
+    expect { Raider::RoleQuery.run(bridge, nil, 'button', {}) }
+      .to raise_error(Selenium::WebDriver::Error::JavascriptError, /boom/)
+    expect(bridge.script_calls.length).to eq(1)
+  end
+
+  it 'passes the scope, role and camelCase options' do
+    bridge.script_results << elements
+    Raider::RoleQuery.run(bridge, :scope, 'link', name: 'Save', exact: true, include_hidden: true)
+    expect(bridge.script_calls.first.drop(1))
+      .to eq([:scope, 'link', { 'name' => 'Save', 'exact' => true, 'includeHidden' => true, 'level' => nil }])
+  end
+
+  it 'always carries all four option keys' do
+    bridge.script_results << elements
+    Raider::RoleQuery.run(bridge, nil, 'link', {})
+    expect(bridge.script_calls.first.last).to eq('name' => nil, 'exact' => false, 'includeHidden' => false,
+                                                 'level' => nil)
+  end
+
+  it 'carries the heading level' do
+    bridge.script_results << elements
+    Raider::RoleQuery.run(bridge, nil, 'heading', level: 3)
+    expect(bridge.script_calls.first.last).to include('level' => 3)
+  end
+
+  it 'exposes the engine source as a frozen string' do
+    expect(Raider::RoleFinder::ENGINE).to be_frozen.and include('__raider')
+  end
+end

data/spec/runtime/selectors_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/ruby_raider/runtime/selectors'
+
+RSpec.describe 'Raider::Selectors' do
+  let(:controls) do
+    '(self::input or self::textarea or self::select or self::button or ' \
+      "self::meter or self::output or self::progress) and not(self::input[@type='hidden'])"
+  end
+  let(:excluded) do
+    'not(self::script or self::style or self::noscript or self::template or self::title or self::head) ' \
+      'and not(ancestor::head)'
+  end
+
+  describe '.xpath_literal' do
+    it 'single-quotes a value without single quotes' do
+      expect(Raider::Selectors.xpath_literal('Sign in')).to eq("'Sign in'")
+    end
+
+    it 'double-quotes a value with only single quotes' do
+      expect(Raider::Selectors.xpath_literal("O'Neil")).to eq(%q("O'Neil"))
+    end
+
+    it 'single-quotes a value with only double quotes' do
+      expect(Raider::Selectors.xpath_literal('say "hi"')).to eq(%q('say "hi"'))
+    end
+
+    it 'uses concat when both quote kinds appear' do
+      expect(Raider::Selectors.xpath_literal(%q(O'Neil "the" boss)))
+        .to eq(%q(concat('O', "'", 'Neil "the" boss')))
+    end
+
+    it 'handles leading, trailing and repeated single quotes with concat' do
+      expect(Raider::Selectors.xpath_literal(%q('a''"b')))
+        .to eq(%q(concat('', "'", 'a', "'", '', "'", '"b', "'", '')))
+    end
+
+    it 'converts non-strings with to_s' do
+      expect(Raider::Selectors.xpath_literal(42)).to eq("'42'")
+    end
+  end
+
+  describe '.label' do
+    it 'builds the contains union by default' do
+      expect(Raider::Selectors.label('Email', exact: false)).to eq(
+        ".//*[@id = //label[contains(normalize-space(.), 'Email')]/@for] | " \
+        ".//label[contains(normalize-space(.), 'Email')]//*[#{controls}] | " \
+        ".//*[contains(normalize-space(@aria-label), 'Email')] | " \
+        ".//*[@aria-labelledby and contains(normalize-space(string(id(@aria-labelledby))), 'Email')]"
+      )
+    end
+
+    it 'builds the equality union with exact: true' do
+      expect(Raider::Selectors.label('Email', exact: true)).to eq(
+        ".//*[@id = //label[normalize-space(.) = 'Email']/@for] | " \
+        ".//label[normalize-space(.) = 'Email']//*[#{controls}] | " \
+        ".//*[normalize-space(@aria-label) = 'Email'] | " \
+        ".//*[@aria-labelledby and normalize-space(string(id(@aria-labelledby))) = 'Email']"
+      )
+    end
+
+    it 'does not let a quote break out of the literal' do
+      xpath = Raider::Selectors.label("x'] | //*['", exact: false)
+      expect(xpath).to include(%q("x'] | //*['"))
+    end
+  end
+
+  describe '.text' do
+    it 'builds the innermost-match xpath' do
+      expect(Raider::Selectors.text('Sign in', exact: false)).to eq(
+        ".//*[#{excluded} and contains(normalize-space(.), 'Sign in') and " \
+        "not(.//*[#{excluded} and contains(normalize-space(.), 'Sign in')])]"
+      )
+    end
+
+    it 'uses equality with exact: true' do
+      expect(Raider::Selectors.text('Sign in', exact: true)).to eq(
+        ".//*[#{excluded} and normalize-space(.) = 'Sign in' and " \
+        "not(.//*[#{excluded} and normalize-space(.) = 'Sign in'])]"
+      )
+    end
+
+    it 'uses concat for a value with both quote kinds' do
+      literal = %q(concat('O', "'", 'Neil "the" boss'))
+      expect(Raider::Selectors.text(%q(O'Neil "the" boss), exact: false)).to eq(
+        ".//*[#{excluded} and contains(normalize-space(.), #{literal}) and " \
+        "not(.//*[#{excluded} and contains(normalize-space(.), #{literal})])]"
+      )
+    end
+
+    it 'single-quotes a value with only double quotes' do
+      expect(Raider::Selectors.text('say "hi"', exact: true)).to include(%q(= 'say "hi"'))
+    end
+  end
+
+  describe '.attribute_css' do
+    it 'escapes the inner quote for a contains match' do
+      expect(Raider::Selectors.attribute_css('placeholder', 'a[b]"c', exact: false))
+        .to eq('[placeholder*="a[b]\"c"]')
+    end
+
+    it 'uses equality when exact' do
+      expect(Raider::Selectors.attribute_css('title', 'Hi', exact: true)).to eq('[title="Hi"]')
+    end
+
+    it 'escapes backslashes before quotes' do
+      expect(Raider::Selectors.attribute_css('alt', 'a\\"b', exact: true))
+        .to eq('[alt="a\\\\\\"b"]')
+    end
+
+    it 'rejects an invalid attribute name' do
+      expect { Raider::Selectors.attribute_css('a]b', 'x', exact: true) }
+        .to raise_error(ArgumentError, 'invalid attribute name: a]b')
+    end
+  end
+
+  describe '.test_id' do
+    after { Raider.reset }
+
+    it 'uses the default attribute' do
+      expect(Raider::Selectors.test_id('x')).to eq('[data-testid="x"]')
+    end
+
+    it 'uses a configured attribute' do
+      Raider.test_id_attribute = 'data-qa'
+      expect(Raider::Selectors.test_id('x')).to eq('[data-qa="x"]')
+    end
+
+    it 'rejects a configured attribute that is not a plain name' do
+      Raider.test_id_attribute = 'data-qa]'
+      expect { Raider::Selectors.test_id('x') }.to raise_error(ArgumentError, /invalid attribute name/)
+    end
+  end
+end

data/spec/runtime/strict_spec.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/ruby_raider/runtime'
+require_relative 'support/fake_bridge'
+
+RSpec.describe 'Raider strict find_element' do
+  let(:bridge) { Raider::Spec::FakeBridge.new }
+  let(:driver) { Raider::Spec.driver(bridge) }
+
+  before { allow(Raider::Describe).to receive(:element) { |element| "<el #{element.ref.last}>" } }
+
+  after { Raider.reset }
+
+  it 'raises AmbiguousMatch listing both matches' do
+    bridge.enqueue(%w[a b])
+    expect { driver.find_element(label: 'Email') }.to raise_error(Raider::AmbiguousMatch) { |error|
+      expect(error.message).to include('label: "Email"')
+      expect(error.message).to include('matched 2 elements', '<el a>', '<el b>')
+    }
+  end
+
+  it 'returns the single match through one find_elements_by call' do
+    bridge.enqueue(['a'])
+    expect(driver.find_element(label: 'Email')).to be_a(Selenium::WebDriver::Element)
+    expect(bridge.calls.map(&:first)).to eq([:find_elements_by])
+  end
+
+  it 'raises NoSuchElementError when nothing matches' do
+    Raider.timeout = 0
+    expect { driver.find_element(label: 'Email') }
+      .to raise_error(Selenium::WebDriver::Error::NoSuchElementError, /no such element: \{ label: "Email" \}/)
+  end
+
+  it 'goes back to find_element_by when strict is off' do
+    Raider.strict = false
+    bridge.enqueue(['a'])
+    driver.find_element(label: 'Email')
+    expect(bridge.calls.map(&:first)).to eq([:find_element_by])
+  end
+
+  it 'passes the element ref through for an element scope' do
+    bridge.enqueue(['a'])
+    Selenium::WebDriver::Element.new(bridge, 'root').find_element(label: 'Email')
+    expect(bridge.calls.last).to end_with([:element, 'root'])
+    expect(bridge.calls.last.first).to eq(:find_elements_by)
+  end
+
+  it 'makes driver.first strict' do
+    bridge.enqueue(%w[a b])
+    expect { driver.first(label: 'Email') }.to raise_error(Raider::AmbiguousMatch)
+    expect(bridge.calls.map(&:first)).to eq([:find_elements_by])
+  end
+
+  it 'makes element.first strict' do
+    bridge.enqueue(%w[a b])
+    expect { Selenium::WebDriver::Element.new(bridge, 'root').first(label: 'Email') }.to raise_error(Raider::AmbiguousMatch)
+    expect(bridge.calls.map(&:first)).to eq([:find_elements_by])
+  end
+
+  it 'sends driver.first back to find_element_by when strict is off' do
+    Raider.strict = false
+    bridge.enqueue(['a'])
+    driver.first(label: 'Email')
+    expect(bridge.calls.map(&:first)).to eq([:find_element_by])
+  end
+
+  it 'returns find_elements results that already match without waiting' do
+    bridge.enqueue(%w[a b])
+    expect(driver.find_elements(label: 'Email').size).to eq(2)
+  end
+
+  describe 'waiting for a match' do
+    def find_calls(command = :find_elements_by)
+      bridge.calls.count { |call| call.first == command }
+    end
+
+    it 'returns the element once it shows up, after three calls' do
+      bridge.enqueue([])
+      bridge.enqueue([])
+      bridge.enqueue(['a'])
+      expect(driver.find_element(id: 'x')).to be_a(Selenium::WebDriver::Element)
+      expect(find_calls).to eq(3)
+    end
+
+    it 'raises NoSuchElementError naming the wait when nothing ever matches' do
+      Raider.timeout = 0.3
+      expect { driver.find_element(id: 'x') }
+        .to raise_error(Selenium::WebDriver::Error::NoSuchElementError, /no such element: \{ id: "x" \} \(waited 0\.[34]\d?s\)/)
+    end
+
+    it 'waits the same way when strict is off' do
+      Raider.strict = false
+      Raider.timeout = 0.3
+      expect { driver.find_element(id: 'x') }
+        .to raise_error(Selenium::WebDriver::Error::NoSuchElementError, /\(waited 0\.[34]\d?s\)/)
+      expect(find_calls(:find_element_by)).to be >= 3
+    end
+
+    it 'raises AmbiguousMatch on the first call' do
+      bridge.enqueue(%w[a b])
+      expect { driver.find_element(id: 'x') }.to raise_error(Raider::AmbiguousMatch)
+      expect(find_calls).to eq(1)
+    end
+
+    it 'returns the elements of find_elements once they show up, after three calls' do
+      bridge.enqueue([])
+      bridge.enqueue([])
+      bridge.enqueue(%w[a b])
+      expect(driver.find_elements(css: '.row').size).to eq(2)
+      expect(find_calls).to eq(3)
+    end
+
+    it 'returns [] from find_elements after about the timeout' do
+      Raider.timeout = 0.3
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      expect(driver.find_elements(css: '.row')).to eq([])
+      expect(Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).to be_between(0.25, 0.6)
+    end
+
+    it 'makes one call per find inside Wait.immediately' do
+      Raider.timeout = 5
+      Raider::Wait.immediately do
+        expect(driver.find_elements(css: '.row')).to eq([])
+        expect { driver.find_element(id: 'x') }.to raise_error(Selenium::WebDriver::Error::NoSuchElementError)
+      end
+      expect(bridge.calls.map(&:first)).to eq(%i[find_elements_by find_elements_by])
+    end
+
+    it 'makes one call per find on the native path inside Wait.immediately' do
+      Raider.strict = false
+      Raider::Wait.immediately do
+        expect { driver.find_element(id: 'x') }.to raise_error(Selenium::WebDriver::Error::NoSuchElementError)
+      end
+      expect(bridge.calls.map(&:first)).to eq([:find_element_by])
+    end
+  end
+
+  context 'with an Appium bridge' do
+    let(:context_name) { 'NATIVE_APP' }
+    let(:bridge) do
+      name = context_name
+      klass = stub_const('Appium::Core::Base::Bridge', Class.new(Raider::Spec::FakeBridge) do
+        class << self; attr_accessor :locator_converter; end
+        define_method(:current_context) { name }
+      end)
+      klass.locator_converter = Selenium::WebDriver::Remote::Bridge::LocatorConverter.new
+      klass.new
+    end
+
+    it 'does not apply strictness on NATIVE_APP' do
+      bridge.enqueue(%w[a b])
+      driver.find_element(id: 'x')
+      expect(bridge.calls.map(&:first)).to eq([:find_element_by])
+    end
+
+    it 'waits for a match on NATIVE_APP too' do
+      Raider.timeout = 0.3
+      bridge.enqueue([])
+      bridge.enqueue(['a'])
+      expect(driver.find_element(id: 'x')).to be_a(Selenium::WebDriver::Element)
+      expect { driver.find_element(id: 'gone') }
+        .to raise_error(Selenium::WebDriver::Error::NoSuchElementError, /\(waited 0\.[34]\d?s\)/)
+      expect(driver.find_elements(id: 'gone')).to eq([])
+    end
+
+    it 'reports the elapsed wait, not the timeout, inside a shorter enclosing wait' do
+      Raider.timeout = 5
+      expect { Raider::Wait.until(timeout: 0.2) { driver.find_element(id: 'x') } }
+        .to raise_error(Selenium::WebDriver::Error::NoSuchElementError, /\(waited 0\.[23]\d?s\)/)
+    end
+
+    it 'raises NotSupported at once for a role find on NATIVE_APP' do
+      Raider.timeout = 5
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      expect { driver.find_element(role: 'button') }.to raise_error(Raider::NotSupported)
+      expect(Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).to be < 1
+    end
+
+    context 'in a webview' do
+      let(:context_name) { 'WEBVIEW_1' }
+
+      it 'applies strictness' do
+        bridge.enqueue(%w[a b])
+        expect { driver.find_element(id: 'x') }.to raise_error(Raider::AmbiguousMatch)
+      end
+
+      it 'asks for the context once on a strict role find' do
+        bridge.script_results << ['a']
+        allow(bridge).to receive(:current_context).and_call_original
+        driver.find_element(role: 'button')
+        expect(bridge).to have_received(:current_context).once
+      end
+
+      it 'asks for the context once on a strict role find that waits several polls' do
+        bridge.script_results.push([], [], ['a'])
+        allow(bridge).to receive(:current_context).and_call_original
+        driver.find_element(role: 'button')
+        expect(bridge).to have_received(:current_context).once
+      end
+
+      it 'asks for the context once on a non-strict role find that waits several polls' do
+        Raider.strict = false
+        bridge.script_results.push([], [], ['a'])
+        allow(bridge).to receive(:current_context).and_call_original
+        driver.find_element(role: 'button')
+        expect(bridge).to have_received(:current_context).once
+      end
+
+      it 'asks for the context once on a role find_elements that waits several polls' do
+        bridge.script_results.push([], [], ['a'])
+        allow(bridge).to receive(:current_context).and_call_original
+        expect(driver.find_elements(role: 'button').size).to eq(1)
+        expect(bridge).to have_received(:current_context).once
+      end
+
+      it 'asks for the context once on a strict css find' do
+        bridge.enqueue(['a'])
+        allow(bridge).to receive(:current_context).and_call_original
+        driver.find_element(css: 'x')
+        expect(bridge).to have_received(:current_context).once
+      end
+    end
+  end
+
+  describe Raider::Locator do
+    it 'describes a role with options as by_role' do
+      expect(described_class.describe([{ role: ['button', { name: 'Save' }] }])).to eq("by_role('button', name: \"Save\")")
+    end
+
+    it 'shows the heading level' do
+      expect(described_class.describe([Raider.by_role('heading', level: 2)])).to eq("by_role('heading', level: 2)")
+    end
+
+    it 'describes a role without options' do
+      expect(described_class.describe([{ role: ['button', {}] }])).to eq("by_role('button')")
+    end
+
+    it 'describes a plain key' do
+      expect(described_class.describe([{ label: 'Email' }])).to eq('{ label: "Email" }')
+    end
+
+    it 'shows exact when set' do
+      expect(described_class.describe([{ label: ['Email', { exact: true }] }])).to eq('{ label: "Email", exact: true }')
+    end
+
+    it 'describes the two-argument form' do
+      expect(described_class.describe(['css selector', '.a'])).to eq('{ "css selector": ".a" }')
+    end
+
+    it 'never raises on odd shapes' do
+      [[], [nil], [{ role: [] }], [{ role: 5 }], [1, 2, 3]].each do |args|
+        expect(described_class.describe(args)).to be_a(String)
+      end
+    end
+  end
+end

data/spec/runtime/support/browser.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'selenium-webdriver'
+
+module Raider
+  module Spec
+    # One headless Chrome per process, created after the runtime is required.
+    module Browser
+      FIXTURES_DIR = File.expand_path('../fixtures', __dir__)
+
+      module_function
+
+      def driver
+        @driver ||= Selenium::WebDriver.for(:chrome, options: options)
+      end
+
+      def fixture_url(fixture)
+        "file://#{File.expand_path(fixture, FIXTURES_DIR)}"
+      end
+
+      def open(fixture)
+        driver.navigate.to(fixture_url(fixture))
+      end
+
+      def bidi_driver
+        @bidi_driver ||= Selenium::WebDriver.for(:chrome, options: options.tap { |chrome| chrome.web_socket_url = true })
+      end
+
+      def quit_bidi
+        @bidi_driver&.quit
+        @bidi_driver = nil
+      end
+
+      def quit
+        @driver&.quit
+        @driver = nil
+      end
+
+      def options
+        Selenium::WebDriver::Chrome::Options.new.tap do |chrome|
+          %w[--headless=new --no-sandbox --disable-dev-shm-usage --window-size=1280,900].each do |flag|
+            chrome.add_argument(flag)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/runtime/support/fake_bridge.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'selenium-webdriver'
+
+module Raider
+  module Spec
+    # A stand-in for Selenium's remote bridge: converts locators the way a real
+    # bridge does, records what reaches the wire and answers from a script.
+    # :reek:TooManyInstanceVariables { max_instance_variables: 6 } -- a test double: one slot per wire recorder and answer channel
+    class FakeBridge
+      attr_reader :calls, :script_results, :script_calls
+
+      def initialize
+        @locator_converter = Selenium::WebDriver::Remote::Bridge.locator_converter
+        @calls = []
+        @queue = []
+        @script_results = []
+        @script_calls = []
+        @answers = Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      # Scripts per-poll answers for an element command; the last answer repeats.
+      # An Exception class or instance is raised instead of returned.
+      def answer(command, *values)
+        @answers[command].concat(values)
+        self
+      end
+
+      %i[element_text element_attribute element_displayed? element_enabled? element_selected?].each do |command|
+        define_method(command) { |*_args| next_answer(command) }
+      end
+
+      def enqueue(ids)
+        @queue << ids
+      end
+
+      def find_element_by(how, what, ref = [])
+        how, what = @locator_converter.convert(how, what)
+        calls << [:find_element_by, how, what, ref]
+        ids = @queue.shift || []
+        raise Selenium::WebDriver::Error::NoSuchElementError, 'no such element' if ids.empty?
+
+        wrap(ids.first)
+      end
+
+      def find_elements_by(how, what, ref = [])
+        how, what = @locator_converter.convert(how, what)
+        calls << [:find_elements_by, how, what, ref]
+        (@queue.shift || []).map { |id| wrap(id) }
+      end
+
+      def execute_script(script, *args)
+        script_calls << [script, *args]
+        result = script_results.shift
+        raise result if result.is_a?(Exception)
+
+        result
+      end
+
+      def click_element(id)
+        calls << [:click_element, id]
+      end
+
+      def send_keys_to_element(id, keys)
+        calls << [:send_keys_to_element, id, keys]
+      end
+
+      def clear_element(id)
+        calls << [:clear_element, id]
+      end
+
+      def submit_element(id)
+        calls << [:submit_element, id]
+      end
+
+      # Records the call; answers from the scripted channel, else raises so
+      # Describe.element falls back to <element>.
+      def element_tag_name(ref)
+        calls << [:element_tag_name, ref]
+        raise Selenium::WebDriver::Error::WebDriverError, 'no tag' if @answers[:element_tag_name].empty?
+
+        next_answer(:element_tag_name)
+      end
+
+      def element_class
+        Selenium::WebDriver::Element
+      end
+
+      private
+
+      def next_answer(command)
+        queue = @answers[command]
+        value = queue.size > 1 ? queue.shift : queue.first
+        raise value, 'scripted' if value.is_a?(Class) && value <= Exception
+
+        value
+      end
+
+      def wrap(id)
+        Selenium::WebDriver::Element.new(self, id)
+      end
+    end
+
+    # An initialized real bridge of klass, built without a network call: the
+    # initializer signature differs across selenium versions.
+    def self.real_bridge(klass)
+      keywords = Selenium::WebDriver::Remote::Bridge.instance_method(:initialize).parameters.map(&:last)
+      args = { http_client: Selenium::WebDriver::Remote::Http::Default.new }
+      args[:url] = 'http://127.0.0.1:4444/' if keywords.include?(:url)
+      klass.allocate.tap { |bridge| bridge.send(:initialize, **args) }
+    end
+
+    def self.driver(bridge)
+      Selenium::WebDriver::Driver.allocate.tap { |driver| driver.instance_variable_set(:@bridge, bridge) }
+    end
+  end
+end