capybara-dommy 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 288082f09fb0e1151ba15dfa7bce080997855de9ac4cbced143238b8fbc6db6b
-  data.tar.gz: 8c7c68b114eb0526071f15ae2675a94bc38492161fadbf29f3b5cf934d810f09
+  metadata.gz: f6479bfca855b3003e8b6b7876981e9b59b5a2fa870b96b2528e387966986d90
+  data.tar.gz: 54d05d18a6bd90fd2a795543130c54e8bc62d438a21c8a14f0fd06f83f5918d4
 SHA512:
-  metadata.gz: a6544c835b5721f26d77ab97c8278dc7a722c859a86c32ca06b81c263c8cb5a2d9062b318b92e731dd646795cb634bc69c91bbb229da6de3dbaf719f1bec2887
-  data.tar.gz: 707be8eeb45ba4a7ca871f1aef7160755bc0fb8a33f587b9bd37ea10fc69c9095c164684d765a5884ca7c1f79d69db650bc0fe758cdc5b752c3d61715abee610
+  metadata.gz: 588846fe1ca9d36119c237d71349d1af04fe5082fc73d64dbb48f8b7cc8b097b607d25bbb1af888ec58157547bd03793947faacf22106df80dc96d2a17a767bf
+  data.tar.gz: 48594055d5a1a63e80634fee2bc57c566ce8f33363c7163c58c6dc0b9df9aa6cfd612a9feec5321f3d326baa63a3e715072f6c50f3f75a5676f2d659d6975ce6

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.11.0 — 2026-09-11
+
+### Added
+- **Native dialog helpers in JS mode.** `accept_confirm`, `dismiss_confirm`, `accept_alert`, `accept_prompt` (with `with:`) and `dismiss_prompt` work against the page's real `confirm` / `alert` / `prompt`, including a `text:` string or Regexp to say which dialog is expected. Nested helper blocks answer the dialogs in the order the page opens them, and a dialog nobody is waiting for falls back to the headless default, so a stray `confirm` cannot silently accept. A block that opens no matching dialog raises `Capybara::ModalNotFound`, naming what turned up instead.
+
+### Fixed
+- Turbo-driven navigation in JS apps is followed, so `have_current_path` and the matchers after a Turbo visit see the page the app actually moved to.
+- `current_url` advances the virtual clock like the other queries do, so a `have_current_path` poll converges when the navigation settles in a scheduled task rather than a microtask.
+
+## 0.10.0 — 2026-07-13
+
+### Added
+- **JavaScript-enabled driver variant** (`:dommy_js`, or `Driver.new(app, javascript: true)` / `config.javascript`): pages run their real Turbo/Stimulus/React bundles in the embedded QuickJS runtime, no browser process. Node interactions behave like a browser instead of the HTML-only fast paths — `click` dispatches the full pointer/mouse/click sequence before the default action (Turbo can `preventDefault` and take over), `set` types with focus + `input` / `change` events, `select_option` fires `input` / `change`, and `send_keys` dispatches real keyboard events. `execute_script` / `evaluate_script` run for real, and a time pump advances the virtual clock inside Capybara's synchronize loop so waiting matchers converge. Requires `dommy-js-quickjs`.
+
+### Fixed
+- The dommy-rack session is fully disposed on `reset!` and when the effective host changes, so JS runtimes and open WebSocket transports no longer leak across tests.
+
 ## 0.9.0 — 2026-06-22
 
 Versioned in lockstep with [`dommy`](https://github.com/takahashim/dommy) 0.9.0.

data/README.md

@@ -19,15 +19,24 @@ speed and simplicity of a Rack-style driver.
 - Preserves session state such as cookies, follows redirects by default, and
   supports browser-like back, forward, and refresh navigation.
 - Implements HTML-level visibility through `dommy-rack`.
+- In JavaScript-enabled mode, supports Capybara's `accept_alert`,
+  `accept_confirm`, `dismiss_confirm`, `accept_prompt`, and `dismiss_prompt`
+  helpers with deterministic responses.
 - Provides a Rails convenience require for `driven_by :dommy`.
 
 ## Limitations
 
 `capybara-dommy` is intentionally not a browser automation driver.
 
-- JavaScript is not executed.
-- Screenshots, browser windows, alerts, confirms, prompts, and other real
-  browser features are not supported.
+- The default driver does not execute JavaScript. Use the JavaScript-enabled
+  variant for embedded QuickJS execution.
+- Screenshots and browser windows are not supported. Native alerts, confirms,
+  and prompts are supported by the JavaScript-enabled variant through
+  Capybara's modal helpers.
+- Constructable stylesheets can be built (`new CSSStyleSheet()`), but
+  `adoptedStyleSheets` is not implemented — assigning one applies no style.
+  Component libraries that feature-detect (`'adoptedStyleSheets' in
+  Document.prototype`) fall back to injecting a `<style>`, which is handled.
 - CSS layout is not calculated. Visibility is based on HTML-level rules such as
   `hidden`, `type="hidden"`, and inline `display: none` handling provided by
   `dommy-rack`.

data/lib/capybara/dommy/configuration.rb

@@ -6,7 +6,7 @@ module Capybara
     # when a keyword argument is omitted.
     class Configuration
       attr_accessor :default_host, :follow_redirects, :max_redirects, :visibility,
-                    :raise_on_unsupported_js
+                    :raise_on_unsupported_js, :javascript
 
       def initialize
         @default_host = "http://example.org"
@@ -14,6 +14,7 @@ module Capybara
         @max_redirects = 5
         @visibility = :html
         @raise_on_unsupported_js = true
+        @javascript = false
       end
     end
 

data/lib/capybara/dommy/driver.rb

@@ -4,9 +4,10 @@ module Capybara
   module Dommy
     # A Capybara driver backed by Dommy::Rack::Session. Implements the
     # navigation / query / reset! parts of the Capybara::Driver::Base contract;
-    # element interaction lives in Capybara::Dommy::Node. JavaScript, screenshot,
-    # window, and modal methods are left to Driver::Base (which raises
-    # Capybara::NotSupportedByDriverError).
+    # element interaction lives in Capybara::Dommy::Node. The JS-enabled mode
+    # additionally supplies deterministic native dialog responses for Capybara's
+    # alert/confirm/prompt helpers. Screenshot and window methods remain with
+    # Driver::Base (which raises Capybara::NotSupportedByDriverError).
     class Driver < Capybara::Driver::Base
       VISIBILITY_MODES = %i[all html none].freeze
 
@@ -28,10 +29,12 @@ module Capybara
                      default_host: nil,
                      follow_redirects: nil,
                      max_redirects: nil,
-                     visibility: nil)
+                     visibility: nil,
+                     javascript: nil)
         super()
         config = Capybara::Dommy.configuration
         @app = app
