turbo_rspec 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a09c91b6fcf16983b8ebbdf20dac6bfb350a9fea07e1779541a05200ba9fc16
-  data.tar.gz: 43d963aacdbc42a3d90ff131953418c07063e78537bec4cabde4f9189416f06f
+  metadata.gz: 3211f811cbd7919d35f8b918260ea97346668fb2ef3213f189d91c642a014b53
+  data.tar.gz: dda8641bcf4d6cb1a8ebc6de4ee5d7622f90bcec3a79b8180444b6e4bfcd2c38
 SHA512:
-  metadata.gz: 5d01faa2f37db0c9ea82322fd3445a70a8c0201f9176a0f578f6d87a84954ce2f0dbecc5ccaeb6a347aad02d1d47ab16c2fb9568eb0b0b19a2230a6f06917267
-  data.tar.gz: a3958b07e62ff57af1d72540364df29e374b912752a16c0faf7a3533ed8a08f4fb51dc54ad691c3a67fae39f3aac378f40f16af3d3b567650fc469d076db1707
+  metadata.gz: 352e59c5604c6362263a51d6b0eb9903b1b7c7b337bca65a05e01c15b42bae5e121def5d638ed66f8b73d06fda382460a85dce4d15ab7a3bff234fb26c310759
+  data.tar.gz: 1243fc05f3fc0256f3e028c66d505a0cbf8335108238c6fde0c0b4e6a0fc97f630bd2ae59c51cb37e64a0ce81265fb20b2d8c9be2e850ef7b29a3442c18f6991

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## [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
+
+- `match_turbo_stream_snapshot` failure message now shows a line-by-line inline diff (stored → actual) instead of raw before/after strings
+- `have_broadcasted_turbo_stream_to` failure message now lists all streams broadcast to the channel and shows a closest-match diff with per-constraint ✓/✗ indicators — mirrors the behaviour already present in `have_turbo_stream`
+- `have_broadcasted_turbo_stream_to` now validates action names via `TurboRspec.known_actions`, raising `ArgumentError` for unrecognised actions — consistent with `have_turbo_stream`
+- `have_broadcasted_turbo_stream_to.with_attributes(hash)` — assert arbitrary HTML attributes on broadcast stream elements
+- `have_broadcasted_turbo_stream_to.children_only` — assert the `[children-only]` attribute on morph broadcasts
+
 ## [1.4.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
