capybara-lightpanda 0.14.0 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 759abeb96b5d6898d9458d2e81af39b97d155766cfd2c80fa1ed363409a6aff6
-  data.tar.gz: 66d54d836501ab8ec7d3cc23ffc389f58777c938a19490f9dc81a076819b4489
+  metadata.gz: 197930c8808e3cb4d58ce97952b13e657dfbf8e7d200a98b03a5e71e7afdc87f
+  data.tar.gz: 6401c206e53dce565b29eab2e4c4b01bbf141a88c81025bc12b584b7cc0e75af
 SHA512:
-  metadata.gz: ffdc46e2b18c6ce822fb7765cc668bfda6594e1ce27f9ad88b29e4d9a34f6882b80aad54fcb0581d460e68b3fbcaaaa853017f825295b1a8758a244da520d12d
-  data.tar.gz: 6ae51661f2a7108ec85bebf773965dd792f74d04b80cdff7c5992b41be5c32f15b3d7e08d97a64212a64a812be4ebe811f222ad6fa91866888d1f6e50a805b71
+  metadata.gz: 0cfe0bd2b2491e8b26715110950286a74e9bd1a7816d52a76b87cc601814ed4dd4faabf5665108f82624d6720581bdc7560c82445220456cb089a13313618857
+  data.tar.gz: 84fb972984583e315cf20f0a70a114238015aa29c49786a6aec5f329556518fc63ee5bb2204e430ccdb81e014943535cc2899c1ec40fb673d3f641bf5b201063

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.14.2] - 2026-10-14
+
+### Fixed
+
+- **A browser that stops reading no longer hangs the test process.** If Lightpanda got stuck (a page in an endless synchronous loop, a stopped process) while a large command was being sent, about 1 MB and up (a big `execute_script` bundle, for example), the send blocked forever: the command's timeout never started, every other command waited behind it, and so did quitting the browser, at exit included. Sending now gives up after the command's timeout and raises `DeadBrowserError`.
+- **Clicking a `mailto:` or `tel:` link keeps the page, as in Chrome.** On Lightpanda 1.0.0, clicking `<a href="mailto:someone@example.com">` left the page and loaded `example.com`, the host in the address. On nightlies 10261 to 10535, clicking a `tel:` link left the page unusable: every later call raised `NoExecutionContextError`. The page now stays and your own click handlers still run. The same applies to any link whose scheme the browser can't load (`sms:`, `ftp:`…).
+
+## [0.14.1] - 2026-10-12
+
+### Fixed
+
+- **A click that loads a new page waits for that page's scripts.** `click` used to return as soon as the new document existed, before its deferred and module scripts had run. Apps load Stimulus, Turbo and Bootstrap that way, so the next action could land on a page whose handlers were not wired yet: a Bootstrap collapse that did not open, a `confirm()` that never showed (`accept_confirm` raised `ModalNotFound`) while the form was submitted anyway, a form posted before its JavaScript was ready. The click now also waits for `DOMContentLoaded`, as Cuprite waits for the load event. `send_keys`, `go_back` and `go_forward` wait the same way when they load a new page. Clicks that don't navigate are as fast as before.
+- **A click on a link that Turbo hands back to the browser waits for the new page.** With Turbo on the page, such a click returned immediately on the page being left, because Turbo reported activity and went idle again before the navigation started.
+
 ## [0.14.0] - 2026-10-11
 
 ### Fixed

data/lib/capybara/lightpanda/browser.rb

@@ -167,6 +167,7 @@ module Capybara
         subscribe_to_console_capture
         subscribe_to_execution_context
         subscribe_to_navigation
+        subscribe_to_document_ready
         subscribe_to_turbo_signals
         # Network owns the Network.* domain: enabling installs traffic
         # tracking AND the navigation-response capture behind status_code.
@@ -425,13 +426,15 @@ module Capybara
       #
       # Sniff window: the action returns synchronously, but the CDP events
       # signalling its async fallout arrive later on the dispatch thread. We
-      # poll briefly for any of them — a main-frame navigation start (see
-      # subscribe_to_navigation), Runtime.executionContextsCleared, or the
-      # turbo sentinel — and if none fires within the window, assume the
-      # action was inert and exit fast. Lightpanda announces a navigation
-      # ~5 ms after the click but only swaps the execution context once the
-      # response lands, so watching the context alone returned on the old
-      # document whenever the server took longer than the window.
+      # poll briefly for either of them — a main-frame navigation start (see
+      # subscribe_to_navigation) or Runtime.executionContextsCleared — and if
+      # none fires within the window, assume the action was inert and exit
+      # fast. Lightpanda announces a navigation ~5 ms after the click but only
+      # swaps the execution context once the response lands, so watching the
+      # context alone returned on the old document whenever the server took
+      # longer than the window. The turbo sentinel does not end the sniff
+      # (it is awaited after): Turbo goes busy then idle within a few ms on a
+      # link it hands back to the browser, before the navigation start lands.
       SNIFF_WINDOW = 0.05
       private_constant :SNIFF_WINDOW
 
