capybara-simulated 0.8.0 → 0.10.0

data/lib/capybara/simulated/driver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'capybara/driver/base'
+require 'capybara/server/animation_disabler'
 require 'weakref'
 require_relative 'browser'
 require_relative 'node'
@@ -52,7 +53,10 @@ module Capybara
           @@live.select!(&:weakref_alive?)
           @@live.filter_map {|ref| ref.__getobj__ rescue nil }
         }
-        drivers.each {|d| yield d if d.owner_thread == thread }
+        # A DISPOSED driver is not live: its runtime context is gone, so calling into it raises
+        # (`undefined method 'call' for nil` out of `run_loop_step`). `dispose` deregisters, but the
+        # predicate is the belt — a WeakRef stays in the list until GC actually collects.
+        drivers.each {|d| yield d if d.owner_thread == thread && !d.disposed? }
       end
 
       # `viewport: [w, h]` and `user_agent:` (typically supplied via
@@ -64,13 +68,22 @@ module Capybara
       # loads. The Browser tracks both as "defaults" so `reset!`
       # (per-test teardown) restores them between specs.
       def initialize(app, js_engine: nil, viewport: nil, user_agent: nil)
-        @app             = app
+        # `Capybara.disable_animation` is delivered to the real drivers by a SERVER
+        # middleware (session.rb adds AnimationDisabler to the Puma stack), which
+        # injects `animation-duration: 0s !important` CSS into every HTML response.
+        # This driver calls the Rack app in-process and never builds that server, so
+        # the same wrap happens here — an app suite that turns animations off
+        # (Discourse's rails_helper) must see the same 0s durations a real browser
+        # run sees, or every `await`-on-animation close path (FloatKit's menu) parks
+        # on a full-length animation-fallback timer no user action waits for.
+        @app             = Capybara.disable_animation ? Capybara::Server::AnimationDisabler.new(app) : app
         @js_engine       = js_engine
         # Cookies + localStorage are origin-shared across windows
         # (real browser semantics), so we own the jars at the Driver
         # level and inject them into every per-window Browser. Each
         # Browser still has its own sessionStorage + DOM + JS VM.
         @cookies         = {}
+        @cookie_flags    = {}   # (host \0 name) => {secure: true} — attribute sidecar for the shared jar
         @auth_cache      = {}
         @local_storage   = {}
         # Cache Storage (caches/Cache) is origin-shared like localStorage — owned at the
@@ -85,6 +98,13 @@ module Capybara
         @browser         = build_window_browser
         @browser.window_handle = PRIMARY_HANDLE
         @aux_windows     = []  # [{handle:, browser:, name:, opener:}, …]
+        # Browsers whose WINDOW closed while they still host an active service-worker
+        # registration. A registration is profile-wide state independent of the document
+        # that created it (a page registers, closes, and the SW keeps controlling
+        # navigations elsewhere), so the Browser is parked — keeping its SW worker
+        # thread + scope registry alive for sw_navigation_fetch — instead of disposed.
+        # Reclaimed by reset_windows!.
+        @sw_parked       = []
         @active_handle   = nil
         @next_window_seq = 0
         # Driver-level blob URL partition map: url => {browser:, site:}. A blob URL's
@@ -105,6 +125,7 @@ module Capybara
                     driver:          self,
                     js_engine:       @js_engine,
                     cookies:         @cookies,
+                    cookie_flags:    @cookie_flags,
                     auth_cache:      @auth_cache,
                     local_storage:   @local_storage,
                     cache_storage:   @cache_storage,
@@ -123,6 +144,15 @@ module Capybara
         result
       end
 
