inline_forms 8.1.21 → 8.1.42

data/test/inline_forms_addto_generator_test.rb

@@ -5,6 +5,7 @@ require "tmpdir"
 require "fileutils"
 require "logger"
 require "rails"
+require "active_record"
 require "rails/generators"
 require "inline_forms"
 require_relative "../lib/generators/inline_forms_addto_generator"
@@ -56,6 +57,45 @@ class InlineFormsAddtoGeneratorTest < Minitest::Test
     end
   RUBY
 
+  # A model whose list ends with a trailing metadata block (a :header above
+  # :info / timestamps rows). New rows must land above the header, not after
+  # the info rows.
+  METADATA_MODEL = <<~RUBY
+    class Profile < ApplicationRecord
+
+      def inline_forms_attribute_list
+        @inline_forms_attribute_list ||= [
+          [ :name, :text_field ],
+          [ :bio, :text_area ],
+          [ :header_meta, :header ],
+          [ :encrypted_password, :info ],
+          [ :created_at, :info ],
+          [ :updated_at, :info ],
+        ]
+      end
+
+    end
+  RUBY
+
+  # List closed with `].freeze` and a method defined *after* the list. The old
+  # greedy `]\\n end` regex could mismatch here; the bracket-depth scan must not.
+  FROZEN_LIST_MODEL = <<~RUBY
+    class Gadget < ApplicationRecord
+
+      def inline_forms_attribute_list
+        @inline_forms_attribute_list ||= [
+          [ :name, :text_field ],
+          [ :size, :integer_field ],
+        ].freeze
+      end
+
+      def _presentation
+        "\#{name}"
+      end
+
+    end
+  RUBY
+
   def setup
     @destination_root = Dir.mktmpdir("inline_forms_addto_generator_test")
     mkdir_p("app/models")
@@ -110,6 +150,27 @@ class InlineFormsAddtoGeneratorTest < Minitest::Test
     refute_includes(migration, "create_table")
   end
 
+  def test_header_adds_a_row_but_no_migration_column
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    capture_io { run_generator("Widget", "section:header") }
+
+    model = read("app/models/widget.rb")
+    assert_includes(model, "[ :section, :header ]")
+    # A header needs no column, so no migration should be written at all.
+    refute_addto_migration_for("widgets")
+  end
+
+  def test_header_alongside_scalar_migrates_only_the_scalar
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    capture_io { run_generator("Widget", "section:header", "note:string") }
+
+    migration = read_single_addto_migration_for("widgets")
+    assert_includes(migration, "add_column :widgets, :note, :string")
+    refute_includes(migration, ":section")
+  end
+
   def test_idempotent_rerun_does_not_duplicate_lines
     write_model("widget.rb", GENERATOR_SHAPED_MODEL)
 
@@ -220,12 +281,171 @@ class InlineFormsAddtoGeneratorTest < Minitest::Test
     refute_includes(model, "self.name <=> other.name")
   end
 
