inline_forms 8.1.40 → 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/pending_migration_gate_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# Covers the pending-migration gate: an attribute_list row whose column does
+# not exist yet (the inline_forms_addto window between the model edit and
+# `rails db:migrate`) must render a read-only placeholder and be skipped on
+# write, instead of 500ing on the missing column. Gizmo's list references
+# :pending_note, which has no column on the gizmos table (see
+# test/integration_test_helper.rb and test/dummy/app/models/gizmo.rb).
+class PendingMigrationGateTest < InlineFormsIntegrationTestCase
+  setup do
+    @gizmo = Gizmo.create!(name: "Gadget")
+  end
+
+  test "predicate flags a phantom column and only that" do
+    g = @gizmo
+    # phantom scalar column -> pending
+    assert InlineForms.attribute_pending_migration?(g, :pending_note, :text_field)
+    # real column -> not pending
+    refute InlineForms.attribute_pending_migration?(g, :name, :text_field)
+    # header is a label, never gated
+    refute InlineForms.attribute_pending_migration?(g, :section, :header)
+    # info bound to a real column
+    refute InlineForms.attribute_pending_migration?(g, :created_at, :info)
+    # relation dropdown backed by a missing foreign key -> pending
+    assert InlineForms.attribute_pending_migration?(g, :vendor, :dropdown)
+    # no-column elements are never gated
+    refute InlineForms.attribute_pending_migration?(g, :parts, :has_many)
+    refute InlineForms.attribute_pending_migration?(g, :body, :rich_text)
+    refute InlineForms.attribute_pending_migration?(g, :report, :pdf_link)
+    # exempt virtual-backed elements (column name != attribute)
+    refute InlineForms.attribute_pending_migration?(g, :amount, :money_field)
+  end
+
+  test "row show renders a pending placeholder and does not raise" do
+    frame = "gizmo_#{@gizmo.id}"
+    get gizmo_path(@gizmo, update: frame), headers: frame_headers(frame)
+
+    assert_response :success
+    assert_includes response.body, "pending migration"
+    # the real field still renders its own edit frame
+    assert_includes response.body, %(<turbo-frame id="gizmo_#{@gizmo.id}_name">)
+    # the phantom field is NOT rendered as an editable field frame
+    refute_includes response.body, %(<turbo-frame id="gizmo_#{@gizmo.id}_pending_note">)
+  end
+
+  test "new form renders a pending placeholder instead of an input" do
+    get new_gizmo_path(update: "gizmos_list"), headers: frame_headers("gizmos_list")
+
+    assert_response :success
+    assert_includes response.body, "pending migration"
+    refute_includes response.body, %(name="pending_note")
+  end
+
+  test "create skips the pending column and still saves" do
+    assert_difference -> { Gizmo.count }, +1 do
+      post gizmos_path(update: "gizmos_list"),
+           params: { name: "Fresh", pending_note: "ignored — no column yet" },
+           headers: frame_headers("gizmos_list")
+    end
+    assert_response :success
+    assert Gizmo.exists?(name: "Fresh")
+  end
+
+  test "forced update of a pending field is refused, not a 500" do
+    frame = "gizmo_#{@gizmo.id}_pending_note"
+    put gizmo_path(@gizmo, attribute: "pending_note", form_element: "text_field",
+                   update: frame),
+        params: { pending_note: "x" }, headers: frame_headers(frame)
+
+    assert_response :unprocessable_entity
+    assert_includes response.body, "pending migration"
+  end
+end

