capybara-simulated 0.7.0 → 0.8.0

data/lib/capybara/simulated/v8_runtime.rb

@@ -364,6 +364,10 @@ module Capybara
       # Browser's `@current_realm_id` may still point at it; the Browser uses
       # this to raise a stale-element instead of running a frame handle op
       # against the main registry.
+      # Per-frame browsing contexts (nested realms for iframes / aux windows) are a V8-engine
+      # feature; QuickJS keeps a same-realm fallback. `within_frame` gates on this.
+      def supports_frames? = true
+
       # Ids of every live frame / window realm in this isolate (excludes the main
       # realm, id 0). Used to fan a BroadcastChannel post out to sibling realms.
       def frame_realm_ids = frame_realms.keys
@@ -440,10 +444,22 @@ module Capybara
       # keeps the new realm's `parent`/`top` wired to the owning realm. The
       # Browser then re-points the iframe element at the new id (`__csimRebindFrameRealm`).
       def reload_frame_realm(old_id, parent_id, url, body, content_type)
-        dispose_frame_realm(old_id)
+        # A re-navigated document discards its child browsing contexts, so dispose the old realm's
+        # DESCENDANT frame realms too — not just old_id. The JS src-reassignment path gets this for
+        # free (the old document's iframe elements go away → DOM-unregister disposes their realms);
+        # the Ruby reload path (navigate_realm_self_get/_post) rebuilds without that DOM teardown, so
+        # a descendant frame's realm would otherwise linger and its contentWindow stay live.
+        dispose_frame_realm_tree(old_id)
         create_frame_realm(ctx, url, body, content_type, parent_id)
       end
 
+      # Dispose a frame realm and every descendant frame realm (transitively), deepest first so a
+      # parent's child-realm set is consistent as each level is torn down.
+      def dispose_frame_realm_tree(id)
+        frame_realm_parents.select {|_child, parent| parent == id }.each_key {|child| dispose_frame_realm_tree(child) }
+        dispose_frame_realm(id)
+      end
+
       # Navigate a window realm (`win.location = …`): a FRESH realm for the new
       # document, like reload_frame_realm — an in-place `__csimLoadDocument` on an
       # already-loaded realm does NOT re-run inline scripts, but a fresh realm does.
@@ -452,7 +468,9 @@ module Capybara
       # the window after navigating it; a stable WindowProxy is future work.)
       def reload_window_realm(old_id, url, body, content_type)
         meta = window_realm_meta[old_id] || {}
-        dispose_frame_realm(old_id)
+        # Like reload_frame_realm, a re-navigated window discards its child browsing contexts — dispose
+        # the descendant frame realms too, not just old_id, so a popup's iframes don't linger.
+        dispose_frame_realm_tree(old_id)
         create_window_realm(url, body, content_type, opener_id: meta[:opener_id], window_name: meta[:window_name])
       end
 
@@ -463,6 +481,8 @@ module Capybara
         # The frame's browsing context is going away — revoke the blob URLs it
         # created (url-lifetime "Removing an iframe").
         @browser.revoke_realm_blobs(id) rescue nil
+        # Drop it from the SW Client registry so matchAll stops returning a dead client.
+        @browser.sw_unregister_client(id) rescue nil
         @realm_module_handles&.delete(id)
         @frame_realm_depths&.delete(id)
         @frame_realm_parents&.delete(id)
@@ -733,8 +753,8 @@ module Capybara
       # id (or nil on failure — then the bridge keeps its same-realm fallback).
       # The bridge maps `iframe.contentWindow` to `RustyRacer.contextGlobal(id)`.
       def attach_frame_realm_loader(c)
