admin_suite 0.5.0 → 0.6.1

data/test/integration/searchable_select_search_test.rb

@@ -263,10 +263,10 @@ module AdminSuite
       assert_response :forbidden
     end
 
-    test "authorize hook receives action: :read, the resource, a nil record, and the controller" do
+    test "authorize hook receives action: :read, the resource, a nil record, and the context" do
       captured = nil
-      hook = lambda do |actor:, action:, resource:, record:, controller:|
-        captured = { action: action, resource: resource, record: record, controller: controller.class }
+      hook = lambda do |actor:, action:, resource:, record:, context:|
+        captured = { action: action, resource: resource, record: record, context: context }
         true
       end
 
@@ -275,7 +275,8 @@ module AdminSuite
       assert_equal :read, captured[:action]
       assert_equal Admin::Resources::SearchableSelectCompanyResource, captured[:resource]
       assert_nil captured[:record]
-      assert_equal AdminSuite::ResourcesController, captured[:controller]
+      assert_equal :web, captured[:context].surface
+      assert_equal AdminSuite::ResourcesController, captured[:context].controller.class
     end
 
     test "a stray ?id= is never loaded and never reaches authorize's record:" do

data/test/lib/auth_host_user_test.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class AuthNormalizeActorTest < ActiveSupport::TestCase
+  test "normalizes the authenticated-but-anonymous sentinel to nil" do
+    assert_nil AdminSuite::Auth.normalize_actor(true)
+    assert_nil AdminSuite::Auth.normalize_actor(false)
+    assert_nil AdminSuite::Auth.normalize_actor(nil)
+  end
+
+  test "passes a real actor through untouched" do
+    user = Struct.new(:email).new("ravi@techwright.io")
+    assert_same user, AdminSuite::Auth.normalize_actor(user)
+  end
+end
+
+class AuthHostUserTest < ActiveSupport::TestCase
+  Controller = Struct.new(:performed) do
+    def performed? = !!performed
+    def head(*) = nil
+  end
+
+  test "is registered under :host_user" do
+    assert_equal AdminSuite::Auth::HostUser, AdminSuite::Auth.lookup(:host_user)
+  end
+
+  test "returns the host user the resolver produced" do
+    user = Struct.new(:email).new("ravi@techwright.io")
+    strategy = AdminSuite::Auth::HostUser.new(resolve: ->(_c) { user })
+
+    assert_same user, strategy.authenticate!(Controller.new(false))
+  end
+
+  test "denies when the resolver returns nothing" do
+    strategy = AdminSuite::Auth::HostUser.new(resolve: ->(_c) { nil })
+
+    assert_nil strategy.authenticate!(Controller.new(false))
+  end
+
+  test "denies rather than raising when the resolver blows up" do
+    strategy = AdminSuite::Auth::HostUser.new(resolve: ->(_c) { raise "boom" })
+
+    assert_nil strategy.authenticate!(Controller.new(false))
+  end
+
+  test "denies loudly when no resolver is configured" do
+    strategy = AdminSuite::Auth::HostUser.new({})
+
+    assert_nil strategy.authenticate!(Controller.new(false))
+  end
+end

data/test/lib/auth_http_basic_test.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 raise "unset ADMIN_SUITE_USERNAME in test env" if ENV["ADMIN_SUITE_USERNAME"]
+raise "unset ADMIN_SUITE_PASSWORD in test env" if ENV["ADMIN_SUITE_PASSWORD"]
 
 require "test_helper"
 
@@ -55,6 +56,15 @@ module AdminSuite
       assert_equal :forbidden, controller.rendered_status
     end
 
+    test "denies with 403 when password is blank" do
+      strategy = Auth::HttpBasic.new(username: "ravi", password: nil)
+      controller = ControllerDouble.new(given_username: "ravi", given_password: nil)
+
+      assert_nil strategy.authenticate!(controller)
+      assert_equal :forbidden, controller.rendered_status
+      refute controller.challenged
+    end
+
     test "is registered as :http_basic" do
       assert_equal Auth::HttpBasic, Auth.lookup(:http_basic)
     end

data/test/lib/auth_test.rb