+  def test_smart_placement_lands_above_trailing_metadata_block
+    write_model("profile.rb", METADATA_MODEL)
+
+    capture_io { run_generator("Profile", "occupation:string") }
+
+    model = read("app/models/profile.rb")
+    assert_includes(model, "[ :occupation, :text_field ]")
+    # Above the metadata header, and therefore above every :info row.
+    assert(model.index("[ :occupation") < model.index("[ :header_meta"),
+           "occupation should be inserted above the metadata header")
+    assert(model.index("[ :bio") < model.index("[ :occupation"),
+           "occupation should stay below the existing content rows")
+  end
+
+  def test_frozen_list_and_trailing_method_do_not_break_insertion
+    write_model("gadget.rb", FROZEN_LIST_MODEL)
+
+    capture_io { run_generator("Gadget", "color:string") }
+
+    model = read("app/models/gadget.rb")
+    assert_includes(model, "[ :color, :text_field ]")
+    # Still a single, valid, frozen list; the trailing method is untouched.
+    assert_equal(1, model.scan("].freeze").size)
+    assert_includes(model, "def _presentation")
+    assert(model.index("[ :size") < model.index("[ :color"),
+           "color should be appended after the last existing row")
+    assert(model.index("[ :color") < model.index("].freeze"),
+           "color should be inside the frozen array")
+    refute_includes(model, "no inline_forms_attribute_list found")
+  end
+
+  def test_after_option_places_row_after_named_attribute
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    capture_io { run_generator("Widget", "occupation:string", "--after=name") }
+
+    model = read("app/models/widget.rb")
+    assert(model.index("[ :name") < model.index("[ :occupation"))
+    assert(model.index("[ :occupation") < model.index("[ :category"))
+  end
+
+  def test_before_option_places_row_before_named_attribute
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    capture_io { run_generator("Widget", "occupation:string", "--before=category") }
+
+    model = read("app/models/widget.rb")
+    assert(model.index("[ :occupation") < model.index("[ :category"))
+  end
+
+  def test_missing_anchor_warns_and_falls_back_to_default
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    out, _err = capture_io do
+      run_generator("Widget", "occupation:string", "--after=nope")
+    end
+
+    assert_includes(out, "--after nope not found")
+    model = read("app/models/widget.rb")
+    assert_includes(model, "[ :occupation, :text_field ]")
+  end
+
+  def test_value_bearing_element_gets_placeholder_hash_and_warns
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    out, _err = capture_io do
+      run_generator("Widget", "status:dropdown_with_values")
+    end
+
+    model = read("app/models/widget.rb")
+    assert_includes(model, "[ :status, :dropdown_with_values, { 1 => 'one', 2 => 'two' } ]")
+    assert_includes(out, "values hash")
+  end
+
+  def test_back_to_back_runs_produce_distinct_migration_filenames
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    # No sleep between runs: unique_time_stamp must still disambiguate.
+    capture_io { run_generator("Widget", "alpha:string") }
+    capture_io { run_generator("Widget", "beta:string") }
+
+    files = Dir.glob(File.join(@destination_root, "db/migrate/*_inline_forms_add_to_widgets_*.rb"))
+    assert_equal(2, files.size, "expected two distinct addto migrations, got #{files.inspect}")
+    prefixes = files.map { |f| File.basename(f)[/\A(\d{14})/, 1] }
+    assert_equal(prefixes.uniq.size, prefixes.size, "migration timestamps collided: #{prefixes.inspect}")
+  end
+
+  def test_generated_migration_applies_cleanly_to_sqlite
+    write_model("widget.rb", GENERATOR_SHAPED_MODEL)
+
+    capture_io { run_generator("Widget", "occupation:string", "organization:belongs_to") }
+
+    migration_file = Dir.glob(
+      File.join(@destination_root, "db/migrate/*_inline_forms_add_to_widgets_*.rb")
+    ).first
+    refute_nil(migration_file, "expected an addto migration to be generated")
+
+    conn = apply_migration_to_memory_sqlite(migration_file, tables: %i[organizations widgets])
+
+    assert(conn.column_exists?(:widgets, :occupation), "occupation column should exist after migrate")
+    assert(conn.column_exists?(:widgets, :organization_id), "organization_id column should exist after migrate")
+  ensure
+    teardown_sqlite
+  end
+
   private
 
   def run_generator(*args)
     InlineForms::InlineFormsAddtoGenerator.start(args, destination_root: @destination_root)
   end
 
