capybara-simulated 0.0.7 → 0.1.1

data/lib/capybara/simulated/js/snapshot_stubs.js

@@ -0,0 +1,110 @@
+// Stub host fns so bridge.js can be baked into a Snapshot (V8) /
+// compiled to bytecode (QuickJS) without the real Ruby-side hosts
+// being attached yet. Real implementations land at Context build
+// time via the engine's attach API. Only the host fns bridge.js
+// actually invokes appear here — if you add a new host fn, add the
+// matching stub here too.
+Object.defineProperty(globalThis, Symbol.toStringTag, { value: 'Window' });
+
+// The vendored whatwg-url engine captures `SharedArrayBuffer` and a
+// `TextEncoder`/`TextDecoder` at module-load time = snapshot-BUILD time here —
+// and the V8 snapshot context exposes neither (SharedArrayBuffer is
+// Spectre-disabled; our real TextEncoder lives in bridge's encoding.js, which
+// loads AFTER the vendor bundle). Provide them before the vendor bundle so
+// whatwg-url bakes cleanly. SharedArrayBuffer is only touched by whatwg-url's
+// (unused-for-URL) WebIDL buffer-type guard, so aliasing it to ArrayBuffer is
+// fine. The TextEncoder/TextDecoder MUST be real UTF-8 — whatwg-url captures
+// them in a module closure and uses them for percent-encoding at runtime (the
+// bridge's full encoding.js later overrides `globalThis.TextEncoder` for app
+// code, but whatwg-url keeps the instance it captured here).
+globalThis.SharedArrayBuffer = globalThis.SharedArrayBuffer || globalThis.ArrayBuffer;
+if (typeof globalThis.TextEncoder === 'undefined') {
+  globalThis.TextEncoder = class TextEncoder {
+    get encoding() { return 'utf-8'; }
+    encode(str) {
+      str = String(str === undefined ? '' : str);
+      const out = [];
+      for (let i = 0; i < str.length; i++) {
+        let c = str.codePointAt(i);
+        if (c > 0xffff) i++;                            // surrogate pair — skip the low half
+        else if (c >= 0xd800 && c <= 0xdfff) c = 0xfffd; // unpaired surrogate → U+FFFD (WHATWG)
+        if (c < 0x80) out.push(c);
+        else if (c < 0x800) out.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        else if (c < 0x10000) out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        else out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 0x3f), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+      }
+      return new Uint8Array(out);
+    }
+  };
+}
+if (typeof globalThis.TextDecoder === 'undefined') {
+  globalThis.TextDecoder = class TextDecoder {
+    constructor() {}
+    get encoding() { return 'utf-8'; }
+    decode(input) {
+      if (!input) return '';
+      const b = input instanceof Uint8Array ? input : new Uint8Array(input.buffer || input);
+      let s = '';
+      for (let i = 0; i < b.length;) {
+        let c = b[i++];
+        if (c >= 0xf0)      c = ((c & 0x07) << 18) | ((b[i++] & 0x3f) << 12) | ((b[i++] & 0x3f) << 6) | (b[i++] & 0x3f);
+        else if (c >= 0xe0) c = ((c & 0x0f) << 12) | ((b[i++] & 0x3f) << 6) | (b[i++] & 0x3f);
+        else if (c >= 0xc0) c = ((c & 0x1f) << 6) | (b[i++] & 0x3f);
+        s += String.fromCodePoint(c);
+      }
+      return s;
+    }
+  };
+}
+globalThis.__csim_parseUrl = function (input, base) {
+  return {
+    href: 'http://placeholder/', protocol: 'http:',
+    username: '', password: '', host: 'placeholder',
+    hostname: 'placeholder', port: '', pathname: '/',
+    search: '', hash: '', origin: 'http://placeholder'
+  };
+};
+globalThis.__csim_randomUUID  = function () { return '00000000-0000-0000-0000-000000000000'; };
+globalThis.__csim_randomBytes = function (n) { return new Array(n).fill(0); };
+globalThis.__csim_atob        = function (s) { return ''; };
+globalThis.__csim_btoa        = function (s) { return ''; };
+globalThis.__csim_utf8Encode  = function (s) { return []; };
+globalThis.__csim_utf8Decode  = function (a) { return ''; };
+globalThis.__rackFetch              = function () { return null; };
+globalThis.__locationAssign         = function () { return null; };
+globalThis.__locationReload         = function () { return null; };
+globalThis.__setTimersActive        = function () { return null; };
+globalThis.__setCurrentUrl          = function () { return null; };
+globalThis.__pushHistoryEntry       = function () { return null; };
+globalThis.__historyLength          = function () { return 1; };
+globalThis.__csimReadFilePick       = function () { return null; };
+globalThis.__getDocumentCookie      = function () { return ''; };
+globalThis.__setDocumentCookie      = function () { return null; };
+globalThis.__csim_storageGet        = function () { return null; };
+globalThis.__csim_storageSet        = function () { return null; };
+globalThis.__csim_storageRemove     = function () { return null; };
+globalThis.__csim_storageClear      = function () { return null; };
+globalThis.__csim_storageKey        = function () { return null; };
+globalThis.__csim_storageLength     = function () { return 0; };
+// Geolocation override state; JSON string ('null' = no override configured).
+globalThis.__csimGeolocationState   = function () { return 'null'; };
+globalThis.__modalDialog            = function () { return null; };
+globalThis.__csim_pushImportmap     = function () { return null; };
+globalThis.__csim_logConsole        = function () { return null; };
+globalThis.__csim_eventSourceOpen   = function () { return 0; };
+globalThis.__csim_eventSourceClose  = function () { return null; };
+globalThis.__csim_workerSpawn       = function () { return 0; };
+globalThis.__csim_workerPostToWorker= function () { return null; };
+globalThis.__csim_workerTerminate   = function () { return null; };
+globalThis.__csim_workerPostMessage = function () { return null; };
+globalThis.__csim_decodeImage       = function () { return null; };
+globalThis.__csim_blobRegister      = function () { return null; };
+globalThis.__csim_blobResolve       = function () { return null; };
+globalThis.__csim_blobUnregister    = function () { return null; };
+// Default classic-script runner: indirect-eval at global scope. Both
+// runtimes override this with a bytecode-caching host fn at attach
+// time. `//# sourceURL=…` labels eval'd content so stack traces
+// report the script URL instead of `<anonymous>`.
+globalThis.__csim_runScript         = function (label, body) {
+  (0, eval)(body + '\n//# sourceURL=' + (label || 'csim-eval'));
+};

