capybara-simulated 0.1.1 → 0.2.0

data/lib/capybara/simulated/node.rb

@@ -17,9 +17,13 @@ module Capybara
         @browser      = driver.current_browser
         @initial_node = @browser.lookup_node(handle)
         @context_gen  = @browser.context_gen
+        # The frame realm this handle belongs to (nil = main document). Handle
+        # integers are per-realm, so a main-document node and a frame node can
+        # share an id — `==` includes the realm to keep them distinct.
+        @realm_id     = @browser.current_realm_id
       end
 
-      attr_reader :handle_id, :context_gen
+      attr_reader :handle_id, :context_gen, :realm_id
 
       # Tick the virtual clock unconditionally on the text path. Unlike
       # `Node#[]` (attribute reads), the text readers are NOT preceded by
@@ -211,13 +215,25 @@ module Capybara
       def ==(other)
         other.is_a?(Node) &&
           other.handle_id == @handle_id &&
-          other.context_gen == @context_gen
+          other.context_gen == @context_gen &&
+          other.realm_id == @realm_id
       end
 
       private
 
       def browser     = @browser
-      def check_stale = browser.check_stale(handle_id, @initial_node, @context_gen)
+      def check_stale
+        # Handle integers are per-realm. If the browser is no longer switched
+        # to this node's frame (block exited, or a different frame entered),
+        # routing its handle through `dom_call` would hit the wrong realm's
+        # registry — so treat a cross-realm access as stale, matching how real
+        # browsers invalidate frame element references after `switch_to_frame`.
+        if @realm_id != browser.current_realm_id
+          raise Capybara::Simulated::StaleElement,
+            'element belongs to a different browsing context than the active frame'
+        end
+        browser.check_stale(handle_id, @initial_node, @context_gen)
+      end
     end
   end
 end

data/lib/capybara/simulated/runtime_shared.rb

@@ -68,6 +68,16 @@ module Capybara
         '__csim_eventSourceClose'    => ->(b, *a) { b.event_source_close(a[0]); nil },
         '__csim_rackFetchAsync'      => ->(b, *a) { b.rack_fetch_async(a[0], a[1], a[2], a[3]) },
         '__csim_rackFetchAsyncAbort' => ->(b, *a) { b.rack_fetch_async_abort(a[0]); nil },
+        # Cross-window references (window.open / opener / postMessage). Each
+        # window is a separate VM, so these forward to the Driver to route to
+        # the target window's Browser.
+        '__csimWindowOpen'           => ->(b, *a) { b.open_child_window(a[0], a[1]) },
+        '__csimWindowPostMessage'    => ->(b, *a) { b.post_message_to_window(a[0], a[1], a[2]); nil },
+        '__csimWindowLocation'       => ->(b, *a) { b.window_location_of(a[0]) },
+        '__csimWindowSetLocation'    => ->(b, *a) { b.set_window_location(a[0], a[1]); nil },
+        '__csimWindowClosed'         => ->(b, *a) { b.window_closed?(a[0]) },
+        '__csimWindowClose'          => ->(b, *a) { b.close_child_window(a[0]); nil },
+        '__csimWindowOpener'         => ->(b, *_) { b.opener_handle },
         '__csim_workerSpawn'         => ->(b, *a) { b.worker_spawn(a[0]) },
         '__csim_workerPostToWorker'  => ->(b, *a) { b.worker_post_to_worker(a[0], a[1]); nil },
         '__csim_workerTerminate'     => ->(b, *a) { b.worker_terminate(a[0]); nil },

data/lib/capybara/simulated/v8_runtime.rb

@@ -26,6 +26,13 @@ begin
   # media-optimization-worker hands a 317 MB raw RGBA frame from an
   # 8900×8900 fixture through the transfer-buffer path). Match
   # Discourse's own testem flag of 4 GB so the test fits.
+  #
+  # rusty_racer >= 0.1.4 installs a near-heap-limit callback on every isolate,
+  # so EXCEEDING this cap raises a catchable `RustyRacer::V8OutOfMemoryError`
+  # (and the isolate recovers) instead of V8 aborting the whole process with a
+  # fatal "Reached heap limit". So this value doubles as the memory backstop: a
+  # runaway script fails one example, it doesn't kill the run. No per-isolate
+  # `memory_limit` needed — the default protection catches at the cap.
   max_old_mb = (ENV['CSIM_V8_MAX_OLD_SPACE_MB'] || '4096').to_i
   RustyRacer::Platform.set_flags!('max-old-space-size': max_old_mb) if max_old_mb > 0
   # `CSIM_V8_PROF=1` turns on V8's tick-sampling profiler. Output
@@ -331,6 +338,32 @@ module Capybara
         result
       end
 
