capybara-simulated 0.7.0 → 0.9.0

data/lib/capybara/simulated/driver.rb

@@ -52,7 +52,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
@@ -71,7 +74,12 @@ module Capybara
         # level and inject them into every per-window Browser. Each
         # Browser still has its own sessionStorage + DOM + JS VM.
         @cookies         = {}
+        @auth_cache      = {}
         @local_storage   = {}
+        # Cache Storage (caches/Cache) is origin-shared like localStorage — owned at the
+        # Driver level and injected, so a service worker and every same-origin window see
+        # the same caches (partitioned by origin key within the store).
+        @cache_storage   = {}
         # Capture the universal-server flag ONCE, at session construction — the WPT
         # runner sets CSIM_LOCAL_ALL_HOSTS only while building the session, then
         # restores it. Every window (incl. aux windows opened later) inherits this so
@@ -100,7 +108,9 @@ module Capybara
                     driver:          self,
                     js_engine:       @js_engine,
                     cookies:         @cookies,
+                    auth_cache:      @auth_cache,
                     local_storage:   @local_storage,
+                    cache_storage:   @cache_storage,
                     all_hosts_local: @all_hosts_local)
       end
 
@@ -292,6 +302,29 @@ module Capybara
         @active_handle = nil
         @blob_partitions_lock.synchronize { @blob_partitions.clear }
       end
+
+      # Full teardown of the whole driver: aux windows AND the primary browser's
+      # V8 isolate. `reset_windows!` deliberately keeps the primary alive (the
+      # per-test reset path rebuilds only its page); this is for permanently
+      # DROPPING a session. A caller that nils its session without this leaks the
+      # primary isolate — with its heap, canvas pixel buffers, and worker threads —
+      # into V8Runtime's process-wide `@@live` until at_exit. The WPT runner recycles
+      # the cross-origin session per `.sub.`/`.https.` file, so that leak is ~one
+      # 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!
@@ -341,6 +374,12 @@ 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
@@ -404,7 +443,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
@@ -420,7 +459,7 @@ 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)
@@ -506,10 +545,30 @@ module Capybara
 
       # `BroadcastChannel.postMessage` — deliver to every OTHER window's channels
       # with the same name (same-window delivery is handled in-VM by the sender).
-      def broadcast_channel(source_browser, name, data)
+      def broadcast_channel(source_browser, name, data, origin = nil)
+        # An opaque origin is unique to its own agent cluster; its key is a token ('opaque:…') minted
+        # per-realm and therefore only unique WITHIN one isolate — two unrelated opaque contexts in
+        # DIFFERENT windows could mint the same token. A BroadcastChannel never bridges two distinct
+        # opaque origins, and no opaque origin spans separate top-level windows here, so a cross-
+        # WINDOW post from an opaque origin reaches no one: drop it rather than risk a cross-isolate
+        # token collision. (Same-isolate opaque peers are reached in-VM / via enqueue_broadcast; an
+        # inherited-origin blob worker via its own inbox — neither goes through this cross-window path.)
+        return if origin.to_s.start_with?('opaque:')
         window_entries.each do |w|
           next if w[:browser].equal?(source_browser)
-          w[:browser].enqueue_broadcast(name, data)
+          w[:browser].enqueue_broadcast(name, data, nil, origin)
+        end
+      end
+
+      # A localStorage change fans out to every OTHER window (localStorage spans same-origin
+      # browsing contexts). Every window shares the Driver's one `@local_storage` jar, so all
+      # windows are same-origin peers here (cross-origin storage partitioning is a separate
+      # backlog item); a nil source realm reaches each target's every realm. sessionStorage is
+      # per-context and never reaches this path.
+      def storage_broadcast(source_browser, kind, key, old, new, url)
+        window_entries.each do |w|
+          next if w[:browser].equal?(source_browser)
+          w[:browser].enqueue_storage_event(kind, key, old, new, url, nil)
         end
       end
 
@@ -593,7 +652,14 @@ 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|
@@ -614,19 +680,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))