+      # Which JS engine is behind this driver (`:v8` / `:quickjs`), for a trace's metadata.
+      def js_engine = browser.js_engine
+
+      # The ACTIVE window's page, painted for the trace's final state (`TracePersistence`) —
+      # `current_browser`, like every other user-facing read here, not the primary `browser`: a
+      # test that ended inside `switch_to_window` would otherwise be handed a picture of the
+      # window it was not looking at.
+      def trace_screenshot = current_browser.trace_screenshot
+
       def tracing?      = !current_trace.nil?
       def current_trace = browser.trace || browser.pending_trace
 
@@ -253,6 +283,16 @@ module Capybara
         state
       end
 
+      # Worker cross-thread work in flight in ANY window — the same aggregate scope
+      # as run_event_loop_frame's merged `async` (which folds every window in), so a
+      # caller distinguishing "waiting on a worker thread" from other async channels
+      # (the wpt_runner's clock-hold) sees a popup-hosted worker/SW round trip too,
+      # not just the active window's.
+      def worker_drive_pending?
+        return true if current_browser.worker_drive_pending?
+        @aux_windows.any? {|w| !w[:browser].equal?(current_browser) && w[:browser].worker_drive_pending? }
+      end
+
       # Fold an aux window's frame state into the running aggregate: any window that
       # progressed / has a queued rAF / has an async channel in flight keeps the
       # whole loop live, and `next_timer` becomes the nearest pending timer across
@@ -285,6 +325,27 @@ module Capybara
         browser.reset!
       end
 
+      # Start the next fetches from a cold HTTP cache. `reset!` keeps what a persistent
+      # browser profile would — fresh `Cache-Control: immutable` responses, plus the
+      # still-fresh script / stylesheet sources and @font-face files — so a test whose
+      # app serves new bytes at a cacheable URL it already served (a stylesheet digested
+      # from a DB row that a rolled-back example reuses) asks for the cold cache a fresh
+      # Playwright / Cuprite context starts with. Process-wide: every session shares the
+      # one cache (`Capybara::Simulated.clear_http_cache` is the same call for a hook
+      # that runs before any session exists).
+      def clear_http_cache = Browser.clear_http_cache
+
+      # Join every window's background app-request threads (async <img> loads,
+      # keepalive fetches) without resetting anything else. The test harness calls
+      # this ahead of the app's own after-hooks: cleanup that bypasses
+      # ActiveRecord's per-connection lock (Discourse's mini_sql `DB.exec`) must
+      # not interleave with a still-running background request on the same raw
+      # socket — `reset!`'s drain alone runs after those hooks.
+      def drain_background_requests
+        @aux_windows.each {|w| w[:browser].drain_app_request_threads rescue nil }
+        browser.drain_app_request_threads
+      end
+
       # Dispose every auxiliary window and return focus to the primary — a fresh
       # browsing context has no sibling windows. Disposing each aux Browser tears
       # down its worker / SSE / websocket threads and its V8 isolate eagerly; left
@@ -296,6 +357,8 @@ module Capybara
       def reset_windows!
         @aux_windows.each {|w| w[:browser].dispose rescue nil }
         @aux_windows.clear
+        @sw_parked.each {|b| b.dispose rescue nil }
+        @sw_parked.clear
         @active_handle = nil
         @blob_partitions_lock.synchronize { @blob_partitions.clear }
       end
@@ -310,9 +373,18 @@ module Capybara
       # isolate per cross-origin file (hundreds over the suite); disposing here
       # incrementally is what reset_windows! already does for aux windows.
       def dispose
+        return if @disposed
+        @disposed = true
+        # Drop out of the live registry FIRST: everything below tears down the runtime this driver
+        # would be asked to step if `each_live_on_thread` still yielded it.
+        @@live_lock.synchronize { @@live.reject! {|ref| (ref.__getobj__ rescue nil).equal?(self) } }
         reset_windows!
         @browser.dispose rescue nil
       end
+
+      # Has this driver been permanently dropped? (A `reset!` between examples does NOT set this —
+      # that rebuilds the page on a live runtime.)
+      def disposed? = @disposed == true
       def go_back              = current_browser.go_back
       def go_forward           = current_browser.go_forward
       def reset_history!       = current_browser.reset_history!