@@ -9,9 +9,11 @@ module AdminSuite
     end
 
     test "register and lookup a strategy by name" do
-      AdminSuite::Auth.register(:fake, FakeStrategy)
-      assert_equal FakeStrategy, AdminSuite::Auth.lookup(:fake)
-      assert_equal FakeStrategy, AdminSuite::Auth.lookup("fake")
+      with_auth_registry_snapshot do
+        AdminSuite::Auth.register(:fake, FakeStrategy)
+        assert_equal FakeStrategy, AdminSuite::Auth.lookup(:fake)
+        assert_equal FakeStrategy, AdminSuite::Auth.lookup("fake")
+      end
     end
 
     test "lookup of unknown strategy raises UnknownStrategyError" do
@@ -20,10 +22,25 @@ module AdminSuite
       end
     end
 
+    test "registered lists registered strategy names" do
+      with_auth_registry_snapshot do
+        AdminSuite::Auth.register(:fake, FakeStrategy)
+
+        assert_includes AdminSuite::Auth.registered, :fake
+        assert_includes AdminSuite::Auth.registered, :http_basic
+      end
+    end
+
     test "base strategy exposes options and requires authenticate!" do
       strategy = AdminSuite::Auth::Strategy.new(username: "u")
       assert_equal({ username: "u" }, strategy.options)
       assert_raises(NotImplementedError) { strategy.authenticate!(nil) }
     end
+
+    test "base strategy symbolizes string-keyed options" do
+      strategy = AdminSuite::Auth::Strategy.new("username" => "u")
+
+      assert_equal({ username: "u" }, strategy.options)
+    end
   end
 end

data/test/lib/authorization_context_test.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AuthorizationContextFixtures
+  # A plain object implementing #call -- exactly the shape a host might write
+  # as an authorize adapter. Has no #parameters of its own; the writer must
+  # fall back to introspecting #call's method object.
+  class CorrectArityCallable
+    def call(actor:, action:, resource:, record:, context:)
+      true
+    end
+  end
+
+  class OldArityCallable
+    def call(actor:, action:, resource:, record:, controller:)
+      true
+    end
+  end
+
+  class SplatCallable
+    def call(**)
+      true
+    end
+  end
+end
+
+class AuthorizationContextTest < ActiveSupport::TestCase
+  test "reports its surface" do
+    web = AdminSuite::AuthorizationContext.new(surface: :web, controller: :ctrl)
+    mcp = AdminSuite::AuthorizationContext.new(surface: :mcp)
+
+    assert_predicate web, :web?
+    refute_predicate web, :mcp?
+    assert_equal :ctrl, web.controller
+    assert_predicate mcp, :mcp?
+    assert_nil mcp.controller
+  end
+
+  test "rejects an unknown surface" do
+    assert_raises(ArgumentError) { AdminSuite::AuthorizationContext.new(surface: :carrier_pigeon) }
+  end
+
+  test "assigning an old-arity authorize hook raises immediately" do
+    error = assert_raises(ArgumentError) do
+      AdminSuite.config.authorize = ->(actor:, action:, resource:, record:, controller:) { true }
+    end
+
+    # Assert on the COMPUTED diagnosis, not the message's fixed footer -- that
+    # footer explains the controller:/context: migration on every failure, so
+    # `assert_match(/controller:/)` alone would pass for any rejection at all.
+    assert_match(/Missing: \[:context\]/, error.message)
+    assert_match(/Unexpected: \[:controller\]/, error.message)
+  ensure
+    AdminSuite.config.authorize = nil
+  end
+
+  test "accepts a correct-arity hook and a nil hook" do
+    AdminSuite.config.authorize = ->(actor:, action:, resource:, record:, context:) { true }
+    assert_respond_to AdminSuite.config.authorize, :call
+    AdminSuite.config.authorize = nil
+    assert_nil AdminSuite.config.authorize
+  end
+
+  test "accepts a hook that takes a keyword splat" do
+    AdminSuite.config.authorize = ->(**) { true }
+    assert_respond_to AdminSuite.config.authorize, :call
+
+    AdminSuite.config.authorize = ->(action:, **) { action == :read }
+    assert_respond_to AdminSuite.config.authorize, :call
+  ensure
+    AdminSuite.config.authorize = nil
+  end
+
+  test "still rejects controller: even behind a splat" do
+    error = assert_raises(ArgumentError) do
+      AdminSuite.config.authorize = ->(controller:, **) { true }
+    end
+
+    # The splat means nothing is missing; `controller:` being named is the
+    # whole defect, so assert exactly that rather than the shared footer.
+    assert_match(/Missing: \[\]/, error.message)
+    assert_match(/Unexpected: \[:controller\]/, error.message)
+  ensure
+    AdminSuite.config.authorize = nil
+  end
+
+  test "accepts a correct-arity callable object without #parameters" do
+    AdminSuite.config.authorize = AuthorizationContextFixtures::CorrectArityCallable.new
+    assert_respond_to AdminSuite.config.authorize, :call
+  ensure
+    AdminSuite.config.authorize = nil
+  end
+
+  test "rejects an old-arity callable object, proving the fallback validates rather than bypasses" do
+    error = assert_raises(ArgumentError) do
+      AdminSuite.config.authorize = AuthorizationContextFixtures::OldArityCallable.new
+    end
+
+    # This test's name claims the fallback VALIDATES rather than bypasses, so
+    # it must assert the guard actually read this object's `#call` signature.
+    # Matching the footer would also pass for a fallback that rejected every
+    # callable outright -- the opposite of validation.
+    assert_match(/Missing: \[:context\]/, error.message)
+    assert_match(/Unexpected: \[:controller\]/, error.message)
+  ensure
+    AdminSuite.config.authorize = nil
+  end
+
+  test "accepts a callable object whose #call takes a keyword splat" do
+    AdminSuite.config.authorize = AuthorizationContextFixtures::SplatCallable.new
+    assert_respond_to AdminSuite.config.authorize, :call
+  ensure
+    AdminSuite.config.authorize = nil
+  end
+
+  test "rejects a non-callable with an ArgumentError naming the problem" do
+    error = assert_raises(ArgumentError) do
+      AdminSuite.config.authorize = "nope"
+    end
+
+    assert_match(/callable/, error.message)
+    assert_match(/String/, error.message)
+  ensure
+    AdminSuite.config.authorize = nil
+  end
+end