@@ -183,6 +183,14 @@ expect { MyJob.perform_now }.to have_broadcasted_turbo_stream_to("notifications"
   .targeting("messages")
   .with_content("Hello")
 
+# With arbitrary attributes
+expect { MyJob.perform_now }.to have_broadcasted_turbo_stream_to("notifications")
+  .with_attributes("data-controller" => "messages")
+
+# Turbo 8 morph with children-only
+expect { MyJob.perform_now }.to have_broadcasted_turbo_stream_to("body")
+  .with_action(:morph).children_only
+
 # Count qualifiers
 expect { MyJob.perform_now }.to have_broadcasted_turbo_stream_to("notifications").once
 expect { MyJob.perform_now }.to have_broadcasted_turbo_stream_to("notifications").exactly(3).times
@@ -212,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")
 
@@ -238,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")
 ```
 
@@ -422,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,8 +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.
 
----
-
 ## 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_broadcasted_turbo_stream_to.rb

@@ -12,6 +12,8 @@ module TurboRspec
         @target_all = nil
         @content = nil
         @partial = nil
+        @attributes = {}
+        @children_only = false
         @expected_count = nil
         @count_type = :at_least
       end
@@ -19,7 +21,12 @@ module TurboRspec
       # Stream constraints (mirrors HaveTurboStream)
 
       def with_action(action)
-        @action = action.to_s
+        action_str = action.to_s
+        unless TurboRspec.known_actions.include?(action_str)
+          raise ArgumentError, "Unknown Turbo stream action #{action_str.inspect}. " \
+            "Register custom actions with TurboRspec.register_action(:#{action_str})."
+        end
+        @action = action_str
         self
       end
 
@@ -43,6 +50,16 @@ module TurboRspec
         self
       end
 
+      def with_attributes(attrs)
+        @attributes = attrs.transform_keys(&:to_s).transform_values(&:to_s)
+        self
+      end
+
+      def children_only
+        @children_only = true
+        self
+      end
+
       # Count qualifiers
 
       def once
@@ -82,7 +99,9 @@ module TurboRspec
       def matches?(block)
         before = snapshot
         block.call
-        @matching = (snapshot - before).select { |msg| message_matches?(msg) }
+        @new_broadcasts = snapshot - before
+        @all_streams = parse_all_streams(@new_broadcasts)
+        @matching = @new_broadcasts.select { |msg| message_matches?(msg) }
         count_matches?(@matching.size)
       end
 
@@ -131,7 +150,9 @@ module TurboRspec
           matches_target?(stream) &&
           matches_target_all?(stream) &&
           matches_content?(stream) &&
-          matches_partial?(stream)
+          matches_partial?(stream) &&
+          matches_attributes?(stream) &&
+          matches_children_only?(stream)
       end
 
       def matches_action?(stream)
@@ -156,6 +177,16 @@ module TurboRspec
         stream.to_html.include?(@partial)
       end
 
+      def matches_attributes?(stream)
+        return true if @attributes.empty?
+        @attributes.all? { |k, v| stream[k] == v }
+      end
+
+      def matches_children_only?(stream)
+        return true unless @children_only
+        !stream["children-only"].nil?
+      end
+
       def count_matches?(n)
         if @expected_count.nil?
           n >= 1
@@ -177,6 +208,8 @@ module TurboRspec
         parts << " targeting all #{@target_all.inspect}" if @target_all
         parts << " with content #{@content.inspect}" if @content
         parts << " rendering #{@partial.inspect}" if @partial
+        parts << " with attributes #{@attributes.inspect}" if @attributes.any?
+        parts << " children only" if @children_only
         parts.join
       end
 
@@ -192,11 +225,75 @@ module TurboRspec
       end
 
       def found_message
-        if @matching.empty?
-          "but no matching broadcasts were found"
-        else
+        if @matching.size > 0
           "found #{@matching.size} matching broadcast(s)"
+        elsif @all_streams.empty?
+          "but no broadcasts were made to #{stream_name.inspect}"
+        else
+          no_match_message
+        end
+      end
+
+      def no_match_message
+        lines = ["found #{@all_streams.size} stream(s) broadcast to #{stream_name.inspect}:"]
+        @all_streams.each_with_index do |s, i|
+          content_preview = s.text.strip.slice(0, 50)
+          content_preview = content_preview.empty? ? "(empty)" : content_preview.inspect
+          lines << "  #{i + 1}. action=#{s["action"].inspect} target=#{s["target"].inspect} content=#{content_preview}"
+        end
+
+        # :nocov:
+        if constraint_count > 0
+          # :nocov:
+          closest = @all_streams.max_by { |s| count_matching_constraints(s) }
+          lines << ""
+          lines << "closest match (#{count_matching_constraints(closest)}/#{constraint_count} constraint(s) matched):"
+          lines.concat(constraint_diff(closest))
+        end
+
+        lines.join("\n")
+      end
+
+      def parse_all_streams(broadcasts)
+        broadcasts.flat_map do |msg|
+          html = JSON.parse(msg)
+          Nokogiri::HTML5.fragment(html).css("turbo-stream").to_a
+        rescue JSON::ParserError
+          []
+        end
+      end
+
+      def count_matching_constraints(stream)
+        count = 0
+        count += 1 if !@action.nil? && matches_action?(stream)
+        count += 1 if !@target.nil? && matches_target?(stream)
+        count += 1 if !@target_all.nil? && matches_target_all?(stream)
+        count += 1 if !@content.nil? && matches_content?(stream)
+        count += 1 if !@partial.nil? && matches_partial?(stream)
+        count += 1 if @attributes.any? && matches_attributes?(stream)
+        count += 1 if @children_only && matches_children_only?(stream)
+        count
+      end
+
+      def constraint_count
+        [@action, @target, @target_all, @content, @partial].count { |c| !c.nil? } +
+          (@attributes.any? ? 1 : 0) +
+          (@children_only ? 1 : 0)
+      end
+
+      def constraint_diff(stream)
+        lines = []
+        lines << "  #{matches_action?(stream) ? "✓" : "✗"} action:   expected #{@action.inspect}, got #{stream["action"].inspect}" if @action
+        lines << "  #{matches_target?(stream) ? "✓" : "✗"} target:   expected #{@target.inspect}, got #{stream["target"].inspect}" if @target
+        lines << "  #{matches_target_all?(stream) ? "✓" : "✗"} targets:  expected #{@target_all.inspect}, got #{stream["targets"].inspect}" if @target_all
+        lines << "  #{matches_content?(stream) ? "✓" : "✗"} content:  expected to include #{@content.inspect}, got #{stream.text.strip.slice(0, 50).inspect}" if @content
+        lines << "  #{matches_partial?(stream) ? "✓" : "✗"} rendering: expected to include #{@partial.inspect}" if @partial
+        @attributes.each do |k, v|
+          actual = stream[k]
+          lines << "  #{(actual == v) ? "✓" : "✗"} attr[#{k}]: expected #{v.inspect}, got #{actual.inspect}"
         end
+        lines << "  #{matches_children_only?(stream) ? "✓" : "✗"} children-only: expected attribute to be present" if @children_only
+        lines
       end
     end
   end

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/match_turbo_stream_snapshot.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "diff/lcs"
 
 module TurboRspec
   module Matchers
@@ -44,8 +45,7 @@ module TurboRspec
       # @return [String]
       def failure_message
         "expected response to match turbo stream snapshot #{@name.inspect}\n\n" \
-          "stored:\n#{@stored}\n\n" \
-          "actual:\n#{@actual}\n\n" \
+          "diff (stored → actual):\n#{inline_diff}\n\n" \
           "To update: run with UPDATE_TURBO_SNAPSHOTS=1"
       end
 
@@ -81,6 +81,22 @@ module TurboRspec
       def update_snapshots?
         ENV["UPDATE_TURBO_SNAPSHOTS"] == "1"
       end
+
+      def inline_diff
+        stored_lines = @stored.strip.lines
+        actual_lines = @actual.strip.lines
+        hunks = Diff::LCS.diff(stored_lines, actual_lines)
+        return "  (no textual difference — whitespace only?)" if hunks.empty?
+
+        lines = []
+        hunks.each do |hunk|
+          hunk.each do |change|
+            prefix = (change.action == "+") ? "+" : "-"
+            lines << "#{prefix} #{change.element.chomp}"
+          end
+        end
+        lines.join("\n")
+      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.4.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
@@ -85,6 +88,8 @@ module TurboRspec
       def targeting_all: (String selector) -> self
       def with_content: (String text) -> self
       def rendering: (String partial) -> self
+      def with_attributes: (Hash[String | Symbol, untyped] attrs) -> self
+      def children_only: () -> self
 
       # Count qualifiers
       def once: () -> self
@@ -103,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
@@ -128,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
@@ -151,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.4.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