capybara-simulated 0.6.0 → 0.8.0

data/lib/capybara/simulated/driver.rb

@@ -71,7 +71,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 +105,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
 
@@ -274,11 +281,37 @@ module Capybara
       def visit(path)          = current_browser.visit(path)
       def refresh              = current_browser.refresh
       def reset!
+        reset_windows!
+        browser.reset!
+      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
+      # alone they pile into V8Runtime's process-wide `@@live` set and are only
+      # reclaimed by the at_exit hook, which on a long-lived multi-file session
+      # (the WPT runner) means a slow — sometimes minutes-long — process exit. Split
+      # out of `reset!` so a caller can drop windows WITHOUT resetting the primary's
+      # page state (the WPT runner rebuilds the primary itself, per file, via visit).
+      def reset_windows!
         @aux_windows.each {|w| w[:browser].dispose rescue nil }
         @aux_windows.clear
         @active_handle = nil
         @blob_partitions_lock.synchronize { @blob_partitions.clear }
-        browser.reset!
+      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
+        reset_windows!
+        @browser.dispose rescue nil
       end
       def go_back              = current_browser.go_back
       def go_forward           = current_browser.go_forward
@@ -494,10 +527,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, 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_broadcast(name, data)
+          w[:browser].enqueue_storage_event(kind, key, old, new, url, nil)
         end
       end