admin_suite 0.3.1 → 0.5.0

data/test/integration/index_table_test.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Self-contained fixtures, following the pattern established in
+# association_linking_test.rb/pagination_and_stats_test.rb: this file must
+# work in isolation under `rake test TEST=test/integration/index_table_test.rb`,
+# so it defines everything it needs rather than depending on fixtures that
+# live only in a sibling test file. `LinkingFixtures::Company` is the one
+# exception -- it lives in test_helper.rb (loaded for every run) precisely
+# so tasks like this one can reuse it (see test_helper.rb's comment above
+# it).
+module IndexTableFixtures
+  # Two rows: one fully populated (including a present `belongs_to`-shaped
+  # association), one deliberately sparse (nil scalar, nil association) --
+  # covers item 5 (nil -> em dash) and Task 3's non-regression (a present
+  # association still renders as a link) in the same fixture.
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name, :count, :status, :company
+
+    def initialize(id:, name:, count:, status:, company:)
+      @id = id
+      @name = name
+      @count = count
+      @status = status
+      @company = company
+    end
+
+    ROWS = [
+      new(id: 1, name: "Alpha", count: 5, status: "ok", company: LinkingFixtures::Company.new),
+      new(id: 2, name: "Beta", count: nil, status: nil, company: nil)
+    ]
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new(ROWS)
+    def self.column_names = %w[id name count status]
+    def self.primary_key = "id"
+    def self.columns_hash = { "id" => Struct.new(:type).new(:integer) }
+    def self.find(id) = ROWS.find { |w| w.to_param == id.to_s }
+    def to_param = id.to_s
+    def attributes = { "id" => id, "name" => name, "count" => count, "status" => status }
+  end
+
+  # A real slicing relation (unlike `ReadOnlyResourceFixtures::Relation`,
+  # whose `#offset`/`#limit` are no-ops returning self -- see
+  # test-harness fact #8). `Pagy::Backend#pagy_get_items` calls
+  # `collection.offset(pagy.offset).limit(pagy.limit)`, so this must
+  # actually slice for the per-page tests to prove anything.
+  class SlicingRelation
+    include Enumerable
+
+    def initialize(records, offset: 0)
+      @records = records
+      @offset = offset
+    end
+
+    def each(&block) = @records.each(&block)
+    def count(*) = @records.length
+    def offset(n) = SlicingRelation.new(@records, offset: n)
+    def limit(n) = @records[@offset, n] || []
+  end
+
+  class PagedWidget
+    extend ActiveModel::Naming
+
+    attr_reader :id
+
+    def initialize(id:) = @id = id
+
+    ALL_ROWS = (1..150).map { |n| new(id: n) }
+
+    def self.all = SlicingRelation.new(ALL_ROWS)
+    def self.column_names = %w[id]
+    def self.primary_key = "id"
+    def self.columns_hash = { "id" => Struct.new(:type).new(:integer) }
+    def self.find(id) = ALL_ROWS.find { |w| w.to_param == id.to_s }
+    def to_param = id.to_s
+    def attributes = { "id" => id }
+  end
+end
+
+module Admin
+  module Resources
+    class IndexTableWidgetResource < Admin::Base::Resource
+      model IndexTableFixtures::Widget
+      portal :ops
+      section :observability
+
+      index do
+        # A filter is required for the sidebar (and thus the per-page
+        # selector, which lives inside that same form) to render at all --
+        # see `index.html.erb`'s `if index_config&.filters_list&.any? || ...`
+        # guard.
+        filters { filter :name, type: :text }
+        columns do
+          column :name, class: "font-mono"
+          column :count, align: :right
+          column :status, align: :diagonal
+          column :company
+        end
+        paginate 10
+      end
+    end
+
+    class IndexTablePagedWidgetResource < Admin::Base::Resource
+      model IndexTableFixtures::PagedWidget
+      portal :ops
+      section :observability
+
+      index do
+        columns { column :id }
+        # Deliberately distinct from the hardcoded 25 default and from any
+        # of the per_page values under test (10, 50, 100), so a test that
+        # asserts "10 rows" can only be passing because the DSL fallback
+        # kicked in, not by coincidence with some other default.
+        paginate 10
+      end
+    end
+  end
+end
+
+module AdminSuite
+  class IndexTableTest < ActionDispatch::IntegrationTest
+    # Item 1: sticky header.
+    test "the index thead carries the sticky header classes" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      assert_match %r{<thead[^>]*\bsticky\b[^>]*\btop-0\b[^>]*\bz-10\b[^>]*>}, response.body
+    end
+
+    # `sticky top-0` only actually pins the header if its nearest scroll
+    # container ancestor genuinely scrolls internally. `overflow-x: auto`
+    # alone forces the browser to compute `overflow-y` as `auto` too (per
+    # the CSS Overflow spec's "visible becomes auto when the other axis
+    # isn't visible" rule), making the wrapper div a sticky containing
+    # block -- but with no bounded height, that div never scrolls, so the
+    # header has nothing to stick against and just scrolls away with the
+    # page. This asserts the wrapper is *also* given a bounded height and
+    # `overflow-y-auto`, so a future edit that drops the height silently
+    # re-breaks sticky (a class-presence-only test on `<thead>` would stay
+    # green even if the header stopped sticking) and fails here instead.
+    test "the table's scroll wrapper is bounded so the sticky header has something to stick against" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      assert_match(
+        %r{<div class="[^"]*overflow-x-auto[^"]*overflow-y-auto[^"]*max-h-\[70vh\][^"]*"},
+        response.body
+      )
+    end
+
+    # Item 2: row click wiring, via the already-existing ClickActionsController.
+    test "each row wires the click-actions controller to its own show path" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+
+      assert_match(/<tr[^>]*data-controller="admin-suite--click-actions"[^>]*>/, response.body)
+      # ERB HTML-escapes the `>` in the Stimulus action descriptor, so the
+      # attribute renders as `click-&gt;...`, not a literal `->`.
+      assert_match(/<tr[^>]*data-action="click-&gt;admin-suite--click-actions#navigate"[^>]*>/, response.body)
+      assert_match(
+        %r{<tr[^>]*data-admin-suite--click-actions-url-value="[^"]*index_table_widgets/1"[^>]*>},
+        response.body
+      )
+    end
+
+    # Item 3: per-page selector + server-side clamp.
+    test "the filter form offers a 25/50/100 per_page selector" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      assert_match(/<select[^>]*name="per_page"[^>]*>/, response.body)
+      assert_match(/<option[^>]*value="25"/, response.body)
+      assert_match(/<option[^>]*value="50"/, response.body)
+      assert_match(/<option[^>]*value="100"/, response.body)
+    end
+
+    # Counts `<tr>` inside `<tbody>` only, deliberately independent of item
+    # 2's row-click markup (which lands in the same `<tr>` tags) -- so a
+    # per_page test failure can never be secretly caused by row-click not
+    # being wired yet.
+    def row_count(body)
+      tbody = body[%r{<tbody.*?</tbody>}m]
+      tbody ? tbody.scan(/<tr[ >]/).size : 0
+    end
+
+    test "no per_page param falls back to the DSL's paginate(n) value" do
+      get "/internal/admin_suite/ops/index_table_paged_widgets"
+      assert_response :success
+      assert_equal 10, row_count(response.body)
+    end
+
+    test "a valid per_page renders that many rows" do
+      get "/internal/admin_suite/ops/index_table_paged_widgets", params: { per_page: 50 }
+      assert_response :success
+      assert_equal 50, row_count(response.body)
+    end
+
+    test "per_page above the max clamps to 100, not the requested amount" do
+      get "/internal/admin_suite/ops/index_table_paged_widgets", params: { per_page: 999_999 }
+      assert_response :success
+      assert_equal 100, row_count(response.body)
+    end
+
+    test "per_page=0 falls back to the DSL value instead of an empty/unbounded page" do
+      get "/internal/admin_suite/ops/index_table_paged_widgets", params: { per_page: 0 }
+      assert_response :success
+      assert_equal 10, row_count(response.body)
+    end
+
+    test "a negative per_page falls back to the DSL value" do
+      get "/internal/admin_suite/ops/index_table_paged_widgets", params: { per_page: -1 }
+      assert_response :success
+      assert_equal 10, row_count(response.body)
+    end
+
+    test "a non-numeric per_page falls back to the DSL value" do
+      get "/internal/admin_suite/ops/index_table_paged_widgets", params: { per_page: "abc" }
+      assert_response :success
+      assert_equal 10, row_count(response.body)
+    end
+
+    test "an array-shaped per_page (per_page[]=1) falls back to the DSL value" do
+      get "/internal/admin_suite/ops/index_table_paged_widgets", params: { per_page: [ "1" ] }
+      assert_response :success
+      assert_equal 10, row_count(response.body)
+    end
+
+    # Item 4: column alignment + css_class.
+    test "align: :right emits text-right on the td" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      assert_match(%r{<td class="[^"]*\btext-right\b[^"]*">\s*5\s*</td>}, response.body)
+    end
+
+    test "column.css_class (the class: option) reaches the td" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      assert_match(%r{<td class="[^"]*\bfont-mono\b[^"]*">}, response.body)
+    end
+
+    test "an unknown align value renders successfully with no fabricated text-<value> class" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      refute_includes response.body, "text-diagonal"
+    end
+
+    # Isolates a single fixture row's `<tr>...</tr>` markup by a distinctive
+    # cell value, so nil-cell assertions can target Beta's row specifically
+    # instead of matching the first empty-looking `<td>` anywhere on the
+    # page (there are several: Alpha's row has none, but a loose regex
+    # would not tell the two rows apart).
+    def widget_row(body, marker)
+      tbody = body[%r{<tbody.*?</tbody>}m]
+      tbody.scan(%r{<tr.*?</tr>}m).find { |r| r.include?(marker) }
+    end
+
+    # Item 5: nil cells render an em dash, and Task 3's association links
+    # are not regressed by that change.
+    test "a nil scalar column renders an em dash, not a blank cell" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      beta_row = widget_row(response.body, "Beta")
+      refute_nil beta_row, "expected to find Beta's row"
+      # Beta's `count` is nil -- the fallback branch must turn that into an
+      # em dash instead of the empty string it renders today.
+      assert_match(%r{<td[^>]*>\s*—\s*</td>}, beta_row)
+    end
+
+    test "a nil association column renders an em dash, not a blank cell" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      beta_row = widget_row(response.body, "Beta")
+      refute_nil beta_row, "expected to find Beta's row"
+      # Beta's `company` is nil (Task 3 deliberately left nil association
+      # handling to this task). Count how many dash-only cells the row has:
+      # count and status are also nil, so there must be at least 3 (not 2),
+      # proving company's cell got the dash too rather than staying blank.
+      dash_cells = beta_row.scan(%r{<td[^>]*>\s*—\s*</td>}).size
+      assert_equal 3, dash_cells,
+        "expected 3 dash cells (count, status, company all nil) in Beta's row, got #{dash_cells}"
+    end
+
+    test "a present association still renders as a link (Task 3 non-regression)" do
+      get "/internal/admin_suite/ops/index_table_widgets"
+      assert_response :success
+      assert_match %r{<a[^>]+href="[^"]*linking_companies/7"[^>]*>\s*Acme Corp\s*</a>}, response.body
+    end
+  end
+end