@@ -362,12 +434,23 @@ module Capybara
         window_entries.find {|w| w[:handle] == handle }&.fetch(:browser)
       end
 
+      # Same, but for the operations that ADDRESS a window rather than probe for one: a closed or
+      # unknown handle is Capybara's `WindowError`, never a silent fall back to the current window.
+      def window_browser!(handle)
+        window_browser(handle) or raise Capybara::WindowError, "Unknown window handle: #{handle}"
+      end
+
       # Open (or, by `name`, reuse) an auxiliary window. `target="_blank"`
       # clicks and `window.open` both land here. A non-empty `name` that
       # matches an existing window navigates that window instead of opening a
       # new one (HTML window-name targeting); `opener_handle` records the
       # opener so the new window's `window.opener` resolves back to it.
-      def open_aux_window(url = nil, name: nil, opener_handle: nil, source: nil, blob_snapshot: nil, post: nil, opener: false, referrer: nil)
+      # `defer_load`: the caller will fire the new window's `load` itself, one task
+      # later, so that a handler either side registers right after `window.open()` is
+      # in place first (platform-globals' `fireAuxLoadSoon`). ONLY the JS `window.open`
+      # path does that — a `target=_blank` click or `open_new_window` hands nobody a
+      # reference to hook, so their window announces its own load like any other.
+      def open_aux_window(url = nil, name: nil, opener_handle: nil, source: nil, blob_snapshot: nil, post: nil, opener: false, referrer: nil, defer_load: false)
         name = name.to_s
         # A blob: URL opened from a different storage partition is forced noopener
         # (cross-partition-navigation), overriding an explicit rel=opener — the new
@@ -379,7 +462,7 @@ module Capybara
         opener_handle ||= handle_for(source) if opener && source
         if !name.empty? && (existing = @aux_windows.find {|w| w[:name] == name })
           if post
-            existing[:browser].navigate_post(url, post[:body], post[:content_type], referer: referrer)
+            existing[:browser].navigate_post(url, post[:body], post[:content_type], referer: referrer, initiator: source&.raw_current_url)
           else
             navigate_window(existing[:browser], url, source: source)
           end
@@ -388,6 +471,7 @@ module Capybara
         @next_window_seq += 1
         handle = "csim-window-#{@next_window_seq}"
         aux = build_window_browser
+        aux.defer_window_load = defer_load
         aux.window_handle = handle
         # Register BEFORE visiting: the opened document's own boot scripts read
         # `window.opener`, which resolves through this entry — so the entry
@@ -397,7 +481,7 @@ module Capybara
           if post
             # A `<form target=_blank method=post>` loads the new window via POST,
             # carrying the opener's URL as referrer (unless rel=noreferrer → '').
-            aux.navigate_post(url, post[:body], post[:content_type], referer: referrer)
+            aux.navigate_post(url, post[:body], post[:content_type], referer: referrer, initiator: source&.raw_current_url)
           # A blob: URL isn't rack-navigable and its bytes live in the OPENER's
           # isolate — load the document directly from a click-time snapshot (a
           # deferred target=_blank nav may revoke the URL first) or, failing that,
@@ -405,7 +489,12 @@ module Capybara
           elsif !(url.to_s.start_with?('blob:') && load_blob_into_window(aux, url, source, snapshot: blob_snapshot))
             # A form submission carries a referrer (the opener's URL) unless the
             # form opted out via rel=noreferrer (referrer: '').
-            aux.visit(url, referer: referrer)
+            # The OPENER's document is the navigation initiator — it seeds the popup
+            # load's Sec-Fetch-Site (the SameSite cookie gate reads it).
+            # The OPENER's document is the navigation initiator — it seeds the popup
+            # load's Sec-Fetch-Site (the SameSite cookie gate reads it). raw_current_url:
+            # the ticking `current_url` must not run re-entrantly inside window.open.
+            aux.visit(url, referer: referrer, initiator: source&.raw_current_url)
           end
         end
         handle