+      # Route a host-fn call into a specific frame realm's context — or the
+      # main context when `realm_id` is nil/0. Each frame realm is a full
+      # bridge with its OWN handle registry + `document`, so a node / query
+      # op on a frame node (a `within_frame` body) must execute in that
+      # realm; running it in the main context would dereference the handle
+      # against the wrong registry. Callers (`Browser#dom_call`) gate on
+      # `frame_realm_alive?` first, so a disposed realm surfaces as a stale
+      # element rather than silently mis-resolving against the main registry.
+      def realm_call(realm_id, name, *args)
+        return call(name, *args) if realm_id.nil? || realm_id.zero?
+        fr = frame_realms[realm_id]
+        return call(name, *args) unless fr
+        result = fr.call(name, *args)
+        ScriptCache.warm_pending!
+        result
+      end
+
+      # Is `realm_id` a live frame realm? A frame removed / re-navigated
+      # mid-block disposes its realm (`__csim_disposeFrameRealm`) while the
+      # 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.
+      def frame_realm_alive?(realm_id)
+        !(realm_id.nil? || realm_id.zero?) && frame_realms.key?(realm_id)
+      end
+
       # bridge.js owns the virtual clock; Ruby still drives it because
       # Capybara's polling cadence is wall-clock-anchored. Use `call`
       # (function reference) rather than `eval` (string compile) — the
@@ -370,6 +403,21 @@ module Capybara
         @frame_realms.clear
       end
 
+      # Frame-scoped navigation: tear down the realm `old_id` and build a fresh
+      # one for the same `<iframe>` from the just-fetched document, returning the
+      # new realm's context id. A new context (not an in-place document reset) is
+      # the right model — it drops the prior frame document's timers / listeners
+      # / module state, exactly like the main page's per-visit rebuild. `parent_id`
+      # 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)
+        if (fr = frame_realms.delete(old_id))
+          @realm_module_handles&.delete(old_id)
+          fr.dispose rescue nil
+        end
+        create_frame_realm(ctx, url, body, content_type, parent_id)
+      end
+
       # One native microtask checkpoint — a checkpoint runs the queue until
       # empty, and rusty already performs one at the end of every top-level
       # eval/call (V8's default kAuto policy), so a single explicit checkpoint
@@ -536,15 +584,16 @@ module Capybara
         attach_frame_realm_loader(c)
       end
 
-      # The bridge calls `__csim_createFrameRealm(url, body, contentType)` (from
-      # `iframe.contentWindow`'s getter) to spin up a real per-iframe realm. This
+      # The bridge calls `__csim_createFrameRealm(url, body, contentType, parentId)`
+      # (from `iframe.contentWindow`'s getter) to spin up a real per-iframe realm
+      # whose `parent`/`top` point at the realm `parentId` identifies. This
       # runs re-entrantly inside the main ctx's eval — rusty services nested
       # requests while a host callback is in flight. Returns the realm's context
       # 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) {
-          RuntimeShared.safe_call { create_frame_realm(c, url, body, content_type) }
+        c.attach('__csim_createFrameRealm', ->(url, body, content_type, parent_id = 0) {
+          RuntimeShared.safe_call { create_frame_realm(c, url, body, content_type, parent_id) }
         })
         # 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
@@ -564,7 +613,7 @@ module Capybara
       # state, point it at its own URL with the top frame as parent/top, then
       # load its document (running its scripts in the realm). Tracked for
       # event-loop draining + teardown.
-      def create_frame_realm(parent_ctx, url, body, content_type)
+      def create_frame_realm(parent_ctx, url, body, content_type, parent_id = 0)
         realm = parent_ctx.create_context
         # Re-evaling the snapshot source would redefine snapshot globals (e.g.
         # the `scrollX` accessor) and throw — re-entrantly. Only eval the
@@ -580,12 +629,18 @@ module Capybara
         attach_run_script_with_cache(realm)
         attach_realm_esm_entry(realm)
         reseed_realm_js(realm)
-        # Wire parent/top to the main realm (context id 0). No user data in
-        # this eval — only the literal namespace.
+        # Wire `parent` / `top` to the realm that owns this iframe (its context
+        # id passed from `__csimFrameWindow`), BEFORE the frame's scripts run —
+        # `top` propagates up the chain (the main realm's `top` is itself). A
+        # nested frame thus reaches its TRUE parent, not unconditionally the
+        # main frame. `parent_id` is an integer the marshaller carries verbatim.
         realm.eval(<<~JS)
           if (globalThis.#{HOST_NAMESPACE_NAME} && typeof globalThis.#{HOST_NAMESPACE_NAME}.contextGlobal === 'function') {
-            var __topWin = globalThis.#{HOST_NAMESPACE_NAME}.contextGlobal(0);
-            globalThis.parent = __topWin; globalThis.top = __topWin;
+            var __parentWin = globalThis.#{HOST_NAMESPACE_NAME}.contextGlobal(#{parent_id.to_i});
+            if (__parentWin) {
+              globalThis.parent = __parentWin;
+              globalThis.top    = __parentWin.top || __parentWin;
+            }
           }
         JS
         # Pass the URL + document body as call ARGUMENTS, not interpolated into

data/lib/capybara/simulated/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Simulated
-    VERSION = '0.1.1'
+    VERSION = '0.2.0'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-simulated
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Keita Urashima