turbo_rspec 1.5.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d66e89583c0c374bd4b69c308390e275e70623726fd8cdc6f7f44e4df7028e06
-  data.tar.gz: a0be5a9653a1cfc59604b506ac2d890db6f1fd931800e21f9eccf528895d3bb8
+  metadata.gz: 3211f811cbd7919d35f8b918260ea97346668fb2ef3213f189d91c642a014b53
+  data.tar.gz: dda8641bcf4d6cb1a8ebc6de4ee5d7622f90bcec3a79b8180444b6e4bfcd2c38
 SHA512:
-  metadata.gz: 49f3d0f02e97d332ed7a8c9bc28bd5c555c7ce8d969647a691e38d064afe94a77e8f0b1bd4c42b3138917c0291031aab073ae132482db60569c252acbe889c97
-  data.tar.gz: 41dad12a7885d0091afc1d5fa01b322f884c295b12ae753795c59ba86bbf86123281c768415c9bfa89c79d3f2812210680fcb7fd19e7f66a402db0b31cf7106e
+  metadata.gz: 352e59c5604c6362263a51d6b0eb9903b1b7c7b337bca65a05e01c15b42bae5e121def5d638ed66f8b73d06fda382460a85dce4d15ab7a3bff234fb26c310759
+  data.tar.gz: 1243fc05f3fc0256f3e028c66d505a0cbf8335108238c6fde0c0b4e6a0fc97f630bd2ae59c51cb37e64a0ce81265fb20b2d8c9be2e850ef7b29a3442c18f6991

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [1.6.0] - 2026-06-02
+
+### Added
+
+- `have_stimulus_controller`, `have_stimulus_action`, `have_stimulus_target` request-spec matchers — assert Stimulus `data-*` attributes in response HTML, auto-included in `type: :request` and `type: :controller` example groups
+- `assert_broadcasted_turbo_stream_to` and `refute_broadcasted_turbo_stream_to` in `TurboRspec::Assertions` — Minitest broadcast parity with the RSpec `have_broadcasted_turbo_stream_to` matcher
+- `have_turbo_frame` (Capybara) `.eager` chain — asserts `loading="eager"` on the frame (Turbo 8)
+- `have_turbo_frame` (Capybara) `.strict` chain — asserts the `[strict]` boolean attribute on the frame (Turbo 8)
+
 ## [1.5.0] - 2026-06-02
 
 ### Added

data/README.md

