turbo-rails 1.3.0 → 1.5.0

data/app/controllers/turbo/frames/frame_request.rb

@@ -1,20 +1,30 @@
 # Turbo frame requests are requests made from within a turbo frame with the intention of replacing the content of just
 # that frame, not the whole page. They are automatically tagged as such by the Turbo Frame JavaScript, which adds a
-# <tt>Turbo-Frame</tt> header to the request. When that header is detected by the controller, we ensure that any
-# template layout is skipped (since we're only working on an in-page frame, thus can skip the weight of the layout), and
-# that the etag for the page is changed (such that a cache for a layout-less request isn't served on a normal request
-# and vice versa).
+# <tt>Turbo-Frame</tt> header to the request.
 #
-# This is merely a rendering optimization. Everything would still work just fine if we rendered everything including the layout.
-# Turbo Frames knows how to fish out the relevant frame regardless.
+# When that header is detected by the controller, we substitute our own minimal layout in place of the
+# application-supplied layout (since we're only working on an in-page frame, thus can skip the weight of the layout). We
+# use a minimal layout, rather than avoid the layout entirely, so that it's still possible to render content into the
+# <tt>head<tt>.
+#
+# Accordingly, we ensure that the etag for the page is changed, such that a cache for a minimal-layout request isn't
+# served on a normal request and vice versa.
+#
+# This is merely a rendering optimization. Everything would still work just fine if we rendered everything including the
+# full layout. Turbo Frames knows how to fish out the relevant frame regardless.
+#
+# The layout used is <tt>turbo_rails/frame.html.erb</tt>. If there's a need to customize this layout, an application can
+# supply its own (such as <tt>app/views/layouts/turbo_rails/frame.html.erb</tt>) which will be used instead.
 #
 # This module is automatically included in <tt>ActionController::Base</tt>.
 module Turbo::Frames::FrameRequest
   extend ActiveSupport::Concern
 
   included do
-    layout -> { false if turbo_frame_request? }
+    layout -> { "turbo_rails/frame" if turbo_frame_request? }
     etag { :frame if turbo_frame_request? }
+
+    helper_method :turbo_frame_request_id
   end
 
   private

data/app/controllers/turbo/native/navigation.rb

@@ -2,23 +2,34 @@
 # have Turbo Native clients running (see the Turbo iOS and Turbo Android projects for details), you can respond to native
 # requests with three dedicated responses: <tt>recede</tt>, <tt>resume</tt>, <tt>refresh</tt>.
 #
-# FIXME: Supply full description of when we use either.
+# turbo-android handles these actions automatically. You are required to implement the handling on your own for turbo-ios.
 module Turbo::Native::Navigation
-  private
+  extend ActiveSupport::Concern
+
+  included do
+    helper_method :turbo_native_app?
+  end
 
+  # Turbo Native applications are identified by having the string "Turbo Native" as part of their user agent.
+  def turbo_native_app?
+    request.user_agent.to_s.match?(/Turbo Native/)
+  end
+  
+  # Tell the Turbo Native app to dismiss a modal (if presented) or pop a screen off of the navigation stack.
   def recede_or_redirect_to(url, **options)
     turbo_native_action_or_redirect url, :recede, :to, options
   end
 
+  # Tell the Turbo Native app to ignore this navigation.
   def resume_or_redirect_to(url, **options)
     turbo_native_action_or_redirect url, :resume, :to, options
   end
 
+  # Tell the Turbo Native app to refresh the current screen.
   def refresh_or_redirect_to(url, **options)
     turbo_native_action_or_redirect url, :refresh, :to, options
   end
 
-
   def recede_or_redirect_back_or_to(url, **options)
     turbo_native_action_or_redirect url, :recede, :back, options
   end
@@ -30,20 +41,19 @@ module Turbo::Native::Navigation
   def refresh_or_redirect_back_or_to(url, **options)
     turbo_native_action_or_redirect url, :refresh, :back, options
   end