data/lib/capybara/simulated/node.rb

@@ -1,235 +1,223 @@
-require 'capybara/driver/node'
-require 'capybara/node/whitespace_normalizer'
+# frozen_string_literal: true
+
+require 'capybara/node/base'
+require_relative 'errors'
+require_relative 'whitespace_normalizer'
 
 module Capybara
   module Simulated
     class Node < Capybara::Driver::Node
-      include Capybara::Node::WhitespaceNormalizer
-
-      def handle_id = native
-
+      include WhitespaceNormalizer
+
+      def initialize(driver, handle)
+        super(driver, self)
+        @handle_id    = handle
+        # Pin the Browser at construction so nodes from one window
+        # stay valid even after `switch_to_window` flips to another.
+        @browser      = driver.current_browser
+        @initial_node = @browser.lookup_node(handle)
+        @context_gen  = @browser.context_gen
+      end
+
+      attr_reader :handle_id, :context_gen
+
+      # Tick the virtual clock unconditionally on the text path. Unlike
+      # `Node#[]` (attribute reads), the text readers are NOT preceded by
+      # a `find_css` that ticks under the wall throttle: `have_text` /
+      # `assert_text` polls `.text` directly against an already-found,
+      # cached scope node, so the find loop short-circuits without
+      # re-ticking. Gating these behind `timer_wait_elapsed?` therefore
+      # stalls a pure text-poll loop's virtual clock and scheduled
+      # `setTimeout`s never fire (smoke_spec virtual-clock contract).
+      # They run ~once per poll-scope (not once per matched result like
+      # the attribute filters the audit targeted), so they are not the
+      # O(N) hot path and are safe to tick every call.
       def all_text
+        browser.tick_real_time
+        check_stale
         normalize_spacing(browser.all_text(handle_id))
       end
 
       def visible_text
+        browser.tick_real_time
+        check_stale
         normalize_visible_spacing(browser.visible_text(handle_id))
       end
 
-      def [](name)
-        case name.to_s
-        when 'value'    then value
-        when 'checked'  then checked? ? 'true' : nil
-        when 'selected' then selected? ? 'true' : nil
-        else browser.attr(handle_id, name)
-        end
-      end
-
       def value
+        check_stale
         browser.value(handle_id)
       end
 
-      def set(value, **_opts)
-        return if disabled?
-        # readonly is meaningless on checkbox/radio; the HTML spec ignores
-        # it for those types, and Capybara's specs explicitly assert that.
-        type = (self[:type] || tag_name || '').to_s.downcase
-        return if readonly? && type != 'checkbox' && type != 'radio'
-        browser.set_value(handle_id, value)
-      end
-
-      def select_option
-        return if disabled?
-        browser.select_option(handle_id)
-      end
-
-      def unselect_option
-        raise Capybara::UnselectNotAllowed, 'Cannot unselect option from single select box.' unless select_node_multiple?
-        browser.unselect_option(handle_id)
-      end
-
-      def tag_name
-        browser.tag_name(handle_id)
-      end
-
       def visible?