+        @javascript = javascript.nil? ? config.javascript : javascript
         @visibility = visibility || config.visibility
         unless VISIBILITY_MODES.include?(@visibility)
           raise ArgumentError,
@@ -46,6 +49,24 @@ module Capybara
           # hosts (e.g. app_host / multi-server specs), so don't enforce origin.
           enforce_same_origin: false
         }
+        @session_options[:javascript] = true if @javascript
+        # A JS session needs the virtual clock pumped inside Capybara's
+        # synchronize loop, so waiting expectations converge on timer/fetch
+        # driven updates. A host-installed pump (the documented seam) wins.
+        @time_pump ||= -> { @rack_session&.advance_time(16) } if @javascript
+      end
+
+      # Whether this driver runs page JavaScript (`javascript: true`, backed by
+      # a `Dommy::Rack::Session.new(app, javascript: true)`). Node interactions
+      # then dispatch real DOM events (Turbo/Stimulus handlers run) instead of
+      # the HTML-only fast paths.
+      def javascript? = @javascript
+
+      # Drain the JS runtime after an interaction's events (promise reactions
+      # settle before the next Capybara step). No-op without JavaScript.
+      def drain_js
+        rack_session.after_interaction if @javascript
+        nil
       end
 
       # The dommy-rack session. Named `rack_session` to avoid colliding with
@@ -55,6 +76,7 @@ module Capybara
       def rack_session
         host = effective_host
         if @rack_session.nil? || @rack_session_host != host