+  
+  private
 
   # :nodoc:
   def turbo_native_action_or_redirect(url, action, redirect_type, options = {})
+    native_params = options.delete(:native_params) || {}
+
     if turbo_native_app?
-      redirect_to send("turbo_#{action}_historical_location_url", notice: options[:notice] || options.delete(:native_notice))
+      redirect_to send("turbo_#{action}_historical_location_url", notice: options[:notice], **native_params)
     elsif redirect_type == :back
       redirect_back fallback_location: url, **options
     else
       redirect_to url, options
     end
   end
-
-  # Turbo Native applications are identified by having the string "Turbo Native" as part of their user agent.
-  def turbo_native_app?
-    request.user_agent.to_s.match?(/Turbo Native/)
-  end
 end

data/app/helpers/turbo/frames_helper.rb

@@ -36,7 +36,7 @@ module Turbo::FramesHelper
   #   <%= turbo_frame_tag(Article.find(1), Comment.new) %>
   #   # => <turbo-frame id="article_1_new_comment"></turbo-frame>
   def turbo_frame_tag(*ids, src: nil, target: nil, **attributes, &block)
-    id = ids.map { |id| id.respond_to?(:to_key) ? ActionView::RecordIdentifier.dom_id(id) : id }.join("_")
+    id = ids.first.respond_to?(:to_key) ? ActionView::RecordIdentifier.dom_id(*ids) : ids.first
     src = url_for(src) if src.present?
 
     tag.turbo_frame(**attributes.merge(id: id, src: src, target: target).compact, &block)

data/app/helpers/turbo/streams/action_helper.rb

@@ -11,22 +11,34 @@ module Turbo::Streams::ActionHelper
   #
   #   turbo_stream_action_tag "replace", targets: "message_1", template: %(<div id="message_1">Hello!</div>)
   #   # => <turbo-stream action="replace" targets="message_1"><template><div id="message_1">Hello!</div></template></turbo-stream>
+  #
+  # The `target:` keyword option will forward `ActionView::RecordIdentifier#dom_id`-compatible arguments to
+  # `ActionView::RecordIdentifier#dom_id`
+  #
+  #   message = Message.find(1)
+  #   turbo_stream_action_tag "remove", target: message
+  #   # => <turbo-stream action="remove" target="message_1"></turbo-stream>
+  #
+  #   message = Message.find(1)
+  #   turbo_stream_action_tag "remove", target: [message, :special]
+  #   # => <turbo-stream action="remove" target="special_message_1"></turbo-stream>
+  #
   def turbo_stream_action_tag(action, target: nil, targets: nil, template: nil, **attributes)
     template = action.to_sym == :remove ? "" : tag.template(template.to_s.html_safe)
 
     if target = convert_to_turbo_stream_dom_id(target)
-      tag.turbo_stream(template, **attributes.merge(action: action, target: target))
+      tag.turbo_stream(template, **attributes, action: action, target: target)
     elsif targets = convert_to_turbo_stream_dom_id(targets, include_selector: true)
-      tag.turbo_stream(template, **attributes.merge(action: action, targets: targets))
+      tag.turbo_stream(template, **attributes, action: action, targets: targets)
     else
-      tag.turbo_stream(template, **attributes.merge(action: action))
+      tag.turbo_stream(template, **attributes, action: action)
     end
   end
 
   private
     def convert_to_turbo_stream_dom_id(target, include_selector: false)
-      if target.respond_to?(:to_key)
-        [ ("#" if include_selector), ActionView::RecordIdentifier.dom_id(target) ].compact.join
+      if Array(target).any? { |value| value.respond_to?(:to_key) }
+        "#{"#" if include_selector}#{ActionView::RecordIdentifier.dom_id(*target)}"
       else
         target
       end

data/app/javascript/turbo/cable_stream_source_element.js