+  # Applies a generated migration file against a fresh in-memory sqlite DB on a
+  # dedicated connection (ScratchMigrationBase), pre-creating the referenced
+  # tables. Proves the emitted migration DSL is syntactically and semantically
+  # valid without a full Rails app — and without disturbing ActiveRecord::Base's
+  # connection (the engine integration tests share this process). Returns the
+  # scratch connection for assertions.
+  def apply_migration_to_memory_sqlite(path, tables:)
+    scratch_migration_base.establish_connection(adapter: "sqlite3", database: ":memory:")
+    conn = scratch_migration_base.connection
+    ActiveRecord::Migration.verbose = false
+    tables.each do |t|
+      conn.create_table(t, force: true) { |tbl| tbl.string :name }
+    end
+
+    src = File.read(path)
+    klass_name = src[/class\s+(\w+)\s*</, 1]
+    Object.send(:remove_const, klass_name.to_sym) if Object.const_defined?(klass_name.to_sym)
+    Object.class_eval(src)
+    klass = Object.const_get(klass_name)
+    @sqlite_migration_const = klass_name
+    # exec_migration(conn, dir) runs the migration against `conn` specifically,
+    # unlike migrate(:up) which uses ActiveRecord::Base.connection.
+    ActiveRecord::Migration.suppress_messages { klass.new.exec_migration(conn, :up) }
+    conn
+  end
+
+  def teardown_sqlite
+    if @sqlite_migration_const && Object.const_defined?(@sqlite_migration_const.to_sym)
+      Object.send(:remove_const, @sqlite_migration_const.to_sym)
+    end
+    @sqlite_migration_const = nil
+    @@scratch_migration_base&.remove_connection
+  rescue StandardError
+    nil
+  end
+
+  # A dedicated abstract ActiveRecord::Base subclass whose connection is the
+  # scratch in-memory sqlite DB. Created lazily at *runtime* (not file-load
+  # time): subclassing ActiveRecord::Base before the dummy app boots trips the
+  # railtie into resolving the wrong Rails env. Never touches Base's own
+  # connection, so the engine integration tests sharing this process keep the
+  # dummy app's in-memory schema.
+  @@scratch_migration_base = nil
+
+  def scratch_migration_base
+    @@scratch_migration_base ||= begin
+      unless Object.const_defined?(:ScratchAddtoMigrationBase)
+        Object.const_set(:ScratchAddtoMigrationBase,
+                         Class.new(ActiveRecord::Base) { self.abstract_class = true })
+      end
+      Object.const_get(:ScratchAddtoMigrationBase)
+    end
+  end
+
   def write_model(file, content)
     File.write(File.join(@destination_root, "app/models", file), content)
   end