+        check_stale
         browser.visible?(handle_id)
       end
 
-      def obscured?
-        false
-      end
+      def tag_name = browser.tag_name(handle_id)
 
-      def checked?
-        browser.checked?(handle_id)
+      # Convenience accessors mirroring real browser nodes — Discourse
+      # tests reach for `.native.inner_html` (e.g. reviewables XSS
+      # checks); without this method `.native` (= self) raised
+      # NoMethodError.
+      def inner_html
+        check_stale
+        browser.inner_html(handle_id)
       end
 
-      def selected?
-        browser.selected?(handle_id)
+      def outer_html
+        check_stale
+        browser.outer_html(handle_id)
       end
 
-      def disabled?
-        browser.disabled?(handle_id)
-      end
-
-      def readonly?
-        browser.readonly?(handle_id)
-      end
-
-      def multiple?
-        browser.multiple?(handle_id)
+      def [](name)
+        # Tick the virtual clock so Capybara's helpers that poll an
+        # attribute in a tight `sleep(0.1) until` loop (e.g. Avo's
+        # `wait_for_body_class_missing`) actually see the JS chain
+        # progress. Without this the body class never transitions
+        # because we only advance time during `find`, and the helper
+        # caches the body node before its poll loop.
+        #
+        # Gated behind the same wall-clock throttle `find_css` uses
+        # (`timer_wait_elapsed?`): on framework-runloop pages that keep
+        # `@timers_active` permanently true, an ungated tick here would
+        # drain timers on every per-result attribute filter / poll
+        # iteration. The throttle still ticks the first time and once
+        # per ~50 ms window thereafter, so poll loops that wait for a
+        # timer to fire between reads still make progress.
+        #
+        # `tick_real_time` also drains the Worker / EventSource / hijacked
+        # -fetch outboxes, so an attribute poll whose value is delivered
+        # only by one of those channels (with no active timer) would
+        # otherwise never see it. `async_io_pending?` is an O(1) gate
+        # (three empty? checks) that lets those cases drain without paying
+        # an unconditional tick on timer-driven runloop pages.
+        browser.tick_real_time if browser.timer_wait_elapsed? || browser.async_io_pending?
+        check_stale
+        browser.attr(handle_id, name.to_s)
       end
 
       def click(keys = [], **opts)
-        browser.click(handle_id, click_options(keys, opts))
+        check_stale
+        browser.click(handle_id, keys, **opts)
       end
 
       def right_click(keys = [], **opts)
-        browser.right_click(handle_id, click_options(keys, opts))
+        check_stale
+        browser.right_click(handle_id, keys, **opts)
       end
 
       def double_click(keys = [], **opts)
-        browser.double_click(handle_id, click_options(keys, opts))
+        check_stale
+        browser.double_click(handle_id, keys, **opts)
       end
 
-      private
-
-      # x/y from Capybara are *offsets* — from top-left when
-      # Capybara.w3c_click_offset is false, from center when true. The
-      # runtime reads `simRect` to translate these into absolute
-      # clientX/clientY before dispatching the mouse events. Defaults
-      # (no x/y) target the element's center.
-      def click_options(keys, opts)
-        out = modifier_options(keys)
-        if opts.key?(:x) || opts.key?(:y)
-          out['offsetX']   = opts[:x].to_f if opts.key?(:x)
-          out['offsetY']   = opts[:y].to_f if opts.key?(:y)
-          out['w3cOffset'] = !!Capybara.w3c_click_offset
-        end
-        out['delay'] = opts[:delay].to_f if opts.key?(:delay) && opts[:delay].to_f.positive?
-        out
-      end
-
-      def modifier_options(keys)
-        opts = {}
-        Array(keys).each do |k|
-          case k
-          when :shift   then opts['shiftKey'] = true
-          when :ctrl, :control then opts['ctrlKey'] = true
-          when :alt     then opts['altKey'] = true
-          when :meta, :command then opts['metaKey'] = true
-          end
-        end
-        opts
-      end
-
-      public
-
-      def hover
+      def hover(**_opts)
+        check_stale
         browser.hover(handle_id)
+        self
       end
 
-      def trigger(event)
-        browser.trigger(handle_id, event)
+      def scroll_to(*, **)       ; self ; end
+
+      # Capybara's standard rect API. No layout engine — but
+      # Discourse's `wait_for_animation` helper polls `element.rect[:x]`
+      # twice and waits for the values to stabilise, which they
+      # immediately do here (constant zeros) since we never animate.
+      # That unblocks every test guarded by an animation settle.
+      def rect
+        check_stale
+        {x: 0, y: 0, width: 0, height: 0, top: 0, left: 0, bottom: 0, right: 0}
       end
 
       def send_keys(*keys)
+        check_stale
         browser.send_keys(handle_id, keys)
+        true
       end
 