@@ -425,7 +514,7 @@ module Capybara
 
       # `window.open(url, name)` from the `opener` window's JS. Resolves the URL
       # against the opener's document and records the opener relationship.
-      def open_window_from_js(opener_browser, url, name, opener_realm_id = 0)
+      def open_window_from_js(opener_browser, url, name, opener_realm_id = 0, about_base = nil, about_origin = nil)
         resolved = url.to_s.empty? ? nil : opener_browser.resolve_document_url(url)
         # Opening a blob: URL whose storage partition differs from the opener's
         # top-level site is forced NOOPENER (cross-partition-navigation): the new
@@ -441,10 +530,10 @@ module Capybara
         # cross-window scripting/adoption need no cross-isolate RPC. The opener's realm
         # id wires the popup's window.opener. Falls through to the separate-VM aux path
         # (cross-origin, or a URL we don't yet realm-load).
-        if (rid = opener_browser.open_window_realm(resolved, name: name, opener_realm_id: opener_realm_id))
+        if (rid = opener_browser.open_window_realm(resolved, name: name, opener_realm_id: opener_realm_id, about_base: about_base, about_origin: about_origin))
           return rid
         end
-        open_aux_window(resolved, name: name, opener_handle: handle_for(opener_browser), source: opener_browser)
+        open_aux_window(resolved, name: name, opener_handle: handle_for(opener_browser), source: opener_browser, defer_load: true)
       end
 
       # The storage-partition site a blob: URL was created in (its creator's top-level
@@ -518,11 +607,13 @@ module Capybara
         false
       end
 
-      # `targetWindow.postMessage(data, origin)` — queue on the target window's
-      # Browser, tagged with the source window's handle.
-      def window_post_message(source_browser, target_handle, data, _origin)
+      # `targetWindow.postMessage(data, targetOrigin)` — queue on the target window's
+      # Browser, tagged with the source window's handle. The targetOrigin travels with
+      # the message and gates delivery in the target VM (where its current origin is
+      # known); the sender's origin becomes the delivered event.origin.
+      def window_post_message(source_browser, target_handle, data, target_origin, sender_origin)
         target = window_browser(target_handle) or return
-        target.enqueue_window_message(data, _origin, handle_for(source_browser))
+        target.enqueue_window_message(data, target_origin, sender_origin, handle_for(source_browser))
       end
 
       # `BroadcastChannel.postMessage` — deliver to every OTHER window's channels
@@ -554,7 +645,9 @@ module Capybara
         end
       end
 
-      def window_location(handle)        = (window_browser(handle)&.current_url).to_s
+      # raw_: an identity read — this runs inside host-fn callbacks (a popup's boot
+      # script reading opener.location), where the ticking current_url must not re-enter.
+      def window_location(handle)        = (window_browser(handle)&.raw_current_url).to_s
       # A cross-window property read (`win.foo` / `win.document.foo`) — read the
       # primitive off the target window's VM.
       def window_read(handle, prop, doc: false)
@@ -623,7 +716,9 @@ module Capybara
         if browser.equal?(current_browser)
           browser.location_assign(url)
         else
-          browser.visit(url)
+          # A cross-window navigation's initiator is the SETTING window's document
+          # (seeds Sec-Fetch-Site → the SameSite cookie gate); raw_ — no re-entrant tick.
+          browser.visit(url, initiator: source&.raw_current_url)
         end
       end
 
@@ -634,18 +729,87 @@ module Capybara
       def open_new_window(_kind = :tab)
         open_aux_window('about:blank')
       end
