admin_suite 0.4.0 → 0.6.1

data/test/integration/index_query_characterization_test.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Pins the index query path as it behaves at v0.5.0, before
+# AdminSuite::Query is extracted. These assertions intentionally exercise
+# routed requests and rendered rows rather than controller internals.
+module IndexQueryCharacterizationFixtures
+  class Relation
+    include Enumerable
+
+    attr_reader :includes_calls
+
+    def initialize(records, offset: 0, includes_calls: [])
+      @records = records
+      @offset = offset
+      @includes_calls = includes_calls
+    end
+
+    def each(&block) = @records.each(&block)
+    def count(*) = @records.length
+    def offset(value) = self.class.new(@records, offset: value, includes_calls: includes_calls)
+    def limit(value) = @records[@offset, value] || []
+
+    def where(condition = nil, *values, **bindings)
+      condition = bindings if condition.nil?
+      selected =
+        if condition.is_a?(Hash)
+          @records.select { |record| condition.all? { |field, value| record.public_send(field).to_s == value.to_s } }
+        else
+          term = (bindings[:search] || values.first).to_s.delete("%").downcase
+          fields = condition.scan(/(\w+) ILIKE/).flatten
+          @records.select { |record| fields.any? { |field| record.public_send(field).to_s.downcase.include?(term) } }
+        end
+      self.class.new(selected, includes_calls: includes_calls)
+    end
+
+    def order(ordering)
+      field, direction = ordering.first
+      sorted = @records.sort_by { |record| record.public_send(field).to_s }
+      sorted.reverse! if direction.to_sym == :desc
+      self.class.new(sorted, includes_calls: includes_calls)
+    end
+
+    def includes(*associations)
+      includes_calls << associations
+      self
+    end
+  end
+
+  class BadIncludesRelation < Relation
+    def includes(*) = raise(ArgumentError, "unknown association")
+  end
+
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name, :secret, :status
+
+    def initialize(id:, name:, secret:, status:)
+      @id = id
+      @name = name
+      @secret = secret
+      @status = status
+    end
+
+    ROWS = [
+      new(id: 1, name: "Zulu", secret: "hidden alpha", status: "open"),
+      new(id: 2, name: "Alpha", secret: "hidden zulu", status: "closed"),
+      new(id: 3, name: "Bravo", secret: "private", status: "open")
+    ].freeze
+    INCLUDES_CALLS = []
+
+    def self.all = Relation.new(ROWS, includes_calls: INCLUDES_CALLS)
+    def self.column_names = %w[id name secret status]
+    def self.primary_key = "id"
+    def self.columns_hash = { "id" => Struct.new(:type).new(:integer) }
+    def self.find(id) = ROWS.find { |row| row.to_param == id.to_s }
+    def to_param = id.to_s
+    def attributes = { "id" => id, "name" => name, "secret" => secret, "status" => status }
+  end
+
+  class BadIncludesWidget < Widget
+    def self.all = BadIncludesRelation.new(ROWS)
+  end
+
+  class PagedWidget
+    extend ActiveModel::Naming
+
+    attr_reader :id
+
+    def initialize(id:) = @id = id
+
+    ROWS = (1..150).map { |id| new(id: id) }.freeze
+
+    def self.all = Relation.new(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) = ROWS.find { |row| row.to_param == id.to_s }
+    def to_param = id.to_s
+    def attributes = { "id" => id }
+  end
+end
+
+module Admin
+  module Resources
+    class IndexQueryCharacterizationWidgetResource < Admin::Base::Resource
+      model IndexQueryCharacterizationFixtures::Widget
+      portal :ops
+      section :observability
+
+      index do
+        searchable :name
+        sortable :name, default: :name, direction: :desc
+        filters { filter :status, type: :select, options: %w[open closed] }
+        columns do
+          column :name, sortable: true
+          column :status
+        end
+        includes :owner
+      end
+    end
+
+    class IndexQueryCharacterizationBadIncludesWidgetResource < Admin::Base::Resource
+      model IndexQueryCharacterizationFixtures::BadIncludesWidget
+      portal :ops
+      section :observability
+      index do
+        columns { column :name }
+        includes :missing
+      end
+    end
+
+    class IndexQueryCharacterizationPagedWidgetResource < Admin::Base::Resource
+      model IndexQueryCharacterizationFixtures::PagedWidget
+      portal :ops
+      section :observability
+      index do
+        columns { column :id }
+        paginate 30
+      end
+    end
+  end
+end
+
+class IndexQueryCharacterizationTest < ActionDispatch::IntegrationTest
+  WIDGETS_PATH = "/internal/admin_suite/ops/index_query_characterization_widgets"
+  PAGED_PATH = "/internal/admin_suite/ops/index_query_characterization_paged_widgets"
+
+  def rendered_names
+    css_select("tbody tr td:first-child").map { |cell| cell.text.strip }
+  end
+
+  def rendered_row_count = css_select("tbody tr").size
+
+  test "default sort applies when no sort param is given" do
+    get WIDGETS_PATH
+    assert_equal %w[Zulu Bravo Alpha], rendered_names
+  end
+
+  test "explicit sort and direction override the default" do
+    get WIDGETS_PATH, params: { sort: "name", direction: "asc" }
+    assert_equal %w[Alpha Bravo Zulu], rendered_names
+  end
+
+  test "a sort param naming an undeclared field is ignored" do
+    get WIDGETS_PATH, params: { sort: "secret", direction: "asc" }
+    assert_equal %w[Alpha Bravo Zulu], rendered_names
+  end
+
+  test "search examines only declared searchable fields" do
+    get WIDGETS_PATH, params: { search: "alpha" }
+    assert_equal [ "Alpha" ], rendered_names
+  end
+
+  test "a blank search returns the unfiltered scope" do
+    get WIDGETS_PATH, params: { search: " " }
+    assert_equal %w[Zulu Bravo Alpha], rendered_names
+  end
+
+  test "a declared filter narrows while an undeclared filter is ignored" do
+    get WIDGETS_PATH, params: { status: "open", secret: "hidden zulu" }
+    assert_equal %w[Zulu Bravo], rendered_names
+  end
+
+  test "declared includes are applied" do
+    IndexQueryCharacterizationFixtures::Widget::INCLUDES_CALLS.clear
+    get WIDGETS_PATH
+    assert_equal [ [ :owner ] ], IndexQueryCharacterizationFixtures::Widget::INCLUDES_CALLS
+  end
+
+  test "a bad includes association logs and still renders" do
+    logged = []
+    Rails.logger.stub(:warn, ->(message) { logged << message }) do
+      get "/internal/admin_suite/ops/index_query_characterization_bad_includes_widgets"
+    end
+    assert_response :success
+    assert_includes response.body, "Zulu"
+    assert_equal 1, logged.size
+  end
+
+  test "paginate 30 yields 30 rows per page" do
+    get PAGED_PATH
+    assert_equal 30, rendered_row_count
+  end
+
+  test "per_page 50 overrides the DSL value" do
+    get PAGED_PATH, params: { per_page: "50" }
+    assert_equal 50, rendered_row_count
+  end
+
+  test "an excessive per_page clamps to 100" do
+    get PAGED_PATH, params: { per_page: "999999" }
+    assert_equal 100, rendered_row_count
+  end
+
+  test "invalid and zero per_page values fall back to the DSL value" do
+    [ "abc", "0" ].each do |value|
+      get PAGED_PATH, params: { per_page: value }
+      assert_equal 30, rendered_row_count
+    end
+  end
+
+  test "a leading-zero per_page parses with Integer octal semantics" do
+    get PAGED_PATH, params: { per_page: "010" }
+    assert_equal 8, rendered_row_count
+  end
+end

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/mcp_aggregate_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module McpAggregateFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new([new, new])
+  end
+end
+
+module Admin
+  module Resources
+    class McpAggregateWidgetResource < Admin::Base::Resource
+      model McpAggregateFixtures::Widget
+      portal :ops
+      section :observability
+      index do
+        stats { stat :total, ->(scope) { scope.count } }
+      end
+    end
+  end
+end
+
+class McpAggregateTest < McpIntegrationTest
+  def call_tool(arguments)
+    post "/internal/admin_suite/mcp",
+      params: { jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "aggregate", arguments: arguments } }.to_json,
+      headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+    JSON.parse(response.body)
+  end
+
+  test "returns a count and declared stats without records" do
+    result = with_authorize(->(**) { true }) do
+      call_tool(resource: "mcp_aggregate_widget")
+    end
+
+    payload = JSON.parse(result.dig("result", "content", 0, "text"))
+    assert_equal 2, payload.fetch("count")
+    assert_equal 2, payload.dig("stats", "total")
+    refute payload.key?("rows"), "aggregate must never return records"
+  end
+end

