ruby_raider 3.13.0 → 4.0.0

data/lib/generators/templates/helpers/trace_helper.tt

@@ -3,28 +3,28 @@
 require 'cgi/escape'
 require 'fileutils'
 require 'json'
+require 'ruby_raider/runtime'
 require 'selenium-webdriver'
 require 'tmpdir'
 require 'yaml'
 require 'zlib'
 
-# Records a trace of each test: one step per WaitHelper action and navigation, with
+# Records a trace of each test: one step per element action and navigation, with
 # a screenshot and the page HTML after each state-changing step. stop(keep: true)
 # writes it as trace.zip in the raider-trace v1 format, which Raider Desktop and
 # Hideout open. Any capture error prints one [trace] line and turns tracing off for
 # the rest of the run; it never raises into a test. Something only left out (a
 # screenshot, or network on a browser without BiDi) prints at most one notice. TRACE=off skips tracing and
 # TRACE=on keeps the trace of passing tests too.
-# The Recorder follows WaitHelper as its observer. Without helpers/wait_helper.rb a
-# trace records only navigation and the failure. Navigation comes from TraceHelper.listener,
+# The Recorder follows Raider.observer. Navigation comes from TraceHelper.listener,
 # and network and console from passive WebDriver BiDi events (chrome, edge and firefox).
 module TraceHelper
   DEFAULTS = { 'enabled' => true, 'max_steps' => 200, 'max_mb' => 20 }.freeze
   PRODUCER = { name: 'ruby_raider', version: '<%= ruby_raider_version %>' }.freeze
   # Only these get a screenshot and a snapshot; query actions cost almost nothing.
-  MEDIA_ACTIONS = %w[navigate click send_keys clear submit select_by hover drag_and_drop scroll_into_view].freeze
-  # Only these record what was typed or selected, as value (null when secret).
-  TYPED_ACTIONS = %w[send_keys select_by].freeze
+  MEDIA_ACTIONS = %w[navigate click send_keys clear submit].freeze
+  # Only these record what was typed, as value (null when secret).
+  TYPED_ACTIONS = %w[send_keys].freeze
   SECRET_ENV_PREFIX = 'RAIDER_SECRET_'
   # The driver helper sets web_socket_url for these while tracing is on.
   BIDI_BROWSERS = %w[chrome edge firefox].freeze
@@ -35,6 +35,7 @@ module TraceHelper
   @warned = false
   @disable_warned = false
   @active_recorder = nil
+  @flags = Mutex.new
 
   class << self
     attr_accessor :active_recorder
@@ -54,7 +55,7 @@ module TraceHelper
     # True while tracing is on for a browser that speaks WebDriver BiDi (Edge reports MicrosoftEdge).
     def bidi?(browser)
       name = browser.to_s.downcase.delete_prefix('microsoft')
-      enabled? && BIDI_BROWSERS.any? { |bidi_browser| name.start_with?(bidi_browser) }
+      enabled? && ENV['BIDI'].to_s.downcase != 'off' && BIDI_BROWSERS.any? { |bidi_browser| name.start_with?(bidi_browser) }
     end
 
     # Passed to Selenium through the driver helper's fan-out listener when the driver is created.
@@ -69,17 +70,19 @@ module TraceHelper
       return null_recorder unless enabled?
 
       recorder = Recorder.new(driver, screenshot: screenshot, snapshot: snapshot)
-      WaitHelper.observer = recorder if defined?(WaitHelper)
+      Raider.observer = recorder
+      # Lazy: the project may have removed network_helper.
+      NetworkHelper.observer = MockMarks if defined?(NetworkHelper)
       recorder
     rescue StandardError => e
       disable!("could not create a recorder: #{e.message}")
       null_recorder
     end
 
-    # Unhooks the recorder from WaitHelper and the navigation listener.
+    # Unhooks the recorder from Raider.observer and the navigation listener.
     def release(recorder)
       @active_recorder = nil if @active_recorder.equal?(recorder)