data/test/lib/engine_defaults_test.rb

@@ -31,8 +31,7 @@ module AdminSuite
 
     test "dead configuration and DSL members are gone" do
       refute AdminSuite::Configuration.new.respond_to?(:tailwind_cdn)
-      assert Admin::Base::Resource.respond_to?(:exportable),
-        "exportable is a deprecated no-op, not removed -- see ResourceExportableDeprecationTest"
+      refute Admin::Base::Resource.respond_to?(:exportable)
       refute Admin::Base::Resource::ColumnDefinition.members.include?(:render)
     end
   end

data/test/lib/mcp_serializer_test.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class McpSerializerTest < ActiveSupport::TestCase
+  Column = Data.define(:name)
+  Index = Data.define(:columns_list)
+  Config = Data.define(:index_config)
+
+  test "emits only the resource's declared columns" do
+    record = Struct.new(:id, :name, :secret_token).new(1, "Widget", "sh-hh")
+    config = Config.new(Index.new([Column.new(:id), Column.new(:name)]))
+
+    row = AdminSuite::Mcp::Serializer.index_row(record, config)
+
+    assert_equal %w[id name], row.keys.map(&:to_s).sort
+    refute_includes row.keys.map(&:to_s), "secret_token"
+  end
+
+  test "a raising accessor degrades that cell, not the row" do
+    record = Object.new
+    def record.id = 1
+    def record.name = raise("boom")
+    config = Config.new(Index.new([Column.new(:id), Column.new(:name)]))
+
+    row = AdminSuite::Mcp::Serializer.index_row(record, config)
+
+    assert_equal 1, row[:id]
+    assert_nil row[:name]
+  end
+
+  test "association panels return bounded rows containing only declared columns" do
+    show = Admin::Base::Resource::ShowConfig.new
+    show.panel :children, association: :children, columns: [:name], limit: 500
+    config = Struct.new(:show_config).new(show)
+    child = Struct.new(:name, :secret_token).new("Visible", "private")
+    record = Struct.new(:children).new(Array.new(150, child))
+
+    payload = AdminSuite::Mcp::Serializer.associations_payload(record, config, max_rows: 100)
+    assert_equal 100, payload.fetch(:children).fetch(:rows).size
+    assert_equal({ name: "Visible" }, payload.fetch(:children).fetch(:rows).first)
+    assert_equal 100, payload.fetch(:children).fetch(:applied_limit)
+    refute_includes JSON.generate(payload), "private"
+  end
+
+  test "association panels without declared columns do not serialize model attributes" do
+    show = Admin::Base::Resource::ShowConfig.new
+    show.panel :children, association: :children
+    config = Struct.new(:show_config).new(show)
+    record = Object.new
+    def record.children = raise("must not load an undeclared field set")
+
+    assert_empty AdminSuite::Mcp::Serializer.associations_payload(record, config, max_rows: 100)
+  end
+
+  test "a content lambda serializes the proc result, not a missing attribute" do
+    record = Struct.new(:id).new(1)
+    column = Admin::Base::Resource::ColumnDefinition.new(name: :listings_count, content: ->(_r) { 42 })
+    config = Config.new(Index.new([column]))
+
+    assert_equal 42, AdminSuite::Mcp::Serializer.index_row(record, config)[:listings_count]
+  end
+
+  test "a label lambda serializes the proc result" do
+    record = Struct.new(:id).new(1)
+    column = Admin::Base::Resource::ColumnDefinition.new(name: :status, content: ->(_r) { "active" }, type: :label)
+    config = Config.new(Index.new([column]))
+
+    assert_equal "active", AdminSuite::Mcp::Serializer.index_row(record, config)[:status]
+  end
+
+  test "declared times and associations serialize as parseable primitives, not heap dumps" do
+    created_at = Time.utc(2026, 9, 10, 12, 0, 0)
+    application = SerializerApplication.new(id: 7, name: "Acme")
+    record = Struct.new(:created_at, :application, :blob).new(created_at, application, SerializerOpaque.new)
+    config = Config.new(Index.new([Column.new(:created_at), Column.new(:application), Column.new(:blob)]))
+
+    row = AdminSuite::Mcp::Serializer.index_row(record, config)
+    text = AdminSuite::Mcp::Serializer.dump(row)
+
+    assert_equal "2026-09-10T12:00:00Z", row[:created_at]
+    assert_equal created_at, Time.iso8601(row[:created_at])
+    assert_equal "Acme", row[:application]
+    refute_match(/#<|0x[0-9a-f]+/i, text)
+  end
+
+  test "a missing association panel degrades that panel instead of raising" do
+    show = Admin::Base::Resource::ShowConfig.new
+    show.panel :children, association: :missing_kids, columns: [:name]
+    config = Struct.new(:show_config).new(show)
+
+    payload = AdminSuite::Mcp::Serializer.associations_payload(Object.new, config, max_rows: 100)
+
+    assert_equal [], payload.fetch(:children).fetch(:rows)
+  end
+
+  class SerializerApplication < ActiveRecord::Base
+    attr_reader :id, :name
+
+    def initialize(id:, name:)
+      @id = id
+      @name = name
+    end
+  end
+
+  class SerializerOpaque; end
+end

data/test/lib/query_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class QueryTest < ActiveSupport::TestCase
+  Config = Struct.new(:model_class, :index_config)
+  IndexConfig = Struct.new(
+    :per_page,
+    :includes_list,
+    :searchable_fields,
+    :filters_list,
+    :default_sort,
+    :sortable_fields,
+    :default_sort_direction
+  )
+
+  class RaisingIncludesRelation < ReadOnlyResourceFixtures::Relation
+    def includes(*)
+      raise ArgumentError, "bad association"
+    end
+  end
+
+  class Model
+    class << self
+      attr_accessor :relation
+
+      def all = relation
+    end
+  end
+
+  test "per_page falls back to the DSL value when no param is given" do
+    query = AdminSuite::Query.new(resource_config: config_with(per_page: 30), params: {})
+
+    assert_equal 30, query.per_page
+  end
+
+  test "per_page honours the param" do
+    query = AdminSuite::Query.new(resource_config: config_with(per_page: 30), params: { per_page: "50" })
+
+    assert_equal 50, query.per_page
+  end
+
+  test "per_page clamps to MAX_PAGE_SIZE" do
+    query = AdminSuite::Query.new(resource_config: config_with(per_page: 30), params: { per_page: "999999" })
+
+    assert_equal AdminSuite::Query::MAX_PAGE_SIZE, query.per_page
+  end
+
+  test "per_page falls back for junk and non-positive values" do
+    ["abc", "0", "-5", nil, "", [], true].each do |value|
+      query = AdminSuite::Query.new(resource_config: config_with(per_page: 30), params: { per_page: value })
+
+      assert_equal 30, query.per_page, "per_page: #{value.inspect} must fall back to the DSL value"
+    end
+  end
+
+  test "the cap applies to DSL defaults as well as explicit page sizes" do
+    [nil, "", "bad", 0, -1, [], true, 5000].each do |value|
+      query = AdminSuite::Query.new(resource_config: config_with(per_page: 500),
+        params: { per_page: value }, max_page_size: 40)
+      assert_equal 40, query.per_page, "per_page=#{value.inspect}"
+    end
+  end
+
+  test "per_page remains a positive integer when max_page_size is below 1" do
+    [0, -5, nil].each do |cap|
+      query = AdminSuite::Query.new(
+        resource_config: config_with(per_page: 30),
+        params: { per_page: "10" },
+        max_page_size: cap
+      )
+
+      assert_kind_of Integer, query.per_page, "max_page_size=#{cap.inspect}"
+      assert_operator query.per_page, :>, 0, "max_page_size=#{cap.inspect}"
+    end
+  end
+
+  test "a raising includes degrades to the unoptimized scope instead of raising" do
+    relation = RaisingIncludesRelation.new([])
+    Model.relation = relation
+    query = AdminSuite::Query.new(resource_config: config_with(per_page: 25, includes: [:nope]), params: {})
+
+    assert_same relation, query.scope
+  end
+
+  private
+
+  def config_with(per_page:, includes: [])
+    Config.new(Model, IndexConfig.new(per_page, includes, [], [], nil, [], :asc))
+  end
+end

data/test/lib/removed_deprecations_test.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class RemovedDeprecationsTest < ActiveSupport::TestCase
+  test "the gem has no legacy Gleania renderer implementations or defaults" do
+    refute defined?(AdminSuite::Renderers::LegacyGleania)
+    %i[prompt_template_preview messages_preview tool_args_preview turn_messages_preview].each do |key|
+      assert_nil AdminSuite::RendererRegistry.lookup_default(key)
+    end
+  end
+
+  test "exportable is no longer a resource DSL method" do
+    refute Admin::Base::Resource.respond_to?(:exportable)
+  end
+end

data/test/publish_workflow_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "minitest/autorun"
+require "yaml"
+
+class PublishWorkflowTest < Minitest::Test
+  WORKFLOW_PATH = File.expand_path("../.github/workflows/publish.yml", __dir__)
+
+  def setup
+    @source = File.read(WORKFLOW_PATH)
+    @workflow = YAML.load_file(WORKFLOW_PATH)
+    @job = @workflow.fetch("jobs").fetch("publish")
+    @steps = @job.fetch("steps")
+  end
+
+  def test_publishing_uses_the_release_environment_and_job_scoped_oidc
+    assert_equal "release", @job["environment"]
+    assert_equal "write", @job.fetch("permissions")["id-token"]
+    assert_equal "write", @job.fetch("permissions")["contents"]
+    refute @workflow.fetch("permissions", {}).key?("id-token")
+  end
+
+  def test_automatic_publishing_requires_successful_main_push_ci
+    condition = @job.fetch("if")
+    assert_includes condition, "github.repository == 'techwright-lab/admin_suite'"
+    assert_includes condition, "github.event_name == 'workflow_run'"
+    assert_includes condition, "github.event.workflow_run.conclusion == 'success'"
+    assert_includes condition, "github.event.workflow_run.event == 'push'"
+    assert_includes condition, "github.event.workflow_run.head_branch == 'main'"
+    assert_includes condition, "github.event.workflow_run.head_repository.full_name == github.repository"
+    assert_includes condition, "github.event_name == 'workflow_dispatch' && github.ref == 'refs/heads/main'"
+  end
+
+  def test_credentials_are_pinned_conditional_and_before_the_push
+    credentials_index = @steps.index { |step| step["name"] == "Configure RubyGems trusted publishing" }
+    refute_nil credentials_index
+    credentials = @steps.fetch(credentials_index)
+    push_index = @steps.index { |step| step["name"] == "Publish to RubyGems" }
+    push = @steps.fetch(push_index)
+
+    assert_equal "rubygems/configure-rubygems-credentials@dc5a8d8553e6ee01fc26761a49e99e733d17954a", credentials["uses"]
+    assert_equal "steps.version_check.outputs.should_publish == 'true'", credentials["if"]
+    assert_equal credentials["if"], push["if"]
+    assert_operator credentials_index, :<, push_index
+    refute_includes @source, "secrets.RUBYGEMS_API_KEY"
+    refute_includes @source, "GEM_HOST_API_KEY:"
+    refute_includes @source, "~/.gem/credentials"
+    assert_includes push.fetch("run"), "gem push"
+    assert_includes push.fetch("run"), "--host https://rubygems.org"
+  end
+
+  def test_releases_preserve_tested_sha_and_serialization
+    checkout = @steps.find { |step| step.fetch("uses", "").start_with?("actions/checkout@") }
+    assert_equal "${{ github.event.workflow_run.head_sha || github.sha }}", checkout.fetch("with")["ref"]
+    assert_equal false, @workflow.fetch("concurrency")["cancel-in-progress"]
+    assert_includes @source, "different contents. Bump the gem version before publishing."
+    push_index = @steps.index { |step| step["name"] == "Publish to RubyGems" }
+    tag_index = @steps.index { |step| step["name"] == "Create Git tag" }
+    release_index = @steps.index { |step| step["name"] == "Create GitHub Release" }
+    assert_operator push_index, :<, tag_index
+    assert_operator tag_index, :<, release_index
+  end
+end

data/test/test_helper.rb

@@ -16,6 +16,15 @@ if ENV["COVERAGE"]
 end
 
 require_relative "dummy/config/environment"
+
+# Auth strategies are process-global. Tests that register temporary strategies
+# can restore a snapshot with this helper to avoid cross-file registry leakage.
+def with_auth_registry_snapshot
+  registry = AdminSuite::Auth.instance_variable_get(:@registry).dup
+  yield
+ensure
+  AdminSuite::Auth.instance_variable_set(:@registry, registry)
+end
 require "minitest/autorun"
 require "active_support/test_case"
 require "action_dispatch/testing/integration"
@@ -23,6 +32,14 @@ require "action_dispatch/testing/integration"
 # Ensure the engine is loaded (and its initializers run).
 require "admin_suite"
 
+def with_authorize(hook)
+  previous = AdminSuite.config.authorize
+  AdminSuite.config.authorize = hook
+  yield
+ensure
+  AdminSuite.config.authorize = previous
+end
+
 # The dummy app is intentionally database-free, while the generic controller
 # supports Active Record hosts. Supply only the exception type its lookup path
 # rescues so show-page behavior can be exercised with an in-memory fixture.
@@ -181,3 +198,12 @@ module Admin
     end
   end
 end
+
+# MCP never permits anonymous callers, including in the development escape hatch.
+class McpIntegrationTest < ActionDispatch::IntegrationTest
+  setup do
+    @previous_mcp_actor_resolver = AdminSuite.config.current_actor
+    AdminSuite.config.current_actor = ->(_) { "test-operator" }
+  end
+  teardown { AdminSuite.config.current_actor = @previous_mcp_actor_resolver }
+end