capybara-simulated 0.7.0 → 0.9.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
@@ -422,6 +426,12 @@ module Capybara
       # through its own navigation.
       def window_realm_meta = (@window_realm_meta ||= {})
 
+      # Is this realm a TOP-LEVEL browsing context? The main realm is, and so is an auxiliary
+      # window realm — `frame_realm_parents` records 0 for one because it has no parent FRAME,
+      # which is not the same as being nested in the main window. An ancestor walk (the focus
+      # chain, most of all) has to stop here rather than step into the opener.
+      def top_level_realm?(realm_id) = realm_id.to_i.zero? || window_realm_meta.key?(realm_id.to_i)
+
       def dispose_frame_realms
         @realm_module_handles&.clear
         @frame_realm_depths&.clear
@@ -440,10 +450,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,8 +474,14 @@ 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)
-        create_window_realm(url, body, content_type, opener_id: meta[:opener_id], window_name: meta[:window_name])
+        # 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],
+          about_base: meta[:about_base], about_origin: meta[:about_origin]
+        )
       end
 
       # Tear down a single frame realm (e.g. a descendant frame destroyed when an
@@ -463,6 +491,13 @@ 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
+        # A dedicated worker is owned by the context that created it — discarding the context
+        # terminates it (and unregisters its own client record).
+        @browser.terminate_realm_workers(id) rescue nil
+        # If it held the focus chain, focus returns to the top-level browsing context.
+        @browser.note_realm_discarded(id) rescue nil
         @realm_module_handles&.delete(id)
         @frame_realm_depths&.delete(id)
         @frame_realm_parents&.delete(id)
@@ -733,8 +768,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, frame_viewport = 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, frame_viewport) }
         })
         # 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 +795,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 +821,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, frame_viewport = 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}")
@@ -829,6 +873,11 @@ module Capybara
         # loads, so a frame whose load handler reads window.name to identify itself
         # (declarative-shadow declarative-child-frame) sees it.
         realm.call('__csimSetWindowName', frame_name.to_s) unless frame_name.nil?
+        # The frame's viewport is its container's content box, measured by the parent realm. Seed it
+        # BEFORE the document loads so load-time `innerWidth` reads and `@media` evaluation see the
+        # frame's own size rather than the top window's. `nil` = an unrendered container, which is a
+        # 0x0 window — pass it through rather than skipping, or the frame keeps the top-level size.
+        realm.call('__csimFrameViewportChanged', frame_viewport)
         # Seed the frame's document origin (opaque/inherited) BEFORE the document
         # loads, so its load-time scripts read the right self.origin. nil → a
         # real-URL frame whose origin is its own location origin.
@@ -836,7 +885,47 @@ 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'), which
+        # is cross-origin to everything — so it is NOT CONTROLLED AT ALL. It inherits no controller
+        # from its creator (srcdoc-iframe: "sandboxed srcdoc should not inherit"), its subresource
+        # fetches never reach the SW, and it is absent from `clients.matchAll()`. Excluding it from
+        # only the client registry would not hold: a controlled frame's first subresource fetch
+        # re-registers it lazily from the fetch event (js/src/workers.js clientFor). The SW does still
+        # answer its NAVIGATION request, because a CSP-header sandbox is knowable only FROM that
+        # response (sandboxed-iframe-fetch-event, "Service worker should NOT control the sandboxed
+        # page"). allow-same-origin restores the parent origin, and a real-URL frame carries no
+        # explicit origin at all (nil = its own location origin) — both are controlled normally.
+        if frame_doc_origin.to_s != 'null'
+          ctrl   = @browser.sw_client_controller_for(url.to_s)
+          ctrl ||= @browser.sw_inherited_controller_for(parent_id) if opaque
+          if ctrl
+            # Wiring the controller is what registers this frame as a client — the realm reports
+            # itself from installController (js/src/sw-client.js), before the document below loads.
+            realm.call('__csim_swSetControllerDirect', *ctrl)
+            @browser.sw_note_realm_controller(realm.id, ctrl)
+          end
+        end
         realm.call('__csimLoadDocument', body.to_s, content_type.to_s)