-      WaitHelper.observer = nil if defined?(WaitHelper) && WaitHelper.observer.equal?(recorder)
+      Raider.observer = nil if Raider.observer.equal?(recorder)
     end
 
     # The first reason tracing stopped always gets its own [trace] line, even after a notice.
@@ -87,22 +90,33 @@ module TraceHelper
       @disabled = true
       release(@active_recorder)
       detach_observer
-      return nil if @disable_warned
+      return nil unless claim(:@disable_warned)
 
-      @disable_warned = true
       say("#{reason}; tracing disabled for this run")
       nil
     end
 
     # At most one notice per run, for something left out of a trace while tracing goes on.
     def warn_once(message)
-      return nil if @warned
+      return nil unless claim(:@warned)
 
-      @warned = true
       say(message)
       nil
     end
 
+    # One notice per run for events dropped as malformed, apart from warn_once so neither hides the other.
+    def warn_dropped_event(message)
+      return nil unless claim(:@dropped_warned)
+
+      say(message)
+      nil
+    end
+
+    # A real number that is neither NaN nor infinite; a duration or a timestamp is built only from these.
+    def finite_number?(value)
+      value.is_a?(Numeric) && value.real? && value.finite?
+    end
+
     # Above 9999 is taken as 9999, silently; zero or less (or not a number) as the default.
     def max_steps
       value = config['max_steps'].to_i
@@ -141,7 +155,7 @@ module TraceHelper
     end
 
     def detach_observer
-      WaitHelper.observer = nil if defined?(WaitHelper) && WaitHelper.observer.is_a?(Recorder)
+      Raider.observer = nil if Raider.observer.is_a?(Recorder)
     end
 
     def trace_config
@@ -151,6 +165,15 @@ module TraceHelper
       {}
     end
 
+    # Atomically takes a once-only flag; true for the first caller only. Events arrive on websocket threads.
+    def claim(flag)
+      @flags.synchronize do
+        next false if instance_variable_get(flag)
+
+        instance_variable_set(flag, true)
+      end
+    end
+
     # $stderr.puts, not Kernel#warn: warn is silenced under -W0.
     # rubocop:disable Style/StderrPuts
     def say(message)
@@ -159,8 +182,40 @@ module TraceHelper
     # rubocop:enable Style/StderrPuts
   end
 