data/test/integration/schema_batch_pipeline_test.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# The batch pipeline (phases 1-3): drafting intents into a batch, freeze on
+# submit, token-authenticated export + status callback, and import/replay
+# via a recording executor (never mutates the dummy tree).
+class SchemaBatchPipelineTest < InlineFormsIntegrationTestCase
+  def teardown
+    InlineFormsSchemaEdit.export_token = nil
+    super
+  end
+
+  def draft_widget_field!(attribute: "warehouse_note", label: "Warehouse note")
+    post inline_forms_schema_draft_path,
+         params: { model_name: "Widget", attribute: attribute,
+                   form_element: "text_field", after: "name", label: label, locale: "en" }
+  end
+
+  # -- phase 1: drafting + freeze ------------------------------------------
+
+  test "drafting an intent creates a draft batch (the cart) and index shows it" do
+    draft_widget_field!
+    assert_response :redirect
+
+    batch = InlineForms::SchemaBatch.with_status(:draft).first
+    assert batch, "draft batch created"
+    assert_equal 1, batch.intents.count
+    intent = batch.intents.first
+    assert_equal %w[Widget warehouse_note text_field name], [
+      intent.target_model, intent.attr_name, intent.form_element, intent.after_attr
+    ]
+
+    get inline_forms_schema_index_path
+    assert_response :success
+    assert_includes response.body, "warehouse_note"
+    assert_includes response.body, "Submit batch"
+  end
+
+  test "invalid intents are rejected at drafting time" do
+    post inline_forms_schema_draft_path,
+         params: { model_name: "Widget", attribute: "name", form_element: "text_field" }
+    assert_response :success # renders :new with the error
+    assert_includes response.body, "already has a name column"
+    assert_equal 0, InlineForms::SchemaIntentRecord.count
+  end
+
+  test "submit freezes the batch: no more adds, edits or removals; digest sealed" do
+    draft_widget_field!
+    post inline_forms_schema_submit_batch_path
+    assert_response :redirect
+
+    batch = InlineForms::SchemaBatch.last
+    assert_equal "submitted", batch.status
+    assert batch.submitted_at
+    assert_match(/\Asha256:/, batch.content_digest)
+
+    intent = batch.intents.first
+    intent.label = "changed"
+    refute intent.save, "frozen intent must not save"
+    refute intent.destroy, "frozen intent must not be destroyed"
+
+    refute batch.intents.create(target_model: "Widget", attr_name: "late_one",
+                                form_element: "text_field").persisted?,
+           "no new intents into a frozen batch"
+
+    batch.window_at = 2.days.from_now
+    refute batch.save, "frozen batch attributes must not change"
+
+    # A new draft goes into a NEW batch.
+    draft_widget_field!(attribute: "second_note")
+    assert_equal 2, InlineForms::SchemaBatch.count
+  end
+
+  test "submitting an empty batch is refused" do
+    post inline_forms_schema_submit_batch_path
+    assert_redirected_to inline_forms_schema_index_path
+    assert_equal 0, InlineForms::SchemaBatch.where(status: "submitted").count
+  end
+
+  test "status transitions follow the pipeline; illegal jumps raise" do
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+
+    batch.transition!(:processing)
+    batch.transition!(:ready, git_sha: "abc123")
+    assert_equal "abc123", batch.git_sha
+    assert_raises(ArgumentError) { batch.transition!(:submitted) }
+    batch.transition!(:applied)
+    assert batch.applied_at
+  end
+
+  # -- phase 3: machine endpoints ------------------------------------------
+
+  test "export 404s without a configured token and 401s with a wrong one" do
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+
+    get inline_forms_schema_export_path(batch)
+    assert_response :not_found
+
+    InlineFormsSchemaEdit.export_token = "sekret"
+    get inline_forms_schema_export_path(batch), headers: { "Authorization" => "Bearer wrong" }
+    assert_response :unauthorized
+  end
+
+  test "export returns the sealed payload; draft batches are refused" do
+    InlineFormsSchemaEdit.export_token = "sekret"
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last
+
+    get inline_forms_schema_export_path(batch), headers: { "Authorization" => "Bearer sekret" }
+    assert_response :conflict
+
+    batch.submit!
+    get inline_forms_schema_export_path(batch), headers: { "Authorization" => "Bearer sekret" }
+    assert_response :success
+    payload = JSON.parse(response.body)
+    assert_equal 1, payload["format"]
+    assert_equal batch.content_digest, payload["digest"]
+    assert_equal "warehouse_note", payload["intents"].first["attribute"]
+  end
+
+  test "status callback drives the batch through the pipeline" do
+    InlineFormsSchemaEdit.export_token = "sekret"
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+
+    post inline_forms_schema_batch_status_path(batch),
+         params: { status: "processing" }, headers: { "Authorization" => "Bearer sekret" }
+    assert_response :success
+    assert_equal "processing", batch.reload.status
+
+    post inline_forms_schema_batch_status_path(batch),
+         params: { status: "applied" }, headers: { "Authorization" => "Bearer sekret" }
+    assert_response :unprocessable_entity, "processing -> applied skips ready"
+
+    post inline_forms_schema_batch_status_path(batch),
+         params: { status: "failed", error: "test gate red" },
+         headers: { "Authorization" => "Bearer sekret" }
+    assert_equal "failed", batch.reload.status
+    assert_equal "test gate red", batch.error
+  end
+
+  # -- phase 2: export/import round trip -----------------------------------
+
+  test "import verifies the digest and replays intents through the executor" do
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+
+    payload = InlineFormsSchemaEdit::BatchExport.payload(batch)
+
+    recorded = []
+    labels = []
+    import = InlineFormsSchemaEdit::BatchImport.new(
+      payload,
+      executor: ->(args, _root) { recorded << args },
+      label_writer: ->(**kwargs) { labels << kwargs; "/dev/null/labels.yml" }
+    )
+    result = import.apply!(destination_root: Dir.tmpdir)
+
+    assert_equal 1, result.applied
+    assert_equal [ "Widget", "warehouse_note:text_field", "--after=name" ], recorded.first
+    assert_equal "Warehouse note", labels.first[:label]
+    assert_includes result.plan.join("\n"), "inline_forms_addto Widget warehouse_note:text_field"
+  end
+
+  test "import rejects a tampered payload (digest mismatch) and stale intents" do
+    draft_widget_field!
+    batch = InlineForms::SchemaBatch.last.submit!
+    payload = InlineFormsSchemaEdit::BatchExport.payload(batch)
+
+    tampered = payload.deep_dup
+    tampered["intents"].first["attribute"] = "evil_column"
+    error = assert_raises(InlineFormsSchemaEdit::BatchImport::ImportError) do
+      InlineFormsSchemaEdit::BatchImport.new(tampered).verify!
+    end
+    assert_match(/digest mismatch/, error.message)
+
+    # A column that already exists in THIS checkout fails per-intent validation.
+    stale = InlineFormsSchemaEdit::BatchExport.payload(batch)
+    stale["intents"].first["attribute"] = "name"
+    stale["digest"] = "sha256:#{Digest::SHA256.hexdigest(JSON.generate(stale['intents']))}"
+    error = assert_raises(InlineFormsSchemaEdit::BatchImport::ImportError) do
+      InlineFormsSchemaEdit::BatchImport.new(stale).verify!
+    end
+    assert_match(/already has a name column/, error.message)
+  end
+end