@@ -5,7 +5,11 @@ import snakeize from "./snakeize"
 class TurboCableStreamSourceElement extends HTMLElement {
   async connectedCallback() {
     connectStreamSource(this)
-    this.subscription = await subscribeTo(this.channel, { received: this.dispatchMessageEvent.bind(this) })
+    this.subscription = await subscribeTo(this.channel, {
+      received: this.dispatchMessageEvent.bind(this),
+      connected: this.subscriptionConnected.bind(this),
+      disconnected: this.subscriptionDisconnected.bind(this)
+    })
   }
 
   disconnectedCallback() {
@@ -18,6 +22,14 @@ class TurboCableStreamSourceElement extends HTMLElement {
     return this.dispatchEvent(event)
   }
 
+  subscriptionConnected() {
+    this.setAttribute("connected", "")
+  }
+
+  subscriptionDisconnected() {
+    this.removeAttribute("connected")
+  }
+
   get channel() {
     const channel = this.getAttribute("channel")
     const signed_stream_name = this.getAttribute("signed-stream-name")
@@ -25,4 +37,7 @@ class TurboCableStreamSourceElement extends HTMLElement {
   }
 }
 
-customElements.define("turbo-cable-stream-source", TurboCableStreamSourceElement)
+
+if (customElements.get("turbo-cable-stream-source") === undefined) {
+  customElements.define("turbo-cable-stream-source", TurboCableStreamSourceElement)
+}

data/app/javascript/turbo/fetch_requests.js

@@ -3,13 +3,14 @@ export function encodeMethodIntoRequestBody(event) {
     const { target: form, detail: { fetchOptions } } = event
 
     form.addEventListener("turbo:submit-start", ({ detail: { formSubmission: { submitter } } }) => {
-      const method = (submitter && submitter.formMethod) || (fetchOptions.body && fetchOptions.body.get("_method")) || form.getAttribute("method")
+      const body = isBodyInit(fetchOptions.body) ? fetchOptions.body : new URLSearchParams()
+      const method = determineFetchMethod(submitter, body, form)
 
       if (!/get/i.test(method)) {
         if (/post/i.test(method)) {
-          fetchOptions.body.delete("_method")
+          body.delete("_method")
         } else {
-          fetchOptions.body.set("_method", method)
+          body.set("_method", method)
         }
 
         fetchOptions.method = "post"
@@ -17,3 +18,42 @@ export function encodeMethodIntoRequestBody(event) {
     }, { once: true })
   }
 }
+
+function determineFetchMethod(submitter, body, form) {
+  const formMethod = determineFormMethod(submitter)
+  const overrideMethod = body.get("_method")
+  const method = form.getAttribute("method") || "get"
+
+  if (typeof formMethod == "string") {
+    return formMethod
+  } else if (typeof overrideMethod == "string") {
+    return overrideMethod
+  } else {
+    return method
+  }
+}
+
+function determineFormMethod(submitter) {
+  if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) {
+    // Rails 7 ActionView::Helpers::FormBuilder#button method has an override
+    // for formmethod if the button does not have name or value attributes
+    // set, which is the default. This means that if you use <%= f.button
+    // formmethod: :delete %>, it will generate a <button name="_method"
+    // value="delete" formmethod="post">. Therefore, if the submitter's name
+    // is already _method, it's value attribute already contains the desired
+    // method.
+    if (submitter.name === '_method') {
+      return submitter.value
+    } else if (submitter.hasAttribute("formmethod")) {
+      return submitter.formMethod
+    } else {
+      return null
+    }
+  } else {
+    return null
+  }
+}
+
+function isBodyInit(body) {
+  return body instanceof FormData || body instanceof URLSearchParams
+}

data/app/models/concerns/turbo/broadcastable.rb

@@ -27,8 +27,8 @@
 # (which is derived by default from the plural model name of the model, but can be overwritten).
 #
 # You can also choose to render html instead of a partial inside of a broadcast
-# you do this by passing the html: option to any broadcast method that accepts the **rendering argument
-# 
+# you do this by passing the `html:` option to any broadcast method that accepts the **rendering argument. Example:
+#
 #   class Message < ApplicationRecord
 #     belongs_to :user
 #
@@ -39,7 +39,34 @@
 #         broadcast_update_to(user, :messages, target: "message-count", html: "<p> #{user.messages.count} </p>")
 #       end
 #   end
-# 
+#
+# If you want to render a template instead of a partial, e.g. ('messages/index' or 'messages/show'), you can use the `template:` option.
+# Again, only to any broadcast method that accepts the `**rendering` argument. Example:
+#
+#   class Message < ApplicationRecord
+#     belongs_to :user
+#
+#     after_create_commit :update_message
+#
+#     private
+#       def update_message
+#         broadcast_replace_to(user, :message, target: "message", template: "messages/show", locals: { message: self })
+#       end
+#   end
+#
+# If you want to render a renderable object you can use the `renderable:` option.
+#
+#   class Message < ApplicationRecord
+#     belongs_to :user
+#
+#     after_create_commit :update_message
+#
+#     private
+#       def update_message
+#         broadcast_replace_to(user, :message, target: "message", renderable: MessageComponent.new)
+#       end
+#   end
+#
 # There are four basic actions you can broadcast: <tt>remove</tt>, <tt>replace</tt>, <tt>append</tt>, and
 # <tt>prepend</tt>. As a rule, you should use the <tt>_later</tt> versions of everything except for remove when broadcasting
 # within a real-time path, like a controller or model, since all those updates require a rendering step, which can slow down
@@ -72,16 +99,16 @@ module Turbo::Broadcastable
     #     broadcasts_to ->(message) { [ message.board, :messages ] }, partial: "messages/custom_message"
     #   end
     def broadcasts_to(stream, inserts_by: :append, target: broadcast_target_default, **rendering)
-      after_create_commit  -> { broadcast_action_later_to stream.try(:call, self) || send(stream), action: inserts_by, target: target.try(:call, self) || target, **rendering }
-      after_update_commit  -> { broadcast_replace_later_to stream.try(:call, self) || send(stream), **rendering }
-      after_destroy_commit -> { broadcast_remove_to stream.try(:call, self) || send(stream) }
+      after_create_commit  -> { broadcast_action_later_to(stream.try(:call, self) || send(stream), action: inserts_by, target: target.try(:call, self) || target, **rendering) }
+      after_update_commit  -> { broadcast_replace_later_to(stream.try(:call, self) || send(stream), **rendering) }
+      after_destroy_commit -> { broadcast_remove_to(stream.try(:call, self) || send(stream)) }
     end
 
     # Same as <tt>#broadcasts_to</tt>, but the designated stream for updates and destroys is automatically set to
     # the current model, for creates - to the model plural name, which can be overriden by passing <tt>stream</tt>.
     def broadcasts(stream = model_name.plural, inserts_by: :append, target: broadcast_target_default, **rendering)
-      after_create_commit  -> { broadcast_action_later_to stream, action: inserts_by, target: target.try(:call, self) || target, **rendering }
-      after_update_commit  -> { broadcast_replace_later **rendering }
+      after_create_commit  -> { broadcast_action_later_to(stream, action: inserts_by, target: target.try(:call, self) || target, **rendering) }
+      after_update_commit  -> { broadcast_replace_later(**rendering) }
       after_destroy_commit -> { broadcast_remove }
     end
 
@@ -335,8 +362,13 @@ module Turbo::Broadcastable
         # Add the current instance into the locals with the element name (which is the un-namespaced name)
         # as the key. This parallels how the ActionView::ObjectRenderer would create a local variable.
         o[:locals] = (o[:locals] || {}).reverse_merge!(model_name.element.to_sym => self)
-        # if the html option is passed in it will skip setting a partial from #to_partial_path
-        unless o.include?(:html)
+
+        if o[:html] || o[:partial]
+          return o
+        elsif o[:template] || o[:renderable]
+          o[:layout] = false
+        else
+          # if none of these options are passed in, it will set a partial from #to_partial_path
           o[:partial] ||= to_partial_path
         end
       end

data/app/models/turbo/streams/tag_builder.rb

@@ -227,6 +227,8 @@ class Turbo::Streams::TagBuilder
   private
     def render_template(target, content = nil, allow_inferred_rendering: true, **rendering, &block)
       case
+      when content.respond_to?(:render_in)
+        content.render_in(@view_context, &block)
       when content
         allow_inferred_rendering ? (render_record(content) || content) : content
       when block_given?

data/app/views/layouts/turbo_rails/frame.html.erb

@@ -0,0 +1,8 @@
+<html>
+  <head>
+    <%= yield :head %>
+  </head>
+  <body>
+    <%= yield %>
+  </body>
+</html>

data/config/routes.rb

@@ -3,4 +3,4 @@ Rails.application.routes.draw do
   get "recede_historical_location"  => "turbo/native/navigation#recede",  as: :turbo_recede_historical_location
   get "resume_historical_location"  => "turbo/native/navigation#resume",  as: :turbo_resume_historical_location
   get "refresh_historical_location" => "turbo/native/navigation#refresh", as: :turbo_refresh_historical_location
-end
+end if Turbo.draw_routes

data/lib/install/turbo_with_bun.rb

@@ -0,0 +1,9 @@
+if (js_entrypoint_path = Rails.root.join("app/javascript/application.js")).exist?
+  say "Import Turbo"
+  append_to_file "app/javascript/application.js", %(import "@hotwired/turbo-rails"\n)
+else
+  say "You must import @hotwired/turbo-rails in your JavaScript entrypoint file", :red
+end
+
+say "Install Turbo"
+run "bun add @hotwired/turbo-rails"

data/lib/tasks/turbo_tasks.rake

@@ -1,18 +1,27 @@
-def run_turbo_install_template(path)
-  system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{File.expand_path("../install/#{path}.rb", __dir__)}"
-end
+module Turbo
+  module Tasks
+    extend self
+    def run_turbo_install_template(path)
+      system "#{RbConfig.ruby} ./bin/rails app:template LOCATION=#{File.expand_path("../install/#{path}.rb", __dir__)}"
+    end
 
-def redis_installed?
-  Gem.win_platform? ?
-    system('where redis-server > NUL 2>&1') : 
-    system('which redis-server > /dev/null')
-end
+    def redis_installed?
+      Gem.win_platform? ?
+        system('where redis-server > NUL 2>&1') :
+        system('which redis-server > /dev/null')
+    end
 
-def switch_on_redis_if_available
-  if redis_installed?
-    Rake::Task["turbo:install:redis"].invoke
-  else
-    puts "Run turbo:install:redis to switch on Redis and use it in development for turbo streams"
+    def switch_on_redis_if_available
+      if redis_installed?
+        Rake::Task["turbo:install:redis"].invoke
+      else
+        puts "Run turbo:install:redis to switch on Redis and use it in development for turbo streams"
+      end
+    end
+
+    def using_bun?
+      Rails.root.join("bun.config.js").exist?
+    end
   end
 end
 
@@ -21,6 +30,8 @@ namespace :turbo do
   task :install do
     if Rails.root.join("config/importmap.rb").exist?
       Rake::Task["turbo:install:importmap"].invoke
+    elsif Rails.root.join("package.json").exist? && Turbo::Tasks.using_bun?
+      Rake::Task["turbo:install:bun"].invoke
     elsif Rails.root.join("package.json").exist?
       Rake::Task["turbo:install:node"].invoke
     else
@@ -31,19 +42,25 @@ namespace :turbo do
   namespace :install do
     desc "Install Turbo into the app with asset pipeline"
     task :importmap do
-      run_turbo_install_template "turbo_with_importmap"
-      switch_on_redis_if_available
+      Turbo::Tasks.run_turbo_install_template "turbo_with_importmap"
+      Turbo::Tasks.switch_on_redis_if_available
     end
 
     desc "Install Turbo into the app with webpacker"
     task :node do
-      run_turbo_install_template "turbo_with_node"
-      switch_on_redis_if_available
+      Turbo::Tasks.run_turbo_install_template "turbo_with_node"
+      Turbo::Tasks.switch_on_redis_if_available
+    end
+
+    desc "Install Turbo into the app with bun"
+    task :bun do
+      Turbo::Tasks.run_turbo_install_template "turbo_with_bun"
+      Turbo::Tasks.switch_on_redis_if_available
     end
 
     desc "Switch on Redis and use it in development"
     task :redis do
-      run_turbo_install_template "turbo_needs_redis"
+      Turbo::Tasks.run_turbo_install_template "turbo_needs_redis"
     end
   end
 end

data/lib/turbo/broadcastable/test_helper.rb

@@ -0,0 +1,172 @@
+module Turbo
+  module Broadcastable
+    module TestHelper
+      extend ActiveSupport::Concern
+
+      included do
+        include ActionCable::TestHelper
+
+        include Turbo::Streams::StreamName
+      end
+
+      # Asserts that `<turbo-stream>` elements were broadcast over Action Cable
+      #
+      # === Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   channel Action Cable name, or the name itself
+      # * <tt>&block</tt> optional block executed before the
+      #   assertion
+      #
+      # === Options
+      #
+      # * <tt>count:</tt> the number of `<turbo-stream>` elements that are
+      # expected to be broadcast
+      #
+      # Asserts `<turbo-stream>` elements were broadcast:
+      #
+      #     message = Message.find(1)
+      #     message.broadcast_replace_to "messages"
+      #
+      #     assert_turbo_stream_broadcasts "messages"
+      #
+      # Asserts that two `<turbo-stream>` elements were broadcast:
+      #
+      #     message = Message.find(1)
+      #     message.broadcast_replace_to "messages"
+      #     message.broadcast_remove_to "messages"
+      #
+      #     assert_turbo_stream_broadcasts "messages", count: 2
+      #
+      # You can pass a block to run before the assertion:
+      #
+      #     message = Message.find(1)
+      #
+      #     assert_turbo_stream_broadcasts "messages" do
+      #       message.broadcast_append_to "messages"
+      #     end
+      #
+      # In addition to a String, the helper also accepts an Object or Array to
+      # determine the name of the channel the elements are broadcast to:
+      #
+      #     message = Message.find(1)
+      #
+      #     assert_turbo_stream_broadcasts message do
+      #       message.broadcast_replace
+      #     end
+      #
+      def assert_turbo_stream_broadcasts(stream_name_or_object, count: nil, &block)
+        payloads = capture_turbo_stream_broadcasts(stream_name_or_object, &block)
+        stream_name = stream_name_from(stream_name_or_object)
+
+        if count.nil?
+          assert_not_empty payloads, "Expected at least one broadcast on #{stream_name.inspect}, but there were none"
+        else
+          broadcasts = "Turbo Stream broadcast".pluralize(count)
+
+          assert count == payloads.count, "Expected #{count} #{broadcasts} on #{stream_name.inspect}, but there were none"
+        end
+      end
+
+      # Asserts that no `<turbo-stream>` elements were broadcast over Action Cable
+      #
+      # === Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   channel Action Cable name, or the name itself
+      # * <tt>&block</tt> optional block executed before the
+      #   assertion
+      #
+      # Asserts that no `<turbo-stream>` elements were broadcast:
+      #
+      #     message = Message.find(1)
+      #     message.broadcast_replace_to "messages"
+      #
+      #     assert_no_turbo_stream_broadcasts "messages" # fails with MiniTest::Assertion error
+      #
+      # You can pass a block to run before the assertion:
+      #
+      #     message = Message.find(1)
+      #
+      #     assert_no_turbo_stream_broadcasts "messages" do
+      #       # do something other than broadcast to "messages"
+      #     end
+      #
+      # In addition to a String, the helper also accepts an Object or Array to
+      # determine the name of the channel the elements are broadcast to:
+      #
+      #     message = Message.find(1)
+      #
+      #     assert_no_turbo_stream_broadcasts message do
+      #       # do something other than broadcast to "message_1"
+      #     end
+      #
+      def assert_no_turbo_stream_broadcasts(stream_name_or_object, &block)
+        block&.call
+
+        stream_name = stream_name_from(stream_name_or_object)
+
+        payloads = broadcasts(stream_name)
+
+        assert payloads.empty?, "Expected no broadcasts on #{stream_name.inspect}, but there were #{payloads.count}"
+      end
+
+      # Captures any `<turbo-stream>` elements that were broadcast over Action Cable
+      #
+      # === Arguments
+      #
+      # * <tt>stream_name_or_object</tt> the objects used to generate the
+      #   channel Action Cable name, or the name itself
+      # * <tt>&block</tt> optional block to capture broadcasts during execution
+      #
+      # Returns any `<turbo-stream>` elements that have been broadcast as an
+      # Array of <tt>Nokogiri::XML::Element</tt> instances
+      #
+      #     message = Message.find(1)
+      #     message.broadcast_append_to "messages"
+      #     message.broadcast_prepend_to "messages"
+      #
+      #     turbo_streams = capture_turbo_stream_broadcasts "messages"
+      #
+      #     assert_equal "append", turbo_streams.first["action"]
+      #     assert_equal "prepend", turbo_streams.second["action"]
+      #
+      # You can pass a block to limit the scope of the broadcasts being captured:
+      #
+      #     message = Message.find(1)
+      #
+      #     turbo_streams = capture_turbo_stream_broadcasts "messages" do
+      #       message.broadcast_append_to "messages"
+      #     end
+      #
+      #     assert_equal "append", turbo_streams.first["action"]
+      #
+      # In addition to a String, the helper also accepts an Object or Array to
+      # determine the name of the channel the elements are broadcast to:
+      #
+      #     message = Message.find(1)
+      #
+      #     replace, remove = capture_turbo_stream_broadcasts message do
+      #       message.broadcast_replace
+      #       message.broadcast_remove
+      #     end
+      #
+      #     assert_equal "replace", replace["action"]
+      #     assert_equal "replace", remove["action"]
+      #
+      def capture_turbo_stream_broadcasts(stream_name_or_object, &block)
+        block&.call
+
+        stream_name = stream_name_from(stream_name_or_object)
+        payloads = broadcasts(stream_name)
+
+        payloads.flat_map do |payload|
+          html = ActiveSupport::JSON.decode(payload)
+          document = Nokogiri::HTML5.parse(html)
+
+          document.at("body").element_children
+        end
+      end
+    end
+  end
+end

data/lib/turbo/engine.rb

@@ -1,5 +1,4 @@
 require "rails/engine"
-require "turbo/test_assertions"
 
 module Turbo
   class Engine < Rails::Engine
@@ -34,6 +33,12 @@ module Turbo
       end
     end
 
+    initializer "turbo.configs" do
+      config.after_initialize do |app|
+        Turbo.draw_routes = app.config.turbo.draw_routes != false
+      end
+    end
+
     initializer "turbo.helpers", before: :load_config_initializers do
       ActiveSupport.on_load(:action_controller_base) do
         include Turbo::Streams::TurboStreamsTagBuilder, Turbo::Frames::FrameRequest, Turbo::Native::Navigation
@@ -69,8 +74,17 @@ module Turbo
 
     initializer "turbo.test_assertions" do
       ActiveSupport.on_load(:active_support_test_case) do
+        require "turbo/test_assertions"
+        require "turbo/broadcastable/test_helper"
+
         include Turbo::TestAssertions
       end
+
+      ActiveSupport.on_load(:action_dispatch_integration_test) do
+        require "turbo/test_assertions/integration_test_assertions"
+
+        include Turbo::TestAssertions::IntegrationTestAssertions
+      end
     end
 
     initializer "turbo.integration_test_request_encoding" do