-        c.attach('__csim_createFrameRealm', ->(url, body, content_type, parent_id = 0, frame_name = nil, frame_doc_origin = nil, frame_location_origin = nil, js_url_source = nil) {
-          RuntimeShared.safe_call { create_frame_realm(c, url, body, content_type, parent_id, frame_name, frame_doc_origin, frame_location_origin, js_url_source) }
+        c.attach('__csim_createFrameRealm', ->(url, body, content_type, parent_id = 0, frame_name = nil, frame_doc_origin = nil, frame_location_origin = nil, js_url_source = nil, frame_about_base = nil) {
+          RuntimeShared.safe_call { create_frame_realm(c, url, body, content_type, parent_id, frame_name, frame_doc_origin, frame_location_origin, js_url_source, frame_about_base) }
         })
         # Re-navigating an iframe (src/srcdoc reassigned) builds a fresh realm;
         # the bridge calls this to tear down the superseded one so it doesn't
@@ -760,6 +780,15 @@ module Capybara
 
       def frame_realm_depths = (@frame_realm_depths ||= {})
 
+      # A frame whose document URL is opaque — about:blank (empty src), about:srcdoc,
+      # or empty — has no scope of its own; its controller is inherited from the
+      # creator. (create_frame_realm receives 'about:blank'/'about:srcdoc' as the url
+      # for these, seeded by __csimFrameWindow.)
+      def opaque_frame_url?(url)
+        u = url.to_s
+        u.empty? || u.start_with?('about:')
+      end
+
       # Bring a freshly-created realm context up to a runnable bridge, shared by the
       # frame and window realm constructors. Re-evaling the snapshot source would
       # redefine snapshot globals (e.g. the `scrollX` accessor) and throw, so only
@@ -777,7 +806,7 @@ module Capybara
         realm
       end
 
-      def create_frame_realm(parent_ctx, url, body, content_type, parent_id = 0, frame_name = nil, frame_doc_origin = nil, frame_location_origin = nil, js_url_source = nil)
+      def create_frame_realm(parent_ctx, url, body, content_type, parent_id = 0, frame_name = nil, frame_doc_origin = nil, frame_location_origin = nil, js_url_source = nil, frame_about_base = nil)
         depth = (frame_realm_depths[parent_id] || 0) + 1
         if depth > MAX_FRAME_DEPTH
           @browser.log_console('warn', "iframe nesting depth #{depth} exceeds #{MAX_FRAME_DEPTH}; not building #{url}")
@@ -836,6 +865,36 @@ module Capybara
         # The frame's location.origin (opaque "null" for about:blank / srcdoc /
         # javascript:); decoupled from the location string so navigation is intact.
         realm.call('__csimSetLocationOrigin', frame_location_origin.to_s) unless frame_location_origin.nil?
+        # An about:blank / about:srcdoc frame's URL is opaque, but its base URL (for
+        # relative-URL resolution) is INHERITED from the creator. Seed that inherited
+        # base BEFORE the document loads so its load-time scripts resolve relative URLs
+        # against the parent, even though location.href reports about:blank/srcdoc.
+        realm.call('__csimSetAboutBaseURL', frame_about_base.to_s) unless frame_about_base.to_s.empty?
+        # If a service worker's scope covers this frame's URL, the frame is a CONTROLLED client:
+        # wire its `navigator.serviceWorker.controller` BEFORE its document loads, so the frame's
+        # load-time scripts see the controller and route their subresource fetch() / XHR / EventSource
+        # through the SW's fetch event (fetch-event-network-error's controllee fires XHRs during load).
+        # The frame never called register(), so its per-realm registration Map is empty — set the
+        # controller directly from Ruby's scope→handle mirror. An OPAQUE child (about:blank / srcdoc)
+        # has no scope of its own, so it INHERITS its parent frame's controller (HTML: an about:blank
+        # document is controlled by its creator). Inheritance chains through controlled FRAME realms
+        # (sw_note_realm_controller); recording it BEFORE the load also lets a NESTED frame built during
+        # this frame's load inherit the controller.
+        opaque = opaque_frame_url?(url)
+        # A sandboxed frame WITHOUT allow-same-origin has an OPAQUE origin (doc origin 'null') and is
+        # cross-origin to its creator, so it does NOT inherit the creator's controller (srcdoc-iframe:
+        # "sandboxed srcdoc should not inherit"). allow-same-origin restores the parent origin → inherits.
+        inheritable = opaque && frame_doc_origin.to_s != 'null'
+        ctrl   = @browser.sw_client_controller_for(url.to_s)
+        ctrl ||= @browser.sw_inherited_controller_for(parent_id) if inheritable
+        if ctrl
+          realm.call('__csim_swSetControllerDirect', *ctrl)
+          # Only an OPAQUE (about:blank / srcdoc) frame is mirrored into the SW's clients.matchAll():
+          # a real-URL frame's registration would fire during its SYNCHRONOUS SW nav-fetch (main thread
+          # blocked on @sw_nav_outbox), perturbing worker timing — the http-src client model is deferred.
+          @browser.sw_note_realm_controller(realm.id, ctrl)
+          @browser.sw_register_client(realm.id, url.to_s, 'window', 'nested', ctrl[0]) if opaque
+        end
         realm.call('__csimLoadDocument', body.to_s, content_type.to_s)
         # A `javascript:` URL frame: the initial empty document is now loaded and
         # parent/top are wired, so evaluate the URL's script in the realm (global
@@ -1308,10 +1367,26 @@ module Capybara
       # the per-worker postMessage host fn closed over `post_back`.
       # Returns a uniform `WorkerRuntime` adapter that
       # `Browser#run_worker` drives.
-      def self.build_worker(browser, post_back)
+      def self.build_worker(browser, post_back, broadcast_out = nil, sw_hooks = {})
         c = Ctx.new(snapshot: snapshot)
         attach_host_fns(c, browser)
         c.attach('__csim_workerPostMessage', ->(data) { post_back.call(data); nil })
+        # Service-worker → main-thread signals route through the thread-safe outbox (delivered by
+        # deliver_worker_messages): client.postMessage, clients.claim (set the client's controller),
+        # and a controlled fetch's respondWith result. See run_worker for the closures.
+        c.attach('__csim_swPostToClient', ->(client_id, data) { sw_hooks[:post_to_client]&.call(client_id, data); nil }) if sw_hooks[:post_to_client]
+        c.attach('__csim_swClaim',        ->                  { sw_hooks[:claim]&.call; nil }) if sw_hooks[:claim]
+        c.attach('__csim_swFetchRespond', ->(fetch_id, resp, realm_id) { sw_hooks[:fetch_respond]&.call(fetch_id, resp, realm_id); nil }) if sw_hooks[:fetch_respond]
+        c.attach('__csim_swFetchStream',  ->(fetch_id, kind, payload, realm_id) { sw_hooks[:fetch_stream]&.call(fetch_id, kind, payload, realm_id); nil }) if sw_hooks[:fetch_stream]
+        # Cross-isolate MessagePort channel signals (a worker/SW port endpoint + its outbound messages).
+        c.attach('__csim_workerPortPost',     ->(channel, data) { sw_hooks[:port_post]&.call(channel, data); nil }) if sw_hooks[:port_post]
+        c.attach('__csim_workerPortEndpoint', ->(channel)       { sw_hooks[:port_endpoint]&.call(channel); nil }) if sw_hooks[:port_endpoint]
+        # A worker is a SEPARATE isolate: its BroadcastChannel fan-out to the main + frame realms +
+        # other workers can't run `browser.broadcast_to_windows` inline (that would mutate the main
+        # browser's inbox from the worker thread). Route it through the thread-safe outbox instead
+        # (the shared BROWSER_HOST_FNS `__csimBroadcast` above, bound to `browser`, is overridden
+        # here). Same-worker-context delivery already happened in-VM via `_bcChannels`.
+        c.attach('__csimBroadcast', ->(name, data, _rid, origin) { broadcast_out&.call(name, data, origin); nil }) if broadcast_out
         # Worker's timer table is independent from main's; routing the
         # worker's `setTimersActive` through `browser.timers_active=`
         # races the main isolate's polling? gate, dropping main-thread

data/lib/capybara/simulated/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Simulated
-    VERSION = '0.7.0'
+    VERSION = '0.8.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-simulated
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Keita Urashima
@@ -112,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Lightweight Capybara driver with an in-process JS-resident DOM, Chrome-free
 test_files: []