turbo_rspec 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ba06cebbff8c0ae4b76e280171ccd5ae57d06fe8e027010071f9fd9c923696d2
+  data.tar.gz: 1838772f6e8673a0949e3e19ccdadd1f7706b6cdd02b77a1dc272bb7c3524f58
+SHA512:
+  metadata.gz: f7e2693b3fdd61b62e66e248b9a4dbf16ff52096e4084dc24c3dd56c6dfabfed222f458ef1df188f81378d00815e0c1733399fccddb2520a345c9d0e367d6ed5
+  data.tar.gz: 2dbd1d94ff557eb93b7f98882a80a03dbc7c43eaece27fdeef5755c7671e179999aafd762a9a8c32ef1ab4c8708291f0bcef8825b860dfcb2d43c75a8b98e10a

data/.github/workflows/ci.yml

@@ -0,0 +1,57 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      - run: bundle exec standardrb --no-fix
+
+  audit:
+    name: Security Audit
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      - run: bundle exec bundle-audit update
+      - run: bundle exec bundle-audit check
+
+  test:
+    name: Ruby ${{ matrix.ruby }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["3.3", "3.4", "4.0"]
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - run: bundle exec rspec

data/.github/workflows/publish.yml

@@ -0,0 +1,37 @@
+name: Publish
+
+on:
+  push:
+    tags:
+      - "v*"
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: true
+
+jobs:
+  publish:
+    name: Publish to RubyGems
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: "3.4"
+          bundler-cache: true
+
+      - name: Create GitHub Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "${{ github.ref_name }}" \
+            --title "${{ github.ref_name }}" \
+            --notes "See [CHANGELOG.md](https://github.com/${{ github.repository }}/blob/main/CHANGELOG.md) for details." \
+            --verify-tag
+
+      - name: Publish to RubyGems
+        uses: rubygems/release-gem@v1

data/.rubocop.yml

@@ -0,0 +1,18 @@
+# Omakase Ruby styling for Rails
+inherit_gem: { rubocop-rails-omakase: rubocop.yml }
+
+AllCops:
+  Exclude:
+    - "bin/release"
+    - "README.md"
+    - "spec/dummy/config/database.yml"
+
+# Overwrite or add rules to create your own house style
+#
+# # Use `[a, [b, c]]` not `[ a, [ b, c ] ]`
+# Layout/SpaceInsideArrayLiteralBrackets:
+#   Enabled: false
+
+Layout/SpaceInsideArrayLiteralBrackets:
+  Enabled: true
+  EnforcedStyle: no_space

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-05-28
+
+### Added
+
+- Real usage README covering both matchers, setup, and configuration
+- `TurboRspec.configure` block for opt-in configuration
+- Auto-include `TurboRspec::Matchers` into `RSpec::Rails` request example groups when `turbo-rails` is present; disable with `TurboRspec.configure { |c| c.auto_include = false }`
+- Explicit `include TurboRspec::Matchers` supported in any non-Rails or custom context
+- `have_turbo_frame` matcher for asserting `<turbo-frame>` elements in response bodies
+  - `.with_id(id)` — assert a specific `id` attribute
+  - `.with_content(text)` — assert literal text content inside the frame element
+  - `.rendering(partial)` — assert a rendered partial within the frame element
+  - Negation via `not_to have_turbo_frame` works out of the box
+- `have_turbo_stream` matcher for asserting `<turbo-stream>` elements in response bodies
+  - `.with_action(action)` — assert a specific action (append, prepend, replace, update, remove, before, after, refresh)
+  - `.targeting(dom_id)` — assert a specific `target` attribute
+  - `.targeting_all(selector)` — assert a specific `targets` CSS selector attribute
+  - `.with_content(text)` — assert literal text content inside the stream element
+  - `.rendering(partial)` — assert a rendered partial within the stream element
+  - Negation via `not_to have_turbo_stream` works out of the box

data/CLAUDE.md

@@ -0,0 +1,89 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What this is
+
+`solid_queue_web` is a mountable Rails engine (published as a gem) that provides a web dashboard for [Solid Queue](https://github.com/rails/solid_queue). It has no host application — development and testing both use the dummy Rails app under `spec/dummy/`.
+
+## Commands
+
+```bash
+# Run the full suite (rubocop + rspec) — this is what CI runs
+bundle exec rake
+
+# Run only tests
+bundle exec rspec
+
+# Run a single spec file
+bundle exec rspec spec/requests/solid_queue_web/jobs_spec.rb
+
+# Run a single example by line number
+bundle exec rspec spec/requests/solid_queue_web/jobs_spec.rb:42
+
+# Lint
+bin/rubocop
+
+# Set up and seed the development database (dummy app)
+bundle exec rake dev:setup   # creates and migrates spec/dummy/db/development.sqlite3
+bundle exec rake dev:seed    # populates with realistic fake jobs/processes
+
+# Reset dev database (setup + seed)
+bundle exec rake dev:reset
+
+# Start the dummy app for manual testing
+cd spec/dummy && bin/rails server
+# Dashboard is at http://localhost:3000/jobs
+```
+
+## Architecture
+
+### Engine isolation
+
+The engine uses `isolate_namespace SolidQueueWeb`, so all routes, controllers, helpers, and models live under that namespace. The engine requires no database migrations of its own — it reads directly from the host app's Solid Queue tables via `SolidQueue::*` models (a declared gem dependency).
+
+### Execution model pattern
+
+Solid Queue represents job state with separate execution tables. Each status maps to a distinct ActiveRecord model:
+
+| Status      | Model                              |
+|-------------|------------------------------------|
+| `ready`     | `SolidQueue::ReadyExecution`       |
+| `scheduled` | `SolidQueue::ScheduledExecution`   |
+| `claimed`   | `SolidQueue::ClaimedExecution`     |
+| `blocked`   | `SolidQueue::BlockedExecution`     |
+| `failed`    | `SolidQueue::FailedExecution`      |
+
+`JobsController` maps the `?status=` param to these models via `EXECUTION_MODELS`. Only `ready`, `scheduled`, and `blocked` jobs can be discarded from the jobs list (`DISCARDABLE`); failed jobs have their own `FailedJobsController` with retry/discard.
+
+### No asset pipeline dependency
+
+CSS is delivered entirely via the `inline_styles` helper, which reads `application.css` at request time and injects it as a `<style>` tag. This prevents conflicts when mounted in any host app. There is no JavaScript — queue pause/resume and job discard use standard form POSTs or Turbo Stream responses.
+
+### Turbo Stream responses
+
+`JobsController#destroy` responds to both HTML and `turbo_stream` format. When a job is discarded:
+- If more jobs remain in the filtered scope → removes that row from the DOM.
+- If it was the last job → replaces the table with an empty-state element (`sqd-empty`).
+
+### Authentication
+
+`SolidQueueWeb.authenticate` stores a single block (set via an initializer in the host app). `ApplicationController#authenticate!` runs that block in controller context via `instance_exec`. If the block returns falsy, it falls back to HTTP Basic auth. No auth is enforced by default.
+
+### Pagination
+
+Pagy is included via `Pagy::Method` (not `Pagy::Backend`) and configured globally in the engine initializer with a limit of 25.
+
+### Test setup
+
+`spec/rails_helper.rb` loads `spec/dummy/db/schema.rb` directly on every test run (no migrations). Tests are all request specs that hit the dummy app's mounted engine at `/jobs`. Factories are not used — records are created directly with `SolidQueue::*` models.
+
+### Releasing
+
+`bin/release <version>` — bumps the version file, updates `Gemfile.lock` and `CHANGELOG.md`, commits, tags, and pushes. CI picks up the tag and publishes to RubyGems via Trusted Publishing. Must be run from `main` with a clean working tree.
+
+### CHANGELOG conventions
+
+- New entries go under `## [Unreleased]` on the feature branch, before opening a PR.
+- Sections within each version must appear in this order: `### Added`, `### Changed`, `### Fixed`. Omit sections that have no entries — never add an empty section header.
+- Branch workflow: always commit on a `feat/*` or `chore/*` branch; never commit directly to `main`.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Chuck Smith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,145 @@
+# TurboRspec
+
+[![CI](https://github.com/eclectic-coding/turbo_rspec/actions/workflows/ci.yml/badge.svg)](https://github.com/eclectic-coding/turbo_rspec/actions/workflows/ci.yml)
+[![Gem Version](https://img.shields.io/gem/v/turbo_rspec)](https://rubygems.org/gems/turbo_rspec)
+[![Gem Downloads](https://img.shields.io/gem/dt/turbo_rspec)](https://rubygems.org/gems/turbo_rspec)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%203.3-ruby)](https://rubygems.org/gems/turbo_rspec)
+[![codecov](https://codecov.io/gh/eclectic-coding/turbo_rspec/branch/main/graph/badge.svg)](https://codecov.io/gh/eclectic-coding/turbo_rspec)
+
+RSpec matchers for [Turbo](https://github.com/hotwired/turbo-rails) — assert Turbo Stream responses, Turbo Frame content, and ActionCable broadcasts without hand-rolling helpers in every project.
+
+## Installation
+
+Add to your application's `Gemfile`:
+
+```ruby
+group :test do
+  gem "turbo_rspec"
+end
+```
+
+## Setup
+
+### Rails + turbo-rails (automatic)
+
+No setup needed. When `turbo-rails` is in your bundle, `TurboRspec::Matchers` is automatically included in all `type: :request` example groups.
+
+### Manual include
+
+For non-Rails projects or custom contexts, include the matchers explicitly:
+
+```ruby
+# spec/spec_helper.rb
+RSpec.configure do |config|
+  config.include TurboRspec::Matchers
+end
+```
+
+### Configuration
+
+```ruby
+# spec/support/turbo_rspec.rb
+TurboRspec.configure do |config|
+  config.auto_include = false  # disable automatic inclusion into request specs
+end
+```
+
+## Matchers
+
+### `have_turbo_stream`
+
+Assert that a response body contains a `<turbo-stream>` element.
+
+```ruby
+# Basic — any turbo stream present
+expect(response).to have_turbo_stream
+
+# With action
+expect(response).to have_turbo_stream.with_action(:append)
+expect(response).to have_turbo_stream.with_action(:replace)
+expect(response).to have_turbo_stream.with_action(:remove)
+
+# With target (single DOM id)
+expect(response).to have_turbo_stream.targeting("messages")
+
+# With targets (CSS selector)
+expect(response).to have_turbo_stream.targeting_all(".message-item")
+
+# With content
+expect(response).to have_turbo_stream.with_content("Hello, world!")
+
+# With partial
+expect(response).to have_turbo_stream.rendering("messages/_message")
+
+# Chained — all constraints must match the same stream
+expect(response).to have_turbo_stream
+  .with_action(:append)
+  .targeting("messages")
+  .with_content("Hello")
+
+# Negation
+expect(response).not_to have_turbo_stream.with_action(:replace)
+```
+
+#### Actions
+
+Turbo supports the following stream actions: `append`, `prepend`, `replace`, `update`, `remove`, `before`, `after`, `refresh`.
+
+### `have_turbo_frame`
+
+Assert that a response body contains a `<turbo-frame>` element.
+
+```ruby
+# Basic — any turbo frame present
+expect(response).to have_turbo_frame
+
+# With id
+expect(response).to have_turbo_frame.with_id("messages")
+
+# With content
+expect(response).to have_turbo_frame.with_id("messages").with_content("Hello")
+
+# With partial
+expect(response).to have_turbo_frame.with_id("post").rendering("posts/_post")
+
+# Negation
+expect(response).not_to have_turbo_frame.with_id("notifications")
+```
+
+## Example: request spec
+
+```ruby
+RSpec.describe "Messages", type: :request do
+  describe "POST /messages" do
+    it "appends the new message to the list" do
+      post messages_path, params: { message: { body: "Hello" } },
+                          headers: { "Accept" => "text/vnd.turbo-stream.html" }
+
+      expect(response).to have_turbo_stream
+        .with_action(:append)
+        .targeting("messages")
+        .with_content("Hello")
+    end
+  end
+
+  describe "DELETE /messages/:id" do
+    it "removes the message row" do
+      message = create(:message)
+      delete message_path(message),
+             headers: { "Accept" => "text/vnd.turbo-stream.html" }
+
+      expect(response).to have_turbo_stream
+        .with_action(:remove)
+        .targeting("message_#{message.id}")
+    end
+  end
+end
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/eclectic-coding/turbo_rspec).
+
+## License
+
+The gem is available as open source under the [MIT License](https://opensource.org/licenses/MIT).

data/ROADMAP.md

@@ -0,0 +1,87 @@
+# turbo_rspec Roadmap
+
+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.
+
+---
+
+
+## v0.2.0 — Broadcast matchers
+
+**Goal:** cover the broadcast side — jobs/services that push streams over ActionCable.
+
+- `have_broadcasted_turbo_stream_to(channel_or_object)` — wraps ActionCable's test adapter
+  - Same fluent chain as `have_turbo_stream`: `.with_action`, `.targeting`, `.rendering`, `.with_content`
+  - Count qualifiers: `.exactly(n).times`, `.at_least(n).times`, `.at_most(n).times`, `.once`, `.twice`
+  - Works inside `expect { }.to have_broadcasted_turbo_stream_to(...)` blocks
+- Helper `broadcast_turbo_stream_to` alias for symmetry with ActionCable's naming
+- Docs: "testing broadcasts in job specs and service specs"
+
+---
+
+## v0.3.0 — Capybara / system spec integration
+
+**Goal:** assertions that work against a live browser in feature/system specs.
+
+- `have_turbo_frame(id)` Capybara matcher — waits for the frame to appear on the page
+  - `.with_content(...)` — delegates to Capybara's `have_content` with correct scope
+  - `.loaded` — asserts `[complete]` attribute is present (frame finished loading)
+- `within_turbo_frame(id) { ... }` — scopes Capybara assertions to the frame's DOM
+- `have_turbo_stream_tag` — asserts a `<turbo-stream-source>` subscription element exists on the page
+- Docs: system spec patterns, async update testing
+
+---
+
+## v0.4.0 — Developer experience pass
+
+**Goal:** make failure output good enough that you never have to drop into a debugger just to read a matcher failure.
+
+- Rich failure messages: show actual stream actions/targets found vs. expected
+- `assert_no_turbo_stream` alias for teams that mix RSpec/minitest terminology
+- Composable matchers: `include(have_turbo_stream(...), have_turbo_stream(...))` for multi-stream assertions
+- `have_turbo_streams` (plural) — assert multiple streams in one expectation with an array DSL
+- Support for `aggregate_failures` blocks
+
+---
+
+## v0.5.0 — Compatibility and edge cases
+
+**Goal:** harden the gem against real-world app variations.
+
+- Rails 7.1/7.2/8.0/8.1 and Turbo 1.x/2.x compatibility matrix in CI
+- Multi-stream response body parsing (a single response can contain multiple `<turbo-stream>` tags)
+- `refresh` action support (Turbo 8 page refresh streams)
+- `morph` action support (Turbo Morphing)
+- Graceful no-op when `turbo-rails` is not in the Gemfile (no `LoadError`)
+- Minitest module (`TurboRspec::Assertions`) as opt-in companion (no RSpec dependency for that module)
+
+---
+
+## v1.0.0 — Stable API
+
+**Goal:** API freeze. Commit to semver stability. Make the gem the obvious default choice.
+
+- API stability guarantee: no breaking changes without a major version bump
+- `TurboRspec::VERSION` semantic versioning enforced via CI check
+- Migration guide: "replacing hand-rolled Turbo Stream helpers" in the docs
+- Full YARD documentation with `yard` and hosted on RubyDoc.info
+- 100% branch coverage enforced in CI (`simplecov`)
+- Performance: benchmark matcher overhead to keep it negligible in large suites
+- `bin/release` script (mirrors solid_queue_web pattern): bump version, update CHANGELOG, tag, push; CI publishes via Trusted Publishing
+
+---
+
+## Post-1.0 ideas (not scheduled)
+
+- VS Code / RubyMine snippet pack for common patterns
+- `turbo_rspec` generator (`rails generate turbo_rspec:install`) to scaffold `spec/support/turbo.rb`
+- Playwright/Puppeteer bridge for headless assertions outside Capybara
+- Shared examples: `it_behaves_like "a turbo stream response"` for controller testing
+
+---
+
+## Guiding principles
+
+- **Zero magic by default.** Auto-include only when it's unambiguous (Rails request specs). Everything else is opt-in.
+- **Fail loudly with useful output.** A cryptic failure message is a bug.
+- **No minitest dependency in the core.** The gem is RSpec-first; minitest support is a separate module.
+- **Stay close to Turbo's own naming.** Matcher names mirror Turbo's action names so the docs cross-reference naturally.

data/Rakefile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+require "bundler/audit/task"
+Bundler::Audit::Task.new
+
+task default: %i[bundle:audit:update bundle:audit spec standard]

data/codecov.yml

@@ -0,0 +1,17 @@
+# Configure Pull Request Bot Comments
+comment:
+  layout: "reach, diff, flags, files"
+  behavior: default
+  # Only post or update the comment if the coverage drops
+  require_changes: "coverage_drop"
+
+# Configure Commit Status Checks (the green checkmark/red X list)
+coverage:
+  status:
+    project:
+      default:
+        # Prevent "Informational" mode so a drop causes an actual red failure check
+        informational: false
+    patch:
+      default:
+        informational: false

data/lib/turbo_rspec/configuration.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TurboRspec
+  class Configuration
+    attr_accessor :auto_include
+
+    def initialize
+      @auto_include = true
+    end
+  end
+end

data/lib/turbo_rspec/matchers/have_turbo_frame.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module TurboRspec
+  module Matchers
+    class HaveTurboFrame
+      def initialize
+        @id = nil
+        @content = nil
+        @partial = nil
+      end
+
+      def with_id(id)
+        @id = id.to_s
+        self
+      end
+
+      def with_content(text)
+        @content = text.to_s
+        self
+      end
+
+      def rendering(partial)
+        @partial = partial.to_s
+        self
+      end
+
+      def matches?(response_or_body)
+        @body = extract_body(response_or_body)
+        @frames = parse_frames(@body)
+        @frames.any? { |frame| frame_matches?(frame) }
+      end
+
+      def does_not_match?(response_or_body)
+        !matches?(response_or_body)
+      end
+
+      def failure_message
+        "expected response to contain a turbo frame#{constraint_description}\n#{found_frames_message}"
+      end
+
+      def failure_message_when_negated
+        "expected response not to contain a turbo frame#{constraint_description}"
+      end
+
+      def description
+        "have turbo frame#{constraint_description}"
+      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 parse_frames(body)
+        Nokogiri::HTML5.fragment(body).css("turbo-frame")
+      end
+
+      def frame_matches?(frame)
+        matches_id?(frame) &&
+          matches_content?(frame) &&
+          matches_partial?(frame)
+      end
+
+      def matches_id?(frame)
+        @id.nil? || frame["id"] == @id
+      end
+
+      def matches_content?(frame)
+        return true if @content.nil?
+        frame.text.include?(@content)
+      end
+
+      def matches_partial?(frame)
+        return true if @partial.nil?
+        frame.to_html.include?(@partial)
+      end
+
+      def constraint_description
+        parts = []
+        parts << " with id #{@id.inspect}" if @id
+        parts << " with content #{@content.inspect}" if @content
+        parts << " rendering #{@partial.inspect}" if @partial
+        parts.join
+      end
+
+      def found_frames_message
+        if @frames.empty?
+          "but no turbo frames were found in the response"
+        else
+          ids = @frames.map { |f| "  <turbo-frame id=#{f["id"].inspect}>" }
+          "found turbo frames:\n#{ids.join("\n")}"
+        end
+      end
+    end
+  end
+end

data/lib/turbo_rspec/matchers/have_turbo_stream.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+
+module TurboRspec
+  module Matchers
+    class HaveTurboStream
+      def initialize
+        @action = nil
+        @target = nil
+        @target_all = nil
+        @content = nil
+        @partial = nil
+      end
+
+      def with_action(action)
+        @action = action.to_s
+        self
+      end
+
+      def targeting(dom_id)
+        @target = dom_id.to_s
+        self
+      end
+
+      def targeting_all(selector)
+        @target_all = selector.to_s
+        self
+      end
+
+      def with_content(text)
+        @content = text.to_s
+        self
+      end
+
+      def rendering(partial)
+        @partial = partial.to_s
+        self
+      end
+
+      def matches?(response_or_body)
+        @body = extract_body(response_or_body)
+        @streams = parse_streams(@body)
+        @streams.any? { |stream| stream_matches?(stream) }
+      end
+
+      def does_not_match?(response_or_body)
+        !matches?(response_or_body)
+      end
+
+      def failure_message
+        "expected response to contain a turbo stream#{constraint_description}\n#{found_streams_message}"
+      end
+
+      def failure_message_when_negated
+        "expected response not to contain a turbo stream#{constraint_description}"
+      end
+
+      def description
+        "have turbo stream#{constraint_description}"
+      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 parse_streams(body)
+        Nokogiri::HTML5.fragment(body).css("turbo-stream")
+      end
+
+      def stream_matches?(stream)
+        matches_action?(stream) &&
+          matches_target?(stream) &&
+          matches_target_all?(stream) &&
+          matches_content?(stream) &&
+          matches_partial?(stream)
+      end
+
+      def matches_action?(stream)
+        @action.nil? || stream["action"] == @action
+      end
+
+      def matches_target?(stream)
+        @target.nil? || stream["target"] == @target
+      end
+
+      def matches_target_all?(stream)
+        @target_all.nil? || stream["targets"] == @target_all
+      end
+
+      def matches_content?(stream)
+        return true if @content.nil?
+        stream.text.include?(@content)
+      end
+
+      def matches_partial?(stream)
+        return true if @partial.nil?
+        stream.to_html.include?(@partial)
+      end
+
+      def constraint_description
+        parts = []
+        parts << " with action #{@action.inspect}" if @action
+        parts << " targeting #{@target.inspect}" if @target
+        parts << " targeting all #{@target_all.inspect}" if @target_all
+        parts << " with content #{@content.inspect}" if @content
+        parts << " rendering #{@partial.inspect}" if @partial
+        parts.join
+      end
+
+      def found_streams_message
+        if @streams.empty?
+          "but no turbo streams were found in the response"
+        else
+          actions = @streams.map { |s| "  <turbo-stream action=#{s["action"].inspect} target=#{s["target"].inspect}>" }
+          "found turbo streams:\n#{actions.join("\n")}"
+        end
+      end
+    end
+  end
+end

data/lib/turbo_rspec/matchers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "matchers/have_turbo_frame"
+require_relative "matchers/have_turbo_stream"
+
+module TurboRspec
+  module Matchers
+    def have_turbo_frame
+      HaveTurboFrame.new
+    end
+
+    def have_turbo_stream
+      HaveTurboStream.new
+    end
+  end
+end

data/lib/turbo_rspec/version.rb

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

data/lib/turbo_rspec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "turbo_rspec/version"
+require_relative "turbo_rspec/configuration"
+require_relative "turbo_rspec/matchers"
+
+module TurboRspec
+  class Error < StandardError; end
+
+  class << self
+    def configure
+      yield configuration
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+  end
+end
+
+if defined?(RSpec)
+  RSpec.configure do |config|
+    config.include TurboRspec::Matchers, type: :request if TurboRspec.configuration.auto_include &&
+      Gem.loaded_specs.key?("turbo-rails")
+  end
+end

data/sig/turbo_rspec.rbs

@@ -0,0 +1,4 @@
+module TurboRspec
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: turbo_rspec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chuck Smith
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.13'
+description: 'Drop-in RSpec matchers for hotwired/turbo-rails: assert Turbo Stream
+  responses, Turbo Frame content, and ActionCable broadcasts without hand-rolling
+  helpers in every project.'
+email:
+- eclectic-coding@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/ci.yml"
+- ".github/workflows/publish.yml"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CLAUDE.md
+- LICENSE.txt
+- README.md
+- ROADMAP.md
+- Rakefile
+- codecov.yml
+- lib/turbo_rspec.rb
+- lib/turbo_rspec/configuration.rb
+- lib/turbo_rspec/matchers.rb
+- lib/turbo_rspec/matchers/have_turbo_frame.rb
+- lib/turbo_rspec/matchers/have_turbo_stream.rb
+- lib/turbo_rspec/version.rb
+- sig/turbo_rspec.rbs
+homepage: https://github.com/eclectic-coding/turbo_rspec
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/eclectic-coding/turbo_rspec
+  source_code_uri: https://github.com/eclectic-coding/turbo_rspec
+  changelog_uri: https://github.com/eclectic-coding/turbo_rspec/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: RSpec matchers for Turbo Streams, Turbo Frames, and ActionCable broadcasts.
+test_files: []