+        # This document now has a URL and any host-wired controller, so it can announce itself
+        # as a service-worker client — an UNCONTROLLED context is still a client of its origin
+        # and must show up in `matchAll({includeUncontrolled: true})`.
+        realm.call('__csim_swReportClient') rescue nil
         # 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
         # scope). Per HTML, only a STRING result navigates the frame to a new
@@ -885,7 +974,7 @@ module Capybara
       # a native `__csimFrameWindowProxyFor`, so `popup.document` is a real
       # same-isolate Document (cross-window adoptNode works). The single isolate also
       # makes a same-origin window far cheaper than today's isolate-per-window.
-      def create_window_realm(url, body, content_type, opener_id: nil, window_name: nil, doc_origin: nil, location_origin: nil)
+      def create_window_realm(url, body, content_type, opener_id: nil, window_name: nil, doc_origin: nil, location_origin: nil, about_base: nil, about_origin: nil)
         realm = seed_realm_bridge(ctx.create_context)
         # Mark it a top-level window realm so its location setter routes to
         # __csimWindowRealmNavigate (reload THIS realm) rather than the frame-nav or
@@ -917,7 +1006,21 @@ module Capybara
             }
           JS
         end
-        realm.call('__csimUpdateLocation', url.to_s)        unless url.to_s.empty?
+        # `window.open()` with no URL opens about:blank — that IS the new document's URL, and a
+        # realm built from the snapshot would otherwise keep reporting the OPENER's (making the
+        # popup a phantom duplicate of its opener everywhere a document URL is read, the service-
+        # worker client set included). Its ORIGIN and its BASE url are inherited from the opener,
+        # exactly as an empty <iframe>'s are (create_frame_realm's frame_about_base): the origin
+        # so the popup isn't cross-origin to the window that opened it, the base so relative
+        # resolution inside it still targets the opener's document.
+        if url.to_s.empty?
+          realm.call('__csimUpdateLocation', 'about:blank')
+          realm.call('__csimSetAboutBaseURL', about_base.to_s)   unless about_base.to_s.empty?
+          doc_origin      ||= about_origin unless about_origin.to_s.empty?
+          location_origin ||= about_origin unless about_origin.to_s.empty?
+        else
+          realm.call('__csimUpdateLocation', url.to_s)
+        end
         realm.call('__csimSetWindowName', window_name.to_s) unless window_name.nil?
         realm.call('__csimSetDocumentOrigin', doc_origin.to_s)         unless doc_origin.nil?
         realm.call('__csimSetLocationOrigin', location_origin.to_s)    unless location_origin.nil?
@@ -936,8 +1039,10 @@ module Capybara
         # Remember the window's opener / name so a self-navigation (reload_window_realm
         # builds a FRESH realm) can carry them across — a real popup keeps window.opener
         # and window.name through its own navigation.
-        window_realm_meta[realm.id] = {opener_id: opener_id, window_name: window_name}
+        window_realm_meta[realm.id] = {opener_id: opener_id, window_name: window_name, about_base: about_base, about_origin: about_origin}
         realm.call('__csimLoadDocument', body.to_s, content_type.to_s)
+        # As in create_frame_realm: an auxiliary window is a client of its origin too.
+        realm.call('__csim_swReportClient') rescue nil
         realm.call('__csimFireWindowLoad') rescue nil
         realm.id
       rescue StandardError => e
@@ -1308,10 +1413,29 @@ 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_swFocusClient',   ->(client_id)       { sw_hooks[:focus_client]&.call(client_id);       nil }) if sw_hooks[:focus_client]
+        c.attach('__csim_swNavigateClient', ->(client_id, url, nav_id) { sw_hooks[:navigate_client]&.call(client_id, url, nav_id); nil }) if sw_hooks[:navigate_client]
+        c.attach('__csim_swClaim',        ->                  { sw_hooks[:claim]&.call; nil }) if sw_hooks[:claim]
+        c.attach('__csim_swSkipWaitingRequest', ->             { sw_hooks[:skip_waiting]&.call; nil }) if sw_hooks[:skip_waiting]
+        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.9.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.9.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: []