@@ -8,10 +8,10 @@
 
 Drop-in test matchers for [hotwired/turbo-rails](https://github.com/hotwired/turbo-rails) — replace every hand-rolled Turbo helper in your test suite with a single gem.
 
-- **Request/controller specs** — `have_turbo_stream`, `have_turbo_frame`, `have_turbo_streams`
+- **Request/controller specs** — `have_turbo_stream`, `have_turbo_frame`, `have_turbo_streams`, `have_stimulus_controller`, `have_stimulus_action`, `have_stimulus_target`
 - **Broadcast specs** — `have_broadcasted_turbo_stream_to` with count qualifiers
 - **System/feature specs** — Capybara matchers: `have_turbo_frame`, `have_turbo_stream_tag`, `within_turbo_frame`, `have_stimulus_controller`, `have_stimulus_action`, `have_stimulus_target`
-- **Minitest** — `assert_turbo_stream`, `refute_turbo_stream`, `assert_turbo_frame`, `refute_turbo_frame`
+- **Minitest** — `assert_turbo_stream`, `refute_turbo_stream`, `assert_turbo_frame`, `refute_turbo_frame`, `assert_broadcasted_turbo_stream_to`, `refute_broadcasted_turbo_stream_to`
 - **Factory helpers** — `turbo_stream_html`, `turbo_frame_html`
 - **Shared examples** — `it_behaves_like "a turbo stream response"`
 - **Auto-included** — zero setup required when `turbo-rails` is in your bundle
@@ -220,6 +220,12 @@ expect(page).to have_turbo_frame("messages").loaded
 # Lazy frame — assert loading="lazy" attribute
 expect(page).to have_turbo_frame("messages").lazy
 
+# Eager frame — assert loading="eager" attribute (Turbo 8)
+expect(page).to have_turbo_frame("messages").eager
+
+# Strict frame — assert [strict] attribute (Turbo 8)
+expect(page).to have_turbo_frame("messages").strict
+
 # With src — assert the src attribute on a lazy-loaded frame
 expect(page).to have_turbo_frame("messages").with_src("/messages/new")
 
@@ -246,22 +252,22 @@ end
 
 ### Stimulus matchers
 
-Assert Stimulus controller, action, and target attributes on the page (Capybara).
+`have_stimulus_controller`, `have_stimulus_action`, and `have_stimulus_target` work in both **request specs** (parsing response HTML) and **system/feature specs** (Capybara).
 
 ```ruby
-# Controller — data-controller contains "hello"
-expect(page).to have_stimulus_controller("hello")
+# Request specs — asserts Stimulus attributes in rendered HTML response
+expect(response).to have_stimulus_controller("hello")
+expect(response).to have_stimulus_action("click->hello#greet")
+expect(response).to have_stimulus_action("hello#greet")   # shorthand — matches any event
+expect(response).to have_stimulus_target("hello", "name")
 
-# Action — full descriptor
+# System/feature specs — asserts on the live Capybara page
+expect(page).to have_stimulus_controller("hello")
 expect(page).to have_stimulus_action("click->hello#greet")
-
-# Action — shorthand without event (matches any event prefix)
-expect(page).to have_stimulus_action("hello#greet")
-
-# Target — data-hello-target contains "name"
 expect(page).to have_stimulus_target("hello", "name")
 
 # Negation
+expect(response).not_to have_stimulus_controller("missing")
 expect(page).not_to have_stimulus_controller("missing")
 ```
 
@@ -430,6 +436,11 @@ refute_turbo_frame(response, id: "notifications")
 
 # Custom failure message
 assert_turbo_stream(response, action: :append, message: "expected append stream")
+
+# Broadcast assertions (requires ActionCable test adapter)
+assert_broadcasted_turbo_stream_to("notifications") { MyJob.perform_now }
+assert_broadcasted_turbo_stream_to("notifications", action: :append, target: "messages") { MyJob.perform_now }
+refute_broadcasted_turbo_stream_to("notifications") { MyJob.perform_now }
 ```
 
 ## Contributing

data/ROADMAP.md

@@ -2,14 +2,6 @@
 
 RSpec matchers for [Turbo](https://github.com/hotwired/turbo-rails): Turbo Streams, Turbo Frames, and ActionCable broadcasts. The goal is to replace the hand-rolled helpers that every Rails/Turbo project accumulates.
 
-## 1.6 — Minitest & Turbo 8 extensions
-
-- **`assert_broadcasted_turbo_stream_to` / `refute_broadcasted_turbo_stream_to`** — `TurboRspec::Assertions` covers request-spec stream and frame assertions but has no broadcast counterpart. Teams using Minitest with ActionCable have no parity with the RSpec broadcast matcher.
-- **`have_turbo_frame` Capybara `.eager` and `.strict` chains** — `.lazy` is already supported; Turbo 8 also added `loading="eager"` and a `[strict]` boolean attribute for strict frame loading. Both are missing from the Capybara matcher.
-- **Stimulus request-spec matchers** — `have_stimulus_controller`, `have_stimulus_action`, and `have_stimulus_target` currently only work in Capybara system/feature specs. Teams writing request specs can't assert Stimulus attributes on rendered HTML responses without dropping to raw string matching.
-
----
-
 ## Guiding principles
 
 - **Zero magic by default.** Auto-include only when it's unambiguous (Rails request specs). Everything else is opt-in.

data/lib/turbo_rspec/assertions.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "matchers/have_broadcasted_turbo_stream_to"
 require_relative "matchers/have_turbo_frame"
 require_relative "matchers/have_turbo_stream"
 
@@ -12,6 +13,30 @@ module TurboRspec
   #
   # No RSpec dependency required.
   module Assertions
+    # Assert that a block broadcasts a +<turbo-stream>+ to the given stream.
+    # Requires ActionCable's test adapter.
+    #
+    # @param stream [String] the stream name
+    # @param action [Symbol, String, nil] optional action constraint
+    # @param target [String, nil] optional target constraint
+    # @param targets [String, nil] optional targets (CSS selector) constraint
+    # @param content [String, nil] optional content constraint
+    # @param partial [String, nil] optional partial path constraint
+    # @param message [String, nil] optional custom failure message
+    def assert_broadcasted_turbo_stream_to(stream, action: nil, target: nil, targets: nil, content: nil, partial: nil, message: nil, &block)
+      matcher = build_broadcast_matcher(stream, action: action, target: target, targets: targets, content: content, partial: partial)
+      assert matcher.matches?(block), message || matcher.failure_message
+    end
+
+    # Assert that a block does NOT broadcast a +<turbo-stream>+ to the given stream.
+    # Requires ActionCable's test adapter.
+    #
+    # @param stream [String] the stream name
+    def refute_broadcasted_turbo_stream_to(stream, action: nil, target: nil, targets: nil, content: nil, partial: nil, message: nil, &block)
+      matcher = build_broadcast_matcher(stream, action: action, target: target, targets: targets, content: content, partial: partial)
+      assert matcher.does_not_match?(block), message || matcher.failure_message_when_negated
+    end
+
     def assert_turbo_stream(response_or_body, action: nil, target: nil, targets: nil, content: nil, partial: nil, message: nil)
       matcher = build_stream_matcher(action: action, target: target, targets: targets, content: content, partial: partial)
       assert matcher.matches?(response_or_body), message || matcher.failure_message
@@ -34,6 +59,16 @@ module TurboRspec
 
     private
 
+    def build_broadcast_matcher(stream, action:, target:, targets:, content:, partial:)
+      matcher = Matchers::HaveBroadcastedTurboStreamTo.new(stream)
+      matcher.with_action(action) if action
+      matcher.targeting(target) if target
+      matcher.targeting_all(targets) if targets
+      matcher.with_content(content) if content
+      matcher.rendering(partial) if partial
+      matcher
+    end
+
     def build_stream_matcher(action:, target:, targets:, content:, partial:)
       matcher = Matchers::HaveTurboStream.new
       matcher.with_action(action) if action

data/lib/turbo_rspec/capybara/matchers/have_turbo_frame.rb

@@ -10,6 +10,8 @@ module TurboRspec
           @loaded = false
           @src = nil
           @lazy = false
+          @eager = false
+          @strict = false
         end
 
         def with_content(text)
@@ -37,11 +39,27 @@ module TurboRspec
           self
         end
 
+        # Constrains the match to frames with +loading="eager"+.
+        # @return [self]
+        def eager
+          @eager = true
+          self
+        end
+
+        # Constrains the match to frames with the +[strict]+ attribute (Turbo 8).
+        # @return [self]
+        def strict
+          @strict = true
+          self
+        end
+
         def matches?(page_or_node)
           @node = find_frame(page_or_node)
           return false unless @node
           return false if @loaded && !@node[:complete]
           return false if @lazy && @node[:loading] != "lazy"
+          return false if @eager && @node[:loading] != "eager"
+          return false if @strict && @node[:strict].nil?
           return false if @src && @node[:src] != @src
           return false if @content && !@node.has_content?(@content, wait: 0)
           true
@@ -58,6 +76,10 @@ module TurboRspec
             "expected turbo-frame##{@id} to be loaded (missing [complete] attribute)"
           elsif @lazy && @node[:loading] != "lazy"
             "expected turbo-frame##{@id} to be lazy (missing loading=\"lazy\" attribute)"
+          elsif @eager && @node[:loading] != "eager"
+            "expected turbo-frame##{@id} to be eager (missing loading=\"eager\" attribute)"
+          elsif @strict && @node[:strict].nil?
+            "expected turbo-frame##{@id} to be strict (missing [strict] attribute)"
           elsif @src && @node[:src] != @src
             "expected turbo-frame##{@id} to have src #{@src.inspect}, got #{@node[:src].inspect}"
           else
@@ -85,6 +107,8 @@ module TurboRspec
           parts = []
           parts << " loaded" if @loaded
           parts << " lazy" if @lazy
+          parts << " eager" if @eager
+          parts << " strict" if @strict
           parts << " with src #{@src.inspect}" if @src
           parts << " with content #{@content.inspect}" if @content
           parts.join

data/lib/turbo_rspec/matchers/have_stimulus_action.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module TurboRspec
+  module Matchers
+    # RSpec matcher for asserting that a response body contains an element with
+    # the given Stimulus action descriptor (+data-action+ contains the descriptor
+    # as a space-separated token).
+    #
+    # Accepts a full descriptor (+click->hello#greet+) or a shorthand without
+    # an event (+hello#greet+), which matches any event prefix.
+    #
+    # @example Full descriptor
+    #   expect(response).to have_stimulus_action("click->hello#greet")
+    #
+    # @example Shorthand (any event)
+    #   expect(response).to have_stimulus_action("hello#greet")
+    class HaveStimulusAction
+      def initialize(action_descriptor)
+        @action_descriptor = action_descriptor.to_s
+      end
+
+      # @param response_or_body [#body, String]
+      # @return [Boolean]
+      def matches?(response_or_body)
+        @body = extract_body(response_or_body)
+        Nokogiri::HTML5.fragment(@body).css(selector).any?
+      end
+
+      # @param response_or_body [#body, String]
+      # @return [Boolean]
+      def does_not_match?(response_or_body)
+        !matches?(response_or_body)
+      end
+
+      # @return [String]
+      def failure_message
+        "expected response to have Stimulus action #{@action_descriptor.inspect}"
+      end
+
+      # @return [String]
+      def failure_message_when_negated
+        "expected response not to have Stimulus action #{@action_descriptor.inspect}"
+      end
+
+      # @return [String]
+      def description
+        "have Stimulus action #{@action_descriptor.inspect}"
+      end
+
+      private
+
+      def extract_body(response_or_body)
+        if response_or_body.respond_to?(:body)
+          response_or_body.body
+        else
+          response_or_body.to_s
+        end
+      end
+
+      def selector
+        if @action_descriptor.include?("->")
+          "[data-action~='#{@action_descriptor}']"
+        else
+          "[data-action*='#{@action_descriptor}']"
+        end
+      end
+    end
+  end
+end

data/lib/turbo_rspec/matchers/have_stimulus_controller.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module TurboRspec
+  module Matchers
+    # RSpec matcher for asserting that a response body contains an element with
+    # the given Stimulus controller (+data-controller+ contains the name as a
+    # space-separated token).
+    #
+    # @example
+    #   expect(response).to have_stimulus_controller("hello")
+    #   expect(response).not_to have_stimulus_controller("missing")
+    class HaveStimulusController
+      def initialize(controller_name)
+        @controller_name = controller_name.to_s
+      end
+
+      # @param response_or_body [#body, String]
+      # @return [Boolean]
+      def matches?(response_or_body)
+        @body = extract_body(response_or_body)
+        Nokogiri::HTML5.fragment(@body).css("[data-controller~='#{@controller_name}']").any?
+      end
+
+      # @param response_or_body [#body, String]
+      # @return [Boolean]
+      def does_not_match?(response_or_body)
+        !matches?(response_or_body)
+      end
+
+      # @return [String]
+      def failure_message
+        "expected response to have Stimulus controller #{@controller_name.inspect}"
+      end
+
+      # @return [String]
+      def failure_message_when_negated
+        "expected response not to have Stimulus controller #{@controller_name.inspect}"
+      end
+
+      # @return [String]
+      def description
+        "have Stimulus controller #{@controller_name.inspect}"
+      end
+
+      private
+
+      def extract_body(response_or_body)
+        if response_or_body.respond_to?(:body)
+          response_or_body.body
+        else
+          response_or_body.to_s
+        end
+      end
+    end
+  end
+end

data/lib/turbo_rspec/matchers/have_stimulus_target.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module TurboRspec
+  module Matchers
+    # RSpec matcher for asserting that a response body contains an element with
+    # the given Stimulus target (+data-{controller}-target+ contains the target
+    # name as a space-separated token).
+    #
+    # @example
+    #   expect(response).to have_stimulus_target("hello", "name")
+    #   expect(response).not_to have_stimulus_target("hello", "missing")
+    class HaveStimulusTarget
+      def initialize(controller_name, target_name)
+        @controller_name = controller_name.to_s
+        @target_name = target_name.to_s
+      end
+
+      # @param response_or_body [#body, String]
+      # @return [Boolean]
+      def matches?(response_or_body)
+        @body = extract_body(response_or_body)
+        Nokogiri::HTML5.fragment(@body).css("[data-#{@controller_name}-target~='#{@target_name}']").any?
+      end
+
+      # @param response_or_body [#body, String]
+      # @return [Boolean]
+      def does_not_match?(response_or_body)
+        !matches?(response_or_body)
+      end
+
+      # @return [String]
+      def failure_message
+        "expected response to have Stimulus target #{@target_name.inspect} for controller #{@controller_name.inspect}"
+      end
+
+      # @return [String]
+      def failure_message_when_negated
+        "expected response not to have Stimulus target #{@target_name.inspect} for controller #{@controller_name.inspect}"
+      end
+
+      # @return [String]
+      def description
+        "have Stimulus target #{@target_name.inspect} for #{@controller_name.inspect}"
+      end
+
+      private
+
+      def extract_body(response_or_body)
+        if response_or_body.respond_to?(:body)
+          response_or_body.body
+        else
+          response_or_body.to_s
+        end
+      end
+    end
+  end
+end

data/lib/turbo_rspec/matchers.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require_relative "matchers/have_broadcasted_turbo_stream_to"
+require_relative "matchers/have_stimulus_action"
+require_relative "matchers/have_stimulus_controller"
+require_relative "matchers/have_stimulus_target"
 require_relative "matchers/have_turbo_frame"
 require_relative "matchers/have_turbo_stream"
 require_relative "matchers/have_turbo_streams"
@@ -48,6 +51,28 @@ module TurboRspec
       HaveTurboStreams.new(matchers)
     end
 
+    # Assert that a response body contains an element with the given Stimulus controller.
+    # @param controller_name [String]
+    # @return [HaveStimulusController]
+    def have_stimulus_controller(controller_name)
+      HaveStimulusController.new(controller_name)
+    end
+
+    # Assert that a response body contains an element with the given Stimulus action.
+    # @param action_descriptor [String]
+    # @return [HaveStimulusAction]
+    def have_stimulus_action(action_descriptor)
+      HaveStimulusAction.new(action_descriptor)
+    end
+
+    # Assert that a response body contains an element with the given Stimulus target.
+    # @param controller_name [String]
+    # @param target_name [String]
+    # @return [HaveStimulusTarget]
+    def have_stimulus_target(controller_name, target_name)
+      HaveStimulusTarget.new(controller_name, target_name)
+    end
+
     # Assert that a response body matches a stored turbo stream snapshot.
     # Creates the snapshot on the first run; diffs against it on subsequent runs.
     # Set +UPDATE_TURBO_SNAPSHOTS=1+ to overwrite an existing snapshot.

data/lib/turbo_rspec/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TurboRspec
-  VERSION = "1.5.0"
+  VERSION = "1.6.0"
 end

data/sig/turbo_rspec.rbs

@@ -26,6 +26,9 @@ module TurboRspec
     def have_turbo_stream: () -> HaveTurboStream
     def assert_no_turbo_stream: () -> HaveTurboStream
     def have_turbo_streams: (*HaveTurboStream matchers) -> HaveTurboStreams
+    def have_stimulus_controller: (String controller_name) -> HaveStimulusController
+    def have_stimulus_action: (String action_descriptor) -> HaveStimulusAction
+    def have_stimulus_target: (String controller_name, String target_name) -> HaveStimulusTarget
     def match_turbo_stream_snapshot: (String name) -> MatchTurboStreamSnapshot
     def have_turbo_frame: () -> HaveTurboFrame
     def have_broadcasted_turbo_stream_to: (String | untyped stream_or_object) -> HaveBroadcastedTurboStreamTo
@@ -105,6 +108,33 @@ module TurboRspec
       def description: () -> String
     end
 
+    class HaveStimulusController
+      def initialize: (String controller_name) -> void
+      def matches?: (untyped response_or_body) -> bool
+      def does_not_match?: (untyped response_or_body) -> bool
+      def failure_message: () -> String
+      def failure_message_when_negated: () -> String
+      def description: () -> String
+    end
+
+    class HaveStimulusAction
+      def initialize: (String action_descriptor) -> void
+      def matches?: (untyped response_or_body) -> bool
+      def does_not_match?: (untyped response_or_body) -> bool
+      def failure_message: () -> String
+      def failure_message_when_negated: () -> String
+      def description: () -> String
+    end
+
+    class HaveStimulusTarget
+      def initialize: (String controller_name, String target_name) -> void
+      def matches?: (untyped response_or_body) -> bool
+      def does_not_match?: (untyped response_or_body) -> bool
+      def failure_message: () -> String
+      def failure_message_when_negated: () -> String
+      def description: () -> String
+    end
+
     class MatchTurboStreamSnapshot
       def initialize: (String name) -> void
       def matches?: (untyped response_or_body) -> bool
@@ -130,6 +160,8 @@ module TurboRspec
   end
 
   module Assertions
+    def assert_broadcasted_turbo_stream_to: (String stream, ?action: (Symbol | String)?, ?target: String?, ?targets: String?, ?content: String?, ?partial: String?, ?message: String?) { () -> void } -> void
+    def refute_broadcasted_turbo_stream_to: (String stream, ?action: (Symbol | String)?, ?target: String?, ?targets: String?, ?content: String?, ?partial: String?, ?message: String?) { () -> void } -> void
     def assert_turbo_stream: (untyped response_or_body, ?action: (Symbol | String)?, ?target: String?, ?targets: String?, ?content: String?, ?partial: String?, ?message: String?) -> void
     def refute_turbo_stream: (untyped response_or_body, ?action: (Symbol | String)?, ?target: String?, ?targets: String?, ?content: String?, ?partial: String?, ?message: String?) -> void
     def assert_turbo_frame: (untyped response_or_body, ?id: String?, ?content: String?, ?partial: String?, ?message: String?) -> void
@@ -153,6 +185,8 @@ module TurboRspec
         def loaded: () -> self
         def with_src: (String url) -> self
         def lazy: () -> self
+        def eager: () -> self
+        def strict: () -> self
 
         # Capybara matcher interface
         def matches?: (untyped page_or_node) -> bool

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: turbo_rspec
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Chuck Smith
@@ -64,6 +64,9 @@ files:
 - lib/turbo_rspec/helpers.rb
 - lib/turbo_rspec/matchers.rb
 - lib/turbo_rspec/matchers/have_broadcasted_turbo_stream_to.rb
+- lib/turbo_rspec/matchers/have_stimulus_action.rb
+- lib/turbo_rspec/matchers/have_stimulus_controller.rb
+- lib/turbo_rspec/matchers/have_stimulus_target.rb
 - lib/turbo_rspec/matchers/have_turbo_frame.rb
 - lib/turbo_rspec/matchers/have_turbo_stream.rb
 - lib/turbo_rspec/matchers/have_turbo_streams.rb