capybara-lightpanda 0.8.0 → 0.10.0

data/lib/capybara/lightpanda/javascripts/errors.js

@@ -0,0 +1,74 @@
+// --- Uncaught page errors ---
+// Lightpanda implements no `Runtime.exceptionThrown` (upstream gap, wishlist
+// B19), so an uncaught exception in page JS reaches no CDP client at all. It is
+// invisible to console_logs, which only ever sees explicit console.* calls, so
+// a handler that dies on a TypeError leaves no trace and the failure surfaces
+// far away as ElementNotFound on whatever it was supposed to produce. That is
+// the exact shape of the solidus taxon-tree failure in real-apps causes.yml.
+//
+// These listeners are passive — no preventDefault, so nothing the page would
+// otherwise see is swallowed, and nothing that would have propagated stops
+// propagating. They re-emit through the same console.debug sentinel channel
+// turbo.js uses, and console.rb routes them into Browser#page_errors rather
+// than #console_logs. Keeping the two apart is deliberate: console_logs stays
+// "the console.* calls the page made", which is what Chrome models (an
+// exception is exceptionThrown, not consoleAPICalled) and what Playwright and
+// Puppeteer expose (pageerror, separate from console). Folding exceptions into
+// console_logs would also break every suite already asserting that buffer is
+// free of errors.
+//
+// Delete this file once upstream emits Runtime.exceptionThrown and the floor
+// covers it: subscribe Browser::Console to that event and feed the same buffer.
+function _reportPageError(fields) {
+  try {
+    console.debug('__lightpanda_page_error_' + JSON.stringify(fields));
+  } catch (e) {
+    // A field that won't serialize (a getter that throws, a cyclic `reason`)
+    // must not turn one page error into two, so report the kind and move on.
+    try {
+      console.debug('__lightpanda_page_error_' + JSON.stringify({
+        kind: fields && fields.kind ? fields.kind : 'error',
+        message: '(page error could not be serialized)'
+      }));
+    } catch (e2) {}
+  }
+}
+
+window.addEventListener('error', function (e) {
+  // A failed <img>/<script>/<link> fetch fires `error` too, but on the element
+  // and without bubbling, so it shouldn't reach this listener. Guard anyway
+  // (Lightpanda's dispatch need not match Chrome's exactly) and identify those
+  // by their missing string `message` — a resource failure is a network fact
+  // and Network#traffic already carries it.
+  if (!e || typeof e.message !== 'string') return;
+
+  _reportPageError({
+    kind: 'error',
+    message: e.message,
+    url: typeof e.filename === 'string' ? e.filename : '',
+    line: typeof e.lineno === 'number' ? e.lineno : null,
+    column: typeof e.colno === 'number' ? e.colno : null,
+    // Cap the stack: it rides a console argument over the CDP WebSocket, and a
+    // deep recursion stack can be megabytes.
+    stack: e.error && typeof e.error.stack === 'string' ? e.error.stack.slice(0, 4000) : null
+  });
+});
+
+window.addEventListener('unhandledrejection', function (e) {
+  var reason = e ? e.reason : null;
+  var message;
+  try {
+    message = reason && reason.message ? String(reason.message) : String(reason);
+  } catch (err) {
+    message = '(rejection reason could not be stringified)';
+  }
+
+  _reportPageError({
+    kind: 'unhandledrejection',
+    message: message,
+    url: '',
+    line: null,
+    column: null,
+    stack: reason && typeof reason.stack === 'string' ? reason.stack.slice(0, 4000) : null
+  });
+});

data/lib/capybara/lightpanda/javascripts/predicates.js