data/test/integration/inline_forms_crud_test.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# End-to-end (controller + views + Turbo frames) CRUD through the engine's
+# InlineFormsController, running against the test/dummy host app.
+class InlineFormsCrudTest < InlineFormsIntegrationTestCase
+  setup do
+    @widget = Widget.create!(name: "Alpha", priority: 2)
+  end
+
+  test "index lists rows inside the list turbo-frame" do
+    get widgets_path(update: "widgets_list"), headers: frame_headers("widgets_list")
+
+    assert_response :success
+    assert_includes response.body, %(<turbo-frame id="widgets_list" class="list_container">)
+    assert_includes response.body, %(<turbo-frame id="widget_#{@widget.id}">)
+    assert_includes response.body, "Alpha"
+  end
+
+  test "index applies inline_forms_search when ?search= is passed" do
+    Widget.create!(name: "Beta")
+
+    get widgets_path(update: "widgets_list", search: "Alp"),
+        headers: frame_headers("widgets_list")
+
+    assert_response :success
+    assert_includes response.body, "Alpha"
+    refute_includes response.body, "Beta"
+  end
+
+  test "row show renders attribute frames" do
+    frame = "widget_#{@widget.id}"
+    get widget_path(@widget, update: frame), headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, %(<turbo-frame id="#{frame}">)
+    assert_includes response.body, %(<turbo-frame id="widget_#{@widget.id}_name">)
+  end
+
+  test "attribute edit renders the input in its frame" do
+    frame = "widget_#{@widget.id}_name"
+    get edit_widget_path(@widget, attribute: "name", form_element: "text_field",
+                         update: frame),
+        headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, %(<turbo-frame id="#{frame}">)
+    assert_includes response.body, %(name="name")
+    assert_includes response.body, %(value="Alpha")
+  end
+
+  test "attribute update persists and renders the show state" do
+    frame = "widget_#{@widget.id}_name"
+    put widget_path(@widget, attribute: "name", form_element: "text_field",
+                    update: frame),
+        params: { name: "Renamed" }, headers: frame_headers(frame)
+
+    assert_response :success
+    assert_equal "Renamed", @widget.reload.name
+    assert_includes response.body, "Renamed"
+  end
+
+  test "failed save re-renders the edit state, not a fake show (8.1.19)" do
+    frame = "widget_#{@widget.id}_name"
+    put widget_path(@widget, attribute: "name", form_element: "text_field",
+                    update: frame),
+        params: { name: "" }, headers: frame_headers(frame)
+
+    assert_response :success
+    assert_equal "Alpha", @widget.reload.name, "blank name must not persist"
+    assert_includes response.body, %(name="name"),
+      "expected the edit input to be re-rendered after a failed save"
+  end
+
+  test "destroy responds with the destroyed-row state and an undo pointing at the destroy version" do
+    frame = "widget_#{@widget.id}"
+    assert_difference -> { Widget.count }, -1 do
+      delete widget_path(@widget, update: frame), headers: frame_headers(frame)
+    end
+    assert_response :success
+
+    destroy_version = PaperTrail::Version.where(item_type: "Widget",
+                                                item_id: @widget.id,
+                                                event: "destroy").last
+    assert destroy_version, "expected a PaperTrail destroy version"
+    assert_includes response.body, "/widgets/#{destroy_version.id}/revert",
+      "undo link must target the destroy version (8.1.13)"
+  end
+
+  # revert responds with turbo_stream (replaces row + versions panel at once,
+  # see render_revert_response); the undo/Restore links request that format.
+  def turbo_stream_headers(frame_id)
+    frame_headers(frame_id).merge("Accept" => "text/vnd.turbo-stream.html")
+  end
+
+  test "revert of a destroy version restores the row (undo)" do
+    frame = "widget_#{@widget.id}"
+    delete widget_path(@widget, update: frame), headers: frame_headers(frame)
+    destroy_version = PaperTrail::Version.where(item_type: "Widget",
+                                                item_id: @widget.id,
+                                                event: "destroy").last
+
+    assert_difference -> { Widget.count }, +1 do
+      post revert_widget_path(destroy_version.id, update: "widgets_list"),
+           headers: turbo_stream_headers("widgets_list")
+    end
+    assert_response :success
+    assert Widget.exists?(@widget.id), "undo must restore the destroyed row"
+    assert_equal "Alpha", Widget.find(@widget.id).name
+  end
+
+  test "revert of a destroy version is idempotent when the row already exists (8.1.17)" do
+    frame = "widget_#{@widget.id}"
+    delete widget_path(@widget, update: frame), headers: frame_headers(frame)
+    destroy_version = PaperTrail::Version.where(item_type: "Widget",
+                                                item_id: @widget.id,
+                                                event: "destroy").last
+
+    post revert_widget_path(destroy_version.id, update: "widgets_list"),
+         headers: turbo_stream_headers("widgets_list")
+    assert Widget.exists?(@widget.id)
+
+    # Replaying the same restore must not raise RecordNotUnique.
+    post revert_widget_path(destroy_version.id, update: "widgets_list"),
+         headers: turbo_stream_headers("widgets_list")
+    assert_response :success
+    assert_equal 1, Widget.where(id: @widget.id).count
+  end
+
+  test "versions panel lists an update event" do
+    @widget.update!(name: "Renamed once")
+    frame = "widget_#{@widget.id}"
+
+    get list_versions_widget_path(@widget, update: frame),
+        headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, "Renamed once"
+  end
+end

data/test/integration/legacy_elements_test.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# First-ever render coverage for two legacy display elements that no example
+# app exercises (see stuff/improvement-plan.md §4): simple_file_field (raw
+# filename column + host-provided download route) and pdf_link (host-provided
+# /:attribute/:id report route).
+class LegacyElementsTest < InlineFormsIntegrationTestCase
+  setup do
+    @widget = Widget.create!(name: "Legacy")
+  end
+
+  test "simple_file_field blank state renders the inline-edit plus link" do
+    frame = "widget_#{@widget.id}"
+    get widget_path(@widget, update: frame), headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, %(<turbo-frame id="widget_#{@widget.id}_manual">)
+    assert_includes response.body, "fi-plus"
+  end
+
+  test "simple_file_field edit renders a file input" do
+    frame = "widget_#{@widget.id}_manual"
+    get edit_widget_path(@widget, attribute: "manual",
+                         form_element: "simple_file_field", update: frame),
+        headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, %(type="file")
+    assert_includes response.body, %(name="manual")
+  end
+
+  test "pdf_link show renders preview and pdf links for the attribute route" do
+    frame = "widget_#{@widget.id}"
+    get widget_path(@widget, update: frame), headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, %(href="/report/#{@widget.id}")
+    assert_includes response.body, %(href="/report/#{@widget.id}.pdf")
+  end
+end