data/test/integration/layout_assets_test.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# A minimal ActiveModel-backed fixture with two markdown fields, registered
+# as a real resource so we can render an actual /new page through the full
+# stack and assert the vendored EasyMDE tags appear (not just that the files
+# exist on disk, and not just that a markdown-less page omits them).
+#
+# Per Task 9's ledger: `Admin::Base::Resource` subclasses register into a
+# process-global registry via `Class#inherited`, which fires once at class
+# definition (here, at file load) and never again -- so this is safe to
+# define at the top level like `ReadOnlyResourceFixtures`/`ReadOnlyWidgetResource`
+# in test/integration/read_only_resource_test.rb, and doesn't interact badly
+# with the nav-rebuild hazard documented there (this resource is never wiped
+# or reloaded mid-run).
+module LayoutAssetsFixtures
+  class MarkdownWidget
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    attr_accessor :id, :body, :notes
+
+    def initialize(id: nil, body: nil, notes: nil)
+      @id = id
+      @body = body
+      @notes = notes
+    end
+
+    def self.column_names
+      %w[id body notes]
+    end
+
+    def persisted?
+      !id.nil?
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    # render_form_field unconditionally calls `resource.errors[field.name]`
+    # (to add the error border class / message) for every field type; no
+    # test here exercises a validation error, so a Hash defaulting to `[]`
+    # is sufficient (same rationale as form_field_renderer_test.rb's Record).
+    def errors
+      Hash.new([])
+    end
+  end
+end
+
+module Admin
+  module Resources
+    class MarkdownWidgetResource < Admin::Base::Resource
+      model LayoutAssetsFixtures::MarkdownWidget
+      portal :ops
+      section :observability
+
+      # Two markdown fields on the same form: exercises the
+      # `content_for?(:easymde_assets)` dedup guard in
+      # AdminSuite::UI::FieldRendererRegistry's :markdown handler.
+      form do
+        field :body, type: :markdown
+        field :notes, type: :markdown
+      end
+    end
+  end
+end
+
+module AdminSuite
+  class LayoutAssetsTest < ActionDispatch::IntegrationTest
+    test "the admin layout requests no third-party CDN assets" do
+      get "/internal/admin_suite"
+      assert_response :success
+      refute_includes response.body, "cdn.jsdelivr.net"
+      refute_match(%r{<script[^>]+src="https?://(?!localhost)}, response.body)
+    end
+
+    test "EasyMDE ships as a vendored engine asset" do
+      assert AdminSuite::Engine.root.join("app/assets/vendor/easymde.min.js").exist?
+      assert AdminSuite::Engine.root.join("app/assets/vendor/easymde.min.css").exist?
+    end
+
+    test "the markdown controller bounds its editor-availability retry" do
+      js = AdminSuite::Engine.root.join("app/javascript/controllers/admin_suite/markdown_editor_controller.js").read
+      assert_match(/attempts|retries|maxWait/i, js)
+    end
+
+    test "a page rendering a markdown field loads the vendored EasyMDE assets, and still no CDN" do
+      get "/internal/admin_suite/ops/markdown_widgets/new"
+      assert_response :success
+
+      refute_includes response.body, "cdn.jsdelivr.net"
+      assert_match(%r{<link[^>]+href="[^"]*vendor/easymde\.min[^"]*\.css"}, response.body)
+      assert_match(%r{<script[^>]+src="[^"]*vendor/easymde\.min[^"]*\.js"}, response.body)
+    end
+
+    test "multiple markdown fields on one form emit the EasyMDE assets exactly once" do
+      get "/internal/admin_suite/ops/markdown_widgets/new"
+      assert_response :success
+
+      assert_equal 1, response.body.scan(%r{<link[^>]+href="[^"]*vendor/easymde\.min[^"]*\.css"}).size
+      assert_equal 1, response.body.scan(%r{<script[^>]+src="[^"]*vendor/easymde\.min[^"]*\.js"}).size
+    end
+
+    test "a page without a markdown field never references EasyMDE" do
+      get "/internal/admin_suite"
+      assert_response :success
+      refute_includes response.body, "vendor/easymde.min"
+    end
+  end
+end

data/test/integration/navigation_sections_test.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  class NavigationSectionsTest < ActionDispatch::IntegrationTest
+    setup do
+      AdminSuite::PortalRegistry.reset!
+      AdminSuite.portal :ops do
+        label "Ops"
+        section :zzz_last do
+          label "Aaa Displayed First"
+          order 1
+        end
+        section :observability do
+          label "Observability"
+          order 50
+        end
+      end
+    end
+
+    teardown { AdminSuite::PortalRegistry.reset! }
+
+    test "declared sections use their label and order, not alphabetical keys" do
+      get "/internal/admin_suite/ops"
+      assert_response :success
+      first = response.body.index("Aaa Displayed First")
+      second = response.body.index("Observability")
+      assert first, "declared section label missing"
+      assert second, "second section label missing"
+      assert first < second, "sections must honour declared order, not label sort"
+    end
+
+    test "undeclared sections still auto-synthesize a humanized label" do
+      AdminSuite::PortalRegistry.reset!
+      get "/internal/admin_suite/ops"
+      assert_response :success
+      assert_includes response.body, "Observability" # from ReadOnlyWidgetResource's `section :observability`
+    end
+
+    # `:zzz_last` (declared in `setup` above) has no resources registered
+    # under it anywhere in the suite, unlike `:observability`. Before this
+    # fix, `_sidebar.html.erb` rendered a bare section label with nothing
+    # underneath for a section like this; `portals/show.html.erb` already
+    # showed "No resources in this section yet." for the same case, so the
+    # sidebar was the odd one out.
+    test "the sidebar shows the no-resources message for a declared but empty section" do
+      get "/internal/admin_suite/ops"
+      assert_response :success
+
+      # Scoped to the sidebar itself: `portals/show.html.erb`'s own fallback
+      # section list also renders "No resources in this section yet." for
+      # the same empty section, so an unscoped `assert_includes` on the full
+      # body wouldn't actually prove the *sidebar* (as opposed to the main
+      # content) says it.
+      sidebar = Nokogiri::HTML(response.body).at_css(".admin-suite-sidebar")
+      assert sidebar, "expected to find the sidebar"
+      assert_includes sidebar.text, "Aaa Displayed First"
+      assert_includes sidebar.text, "No resources in this section yet."
+    end
+  end
+end

data/test/integration/pagination_and_stats_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Self-contained fixture, following the pattern established in
+# authorization_test.rb/read_only_resource_test.rb: each integration test
+# file defines its own model + resource rather than depending on another
+# test file's fixture being loaded. Rake's TEST= support (rake/testtask.rb)
+# replaces the whole file list with just the one file requested, so a
+# fixture defined only in a sibling test file (e.g. ReadOnlyWidgetResource
+# in read_only_resource_test.rb) does not exist when this file is run in
+# isolation with `rake test TEST=test/integration/pagination_and_stats_test.rb`
+# (the exact command this task's brief calls for) — that dependency was a
+# plan-authored test defect, fixed here rather than in the implementation.
+module PaginationStatsFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name
+
+    def initialize(id: 1, name: "Observed widget")
+      @id = id
+      @name = name
+    end
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new((1..25).map { |n| new(id: n, name: "Observed widget #{n}") })
+    def self.column_names = %w[id name]
+    def self.primary_key = "id"
+    def self.columns_hash = { "id" => Struct.new(:type).new(:integer) }
+
+    def self.find(id)
+      raise ActiveRecord::RecordNotFound unless id.to_s == "1"
+
+      new
+    end
+
+    def to_param = id.to_s
+    def attributes = { "id" => id, "name" => name }
+
+    # A plain Array, not ReadOnlyResourceFixtures::Relation: render_association_section
+    # slices it via `Array.wrap(associated)[pagy.offset, per_page]` (the
+    # branch taken when the association doesn't respond to :offset), which
+    # exercises real pagination slicing rather than the Relation stand-in's
+    # no-op #offset/#limit.
+    def parts
+      (1..5).map { |n| Part.new(n) }
+    end
+  end
+
+  # Plain (non-ActiveRecord) associated record: exercises
+  # render_association_section's pagination path, the sole surviving caller
+  # of the deleted pagy_prev_link/pagy_next_link/pagy_page_links/
+  # render_pagy_series_item/render_association_pagination helpers.
+  class Part
+    attr_reader :id, :name
+
+    def initialize(id)
+      @id = id
+      @name = "Part #{id}"
+    end
+  end
+end
+
+module Admin
+  module Resources
+    class PaginationStatsWidgetResource < Admin::Base::Resource
+      model PaginationStatsFixtures::Widget
+      portal :ops
+      section :observability
+      read_only
+
+      index do
+        columns { column :name }
+        paginate 10
+        stats do
+          stat :total, -> { 7 }, color: :indigo
+        end
+      end
+
+      show do
+        section :parts, association: :parts, paginate: true, per_page: 2
+      end
+    end
+  end
+end
+
+module AdminSuite
+  class PaginationAndStatsTest < ActionDispatch::IntegrationTest
+    test "index stats render without dynamic tailwind color classes" do
+      get "/internal/admin_suite/ops/pagination_stats_widgets"
+      assert_response :success
+      refute_match(/class="[^"]*text-\{/, response.body)
+      # A real stat, with a real (new) color, rendered end to end through
+      # AdminSuite::UI::PanelDefinition + admin_suite/panels/_stat — not
+      # just a source-text check that the dynamic interpolation is gone.
+      assert_includes response.body, "text-indigo-700"
+      assert_includes response.body, ">7<"
+    end
+
+    test "the index stats markup comes from the shared stat partial" do
+      source = AdminSuite::Engine.root.join("app/views/admin_suite/resources/index.html.erb").read
+      refute_includes source, 'text-<%= color %>-600'
+      assert_includes source, "admin_suite/panels/stat"
+    end
+
+    test "pagination markup is a single shared partial" do
+      index = AdminSuite::Engine.root.join("app/views/admin_suite/resources/index.html.erb").read
+      helper = AdminSuite::Engine.root.join("app/helpers/admin_suite/base_helper.rb").read
+      assert_includes index, "admin_suite/shared/pagination"
+      refute_includes helper, "def pagy_prev_link"
+      refute_includes helper, "def render_pagy_series_item"
+    end
+
+    # The brief's original version of this test rendered the partial in
+    # isolation via `ApplicationController.render(partial:, locals:)`. That
+    # bare renderer has no routed request, so `params` carries no
+    # :controller/:action, and the partial's `url_for(params.permit!.merge(...))`
+    # calls (verbatim from the index view, per the brief's Step 3) raise
+    # `ActionController::UrlGenerationError: No route matches`. That is a
+    # second plan-authored test defect: fixed here by exercising the partial
+    # through a real routed request, which is how both callers (index,
+    # association panels) actually invoke it.
+    test "the shared pagination partial renders prev, next and the series" do
+      get "/internal/admin_suite/ops/pagination_stats_widgets", params: { page: 2 }
+      assert_response :success
+      assert_includes response.body, "Prev"
+      assert_includes response.body, "Next"
+      assert_includes response.body, "3"
+    end
+
+    test "association panel pagination renders through the same shared partial" do
+      get "/internal/admin_suite/ops/pagination_stats_widgets/1", params: { parts_page: 2 }
+      assert_response :success
+      assert_includes response.body, "Prev"
+      assert_includes response.body, "Next"
+      # Richer, index-derived markup that render_association_pagination
+      # (now deleted) never rendered: the "Showing X to Y of Z results"
+      # summary line (5 parts, 2 per page, page 2 => items 3-4).
+      assert_includes response.body, "Showing"
+      assert_includes response.body, "results"
+      assert_includes response.body, "3"
+      assert_includes response.body, "4"
+      assert_includes response.body, "5"
+      # The part most likely to regress: the per-association page param
+      # (association_page_param -> "#{section.association}_page"), not the
+      # generic :page the index uses.
+      assert_includes response.body, "parts_page=1"
+      assert_includes response.body, "parts_page=3"
+      refute_includes response.body, "?page=1"
+    end
+  end
+end