@@ -0,0 +1,116 @@
+// --- DOM visibility / state predicates ---
+// Centralized so node.rb's predicate methods (visible?, obscured?, disabled?)
+// and the visible_text walker share one implementation of the ancestor
+// cascade. Available in iframes too because the bundle is registered via
+// Page.addScriptToEvaluateOnNewDocument.
+//
+// These are bare top-level function declarations — attach.js exposes them on
+// window._lightpanda. They reference each other by name (visibleText calls
+// isVisible), not through `this`, so they keep working when node.rb invokes
+// `_lightpanda.visibleText(this)` with `this` bound to a DOM element by CDP.
+
+// Returns true if `el` is visible per Capybara's semantics. Lightpanda's
+// `checkVisibility()` walks ancestors and rejects `display:none` from
+// inline styles, stylesheets, and the UA sheet (PR #2294 — covers
+// HEAD/SCRIPT/STYLE/NOSCRIPT/TEMPLATE/TITLE, `[hidden]`, `[type=hidden]`,
+// closed-<details> children). `visibility:hidden|collapse` is handled
+// separately because checkVisibility's defaults (per spec) ignore it.
+//
+// External `<link rel=stylesheet>` ARE fetched and applied — the gem
+// always passes --enable-external-stylesheets (Lightpanda PR #2487,
+// guaranteed by the build floor) — so stylesheet-driven `display:none`
+// participates in this check. The remaining gap is viewport emulation:
+// `@media` rules and `matchMedia()` evaluate against the hardcoded
+// 1920×1080 viewport (no resize), so visibility gated on a non-desktop
+// viewport — e.g. a mobile-only CTA under `@media (max-width: …)` —
+// resolves like desktop Chrome at 1920×1080. Keep those specs on a
+// full-layout driver (README's dual-driver setup).
+function isVisible(el) {
+  if (!el || el.nodeType !== 1) return false;
+  var win = el.ownerDocument.defaultView || window;
+  var style = win.getComputedStyle(el);
+  if (style.visibility === 'hidden' || style.visibility === 'collapse') return false;
+  return el.checkVisibility();
+}
+
+// Returns true if the element is obscured at its center point — i.e.
+// hit-testing elementFromPoint at the center returns something that is
+// not the element or its descendant. `visibility:hidden|collapse` is
+// short-circuited explicitly because those elements still produce a
+// layout box (so the rect-zero check below can't catch them); every
+// other "not rendered" case (display:none, [hidden], descendants of
+// either) falls out naturally because getBoundingClientRect returns
+// DOMRect{0,0,0,0} for elements with no layout box.
+function isObscured(el) {
+  var doc = el.ownerDocument;
+  var win = doc.defaultView || window;
+  var style = win.getComputedStyle(el);
+  if (style.visibility === 'hidden' || style.visibility === 'collapse') return true;
+  var r = el.getBoundingClientRect();
+  if (r.width === 0 || r.height === 0) return true;
+  var cx = r.left + (r.width / 2);
+  var cy = r.top + (r.height / 2);
+  var w = win.innerWidth || doc.documentElement.clientWidth;
+  var h = win.innerHeight || doc.documentElement.clientHeight;
+  if (cx < 0 || cy < 0 || cx > w || cy > h) return true;
+  var hit = doc.elementFromPoint(cx, cy);
+  if (!hit) return true;
+  if (hit === el) return false;
+  return !el.contains(hit);
+}
+
+// Capybara's `Node#disabled?` is more permissive than CSS `:disabled`:
+// an `<option>` inside a disabled `<select>` or a disabled `<fieldset>`
+// is reported as disabled, even though those don't match CSS `:disabled`
+// per the HTML spec. Mirrors Cuprite's behavior so the shared specs pass.
+function isDisabled(el) {
+  if (el.matches && el.matches(':disabled')) return true;
+  if ((el.tagName || '').toUpperCase() === 'OPTION') {
+    var p = el.parentElement;
+    while (p) {
+      if (p.disabled) return true;
+      p = p.parentElement;
+    }
+  }
+  return false;
+}
+
+// True if the element is the host of a contenteditable region: it (or any
+// ancestor) has a non-"false" `contenteditable` attribute. Lightpanda's
+// native `HTMLElement.isContentEditable` (PR #2310) is hardwired to return
+// `false` for every element — it has no caret/keyboard editing pipeline —
+// so the IDL property is useless here and we walk ancestors ourselves.
+function isContentEditable(el) {
+  var n = el;
+  while (n && n.nodeType === 1) {
+    if (n.hasAttribute && n.hasAttribute('contenteditable')) {
+      var v = (n.getAttribute('contenteditable') || '').toLowerCase();
+      return v !== 'false';
+    }
+    n = n.parentElement;
+  }
+  return false;
+}
+
+// Capybara's "visible text" = WebDriver getText semantics, which native
+// innerText alone doesn't provide at two edges: a non-rendered element must
+// yield "" (innerText returns textContent per the HTML getter's step 1), and a
+// ShadowRoot/DocumentFragment has no innerText at all. So we gate on visibility
+// and otherwise delegate the rendered-text collection — block line breaks +
+// display:none descendant skipping + whitespace — to native innerText
+// (Lightpanda #2785/#2795, guaranteed by the build floor). node.rb#visible_text
+// normalizes the whitespace on top.
+function visibleText(el) {
+  if (el.nodeType === 1) return isVisible(el) ? el.innerText : '';
+  // ShadowRoot / DocumentFragment: no innerText of its own. Concatenate the
+  // native innerText of each visible element child with the text nodes between
+  // them — collapsing the latter's whitespace to a single space so template
+  // newlines between inline children render as a separating space, not a break.
+  var out = '';
+  for (var i = 0; i < el.childNodes.length; i++) {
+    var c = el.childNodes[i];
+    if (c.nodeType === 3) out += c.nodeValue.replace(/[\t\n\r\f\v ]+/g, ' ');
+    else if (c.nodeType === 1 && isVisible(c)) out += c.innerText;
+  }
+  return out;
+}

