admin_suite 0.4.0 → 0.5.0

data/test/integration/show_hide_blank_test.rb

@@ -0,0 +1,195 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Exercises `hide_blank:` on `panel`/`section` `fields:` rows. Mirrors the
+# `ReadOnlyResourceFixtures::Widget` shape (test/integration/read_only_resource_test.rb)
+# so the show route resolves through the ordinary numeric-id `klass.find` path,
+# not the slug/uuid/token fallback.
+module HideBlankFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id
+
+    def initialize(id: 1)
+      @id = id
+    end
+
+    def self.all
+      [ new ]
+    end
+
+    def self.column_names
+      %w[id]
+    end
+
+    def self.primary_key
+      "id"
+    end
+
+    def self.columns_hash
+      { "id" => Struct.new(:type).new(:integer) }
+    end
+
+    def self.find(id)
+      raise ActiveRecord::RecordNotFound unless id.to_s == "1"
+
+      new
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    def attributes
+      { "id" => id }
+    end
+
+    # Non-blank control value -- always kept, hide_blank or not.
+    def title
+      "Widget One"
+    end
+
+    def blank_string
+      ""
+    end
+
+    def whitespace_string
+      "   "
+    end
+
+    def nil_field
+      nil
+    end
+
+    def empty_array
+      []
+    end
+
+    def empty_hash
+      {}
+    end
+
+    def false_flag
+      false
+    end
+
+    def zero_count
+      0
+    end
+
+    def zero_float
+      0.0
+    end
+  end
+end
+
+module Admin
+  module Resources
+    class HideBlankWidgetResource < Admin::Base::Resource
+      model HideBlankFixtures::Widget
+      portal :ops
+      section :observability
+
+      FIELDS = %i[
+        title blank_string whitespace_string nil_field
+        empty_array empty_hash false_flag zero_count zero_float
+      ].freeze
+
+      show do
+        sidebar do
+          panel :sidebar_hidden, title: "Sidebar hidden", fields: FIELDS, hide_blank: true
+          panel :sidebar_default, title: "Sidebar default", fields: FIELDS
+        end
+
+        section :main_hidden, title: "Main hidden", fields: FIELDS, hide_blank: true
+        section :main_default, title: "Main default", fields: FIELDS
+      end
+    end
+  end
+end
+
+module AdminSuite
+  class ShowHideBlankTest < ActionDispatch::IntegrationTest
+    PATH = "/internal/admin_suite/ops/hide_blank_widgets/1"
+
+    test "hide_blank: true hides nil, empty string, empty array, and empty hash" do
+      get PATH
+      assert_response :success
+
+      hidden_section = response.body[/Main hidden.*?(?=Main default)/m]
+      refute_nil hidden_section, "expected to find the 'Main hidden' panel before 'Main default' in the body"
+
+      refute_includes hidden_section, "Nil field"
+      refute_includes hidden_section, "Blank string"
+      refute_includes hidden_section, "Empty array"
+      refute_includes hidden_section, "Empty hash"
+    end
+
+    test "hide_blank: true keeps false, 0, 0.0, and whitespace-only strings" do
+      get PATH
+      assert_response :success
+
+      hidden_section = response.body[/Main hidden.*?(?=Main default)/m]
+      refute_nil hidden_section
+
+      assert_includes hidden_section, "False flag"
+      assert_includes hidden_section, "Zero count"
+      assert_includes hidden_section, "Zero float"
+      assert_includes hidden_section, "Whitespace string"
+      # And the boolean must still render as the meaningful "No" state, not
+      # silently vanish.
+      assert_includes hidden_section, "No"
+    end
+
+    test "hide_blank: true keeps genuinely non-blank fields" do
+      get PATH
+      assert_response :success
+
+      hidden_section = response.body[/Main hidden.*?(?=Main default)/m]
+      assert_includes hidden_section, "Title"
+      assert_includes hidden_section, "Widget One"
+    end
+
+    test "default (no hide_blank option) hides nothing -- every label row still renders" do
+      get PATH
+      assert_response :success
+
+      default_section = response.body[/Main default.*?(?=<\/html>)/m]
+      refute_nil default_section
+
+      %w[Title Blank\ string Whitespace\ string Nil\ field Empty\ array Empty\ hash False\ flag Zero\ count Zero\ float].each do |label|
+        assert_includes default_section, label, "expected label '#{label}' to render in the default (no hide_blank) panel"
+      end
+    end
+
+    test "hide_blank: true on a sidebar panel hides the same blank fields as main" do
+      get PATH
+      assert_response :success
+
+      sidebar_hidden = response.body[/Sidebar hidden.*?(?=Sidebar default)/m]
+      refute_nil sidebar_hidden
+
+      refute_includes sidebar_hidden, "Nil field"
+      refute_includes sidebar_hidden, "Blank string"
+      refute_includes sidebar_hidden, "Empty array"
+      refute_includes sidebar_hidden, "Empty hash"
+      assert_includes sidebar_hidden, "False flag"
+      assert_includes sidebar_hidden, "Zero count"
+      assert_includes sidebar_hidden, "Zero float"
+    end
+
+    test "default sidebar panel (no hide_blank) hides nothing" do
+      get PATH
+      assert_response :success
+
+      sidebar_default = response.body[/Sidebar default.*?(?=<div class="bg-white)/m] || response.body[/Sidebar default.*\z/m]
+      refute_nil sidebar_default
+
+      %w[Nil\ field Blank\ string Empty\ array Empty\ hash].each do |label|
+        assert_includes sidebar_default, label
+      end
+    end
+  end
+end

data/test/integration/toggle_test.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Final review Finding 3: the gem hard-depends on turbo-rails (`turbo_stream`
+# in `ResourcesController#toggle`, `turbo_frame_tag` throughout the resource
+# views) but never declared it in the gemspec. Before that dependency is
+# declared, this test exercises the exact path the review flagged as broken
+# in a turbo-less host: `format.turbo_stream` inside `respond_to` raises the
+# moment it's evaluated, because the `:turbo_stream` MIME type is unregistered
+# without turbo-rails loaded. See `test/test_helper.rb`'s (now removed)
+# `TurboFrameTestHelper`, which only ever patched `turbo_frame_tag` -- it
+# never made `turbo_stream`/the MIME type real, so this branch was untestable
+# until the real dependency was declared.
+module ToggleFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id
+    attr_accessor :active
+
+    def initialize(id: 1, active: false)
+      @id = id
+      @active = active
+    end
+
+    def self.all
+      ReadOnlyResourceFixtures::Relation.new([ new ])
+    end
+
+    def self.column_names
+      %w[id active]
+    end
+
+    def self.primary_key
+      "id"
+    end
+
+    def self.columns_hash
+      { "id" => Struct.new(:type).new(:integer) }
+    end
+
+    def self.find(id)
+      return new(id: 1, active: false) if id.to_s == "1"
+
+      raise ActiveRecord::RecordNotFound
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    # `dom_id` (via `ActionView::RecordIdentifier#record_key_for_dom_id`)
+    # calls `to_key` on the record -- `extend ActiveModel::Naming` alone
+    # only supplies `model_name`, not `to_key`.
+    def to_key
+      [ id ]
+    end
+
+    def update!(attrs)
+      attrs.each { |key, value| public_send("#{key}=", value) }
+      true
+    end
+  end
+end
+
+module Admin
+  module Resources
+    class ToggleWidgetResource < Admin::Base::Resource
+      model ToggleFixtures::Widget
+      portal :ops
+      section :observability
+
+      index do
+        columns do
+          column :active, type: :toggle
+        end
+      end
+    end
+  end
+end
+
+module AdminSuite
+  class ToggleTest < ActionDispatch::IntegrationTest
+    include ActionView::RecordIdentifier
+
+    BASE_PATH = "/internal/admin_suite/ops/toggle_widgets"
+
+    test "toggle's turbo_stream branch replaces the toggle cell with the flipped state" do
+      post "#{BASE_PATH}/1/toggle",
+        params: { field: "active" },
+        headers: { "Accept" => "text/vnd.turbo-stream.html" }
+
+      assert_response :success
+      assert_equal "text/vnd.turbo-stream.html", response.media_type
+
+      target = dom_id(ToggleFixtures::Widget.new(id: 1), "active_toggle")
+      assert_includes response.body, "<turbo-stream"
+      assert_includes response.body, %(action="replace")
+      assert_includes response.body, %(target="#{target}")
+      # The record started with `active: false`; the toggle flips it to
+      # `true` before rendering, so the replaced cell must reflect "on".
+      assert_includes response.body, "is-on"
+    end
+  end
+end

data/test/lib/definition_loader_test.rb

@@ -41,6 +41,18 @@ module AdminSuite
           before.each_value { |definition| AdminSuite::PortalRegistry.register(definition) }
         end
       else
+        # :dashboards/:actions have no accumulating registry to snapshot --
+        # unlike :resources/:portals (which pick up real fixtures registered
+        # by *other* test files at load time), reset! for these two kinds
+        # only clears a single flag/definition object
+        # (`root_dashboard_loaded`/`root_dashboard_definition`,
+        # `handlers_loaded`) that is entirely local to whichever test set it,
+        # via its own `with_globs`/`with_dashboard`-style ensure block. So
+        # there is nothing cross-test left to preserve, and "restore" here
+        # deliberately degrades to a second `reset!` call rather than a real
+        # snapshot+restore -- do not read this branch as returning a
+        # value-preserving restore the way the :resources/:portals branches
+        # above do.
         -> { AdminSuite::DefinitionLoader.reset!(kind) }
       end
     end

data/test/lib/form_field_renderer_test.rb

@@ -6,31 +6,52 @@ module AdminSuite
   class FormFieldRendererTest < ActionView::TestCase
     include AdminSuite::BaseHelper
 
-    Record = Struct.new(:name, :body, :enabled) do
+    Record = Struct.new(:name, :body, :enabled, :error_messages) do
+      # Both a class-level and an instance-level `model_name` are needed:
+      # `render_toggle_field`/`render_searchable_select`/`render_multi_select`
+      # all call `resource.class.model_name.param_key` (class-level), while
+      # `form_with` itself wants the instance-level accessor. (`extend
+      # ActiveModel::Naming` would give both via its own delegation, but
+      # then redefining `model_name` below to force the short "Record" name
+      # -- rather than the fully-qualified nested constant name -- clashes
+      # with that delegation and triggers a "method redefined" warning.
+      # Defining both explicitly avoids it.) The pre-existing instance-level
+      # `model_name` never covered the class-level call site because no test
+      # here exercised `:toggle`/`:searchable_select`/`:multi_select` before.
+      def self.model_name
+        @model_name ||= ActiveModel::Name.new(self, nil, "Record")
+      end
+
       def to_model = self
-      def model_name = ActiveModel::Name.new(self.class, nil, "Record")
+      def model_name = self.class.model_name
       def persisted? = false
       def to_key = nil
 
       # render_form_field unconditionally calls `resource.errors[field.name]`
       # for every field type (to add the error border class / message), so
       # the double needs an `errors` object supporting `[]` -> Array-like
-      # (`.any?`, `.first`). No test here exercises an actual validation
-      # error, so a Hash defaulting to `[]` is sufficient.
-      def errors = Hash.new([])
+      # (`.any?`, `.first`). Most tests here don't exercise an actual
+      # validation error, so a Hash defaulting to `[]` is sufficient; tests
+      # that do pass `error_messages` (a plain Hash of field name -> Array of
+      # messages) to get real per-field errors without losing the default.
+      def errors
+        Hash.new([]).merge(error_messages || {})
+      end
     end
 
-    def field(name, type)
+    def field(name, type, **overrides)
       Admin::Base::Resource::FieldDefinition.new(
-        name: name, type: type, required: false, label: name.to_s.humanize,
-        readonly: false, multiple: false, creatable: false, preview: true
+        {
+          name: name, type: type, required: false, label: name.to_s.humanize,
+          readonly: false, multiple: false, creatable: false, preview: true
+        }.merge(overrides)
       )
     end
 
-    def render_field(type, name: :name)
-      record = Record.new("x", "y", true)
+    def render_field(type, name: :name, error_messages: nil, **field_overrides)
+      record = Record.new("x", "y", true, error_messages)
       html = nil
-      form_with(model: record, url: "/", scope: :record) { |f| html = render_form_field(f, field(name, type), record) }
+      form_with(model: record, url: "/", scope: :record) { |f| html = render_form_field(f, field(name, type, **field_overrides), record) }
       html.to_s
     end
 
@@ -60,5 +81,56 @@ module AdminSuite
     test "the label is rendered for every field" do
       assert_includes render_field(:text), "Name"
     end
+
+    test "a field with a validation error renders the red border and error message" do
+      html = render_field(:text, error_messages: { name: [ "is invalid" ] })
+      assert_includes html, "border-red-500"
+      assert_includes html, "is invalid"
+    end
+
+    # The full set of field types `FieldRendererRegistry` is expected to
+    # have registered (see `lib/admin_suite/ui/field_renderer_registry.rb`).
+    # Pinned explicitly here, NOT derived from the registry itself: an
+    # earlier version of this test iterated `handlers.keys` directly, which
+    # cannot detect a deletion -- a deleted key simply stops appearing in
+    # the iteration, so the loop body never runs for it and the test still
+    # passes with one fewer assertion (verified by deleting the `:toggle`
+    # registration: 42 assertions became 41, 0 failures). The
+    # size-and-membership assertion in the test below is what actually
+    # catches that; a self-referential "iterate the thing you're testing"
+    # loop cannot.
+    EXPECTED_FIELD_TYPES = %i[
+      textarea url email number toggle label select searchable_select
+      dependent_select multi_select tags image attachment trix rich_text
+      markdown file datetime date time json code text string
+    ].freeze
+
+    # :trix/:rich_text both call `f.rich_text_area`, which only exists once
+    # ActionText's FormBuilder extension is loaded -- and per the plan's
+    # Test-harness fact #2, this dummy app is deliberately database-free and
+    # never requires `action_text/engine`. Confirmed by running the
+    # rendering test with them included: `NoMethodError: undefined method
+    # 'rich_text_area'`, not a bug in FieldRendererRegistry. There is no way
+    # to pin these two types in this harness without pulling in ActionText
+    # (and, transitively, ActiveRecord) — out of scope here. Named
+    # explicitly (not an implicit skip) so `EXPECTED_FIELD_TYPES.size` and
+    # the number of types actually exercised below both stay visible and
+    # add up: 24 expected, 2 excluded, 22 rendered.
+    UNTESTABLE_WITHOUT_ACTION_TEXT = %i[trix rich_text].freeze
+
+    test "the registry has exactly the expected set of field types, no more, no fewer" do
+      assert_equal EXPECTED_FIELD_TYPES.sort, AdminSuite::UI::FieldRendererRegistry.handlers.keys.sort
+    end
+
+    test "every expected field type except the ActionText-only ones renders non-empty markup" do
+      sample_collection = [ [ "One", 1 ], [ "Two", 2 ] ]
+      needs_collection = %i[select searchable_select dependent_select multi_select tags]
+
+      (EXPECTED_FIELD_TYPES - UNTESTABLE_WITHOUT_ACTION_TEXT).each do |type|
+        overrides = needs_collection.include?(type) ? { collection: sample_collection } : {}
+        html = render_field(type, **overrides)
+        assert html.present?, "expected #{type.inspect} to render non-empty markup"
+      end
+    end
   end
 end

data/test/lib/format_table_cell_test.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  # `format_table_cell` had no direct unit test anywhere in the suite before
+  # this file -- it was only exercised indirectly through
+  # `association_linking_test.rb`'s AR-focused fixtures. Covers the branches
+  # not already pinned there, and specifically the Integer/Float/BigDecimal
+  # delimiting added to match `format_show_value` (see
+  # `ShowValueFormatterTest#"integers and floats render delimited"`).
+  class FormatTableCellTest < ActionView::TestCase
+    include AdminSuite::BaseHelper
+
+    test "nil renders the em dash placeholder" do
+      assert_equal "—", format_table_cell(nil)
+    end
+
+    test "booleans render Yes/No" do
+      assert_equal "Yes", format_table_cell(true)
+      assert_equal "No", format_table_cell(false)
+    end
+
+    test "Time and DateTime render a short date-time" do
+      assert_equal "Jan 02, 03:04", format_table_cell(Time.utc(2026, 1, 2, 3, 4))
+      assert_equal "Jan 02, 03:04", format_table_cell(DateTime.new(2026, 1, 2, 3, 4))
+    end
+
+    test "Date renders a short date" do
+      assert_equal "Jan 02, 2026", format_table_cell(Date.new(2026, 1, 2))
+    end
+
+    test "integers and floats render delimited, matching format_show_value" do
+      assert_equal "1,234,567", format_table_cell(1_234_567)
+      assert_equal "1,234.5", format_table_cell(1234.5)
+    end
+
+    test "BigDecimal renders delimited rather than in exponential notation" do
+      result = format_table_cell(BigDecimal("9876.5"))
+      assert_includes result, "9,876"
+      refute_includes result, "0.98765e4"
+    end
+
+    test "plain strings are truncated at 50 characters" do
+      assert_equal "hello", format_table_cell("hello")
+      assert_equal ("x" * 47) + "...", format_table_cell("x" * 60)
+    end
+  end
+end