capybara-simulated 0.9.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'
@@ -67,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
@@ -88,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
@@ -108,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,
@@ -126,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
 
@@ -256,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
@@ -288,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
@@ -299,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
@@ -385,7 +445,12 @@ module Capybara
       # 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
@@ -397,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
@@ -406,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
@@ -415,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,
@@ -423,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
@@ -462,7 +533,7 @@ module Capybara
         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
@@ -536,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
@@ -572,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)
@@ -641,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
 
@@ -664,13 +741,75 @@ module Capybara
         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).
@@ -728,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