-      def window_size(_)           = [current_browser.viewport_width, current_browser.viewport_height]
+      # Every window has its own viewport, so these address the window the
+      # handle names — not the active one. `Capybara::Window#resize_to` on a
+      # background window must resize THAT window and leave the current one
+      # (and Capybara's idea of which window is current) alone.
+      def window_size(handle)
+        b = window_browser!(handle)
+        [b.viewport_width, b.viewport_height]
+      end
       def close_window(h)
         return if h == PRIMARY_HANDLE
         @aux_windows.reject! {|w|
           next false unless w[:handle] == h
-          drop_blob_partitions_for(w[:browser])   # don't leave entries pointing at a disposed VM
-          w[:browser].dispose rescue nil
+          # HTML "close a browsing context": the teardown events (pagehide+unload,
+          # this window and every nested frame, parent-first) fire while the VM
+          # still works — a nested iframe's unload keepalive beacon depends on it.
+          w[:browser].fire_document_teardown if w[:browser].respond_to?(:fire_document_teardown)
+          if w[:browser].sw_registrations_active?
+            # Still hosting a live service-worker registration — park (see @sw_parked):
+            # tear down the document-scoped machinery, retire older parked browsers
+            # whose scopes this one re-registered (the newest registration for a scope
+            # is THE registration, as in a real profile), and keep the browser alive.
+            w[:browser].park_for_service_workers!
+            retire_shadowed_parked(w[:browser])
+            @sw_parked << w[:browser]
+          else
+            drop_blob_partitions_for(w[:browser])   # don't leave entries pointing at a disposed VM
+            w[:browser].dispose rescue nil
+          end
           true
         }
         @active_handle = nil if @active_handle == h
       end
 
+      # Dispose parked browsers whose live scopes are ALL re-registered by `newcomer` —
+      # their registrations are replaced, so keeping the old worker would let a stale
+      # SW shadow the new one in sw_navigation_fetch. A partially-overlapping parked
+      # browser stays (its non-shadowed scopes are still the live registrations; the
+      # newest-first search below picks the newcomer for the shared ones).
+      private def retire_shadowed_parked(newcomer)
+        fresh = newcomer.sw_live_scopes
+        @sw_parked.reject! {|b|
+          scopes = b.sw_live_scopes
+          next false if scopes.empty? || !(scopes - fresh).empty?
+          drop_blob_partitions_for(b)
+          b.dispose rescue nil
+          true
+        }
+      end
+
+      # Dispose parked browsers whose service workers have all died since parking
+      # (the SW unregistered itself / closed) — nothing routes to them anymore, and
+      # each pins a whole V8 isolate until reset otherwise.
+      private def sweep_dead_parked
+        @sw_parked.reject! {|b|
+          next false if b.sw_registrations_active?
+          drop_blob_partitions_for(b)
+          b.dispose rescue nil
+          true
+        }
+      end
+
+      # The fetch-event round-trip for a controlled NAVIGATION, resolved across the whole
+      # window set: a service-worker registration is profile-wide, so the Browser hosting
+      # the controlling SW may be any window's — or a parked one whose window already
+      # closed (searched newest-parked first: a re-registered scope's newest worker is
+      # the active registration). Returns the owner's respondWith wire hash, or nil
+      # (uncontrolled → load from the network).
+      def sw_navigation_fetch(url, **kw)
+        sweep_dead_parked
+        owner = ([@browser] + @aux_windows.map {|w| w[:browser] } + @sw_parked.reverse).find {|b|
+          b.sw_controls_navigation?(url)
+        }
+        return nil unless owner
+
+        resp = owner.service_worker_navigation_fetch(url, **kw)
+        # Nobody pumps a parked browser — drop what the handler queued for its dead
+        # clients so the outbox can't grow across a long test.
+        owner.drop_dead_letter_worker_messages if @sw_parked.include?(owner)
+        resp
+      end
+
       # Drop every blob-partition entry created by `browser` — its isolate is being
       # disposed, so the bytes are gone and the reference must not linger (a stale
       # entry would pin the dead Browser and route blob_bytes_for to a dead VM).