+          @rack_session&.dispose
           @rack_session = ::Dommy::Rack::Session.new(@app, **@session_options.merge(default_host: host))
           @rack_session_host = host
         end
@@ -73,6 +95,12 @@ module Capybara
       end
 
       def current_url
+        # Capybara polls current_url for have_current_path. In JS mode that poll
+        # must advance the virtual clock too: Turbo/fetch continuations often
+        # settle in a scheduled task rather than the interaction's microtask
+        # drain. The Rack session's History hook then reflects pushState in its
+        # current URL.
+        pump!
         rack_session.current_url.to_s
       end
 
@@ -179,6 +207,7 @@ module Capybara
       # --- Lifecycle ---
 
       def reset!
+        @rack_session&.dispose
         @rack_session = nil
         @frame_stack = []
       end
@@ -200,18 +229,40 @@ module Capybara
       # When raise_on_unsupported_js is false these become no-ops, so tests
       # that incidentally call them don't fail.
 
-      def execute_script(_script, *_args)
-        unsupported_js!("execute_script")
+      def execute_script(script, *args)
+        return unsupported_js!("execute_script") unless @javascript
+        raise ArgumentError, "script arguments are not supported" unless args.empty?
+
+        rack_session.execute_script(script)
       end
 
-      def evaluate_script(_script, *_args)
-        unsupported_js!("evaluate_script")
+      def evaluate_script(script, *args)
+        return unsupported_js!("evaluate_script") unless @javascript
+        raise ArgumentError, "script arguments are not supported" unless args.empty?
+
+        rack_session.evaluate_script(script)
       end
 
       def evaluate_async_script(_script, *_args)
         unsupported_js!("evaluate_async_script")
       end
 
+      # --- Native dialogs ---
+      #
+      # A native dialog is synchronous in Dommy, so installing the expected
+      # answer before the triggering block runs is sufficient. What is expected,
+      # what it answers and what it saw instead live in ModalExpectation; the
+      # stack they sit on, which is the session's dialog handler while a helper
+      # block is running, is ModalStack.
+
+      def accept_modal(type, **options, &block)
+        respond_to_modal(type, accept: true, **options, &block)
+      end
+
+      def dismiss_modal(type, **options, &block)
+        respond_to_modal(type, accept: false, **options, &block)
+      end
+
       # Visibility decision used by Node#visible?. :all / :none treat every
       # element as visible; :html defers to dommy-rack's HTML-level check.
       def visible?(element)
@@ -295,6 +346,26 @@ module Capybara
         raise Capybara::NotSupportedByDriverError,
               "capybara-dommy does not support JavaScript (#{name})"
       end
+
+      def respond_to_modal(type, accept:, text: nil, with: nil, **_options)
+        expectation = ModalExpectation.new(type: type, accept: accept, text: text, with: with)
+        modals.push(expectation)
+        rack_session.dialog_handler = modals
+        yield if block_given?
+
+        raise Capybara::ModalNotFound, expectation.not_found_message unless expectation.answered?
+
+        expectation.message
+      ensure
+        if expectation
+          modals.delete(expectation)
+          rack_session.dialog_handler = nil if modals.empty? && @rack_session
+        end
+      end
+
+      def modals
+        @modals ||= ModalStack.new
+      end
     end
   end
 end