data/test/integration/native_inputs_test.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# Engine-level render coverage for the native-input form elements introduced
+# in 8.1.25/8.1.26 (previously only covered by the example-app gate).
+class NativeInputsTest < InlineFormsIntegrationTestCase
+  setup do
+    @widget = Widget.create!(
+      name: "Native",
+      released_on: Date.new(2026, 5, 17),
+      meeting_at: Time.utc(2000, 1, 1, 9, 15),
+      start_month: Date.new(2026, 5, 1),
+      priority: 2,
+      rating: 3
+    )
+  end
+
+  def edit_attribute(attribute, form_element)
+    frame = "widget_#{@widget.id}_#{attribute}"
+    get edit_widget_path(@widget, attribute: attribute, form_element: form_element,
+                         update: frame),
+        headers: frame_headers(frame)
+    assert_response :success
+    response.body
+  end
+
+  test "date_select renders a native date input with ISO value" do
+    body = edit_attribute("released_on", "date_select")
+    assert_includes body, %(type="date")
+    assert_includes body, %(value="2026-05-17")
+    refute_includes body, "<script"
+  end
+
+  test "time_select renders a native time input with HH:MM value" do
+    body = edit_attribute("meeting_at", "time_select")
+    assert_includes body, %(type="time")
+    assert_includes body, %(value="09:15")
+  end
+
+  test "month_year_picker renders a native month input with YYYY-MM value" do
+    body = edit_attribute("start_month", "month_year_picker")
+    assert_includes body, %(type="month")
+    assert_includes body, %(value="2026-05")
+  end
+
+  test "month_year_picker update accepts native and legacy formats" do
+    frame = "widget_#{@widget.id}_start_month"
+
+    put widget_path(@widget, attribute: "start_month",
+                    form_element: "month_year_picker", update: frame),
+        params: { start_month: "2026-09" }, headers: frame_headers(frame)
+    assert_equal Date.new(2026, 9, 1), @widget.reload.start_month
+
+    put widget_path(@widget, attribute: "start_month",
+                    form_element: "month_year_picker", update: frame),
+        params: { start_month: "November 2027" }, headers: frame_headers(frame)
+    assert_equal Date.new(2027, 11, 1), @widget.reload.start_month
+  end
+
+  test "dropdown_with_other renders a datalist-backed combobox without inline scripts" do
+    Kind.create!(name: "Gadget")
+    Kind.create!(name: "Gizmo")
+
+    body = edit_attribute("kind", "dropdown_with_other")
+    assert_includes body, "<datalist"
+    assert_includes body, %(<option value="Gadget">)
+    assert_includes body, %(<option value="Gizmo">)
+    assert_includes body, %(name="_widget[kind_other]")
+    refute_includes body, "<script"
+  end
+
+  test "dropdown_with_other update matches an existing record by name" do
+    kind = Kind.create!(name: "Gadget")
+    frame = "widget_#{@widget.id}_kind"
+
+    put widget_path(@widget, attribute: "kind",
+                    form_element: "dropdown_with_other", update: frame),
+        params: { _widget: { kind_other: "Gadget" } }, headers: frame_headers(frame)
+
+    assert_response :success
+    @widget.reload
+    assert_equal kind.id, @widget.kind_id
+    assert_nil @widget.kind_other
+  end
+
+  test "dropdown_with_other update stores unmatched text as the other value" do
+    Kind.create!(name: "Gadget")
+    frame = "widget_#{@widget.id}_kind"
+
+    put widget_path(@widget, attribute: "kind",
+                    form_element: "dropdown_with_other", update: frame),
+        params: { _widget: { kind_other: "Completely new thing" } },
+        headers: frame_headers(frame)
+
+    assert_response :success
+    @widget.reload
+    assert_equal 0, @widget.kind_id
+    assert_equal "Completely new thing", @widget.kind_other
+  end
+
+  test "slider_with_values renders a native range input with label data" do
+    body = edit_attribute("rating", "slider_with_values")
+    assert_includes body, %(type="range")
+    assert_includes body, "slider_with_values"
+    assert_includes body, "data-slider-values"
+    assert_includes body, %(<output)
+    refute_includes body, "<script"
+  end
+
+  test "slider_with_values show renders a progress bar (clickable, non-interactive)" do
+    frame = "widget_#{@widget.id}"
+    get widget_path(@widget, update: frame), headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, "<progress"
+  end
+
+  test "color_field renders a native color input and round-trips a hex value" do
+    @widget.update!(accent: "#a3381e")
+    body = edit_attribute("accent", "color_field")
+    assert_includes body, %(type="color")
+    assert_includes body, %(value="#a3381e")
+
+    frame = "widget_#{@widget.id}_accent"
+    put widget_path(@widget, attribute: "accent", form_element: "color_field",
+                    update: frame),
+        params: { accent: "#2563EB" }, headers: frame_headers(frame)
+    assert_response :success
+    assert_equal "#2563eb", @widget.reload.accent, "hex is normalized to lowercase"
+
+    # Junk input is rejected server-side (stored as nil), not persisted raw.
+    put widget_path(@widget, attribute: "accent", form_element: "color_field",
+                    update: frame),
+        params: { accent: "red; background:url(x)" }, headers: frame_headers(frame)
+    assert_nil @widget.reload.accent
+  end
+end