data/lib/capybara/lightpanda/javascripts/turbo.js

@@ -0,0 +1,67 @@
+// --- Turbo activity tracking ---
+// Tracks pending Turbo operations so the driver can wait for Turbo to settle.
+// Inspired by the CapybaraLockstep approach for stabilizing Turbo integration tests.
+// Events are not perfectly symmetrical in Turbo, so we track multiple pairs
+// and use a counter to handle overlapping operations.
+//
+// Transitions across 0 emit `__lightpanda_turbo_busy` / `__lightpanda_turbo_idle`
+// sentinels via console.debug. Browser#wait_for_turbo subscribes to those
+// sentinels (Runtime.consoleAPICalled) and toggles a Concurrent::Event so the
+// Ruby side can wait event-driven instead of polling.
+//
+// Pages without Turbo never trigger _turboStart, so no sentinels fire and the
+// Ruby Event stays set (idle by default) — wait_for_turbo returns immediately.
+var _pendingTurboOps = 0;
+function _signalTurbo(state) {
+  try { console.debug('__lightpanda_turbo_' + state); } catch (e) {}
+}
+function _turboStart() {
+  _pendingTurboOps++;
+  if (_pendingTurboOps === 1) _signalTurbo('busy');
+}
+function _turboEnd() {
+  if (_pendingTurboOps > 0) {
+    _pendingTurboOps--;
+    if (_pendingTurboOps === 0) _signalTurbo('idle');
+  }
+}
+
+// Fetch requests (covers Drive, Frames, and Form submission fetches)
+document.addEventListener('turbo:before-fetch-request', _turboStart);
+document.addEventListener('turbo:before-fetch-response', _turboEnd);
+document.addEventListener('turbo:fetch-request-error', _turboEnd);
+
+// Form submissions (can outlast their underlying fetch)
+document.addEventListener('turbo:submit-start', _turboStart);
+document.addEventListener('turbo:submit-end', _turboEnd);
+
+// Frame rendering (can outlast the fetch that triggered it)
+document.addEventListener('turbo:before-frame-render', _turboStart);
+document.addEventListener('turbo:frame-render', _turboEnd);
+
+// Stream rendering (no symmetric end event — wrap the render function)
+document.addEventListener('turbo:before-stream-render', function(event) {
+  _turboStart();
+  if (event.detail && event.detail.render) {
+    var originalRender = event.detail.render;
+    event.detail.render = function(streamElement) {
+      var result = originalRender(streamElement);
+      if (result && typeof result.then === 'function') {
+        return result.finally(_turboEnd);
+      }
+      _turboEnd();
+      return result;
+    };
+  } else {
+    _turboEnd();
+  }
+});
+
+// Drive page visits: turbo:load fires after the page is fully rendered.
+// Also serves as a safety reset — clears any counter leaks from aborted fetches.
+// Always re-signal idle so the Ruby Event re-arms even if some `_turboEnd`
+// call dropped on the floor mid-navigation.
+document.addEventListener('turbo:load', function() {
+  _pendingTurboOps = 0;
+  _signalTurbo('idle');
+});