-  # One step of the timeline. parent is the enclosing group Step; the index is given
-  # when the trace is written, after max_steps and eventually have dropped steps.
+  # Where an action was called from, for the observer.
+  module Observation
+    # helpers/ by its given and its real path (__dir__ is the real one), and the runtime's own directory:
+    # the trace, driver and runtime files are never the line that called an action or a navigation.
+    HELPER_DIRS = [File.dirname(__FILE__), __dir__, Raider::Observer::LIB_DIR].uniq.map { |dir| File.join(dir, '') }.freeze
+
+    # The first frame outside helpers/, Ruby and gems, as { file:, line: } (file relative
+    # to the working directory when inside it), or nil.
+    def self.source
+      frame = caller_locations.find { |location| project?(location.absolute_path || location.path) }
+      return unless frame
+
+      { file: relative(frame.absolute_path || frame.path), line: frame.lineno }
+    end
+
+    def self.project?(path)
+      return false if path.start_with?('<internal:') || HELPER_DIRS.any? { |dir| path.start_with?(dir) }
+
+      library_paths.none? { |root| path.start_with?(root) }
+    end
+
+    def self.library_paths
+      @library_paths ||= [*RbConfig::CONFIG.values_at('rubylibdir', 'rubyarchdir'), *Gem.path]
+                         .compact.map { |dir| File.join(dir, '') }
+    end
+
+    def self.relative(path)
+      root = File.join(Dir.pwd, '')
+      path.start_with?(root) ? path.delete_prefix(root) : path
+    end
+  end
+
+  # One step of the timeline. parent is always nil (the v1 group kind stays readable but is no longer
+  # produced); the index is given when the trace is written, after max_steps has dropped steps.
   # element is the format's { tag, label, role }; secret is true, false, or nil while the field is unknown.
   Step = Struct.new(:seq, :parent, :kind, :action, :locator, :url, :page_title, :started_at, :clock, :duration_ms,
                     :waited_ms, :retries, :status, :error, :source, :rect, :screenshot, :snapshot, :element,
@@ -171,12 +226,6 @@ module TraceHelper
       self.duration_ms = ((TraceHelper.monotonic_now - clock) * 1000).round
     end
 
-    def within?(group)
-      step = parent
-      step = step.parent until step.nil? || step.equal?(group)
-      !step.nil?
-    end
-
     def as_json(index, parent_index, media)
       json = { index: index, parent_index: parent_index, kind: kind, action: action, locator: locator }
       json[:element] = element if element
@@ -194,11 +243,13 @@ module TraceHelper
     end
   end
 
-  # Follows a test: WaitHelper reports its actions (the observer protocol) and the
+  # Follows a test: the runtime reports element actions to Raider.observer and the
   # navigation listener calls navigated. Media goes to its own tmpdir until stop.
   # BiDi events arrive on Selenium's websocket threads, so the event lists are locked.
   class Recorder
     SNAPSHOT = :page_source.to_proc
+    # Requests awaiting their response, and responses awaiting their request: a page cannot grow either past this.
+    MAX_PENDING = 1_000
 
     attr_reader :dir, :capabilities
 
@@ -224,16 +275,30 @@ module TraceHelper
       discard
     end
 
-    # Returns the step as the token WaitHelper hands back. args: send_keys' keys or select_by's how and what.
-    # The locator has no label: a page object's element method has returned before the action runs.
-    def action_started(action:, locator:, within:, source:, args: nil)
+    # Returns the step as the token the runtime hands back (nil when not recording, so no ready or finished
+    # follows). args: send_keys' keys. The locator has no label: a page object's element method has returned
+    # before the action runs.
+    def action_started(action:, locator:, within:, args: nil)
       record('action') do
-        step = add(kind: 'action', action: action.to_s, locator: trace_locator(locator, within), source: source)
+        step = add(kind: 'action', action: action.to_s, locator: trace_locator(locator, within),
+                   source: TraceHelper::Observation.source)
         typed(step, Array(args)) if TYPED_ACTIONS.include?(step.action)
         step
       end
     end
 
+    # match_screenshot compared the page with a baseline. The PNG it took is the step's screenshot,
+    # so no second screenshot is taken.
+    def screenshot_compared(name:, status:, png:, error: nil)
+      record('action') do
+        step = add(kind: 'action', action: 'match_screenshot', locator: nil, source: navigation_source)
+        step.name = name
+        step.finish(status, error)
+        step.screenshot = media(step, 'screenshot') { [png, 'png'] }
+        nil
+      end
+    end
+
     # The element is ready and the action is about to run: its rect, what it is, and whether it is secret.
     # Query actions skip it, to stay cheap.
     def action_ready(step, element:)
@@ -254,49 +319,22 @@ module TraceHelper
       end
     end
 
-    def group_started(action:, source:)
-      record('group') do
-        group = add(kind: 'group', action: action.to_s, locator: nil, source: source)
-        @groups.push(group)
-        group
-      end
-    end
-
-    # A new pass of eventually: only the last pass's steps are kept, and the
-    # group's error is the last one an earlier pass raised.
-    def group_retried(group, error: nil)
-      record('group') do
-        dropped, @steps = @steps.partition { |step| step.within?(group) }
-        dropped.each { |step| delete_media(step) }
-        group.error = error
-        nil
-      end
-    end
-
-    def group_finished(group, status:, retries:, error:)
-      record('group') do
-        @groups.reject! { |open| open.equal?(group) }
-        group.finish(status, error || group.error)
-        group.retries = retries
+    # A navigation has begun. Its step stays pending until navigated, so the requests the page makes
+    # while loading are credited to it. A driver.get that fails never reaches navigated.
+    def navigating(url)
+      record('navigation') do
+        finish_navigation(:failed)
+        @navigation = add(kind: 'navigate', action: 'navigate', locator: nil, source: navigation_source)
+        @navigation.url = url if url
         nil
       end
     end
 
-    # A Cucumber step is a group named by its keyword and text; the actions it runs become its children.
-    def step_started(name:, source:)
-      group = group_started(action: :cucumber_step, source: source)
-      group.name = name if group.is_a?(Step)
-      group
-    end
-
-    def step_finished(group, status:, error:)
-      group_finished(group, status: status, retries: 0, error: error) if group.is_a?(Step)
-    end
-
     def navigated(url)
       record('navigation') do
-        step = add(kind: 'navigate', action: 'navigate', locator: nil, source: navigation_source)
-        step.url = url
+        step = @navigation || add(kind: 'navigate', action: 'navigate', locator: nil, source: navigation_source)
+        @navigation = nil
+        step.url = url if url
         step.finish(:passed, nil)
         capture_step_media(step)
         nil
@@ -320,6 +358,8 @@ module TraceHelper
         entry = event(:network, hash)
         early = @lock.synchronize do
           @requests[request] = [entry, at]
+          @requests.shift while @requests.size > MAX_PENDING
+          entry.update(@early_marks.delete(request) || {})
           @early.delete(request)
         end
         network_completed(request, *early) if early
@@ -331,13 +371,32 @@ module TraceHelper
     def network_completed(request, fields, at = nil)
       record('network') do
         entry, started = @lock.synchronize do
-          @requests.delete(request).tap { |found| @early[request] = [fields, at] unless found }
+          @requests.delete(request).tap { |found| remember_early(request, fields, at) unless found }
         end
         complete(entry, fields, at, started) if entry
         nil
       end
     end
 
+    # A mocked request, marked by NetworkHelper before it answers. The entry stays pending: its
+    # completion still arrives, and its status wins when it has one. A mark that comes before
+    # network_started is kept until the entry exists.
+    def network_marked(request, fields)
+      record('network') do
+        fields = fields.transform_keys(&:to_s)
+        @lock.synchronize do
+          entry = @requests[request]&.first
+          if entry
+            entry.update(fields)
+          else
+            @early_marks[request] = fields
+            @early_marks.shift while @early_marks.size > MAX_PENDING
+          end
+        end
+        nil
+      end
+    end
+
     # hash: a console[] entry of the format; step_index is filled in when written.
     def console_event(hash)
       record('console') do
@@ -371,6 +430,7 @@ module TraceHelper
       TraceHelper.release(self)
       return discard unless keep && TraceHelper.enabled?
 
+      finish_navigation(:failed, test[:error])
       failure(test[:error])
       write(test)
     rescue StandardError => e
@@ -390,11 +450,12 @@ module TraceHelper
 
     def reset
       @steps = []
-      @groups = []
+      @navigation = nil
       @lock.synchronize do
         @events = []
         @requests = {}
         @early = {}
+        @early_marks = {}
       end
       @bidi = false
       @seq = 0
@@ -418,7 +479,7 @@ module TraceHelper
     end
 
     # Runs a hook while recording. A hook that fails turns tracing off instead of
-    # raising into WaitHelper (which would warn a second time).
+    # raising into the runtime (which would warn a second time).
     def record(what)
       return nil unless @recording && TraceHelper.enabled?
 
@@ -428,8 +489,9 @@ module TraceHelper
     end
 
     def add(kind:, action:, locator:, source:)
+      finish_navigation(:failed) unless kind == 'navigate'
       @seq += 1
-      step = Step.new(seq: @seq, parent: @groups.last, kind: kind, action: action, locator: locator, source: source,
+      step = Step.new(seq: @seq, parent: nil, kind: kind, action: action, locator: locator, source: source,
                       url: @page[:url], page_title: @page[:page_title], started_at: TraceHelper.timestamp,
                       clock: TraceHelper.monotonic_now, waited_ms: 0, retries: 0)
       @steps << step
@@ -437,14 +499,35 @@ module TraceHelper
       step
     end
 
+    # A navigation still pending when the next step starts, or at stop, never completed. At stop the test's
+    # error goes to it, so failure does not add a second step for the same exception.
+    def finish_navigation(status, error = nil)
+      return unless @navigation
+
+      @navigation.finish(status, error)
+      @navigation = nil
+    end
+
     def drop_oldest_step
-      delete_media(@steps.shift)
+      step = @steps.shift
+      @navigation = nil if step.equal?(@navigation)
+      delete_media(step)
       @truncated[:steps] += 1
     end
 
+    # Called inside the lock.
+    def remember_early(request, fields, at)
+      @early[request] = [fields, at]
+      @early.shift while @early.size > MAX_PENDING
+    end
+
     def complete(entry, fields, finished, started)
-      fields = fields.merge(duration_ms: (finished - started).round) if finished.is_a?(Numeric) && started.is_a?(Numeric)
-      @lock.synchronize { entry.update(fields.transform_keys(&:to_s)) }
+      duration = finished - started if TraceHelper.finite_number?(finished) && TraceHelper.finite_number?(started)
+      fields = fields.merge(duration_ms: duration.round) if TraceHelper.finite_number?(duration)
+      @lock.synchronize do
+        fields = fields.reject { |key, value| key == :status && value.nil? && entry['status'] }
+        entry.update(fields.transform_keys(&:to_s))
+      end
     end
 
     # Returns the stored entry, which network_completed may still fill in.
@@ -463,12 +546,12 @@ module TraceHelper
     end
 
     def navigation_source
-      WaitHelper::Observation.source if defined?(WaitHelper::Observation)
+      TraceHelper::Observation.source
     end
 
-    # The value as typed: strings as they are, keys such as :enter as {enter}; select_by's what.
+    # The value as typed: strings as they are, keys such as :enter as {enter}.
     def typed(step, args)
-      shown = step.action == 'select_by' ? args.last.to_s : args.flatten.map { |key| key_name(key) }.join
+      shown = args.flatten.map { |key| key_name(key) }.join
       step.value = shown
       step.typed_strings = [shown, *args.flatten.grep(String)].reject(&:empty?).uniq
       step.secret = true if step.typed_strings.any? { |each_value| TraceHelper.secret_value?(each_value) }
@@ -526,7 +609,7 @@ module TraceHelper
     end
 
     # A test that raised outside every kept step gets a last failure step. Steps dropped by
-    # eventually or max_steps own nothing, so their error still gets a step.
+    # max_steps own nothing, so their error still gets a step.
     def failure(error)
       return if error.nil? || @steps.any? { |step| step.error.equal?(error) }
 
@@ -602,9 +685,13 @@ module TraceHelper
       { name: nil, version: nil }
     end
 
+    # The inner size: the outer window size includes the browser chrome, so it would not match
+    # the rects or the viewport screenshot.
     def viewport
-      size = @driver.manage.window.size
-      { width: size.width, height: size.height }
+      width, height = @driver.execute_script('return [window.innerWidth, window.innerHeight]')
+      return { width: nil, height: nil } unless width.is_a?(Numeric) && height.is_a?(Numeric)
+
+      { width: width, height: height }
     rescue StandardError
       { width: nil, height: nil }
     end
@@ -748,6 +835,10 @@ module TraceHelper
       nil
     end
 
+    def navigating(_url)
+      nil
+    end
+
     def navigated(_url)
       nil
     end
@@ -764,6 +855,10 @@ module TraceHelper
       nil
     end
 
+    def network_marked(_request, _fields)
+      nil
+    end
+
     def console_event(_hash)
       nil
     end
@@ -966,11 +1061,24 @@ module TraceHelper
   end
 end
 
-# What comes from the browser beside WaitHelper: navigation from Selenium's event listener,
+# What comes from the browser beside the element actions: navigation from Selenium's event listener,
 # network and console from WebDriver BiDi, and the screenshot.
 module TraceHelper
   # Selenium calls these after each navigation (through the driver helper's fan-out listener).
   class Listener < Selenium::WebDriver::Support::AbstractEventListener
+    # Before, so the requests of the load belong to the navigate step. If the navigation fails, after is never called.
+    def before_navigate_to(url, _driver)
+      navigating(url)
+    end
+
+    def before_navigate_back(_driver)
+      navigating(nil)
+    end
+
+    def before_navigate_forward(_driver)
+      navigating(nil)
+    end
+
     def after_navigate_to(url, _driver)
       navigated(url)
     end
@@ -986,12 +1094,28 @@ module TraceHelper
 
     private
 
+    def navigating(url)
+      TraceHelper.active_recorder&.navigating(url)
+      nil
+    end
+
     def navigated(url)
       TraceHelper.active_recorder&.navigated(url)
       nil
     end
   end
 
+  # NetworkHelper's observer: marks the trace entry of a request it answers without the network.
+  module MockMarks
+    def self.request_mocked(request_id:, redirect_count:, outcome:, status: nil)
+      fields = { mocked: outcome }
+      fields[:status] = status if status
+      TraceHelper.active_recorder&.network_marked([request_id, redirect_count], fields)
+    rescue StandardError => e
+      TraceHelper.warn_dropped_event("dropped a mocked-request mark: #{e.class}")
+    end
+  end
+
   # Passive BiDi: one session.subscribe per driver, never network.addIntercept, which would
   # pause every request. Events go to the recorder last attached to that driver. Only the
   # method, URL, status, MIME type, timing, size and error text are kept: no headers, no bodies.
@@ -1015,31 +1139,34 @@ module TraceHelper
     def self.subscribe(bidi)
       bidi.session.subscribe(HANDLERS.keys)
       link = Link.new
-      HANDLERS.each { |event, handler| bidi.add_callback(event) { |params| deliver(link, handler, params) } }
+      HANDLERS.each { |event, handler| bidi.add_callback(event) { |params| deliver(link, event, handler, params) } }
       link
     end
 
-    # On a websocket thread, which swallows errors: a failure is reported here.
-    def self.deliver(link, handler, params)
+    # On a websocket thread, which swallows errors. One event we cannot read is dropped with a notice;
+    # tracing carries on, since the next one is usually fine.
+    def self.deliver(link, event, handler, params)
       recorder = link.recorder
       send(handler, recorder, params) if recorder
     rescue StandardError => e
-      TraceHelper.disable!("network and console capture failed: #{e.message}")
+      TraceHelper.warn_dropped_event("dropped a malformed BiDi #{event} event: #{e.class}")
     end
 
     def self.request_sent(recorder, params)
-      request = params['request'] || {}
-      recorder.network_started(request['request'],
-                               { method: request['method'], url: request['url'], status: nil, mime_type: nil,
+      key = key(params)
+      request = params['request']
+      recorder.network_started(key,
+                               { method: scalar(request['method']), url: scalar(request['url']), status: nil, mime_type: nil,
                                  started_at: time(params['timestamp']), duration_ms: nil, bytes: nil, error: nil },
                                at: params['timestamp'])
     end
 
     def self.response_completed(recorder, params)
-      response = params['response'] || {}
-      recorder.network_completed(params.dig('request', 'request'),
-                                 { status: response['status'], mime_type: response['mimeType'],
-                                   bytes: response['bytesReceived'] || response['encodedDataLength'] },
+      key = key(params)
+      response = params['response'].is_a?(Hash) ? params['response'] : {}
+      recorder.network_completed(key,
+                                 { status: scalar(response['status']), mime_type: scalar(response['mimeType']),
+                                   bytes: scalar(response['bytesReceived'] || response['encodedDataLength']) },
                                  finished_at(params))
     end
 
@@ -1048,17 +1175,35 @@ module TraceHelper
     def self.finished_at(params)
       stamp = params['timestamp']
       origin, response_end = params.dig('request', 'timings')&.values_at('timeOrigin', 'responseEnd')
-      return stamp unless origin.is_a?(Numeric) && response_end.is_a?(Numeric) && response_end.positive?
+      return stamp unless TraceHelper.finite_number?(origin) && TraceHelper.finite_number?(response_end) && response_end.positive?
 
-      [stamp, origin + response_end].grep(Numeric).max
+      [stamp, origin + response_end].select { |ms| TraceHelper.finite_number?(ms) }.max
     end
 
     def self.fetch_error(recorder, params)
-      recorder.network_completed(params.dig('request', 'request'), { error: params['errorText'] }, params['timestamp'])
+      recorder.network_completed(key(params), { error: scalar(params['errorText']) }, params['timestamp'])
+    end
+
+    # A redirect keeps the request id and counts its hops, so the id alone would merge the hops.
+    # An event without an object request that has a string id is malformed: it raises, so deliver drops it.
+    def self.key(params)
+      request = params['request']
+      raise ArgumentError, 'request is not an object with a string id' unless request.is_a?(Hash) && request['request'].is_a?(String)
+
+      hop = params['redirectCount']
+      [request['request'], hop.is_a?(Integer) ? hop : 0]
+    end
+
+    # Only text, finite numbers, booleans and nil are kept from an event; a list or object becomes nil.
+    def self.scalar(value)
+      case value
+      when String, true, false, nil then value
+      when Numeric then value if TraceHelper.finite_number?(value)
+      end
     end
 
     def self.log_entry(recorder, params)
-      recorder.console_event(level: params['level'], text: params['text'], source: location(params),
+      recorder.console_event(level: scalar(params['level']), text: scalar(params['text']), source: location(params),
                              at: time(params['timestamp']))
     end
 
@@ -1070,7 +1215,7 @@ module TraceHelper
 
     # BiDi timestamps are epoch milliseconds.
     def self.time(milliseconds)
-      return TraceHelper.timestamp unless milliseconds.is_a?(Numeric)
+      return TraceHelper.timestamp unless TraceHelper.finite_number?(milliseconds)
 
       TraceHelper.timestamp(Time.at(Rational(milliseconds.to_i, 1000)))
     end

data/lib/generators/templates/helpers/video_helper.tt

@@ -69,7 +69,7 @@ module VideoHelper
       config['enabled'] != false && ENV['VIDEO'] != 'off' && !@disabled
     end
 
-    def recorder_for(driver_or_browser)
+    def recorder_for(driver)
 <%- if mobile? -%>
       return NullRecorder.new unless enabled?
 <%- else -%>
@@ -77,9 +77,9 @@ module VideoHelper
 <%- end -%>
 
 <%- if mobile? -%>
-      AppiumRecorder.new(driver_or_browser)
+      AppiumRecorder.new(driver)
 <%- else -%>
-      FrameRecorder.new(selenium_driver(driver_or_browser))
+      FrameRecorder.new(driver)
 <%- end -%>
     rescue StandardError => e
       disable!("could not create a recorder: #{e.message}")
@@ -186,11 +186,6 @@ module VideoHelper
     # rubocop:enable Style/StderrPuts
 <%- unless mobile? -%>
 
-    # Watir::Browser wraps the Selenium driver.
-    def selenium_driver(driver_or_browser)
-      driver_or_browser.respond_to?(:wd) ? driver_or_browser.wd : driver_or_browser
-    end
-
     # Decided once per process, at the first listener/recorder_for call, so a run
     # that can never get an ffmpeg warns at the start and pays no capture cost.
     def ffmpeg_obtainable?