@@ -444,7 +447,6 @@ module Capybara
           navigating = @navigation_event.iteration > prior_navigation_iteration
           break if navigating
           break if @default_context_event.iteration > prior_context_iteration
-          break unless @turbo_event.set?
           break if monotonic_time > sniff_deadline
 
           sleep 0.001
@@ -452,7 +454,10 @@ module Capybara
 
         # Only a navigation this action started is awaited: one left pending
         # by an earlier load must not make every later click pay the timeout.
-        @navigation_event.wait(@options.timeout) if navigating
+        if navigating
+          @navigation_event.wait(@options.timeout)
+          wait_for_document_ready
+        end
         @default_context_event.wait(@options.timeout)
         @turbo_event.wait(@options.timeout)
         check_unhandled_modal!
@@ -658,6 +663,64 @@ module Capybara
         end
       end
 
+      # The new document's context exists before its deferred and module
+      # scripts have run: this event marks the end of that phase, at
+      # Page.domContentEventFired or anything later that proves it is over
+      # (load, the frame stopping, the document request failing).
+      def subscribe_to_document_ready
+        @document_ready_event = Utils::Event.new
+        @document_ready_event.set
+
+        on("Page.frameStartedNavigating") do |params|
+          @document_ready_event.reset if main_frame_navigation_start?(params)
+        end
+        on("Page.domContentEventFired") { @document_ready_event.set }
+        on("Page.loadEventFired") { @document_ready_event.set }
+        on("Page.frameStoppedLoading") do |params|
+          @document_ready_event.set if params["frameId"] == @target_id
+        end
+        on("Network.loadingFailed") do |params|
+          @document_ready_event.set if params["requestId"] == @navigation_request_id
+        end
+      end
+
+      # After a click that navigated, the next action must not run before the
+      # new page's JS has wired its handlers: Stimulus, Bootstrap's data-api
+      # and Turbo load as module scripts, which run after the document commits
+      # and before DOMContentLoaded. Cuprite waits for the load event. The
+      # event is awaited briefly, then document.readyState is polled for the
+      # rest of the budget, as #go_to does (lightpanda-io/browser#1801: page
+      # events may never come). Never raises: a page that never settles costs
+      # the timeout once, then the action returns as it did before.
+      DOCUMENT_READY_EVENT_WAIT = 2
+      private_constant :DOCUMENT_READY_EVENT_WAIT
+
+      def wait_for_document_ready
+        deadline = monotonic_time + @options.timeout
+        return if @document_ready_event.wait([DOCUMENT_READY_EVENT_WAIT, @options.timeout].min)
+
+        remaining = deadline - monotonic_time
+        return unless remaining.positive?
+
+        Utils::Wait.until(timeout: remaining, interval: 0.1) do
+          @document_ready_event.set? || @client.closed? || document_complete?
+        end
+      rescue TimeoutError
+        nil
+      end
+
+      def document_complete?
+        response = @client.command(
+          "Runtime.evaluate",
+          { expression: "document.readyState", returnByValue: true },
+          session_id: @session_id,
+          timeout: 2
+        )
+        response.dig("result", "value") == "complete"
+      rescue Error
+        false
+      end
+
       def main_frame_navigation_start?(params)
         params["frameId"] == @target_id && !params["navigationType"].to_s.match?(/same/i)
       end

data/lib/capybara/lightpanda/client/web_socket.rb

@@ -26,11 +26,18 @@ module Capybara
           connect
         end
 
-        def send_message(message)
+        # `timeout` bounds how long the browser may go without taking any of
+        # the frame's bytes (see #write); nil falls back to options.timeout.
+        def send_message(message, timeout: nil)
           raise DeadBrowserError, "WebSocket is not open" unless @status == :open
 
           @logger&.puts("\n\n▶ #{@logger.elapsed_time} #{message}")
-          @driver_mutex.synchronize { @driver.text(message) }
+          @driver_mutex.synchronize do
+            @write_timeout = timeout
+            @driver.text(message)
+          ensure
+            @write_timeout = nil
+          end
         end
 
         # The socket is closed even when the connection is already dead. A
@@ -53,8 +60,25 @@ module Capybara
           @status == :closed || @status == :error
         end
 