data/lib/capybara/lightpanda/keyboard.rb

@@ -14,6 +14,7 @@ module Capybara
         enter: { key: "Enter", code: "Enter", keyCode: 13, text: "\r" },
         shift: { key: "Shift", code: "ShiftLeft", keyCode: 16 },
         control: { key: "Control", code: "ControlLeft", keyCode: 17 },
+        ctrl: { key: "Control", code: "ControlLeft", keyCode: 17 },
         alt: { key: "Alt", code: "AltLeft", keyCode: 18 },
         pause: { key: "Pause", code: "Pause", keyCode: 19 },
         escape: { key: "Escape", code: "Escape", keyCode: 27 },
@@ -120,12 +121,14 @@ module Capybara
       def press_modifier(mod, active_mods)
         return if active_mods.include?(mod)
 
-        send_key_event("keyDown", KEYS[mod])
+        # key_definition (not KEYS[mod]) so a MODIFIERS entry missing its
+        # KEYS counterpart fails as ArgumentError, not NoMethodError on nil.
+        send_key_event("keyDown", key_definition(mod))
         active_mods << mod
       end
 
       def release_modifiers(active_mods)
-        active_mods.reverse_each { |m| send_key_event("keyUp", KEYS[m]) }
+        active_mods.reverse_each { |m| send_key_event("keyUp", key_definition(m)) }
         active_mods.clear
       end
 
@@ -133,7 +136,7 @@ module Capybara
         return dispatch_key(key) if active_mods.empty?
 
         modifier_value = active_mods.sum { |m| MODIFIERS[m] }
-        dispatch_modified(key, modifier_value, active_mods)
+        raw_dispatch(key_definition(key), modifiers: modifier_value)
       end
 
       def dispatch_char_with_mods(char, active_mods)
@@ -144,31 +147,28 @@ module Capybara
       end
 
       def dispatch_key(key)
-        definition = KEYS.fetch(key) { raise ArgumentError, "Unknown key: #{key.inspect}" }
-        raw_dispatch(definition)
+        raw_dispatch(key_definition(key))
       end
 
       def dispatch_char(char)
         @browser.page_command("Input.insertText", text: char)
       end
 
+      # An array groups modifiers with the keys they modify —
+      # `send_keys([:ctrl, "a"])` — scoped to the array instead of the rest
+      # of the call. Same press/dispatch/release machinery as held modifiers.
       def type_with_modifiers(keys)
-        modifiers, chars = keys.partition { |k| k.is_a?(Symbol) && MODIFIERS.key?(k) }
-        modifier_value = modifiers.sum { |m| MODIFIERS[m] }
+        modifiers, rest = keys.partition { |k| k.is_a?(Symbol) && MODIFIERS.key?(k) }
 