data/lib/capybara/dommy/modal.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Capybara
+  module Dommy
+    # What one `accept_modal` / `dismiss_modal` block is waiting for, and what
+    # it saw. A native dialog is synchronous in Dommy, so the expectation is
+    # installed before the triggering block runs and answers the dialog the
+    # block opens.
+    class ModalExpectation
+      attr_reader :type, :text
+      # The message of the dialog this expectation answered — nil while it is
+      # still waiting, which is what makes it "not found" at the end of the
+      # block.
+      attr_reader :message
+
+      def initialize(type:, accept:, text: nil, with: nil)
+        @type = type.to_sym
+        @accept = accept
+        @text = text
+        @with = with
+        @message = nil
+        @actual = nil
+      end
+
+      def matches?(type, message)
+        @type == type && text_matches?(message)
+      end
+
+      def answered? = !@message.nil?
+
+      # Record that this dialog is the one, and answer it: a confirm with the
+      # accept/dismiss decision, a prompt with the text to type (`with:`, else
+      # what the page offered) or nil when dismissed. An alert has no answer.
+      def answer(message, default_value)
+        @message = message
+        case @type
+        when :confirm then @accept
+        when :prompt then @accept ? (@with || default_value) : nil
+        end
+      end
+
+      # A dialog this expectation did not want. Remembered for the error at the
+      # end of the block, which says what turned up instead.
+      def saw(type, message)
+        @actual = {type: type, message: message}
+        nil
+      end
+
+      def not_found_message
+        if @actual
+          "Unable to find #{@type} dialog with #{@text.inspect} - found " \
+            "#{@actual[:type]} dialog with #{@actual[:message].inspect} instead."
+        else
+          "Unable to find #{@type} dialog#{@text ? " with #{@text.inspect}" : ""}"
+        end
+      end
+
+      private
+
+      def text_matches?(message)
+        return true if @text.nil?
+
+        pattern = @text.is_a?(Regexp) ? @text : Regexp.new(Regexp.escape(@text.to_s))
+        pattern.match?(message)
+      end
+    end
+
+    # The expectations currently in scope, innermost first, as the dialog
+    # handler a Dommy Window asks (it calls `#call`).
+    #
+    # A stack, because Capybara expresses nested confirms as nested helper
+    # blocks while the page opens them sequentially in one JS call stack:
+    # consuming the inner expectation exposes the outer answer to the next
+    # confirm immediately.
+    class ModalStack
+      def initialize
+        @expectations = []
+      end
+
+      def empty? = @expectations.empty?
+
+      def push(expectation)
+        @expectations << expectation
+        expectation
+      end
+
+      # By identity: two helper blocks with the same arguments build EQUAL
+      # expectations, and removing by value would drop the caller's alongside
+      # this one.
+      def delete(expectation)
+        @expectations.delete_if { |e| e.equal?(expectation) }
+        nil
+      end
+
+      # The dialog handler protocol: answer the dialog, or return
+      # DIALOG_UNANSWERED to leave it to the Window's headless default. An
+      # expectation that does not want this dialog remembers it (so the block
+      # can say what turned up instead) and declines rather than answering.
+      def call(type, message, default_value)
+        expectation = @expectations.last
+        return ::Dommy::Window::DIALOG_UNANSWERED if expectation.nil?
+
+        unless expectation.matches?(type, message)
+          expectation.saw(type, message)
+          return ::Dommy::Window::DIALOG_UNANSWERED
+        end
+
+        answer = expectation.answer(message, default_value)
+        delete(expectation)
+        answer
+      end
+    end
+  end
+end

data/lib/capybara/dommy/node.rb

@@ -107,6 +107,12 @@ module Capybara
       # Capybara's non-JS send_keys specs use. Key *events* are not dispatched
       # (nothing here can observe them without JavaScript).
       def send_keys(*args)
+        # Under JavaScript, dispatch real keyboard events (keydown/keypress/
+        # input/keyup with browser default actions) through the dommy driver,
+        # so keyboard handlers (arrow navigation, Enter selection) run.
+        # Key chords ([:shift, "o"]) are not supported on this path.
+        return driver.rack_session.send_keys_to(native, *args) if driver.javascript?
+
         return unless native.respond_to?(:value=)
 
         state = {chars: native.value.to_s.chars, caret: native.value.to_s.length, shift: false}
@@ -136,6 +142,8 @@ module Capybara
       # --- Interaction ---
 
       def click(_keys = [], **_options)
+        return js_click if driver.javascript?
+
         if link?
           click_link_node
         elsif submits?
@@ -171,6 +179,7 @@ module Capybara
         select_el = select_node
         deselect_all(select_el) unless select_el&.multiple
         native.selected = true
+        notify_select_changed(select_el)
       end
 
       def unselect_option
@@ -257,6 +266,40 @@ module Capybara
       # javascript: links are no-ops in Capybara (a policy decision); every
       # other link delegates to dommy-rack, which handles fragment / same-page
       # / blank-href semantics and raises on genuinely unsupported schemes.