data/test/integration/mcp_authorization_test.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module McpAuthorizationFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new([])
+    def self.find_by(id:) = new
+  end
+end
+
+module Admin
+  module Resources
+    class McpAuthorizationWidgetResource < Admin::Base::Resource
+      model McpAuthorizationFixtures::Widget
+      portal :ops
+      section :observability
+      index { columns { column :name } }
+    end
+
+    class McpAuthorizationDisabledResource < Admin::Base::Resource
+      model McpAuthorizationFixtures::Widget
+      portal :ops
+      section :observability
+      mcp false
+    end
+  end
+end
+
+class McpAuthorizationTest < McpIntegrationTest
+  def rpc(method, params = {})
+    post "/internal/admin_suite/mcp",
+      params: { jsonrpc: "2.0", id: 1, method: method, params: params }.to_json,
+      headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+    JSON.parse(response.body)
+  end
+
+  def call_tool(name, arguments = {})
+    rpc("tools/call", { name: name, arguments: arguments })
+  end
+
+  test "a nil authorize hook advertises no tools" do
+    with_authorize(nil) do
+      assert_empty rpc("tools/list").dig("result", "tools")
+    end
+  end
+
+  test "a nil authorize hook denies a direct call to every tool" do
+    ctx = { actor: "x" }
+
+    with_authorize(nil) do
+      [
+        AdminSuite::Mcp::Tools::DescribeResources.call(server_context: ctx),
+        AdminSuite::Mcp::Tools::ListRecords.call(resource: "mcp_authorization_widget", server_context: ctx),
+        AdminSuite::Mcp::Tools::GetRecord.call(resource: "mcp_authorization_widget", id: "1", server_context: ctx),
+        AdminSuite::Mcp::Tools::Aggregate.call(resource: "mcp_authorization_widget", server_context: ctx)
+      ].each do |response|
+        assert response.error?, response.inspect
+        assert_equal AdminSuite::Mcp::Authorization::DENIED_MESSAGE, response.content.first[:text]
+      end
+    end
+  end
+
+  test "the authorize hook receives an mcp surface and a read action" do
+    seen = []
+    hook = lambda do |action:, record:, context:, **|
+      seen << [action, context.surface, record]
+      true
+    end
+
+    with_authorize(hook) do
+      call_tool("list_records", { resource: "mcp_authorization_widget" })
+    end
+
+    assert_includes seen, [:read, :mcp, nil]
+  end
+
+  test "describe_resources omits resources the hook denies" do
+    hook = ->(resource:, **) { resource.resource_name != "mcp_authorization_widget" }
+
+    with_authorize(hook) do
+      refute_match(/mcp_authorization_widget/, call_tool("describe_resources").to_s)
+    end
+  end
+
+  test "an mcp-disabled resource is invisible and unreachable" do
+    with_authorize(->(**) { true }) do
+      refute_match(/mcp_authorization_disabled/, call_tool("describe_resources").to_s)
+      assert call_tool("list_records", { resource: "mcp_authorization_disabled" }).dig("result", "isError")
+    end
+  end
+
+  test "a raising authorize hook denies instead of returning a server error" do
+    with_authorize(->(**) { raise "boom" }) do
+      result = call_tool("list_records", { resource: "mcp_authorization_widget" })
+
+      assert result.dig("result", "isError"), result.inspect
+    end
+  end
+end