-        modifiers.each { |m| send_key_event("keyDown", KEYS[m]) }
-        chars.each { |key| dispatch_modified(key, modifier_value, modifiers) }
-        modifiers.reverse_each { |m| send_key_event("keyUp", KEYS[m]) }
-      end
-
-      def dispatch_modified(key, modifier_value, modifiers)
-        case key
-        when Symbol
-          definition = KEYS.fetch(key) { raise ArgumentError, "Unknown key: #{key.inspect}" }
-          raw_dispatch(definition, modifiers: modifier_value)
-        when String
-          key.each_char { |char| dispatch_modified_char(char, modifier_value, modifiers) }
+        active_mods = []
+        modifiers.each { |m| press_modifier(m, active_mods) }
+        rest.each do |key|
+          case key
+          when Symbol then dispatch_key_with_mods(key, active_mods)
+          when String then key.each_char { |char| dispatch_char_with_mods(char, active_mods) }
+          end
         end
+        release_modifiers(active_mods)
       end
 
       def dispatch_modified_char(char, modifier_value, modifiers)
@@ -177,6 +177,10 @@ module Capybara
         send_key_event("keyUp", { key: text }, modifiers: modifier_value)
       end
 
+      def key_definition(key)
+        KEYS.fetch(key) { raise ArgumentError, "Unknown key: #{key.inspect}" }
+      end
+
       def raw_dispatch(definition, modifiers: 0)
         type = definition[:text] ? "keyDown" : "rawKeyDown"
         send_key_event(type, definition, modifiers: modifiers)

data/lib/capybara/lightpanda/network.rb

@@ -3,25 +3,54 @@
 module Capybara
   module Lightpanda
     class Network
+      # Tracking is always on (create_page enables it), so the buffer needs
+      # the same unbounded-growth cap as Browser's console ring buffer —
+      # one very long session would otherwise grow @traffic indefinitely.
+      TRAFFIC_LIMIT = 1_000
+
       attr_reader :browser
 
+      # Status/headers of the last top-level document navigation; nil before
+      # the first navigation completes. Backs Browser#status_code /
+      # #response_headers. Captured by #subscribe's handlers.
+      attr_reader :last_navigation_response
+
       def initialize(browser)
         @browser = browser
         @traffic = []
         @traffic_mutex = Mutex.new
         @enabled = false
-        @request_handler = nil
-        @response_handler = nil
+        @request_handler = @response_handler = nil
+        @last_navigation_response = nil
+        @document_request_id = nil
       end
 
+      # The domain toggle is connection-scoped (browser.command), while
+      # setExtraHTTPHeaders is session-scoped (browser.page_command) — see
+      # #headers=. Browser#create_page calls this, so tracking (traffic AND
+      # the navigation-response capture) is on for every page.
       def enable
         return if @enabled
 
-        browser.command("Network.enable")
+        # Subscribe BEFORE flipping the wire toggle (mirror image of
+        # #disable's ordering): events can't be emitted while the domain is
+        # off, so this order can never miss one. If the command fails
+        # (Lightpanda can block commands mid-navigation), roll the handlers
+        # back — orphaned duplicates would double-count every request and
+        # wedge pending_connections above zero for the session.
         subscribe
+        begin
+          browser.command("Network.enable")
+        rescue StandardError
+          unsubscribe
+          raise
+        end
         @enabled = true
       end
 
+      # Caveat: disabling the domain also stops the navigation-response
+      # capture, so Browser#status_code / #response_headers freeze at their
+      # last values until the next #enable.
       def disable
         return unless @enabled
 
@@ -51,8 +80,11 @@ module Capybara
       # cleared the Subscriber first.
       def reset
         unsubscribe
-        @traffic_mutex.synchronize { @traffic.clear }
+        clear
         @enabled = false
+        @extra_headers = nil # the fresh context never received setExtraHTTPHeaders
+        @last_navigation_response = nil
+        @document_request_id = nil
       end
 
       # Headers applied via headers= / add_headers. Backs Driver#headers.
@@ -111,11 +143,41 @@ module Capybara
 
       private
 