-      def drag_to(other, **_opts)
-        browser.trigger(handle_id, 'dragstart')
-        browser.trigger(other.handle_id, 'dragenter')
-        browser.trigger(other.handle_id, 'dragover')
-        browser.trigger(other.handle_id, 'drop')
-        browser.trigger(handle_id, 'dragend')
+      def trigger(event)
+        check_stale
+        browser.dispatch_event(handle_id, event.to_s)
+        true
       end
-
       def drop(*args)
-        items = args.flat_map {|arg| drop_items_for(arg) }
-        browser.drop(handle_id, items)
+        check_stale
+        browser.drop(handle_id, args)
+        true
       end
 
-      def scroll_by(_x, _y); end
-      def scroll_to(_element, _alignment, _position = nil); end
+      def drag_to(target_node, **opts)
+        check_stale
+        target_node.check_stale if target_node.respond_to?(:check_stale)
+        target_handle = target_node.respond_to?(:handle_id) ? target_node.handle_id : target_node.native
+        browser.drag_to(handle_id, target_handle, **opts)
+        self
+      end
+      def set(value, **_)
+        check_stale
+        browser.set_value_with_events(handle_id, value)
+      end
 
-      def submit
-        browser.submit(handle_id)
+      def select_option
+        check_stale
+        browser.select_option(handle_id)
       end
 
-      def find_xpath(xpath)
-        browser.find_xpath(xpath, handle_id).map {|id| self.class.new(driver, id) }
+      def unselect_option
+        check_stale
+        browser.unselect_option(handle_id)
       end
 
-      def find_css(css)
-        browser.find_css(css, handle_id).map {|id| self.class.new(driver, id) }
+      def submit(*_)
+        check_stale
+        browser.submit_form(handle_id)
       end
 
-      def rect
-        browser.rect(handle_id)
+      def find_xpath(query)
+        browser.find_xpath(query, handle_id).map {|id| self.class.new(driver, id) }
       end
 
-      def path
-        browser.path(handle_id)
+      def find_css(query)
+        browser.find_css(query, handle_id).map {|id| self.class.new(driver, id) }
       end
 
       def shadow_root
-        id = browser.shadow_root(handle_id)
-        id ? Node.new(driver, id) : nil
+        check_stale
+        h = browser.shadow_root_handle(handle_id)
+        h && self.class.new(driver, h)
+      end
+      def disabled?        = browser.disabled?(handle_id)
+      def selected?        = browser.option_selected?(handle_id)
+      def checked?         = !!self['checked']
+      def readonly?        = !!self['readonly']
+      def obscured?(*)     = !visible?
+      def synchronize(*)   = yield
+      def style(names = [])
+        check_stale
+        browser.computed_style(handle_id, Array(names))
       end
-
-      def style(_styles)
-        raise NotImplementedError, 'The simulated driver does not process CSS'
+      def path
+        check_stale
+        browser.node_path(handle_id)
       end
 
+      # Both handle_id and context_gen are part of identity: after a
+      # cross-page reload the new element can land on the same handle
+      # id (JS-side counter resets per ctx) but a different generation.
+      # Capybara's synchronize uses `old_base == @base` to decide
+      # whether reload made progress, so id-only equality would mark
+      # a successful reload as a no-op and raise the original error.
       def ==(other)
-        other.is_a?(Node) && other.handle_id == handle_id
-      end
-
-      def inspect
-        %(#<Capybara::Simulated::Node tag="#{tag_name}" id=#{handle_id}>)
-      rescue StandardError
-        super
+        other.is_a?(Node) &&
+          other.handle_id == @handle_id &&
+          other.context_gen == @context_gen
       end
 
       private
 
-      def drop_items_for(arg)
-        case arg
-        when Hash
-          arg.map {|type, data|
-            {'kind' => 'string', 'type' => type.to_s, 'data' => data.to_s}
-          }
-        when String
-          [{'kind' => 'file', 'name' => File.basename(arg), 'type' => '', 'contents' => safely_read(arg)}]
-        else
-          []
-        end
-      end
-
-      def safely_read(path)
-        File.binread(path)
-      rescue StandardError
-        ''
-      end
-
-      def browser = driver.browser
-
-      def select_node_multiple?
-        browser.evaluate_script(<<~JS)
-          (() => {
-            const el = (#{select_lookup_js})
-            const sel = el.closest('select');
-            return !!(sel && sel.multiple);
-          })()
-        JS
-      end
-
-      def select_lookup_js
-        # The JS-side handles map is private; use evaluate via a tiny accessor.
-        # Cheaper: ask browser directly through path/tag inspection.
-        "document.evaluate(#{path.inspect}, document, null, 9, null).singleNodeValue"
-      end
+      def browser     = @browser
+      def check_stale = browser.check_stale(handle_id, @initial_node, @context_gen)
     end
   end
 end