+        # Called by websocket-driver, always under @driver_mutex. A browser
+        # that stops reading (hung, stopped, or a page stuck in a sync JS loop
+        # on Lightpanda's single thread) would block a plain write forever
+        # once the frame outgrows the socket buffers, holding the lock that
+        # every other command, the reader's parse and #close need — and the
+        # command timeout only starts after the write returns. So the write
+        # gives up once the browser takes no byte for the timeout; the wait
+        # restarts on every partial write, so a slow but moving peer is fine
+        # (ferrum #644). Close and pong frames have no command timeout and
+        # fall back to options.timeout rather than waiting forever.
         def write(data)
-          @socket.write(data)
+          until data.empty?
+            written = @socket.write_nonblock(data, exception: false)
+            if written.is_a?(Integer)
+              data = data.byteslice(written..)
+            elsif !wait_for_socket(written)
+              abandon_stalled_write
+            end
+          end
         rescue Errno::EPIPE, Errno::ECONNRESET, IOError
           mark_dead
         end
@@ -71,6 +95,21 @@ module Capybara
 
         private
 
+        def wait_for_socket(state)
+          timeout = @write_timeout || @options.timeout
+          state == :wait_readable ? @socket.wait_readable(timeout) : @socket.wait_writable(timeout)
+        end
+
+        # The frame was cut off midway, so the connection can't be reused:
+        # mark it dead (the reader and message threads stop, pending commands
+        # are released) and close the socket.
+        def abandon_stalled_write
+          timeout = @write_timeout || @options.timeout
+          mark_dead(:error)
+          close_socket
+          raise DeadBrowserError, "Browser accepted no data for #{timeout}s and is likely stuck; connection closed"
+        end
+
         def close_socket
           @socket&.close unless @socket.nil? || @socket.closed?
         rescue IOError, SystemCallError

data/lib/capybara/lightpanda/client.rb

@@ -22,18 +22,18 @@ module Capybara
 
       def command(method, params = {}, async: false, session_id: nil, timeout: nil)
         message = build_message(method, params, session_id: session_id)
+        effective_timeout = timeout || @options.timeout
 
         if async
-          @ws.send_message(JSON.generate(message))
+          @ws.send_message(JSON.generate(message), timeout: effective_timeout)
           return true
         end
 
         pending = Concurrent::IVar.new
         @pendings[message[:id]] = pending
 
-        @ws.send_message(JSON.generate(message))
+        @ws.send_message(JSON.generate(message), timeout: effective_timeout)
 
-        effective_timeout = timeout || @options.timeout
         response = pending.value!(effective_timeout)
 
         if response.nil?

data/lib/capybara/lightpanda/node.rb

@@ -638,8 +638,27 @@ module Capybara
           }
           hit.dispatchEvent(new EventCtor('mouseup', { bubbles: true, cancelable: true }));
           var clickEvt = new EventCtor('click', { bubbles: true, cancelable: true });
-          var notCancelled = hit.dispatchEvent(clickEvt);
-          if (!notCancelled || clickEvt.defaultPrevented) return;
+          // A link to a scheme the browser can't fetch (mailto:, tel:, sms:…)
+          // goes to an external app in Chrome and the page stays. Below
+          // upstream #3940 (build 10536) the link's own activation instead
+          // turns `mailto:a@b.com` into `http://mailto:a@b.com/` and loads
+          // b.com (1.0.0), or loses the execution context on a failed `tel:`
+          // navigation (10261–10535). Cancel that default from a window
+          // listener added for this one dispatch: it runs after the page's
+          // own listeners, which still see an uncancelled click.
+          var link = hit.closest ? hit.closest('a[href]') : null;
+          var scheme = link && /^\\s*([a-z][a-z0-9+.-]*):/i.exec(link.getAttribute('href'));
+          var external = !!scheme && !/^(https?|about|blob|data|file|javascript)$/i.test(scheme[1]);
+          var view = hit.ownerDocument.defaultView;
+          var keepPage = function (e) { if (e === clickEvt) e.preventDefault(); };
+          if (external && view) view.addEventListener('click', keepPage);
+          var notCancelled;
+          try {
+            notCancelled = hit.dispatchEvent(clickEvt);
+          } finally {
+            if (external && view) view.removeEventListener('click', keepPage);
+          }
+          if (external || !notCancelled || clickEvt.defaultPrevented) return;
           var tag = hit.tagName;
           // A `javascript:` link never navigates: the click's own activation
           // behavior has already run its code. Assigning it to location.href

data/lib/capybara/lightpanda/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Lightpanda
-    VERSION = "0.14.0"
+    VERSION = "0.14.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-lightpanda
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.14.2
 platform: ruby
 authors:
 - Navid Emad