+      # CDP events arrive on the message thread while wait_for_idle /
+      # pending_connections read from the main thread; serialize all
+      # @traffic mutations and reads through @traffic_mutex.
+      #
+      # The handlers also capture the last top-level navigation response
+      # (mirrors capybara-playwright-driver's navigation_request? hook). CDP
+      # normally marks the main-document response via
+      # `Network.responseReceived.type`. Lightpanda only started emitting that
+      # field on responses in build 8318 (#3037) — far above the gem's floor —
+      # so match the long way instead: remember the document requestId, store
+      # the response whose requestId equals it. Works on every supported build;
+      # don't "simplify" it to read response.type until the floor clears 8318.
       def subscribe
-        # CDP events arrive on the message thread while wait_for_idle /
-        # pending_connections read from the main thread; serialize all
-        # @traffic mutations and reads through @traffic_mutex.
-        @request_handler = lambda do |params|
+        @request_handler = build_request_handler
+        @response_handler = build_response_handler
+        browser.on("Network.requestWillBeSent", &@request_handler)
+        browser.on("Network.responseReceived", &@response_handler)
+      end
+
+      # Redirects follow Chrome's shape (Lightpanda since #3175, build ≥8602):
+      # every followed hop re-emits requestWillBeSent with the SAME requestId
+      # and the 3xx riding along as `redirectResponse`; the 3xx never gets a
+      # responseReceived of its own. So the hop's event is what closes the
+      # previous entry — without it that entry stays `response: nil` forever,
+      # pending_connections wedges at ≥1 and every wait_for_idle burns its
+      # full timeout after the first redirect (Ferrum's
+      # subscribe_request_will_be_sent does the same close). Deliberately NOT
+      # fed into @last_navigation_response: status_code must report the final
+      # hop, and the redirected requestWillBeSent resets it below anyway.
+      def build_request_handler
+        lambda do |params|
+          if params["type"] == "Document"
+            @document_request_id = params["requestId"]
+            @last_navigation_response = nil
+          end
           entry = {
             request_id: params["requestId"],
             url: params.dig("request", "url"),
@@ -123,24 +185,47 @@ module Capybara
             timestamp: params["timestamp"],
             response: nil,
           }
-          @traffic_mutex.synchronize { @traffic << entry }
+          @traffic_mutex.synchronize do
+            if (redirect = params["redirectResponse"]) && (previous = last_open_entry(params["requestId"]))
+              previous[:response] = response_summary(redirect)
+            end
+            @traffic << entry
+            @traffic.shift(@traffic.size - TRAFFIC_LIMIT) if @traffic.size > TRAFFIC_LIMIT
+          end
         end
+      end
 
-        @response_handler = lambda do |params|
+      def build_response_handler
+        lambda do |params|
+          if params["requestId"] == @document_request_id
+            @last_navigation_response = {
+              status: params.dig("response", "status"),
+              headers: params.dig("response", "headers") || {},
+            }
+          end
           @traffic_mutex.synchronize do
-            request = @traffic.find { |t| t[:request_id] == params["requestId"] }
+            # Last open entry, not `find`: after a redirect chain several
+            # entries share the requestId and only the newest is still open.
+            request = last_open_entry(params["requestId"])
             next unless request
 
-            request[:response] = {
-              status: params.dig("response", "status"),
-              headers: params.dig("response", "headers"),
-              mime_type: params.dig("response", "mimeType"),
-            }
+            request[:response] = response_summary(params["response"])
           end
         end
+      end
 
-        browser.on("Network.requestWillBeSent", &@request_handler)
-        browser.on("Network.responseReceived", &@response_handler)
+      # Caller holds @traffic_mutex.
+      def last_open_entry(request_id)
+        @traffic.reverse_each.find { |t| t[:request_id] == request_id && t[:response].nil? }
+      end
+
+      def response_summary(response)
+        response ||= {}
+        {
+          status: response["status"],
+          headers: response["headers"],
+          mime_type: response["mimeType"],
+        }
       end
 
       def unsubscribe