data/test/integration/schema_edit_test.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative "../integration_test_helper"
+
+# The dev-only schema-change GUI (InlineForms::SchemaController): new -> preview
+# (no migration) -> apply (runs the addto generator, no db:migrate). Apply is
+# exercised with a RECORDING executor so the suite never mutates the dummy tree.
+class SchemaEditTest < InlineFormsIntegrationTestCase
+  def teardown
+    InlineForms::SchemaController.generator_executor = nil
+    InlineForms::SchemaController.label_writer = nil
+    super
+  end
+
+  test "new renders the form with supported elements" do
+    get inline_forms_schema_new_path
+    assert_response :success
+    assert_includes response.body, "Model"
+    assert_includes response.body, "Form element"
+    assert_includes response.body, "text_field"
+    assert_includes response.body, "Preview"
+    # data-turbo opt-out so the standalone utility navigates on POST
+    assert_includes response.body, %(data-turbo="false")
+  end
+
+  test "info is not offered and is rejected; header is not a scalar field" do
+    refute_includes InlineForms::SchemaPreview.supported_form_elements, :header
+    refute_includes InlineForms::SchemaPreview.supported_form_elements, :info
+
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "meta", form_element: "info" }
+    assert_response :success
+    assert_includes response.body, "Unsupported form element"
+  end
+
+  test "header preview adds a no-column row (no migration, no widget)" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "section_title",
+                   form_element: "header", after: "name", label: "Section" }
+    assert_response :success
+    assert_includes response.body, "no column, no migration"
+    assert_includes response.body, "section_title (new)"
+    # header shows its label, not an input widget
+    assert_includes response.body, "Section"
+    refute_includes response.body, %(name="section_title")
+    refute_includes Widget.column_names, "section_title"
+  end
+
+  test "header apply invokes the generator without a column (no migration)" do
+    recorded = []
+    InlineForms::SchemaController.generator_executor = ->(args, _root) { recorded << args }
+
+    post inline_forms_schema_path,
+         params: { model_name: "Widget", attribute: "section_title", form_element: "header" }
+    assert_response :success
+    assert_includes response.body, "header"
+    assert_includes response.body, "no migration"
+    assert_equal [ "Widget", "section_title:header" ], recorded.first
+  end
+
+  test "a label is written through the injected label writer" do
+    recorded = []
+    InlineForms::SchemaController.generator_executor = ->(_args, _root) { }
+    InlineForms::SchemaController.label_writer = ->(**kw) { recorded << kw; "/tmp/inline_forms_labels.en.yml" }
+
+    post inline_forms_schema_path,
+         params: { model_name: "Widget", attribute: "section_title", form_element: "header",
+                   label: "Section", locale: "en" }
+    assert_response :success
+    assert_includes response.body, "Wrote label"
+    assert_equal 1, recorded.size
+    assert_equal :section_title, recorded.first[:attribute]
+    assert_equal "Section", recorded.first[:label]
+    assert_equal "en", recorded.first[:locale]
+  end
+
+  test "preview shows the field at the right position with no migration" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "internal_note",
+                   form_element: "text_field", after: "name" }
+    assert_response :success
+    assert_includes response.body, "internal_note (new)"
+    # rendered live widget for the new field
+    assert_includes response.body, %(name="internal_note")
+    # placement: internal_note appears after name in the rendered order
+    assert response.body.index("name (new)").nil?
+    assert response.body.index(">name<") < response.body.index("internal_note (new)")
+
+    # No schema change happened.
+    refute_includes Widget.column_names, "internal_note"
+    assert_empty Dir.glob(Rails.root.join("db/migrate/*_inline_forms_add_to_*.rb"))
+  end
+
+  test "an unsupported (non-scalar) element is rejected with an error" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "vendor", form_element: "dropdown" }
+    assert_response :success
+    assert_includes response.body, "Unsupported form element"
+  end
+
+  test "a value-bearing element previews with a placeholder values hash (no raise)" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "rank",
+                   form_element: "dropdown_with_values_with_stars", after: "name" }
+    assert_response :success
+    assert_includes response.body, "rank (new)"
+    assert_includes response.body, "placeholder values hash"
+  end
+
+  test "invalid input re-renders the form with an error" do
+    post inline_forms_schema_preview_path,
+         params: { model_name: "Widget", attribute: "Bad Name", form_element: "text_field" }
+    assert_response :success
+    assert_includes response.body, "lowercase letters"
+  end
+
+  test "apply invokes the generator (no db:migrate) via the injected executor" do
+    recorded = []
+    InlineForms::SchemaController.generator_executor = ->(args, _root) { recorded << args }
+
+    post inline_forms_schema_path,
+         params: { model_name: "Widget", attribute: "internal_note",
+                   form_element: "text_field", after: "name" }
+    assert_response :success
+    assert_includes response.body, "Applied"
+    assert_includes response.body, "db:migrate" # the "you run this" instruction
+    assert_equal 1, recorded.size
+    assert_equal [ "Widget", "internal_note:text_field", "--after=name" ], recorded.first
+    # The generator never wrote a migration (recorder), and we never migrated.
+    refute_includes Widget.column_names, "internal_note"
+  end
+
+  test "reachable only outside production" do
+    original = Rails.env
+    Rails.env = ActiveSupport::StringInquirer.new("production")
+    get inline_forms_schema_new_path
+    assert_response :not_found
+  ensure
+    Rails.env = original
+  end
+end