data/test/integration/open_after_create_test.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# "Open after create" (stuff/2026-07-10-nested-creation-options.md, Option A):
+# a successful top-level create of a class with an :associated (has_many)
+# panel responds with Turbo Streams that refresh the list and open the new
+# record's row, so the nested panel is immediately usable. Everything else
+# (classes without :associated, nested creates, failed saves, non-stream
+# clients) keeps the plain frame responses.
+class OpenAfterCreateTest < InlineFormsIntegrationTestCase
+  # Turbo form submissions advertise turbo-stream before text/html.
+  def stream_headers(frame_id)
+    { "Turbo-Frame" => frame_id,
+      "Accept" => "text/vnd.turbo-stream.html, text/html" }
+  end
+
+  test "top-level create with an associated panel streams the list and the opened row" do
+    assert_difference -> { Machine.count }, +1 do
+      post machines_path(update: "machines_list"),
+           params: { name: "Lathe" },
+           headers: stream_headers("machines_list")
+    end
+    assert_response :success
+    assert_equal "text/vnd.turbo-stream.html", response.media_type
+
+    machine = Machine.find_by!(name: "Lathe")
+    assert_includes response.body,
+      %(<turbo-stream action="replace" target="machines_list">)
+    assert_includes response.body,
+      %(<turbo-stream action="replace" target="machine_#{machine.id}">)
+
+    # The opened row exposes the parts panel with its "new part" link,
+    # carrying the freshly created parent's id.
+    assert_includes response.body, %(id="machine_#{machine.id}_parts_list_auto_header")
+    assert_match(
+      %r{/parts/new\?[^"]*parent_id=#{machine.id}},
+      response.body,
+      "expected the associated panel's new-record link for the created parent"
+    )
+  end
+
+  test "top-level create without turbo-stream accept keeps the list frame response" do
+    post machines_path(update: "machines_list"),
+         params: { name: "Mill" },
+         headers: frame_headers("machines_list")
+    assert_response :success
+    assert_equal "text/html", response.media_type
+    assert_includes response.body, %(<turbo-frame id="machines_list">)
+  end
+
+  test "create of a class without an associated panel is unchanged" do
+    post parts_path(update: "parts_list"),
+         params: { name: "Plain" },
+         headers: stream_headers("parts_list")
+    assert_response :success
+    assert_equal "text/html", response.media_type
+    assert_includes response.body, %(<turbo-frame id="parts_list">)
+  end
+
+  test "nested create under a parent keeps the frame response" do
+    machine = Machine.create!(name: "Host")
+    frame = "machine_#{machine.id}_parts"
+
+    assert_difference -> { Part.count }, +1 do
+      post parts_path(update: frame, parent_class: "Machine", parent_id: machine.id),
+           params: { name: "Bolt" },
+           headers: stream_headers(frame)
+    end
+    assert_response :success
+    assert_equal "text/html", response.media_type
+    assert_equal machine.id, Part.find_by!(name: "Bolt").machine_id
+  end
+
+  test "failed top-level create re-renders the new form, not streams" do
+    assert_no_difference -> { Machine.count } do
+      post machines_path(update: "machines_list"),
+           params: { name: "" },
+           headers: stream_headers("machines_list")
+    end
+    assert_response :success
+    assert_equal "text/html", response.media_type
+    assert_includes response.body, 'class="edit_form"'
+  end
+end