@@ -655,19 +819,23 @@ module Capybara
         end
       end
       def switch_to_window(h)
-        if h == PRIMARY_HANDLE
-          @active_handle = nil
-        elsif @aux_windows.any? {|w| w[:handle] == h }
-          @active_handle = h
-        else
-          raise Capybara::WindowError, "Unknown window handle: #{h}"
-        end
+        window_browser!(h)   # unknown / already-closed handle → WindowError
+        @active_handle = (h == PRIMARY_HANDLE ? nil : h)
       end
-      def resize_window_to(_, w, h) = current_browser.set_viewport(w, h)
+      def resize_window_to(handle, w, h) = window_browser!(handle).set_viewport(w, h)
       # Forem's ahoy-tracking spec calls `driver.resize(w, h)` directly
       # rather than through `current_window.resize_to`.
       def resize(w, h) = current_browser.set_viewport(w, h)
-      def maximize_window(_)       ; nil ; end
+      # Both restore the window to the display it lives on (`Browser#screen_size`), which is where
+      # it started — so they undo a `resize_to` rather than doing nothing. Coarse: we model no
+      # window chrome, so a maximized window and a fullscreen one end up the same size (a real
+      # browser's fullscreen is taller by the chrome it hides).
+      def maximize_window(handle)   = restore_window_size(handle)
+      def fullscreen_window(handle) = restore_window_size(handle)
+      private def restore_window_size(handle)
+        b = window_browser!(handle)
+        b.set_viewport(*b.screen_size)
+      end
 
       def evaluate_script(script, *args)
         unwrap(current_browser.evaluate_script(script, args))
@@ -699,11 +867,18 @@ module Capybara
         end
       end
 
-      def invalid_element_errors = [Capybara::Simulated::StaleElement]
+      def invalid_element_errors = [Capybara::Simulated::StaleElement, Capybara::Simulated::ClickIntercepted]
       def no_such_window_error   = Capybara::WindowError
 
-      def save_screenshot(path, **_opts)
-        File.write(path, current_browser.html.to_s)
+      # A real raster of the laid-out page (see js/src/paint.js), not a serialization of it: the
+      # painter reads the same boxes every geometry query reads, so a screenshot can only show
+      # what the driver already believes. `full: true` paints the whole document rather than the
+      # viewport.
+      def save_screenshot(path, full: false, **_opts)
+        data = current_browser.screenshot_png(full: full)
+        raise Capybara::Simulated::ScreenshotFailed, 'screenshot: the page painted nothing' if data.nil?
+
+        File.binwrite(path, data)
         path
       end
 

data/lib/capybara/simulated/errors.rb

@@ -10,11 +10,23 @@ module Capybara
     # cached element.
     class StaleElement < Capybara::ElementNotFound; end
 
+    # Raised when the click point's hit-test lands on an unrelated element
+    # painted over the target (WebDriver "element click intercepted") — a
+    # modal backdrop mid-exit, a full-page overlay. Listed as an
+    # `invalid_element_error`, so Capybara's `synchronize` retries the
+    # find+click until the obstruction is gone, exactly as it does for a
+    # real driver's ElementClickInterceptedError.
+    class ClickIntercepted < Capybara::ElementNotFound; end
+
     # Raised by `switch_to_frame` when the active JS engine can't give the
     # target `<iframe>` its own browsing context (a real per-frame realm).
     # Only the V8 engine (rusty_racer) builds per-frame realms; under
     # QuickJS the frame stays a same-realm fallback we can't route DOM ops
     # into, so `within_frame` is unsupported there.
     class FrameNotSupported < Capybara::NotSupportedByDriverError; end
+
+    # Raised by `save_screenshot` when the page could not be rastered — most often because
+    # `ruby-vips` (the rasteriser behind the whole canvas stack) isn't in the bundle.
+    class ScreenshotFailed < Capybara::CapybaraError; end
   end
 end