+      # A JavaScript click: dispatch the full pointer/mouse/click sequence
+      # (Stimulus actions, Turbo's link/submit interception run like in a
+      # browser), then perform the un-prevented default action ourselves —
+      # link navigation, or the form submission algorithm (a cancelable
+      # submit event, then the real submission if nothing canceled it;
+      # Turbo cancels and takes over). Checkbox/radio toggling already ran
+      # as the click event's activation behavior.
+      def js_click
+        prevented = ::Dommy::Interaction::EventSynthesis.click(native)
+        unless prevented
+          # Link navigation and form submission are the elements' own activation
+          # behavior — run inside EventSynthesis.click above, routing through the
+          # session's navigation delegate (performed when driver.drain_js drains).
+          # Only the non-navigating default actions remain here.
+          if tag_name == "label"
+            click_label
+          elsif (details = native.closest("details"))
+            toggle_details(details)
+          end
+        end
+        driver.drain_js
+        nil
+      end
+
+      # Selecting an option through the UI fires input + change on the select
+      # (under JavaScript; nothing listens without it).
+      def notify_select_changed(select_el)
+        return unless driver.javascript? && select_el
+
+        ::Dommy::Interaction::EventSynthesis.input(select_el)
+        ::Dommy::Interaction::EventSynthesis.change(select_el)
+        driver.drain_js
+      end
+
       def click_link_node
         scheme = native.get_attribute("href").to_s.split(":", 2).first.to_s.downcase
         return if scheme == "javascript"
@@ -303,11 +346,28 @@ module Capybara
         # There is no submitter button in this case.
         form = single_field_form
         if input_field? && string.end_with?("\n") && form
-          native.value = string.chomp
+          write_text(string.chomp)
           driver.submit_form(form, submitter: nil)
         else
+          write_text(string)
+        end
+      end
+
+      # Set a text field's value. Under JavaScript this types like a user:
+      # focus, value, then input + change events, so Stimulus/React handlers
+      # observe the edit; the JS-less driver keeps the bare value write
+      # (nothing listens).
+      def write_text(string)
+        unless driver.javascript?
           native.value = string
+          return
         end
+
+        ::Dommy::Interaction::EventSynthesis.focus(native)
+        native.value = string
+        ::Dommy::Interaction::EventSynthesis.input(native, string)
+        ::Dommy::Interaction::EventSynthesis.change(native)
+        driver.drain_js
       end
 
       def single_field_form

data/lib/capybara/dommy/rails.rb

@@ -8,3 +8,10 @@ require "capybara/dommy"
 Capybara.register_driver(:dommy) do |app|
   Capybara::Dommy::Driver.new(app)
 end
+
+# The JavaScript-enabled variant (`driven_by :dommy_js`): pages run their real
+# Turbo/Stimulus/React bundles in the embedded QuickJS runtime, no browser
+# process. Requires dommy-js-quickjs.
+Capybara.register_driver(:dommy_js) do |app|
+  Capybara::Dommy::Driver.new(app, javascript: true)
+end

data/lib/capybara/dommy/version.rb

@@ -2,6 +2,6 @@
 
 module Capybara
   module Dommy
-    VERSION = "0.9.0"
+    VERSION = "0.11.0"
   end
 end

data/lib/capybara/dommy.rb

@@ -8,6 +8,7 @@ require_relative "dommy/version"
 require_relative "dommy/errors"
 require_relative "dommy/configuration"
 require_relative "dommy/text_extractor"
+require_relative "dommy/modal"
 require_relative "dommy/node"
 require_relative "dommy/driver"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capybara-dommy
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - takahashim
@@ -29,28 +29,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: dommy-rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.11.0
 description: |
   capybara-dommy is a Capybara driver backed by Dommy and dommy-rack. It drives
   Rack/Rails apps through the Capybara DSL without a real browser or JavaScript,
@@ -69,6 +69,7 @@ files:
 - lib/capybara/dommy/configuration.rb
 - lib/capybara/dommy/driver.rb
 - lib/capybara/dommy/errors.rb
+- lib/capybara/dommy/modal.rb
 - lib/capybara/dommy/node.rb
 - lib/capybara/dommy/rails.rb
 - lib/capybara/dommy/text_extractor.rb