admin_suite 0.5.0 → 0.6.1

data/test/integration/mcp_get_record_test.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module McpGetRecordFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name, :secret_token
+
+    def initialize(id: 1, name: "Widget", secret_token: "sh-hh")
+      @id = id
+      @name = name
+      @secret_token = secret_token
+    end
+
+    def self.find_by(id:)
+      new if id.to_s == "1"
+    end
+  end
+end
+
+module Admin
+  module Resources
+    class McpGetRecordWidgetResource < Admin::Base::Resource
+      model McpGetRecordFixtures::Widget
+      portal :ops
+      section :observability
+      show { panel :identity, fields: %i[id name] }
+    end
+  end
+end
+
+class McpGetRecordTest < McpIntegrationTest
+  def call_tool(arguments)
+    post "/internal/admin_suite/mcp",
+      params: { jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "get_record", arguments: arguments } }.to_json,
+      headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+    JSON.parse(response.body)
+  end
+
+  test "returns one record using only the show field set" do
+    result = with_authorize(->(**) { true }) do
+      call_tool(resource: "mcp_get_record_widget", id: "1")
+    end
+
+    refute result.dig("result", "isError"), result.inspect
+    assert_match(/Widget/, result.to_s)
+    refute_match(/sh-hh/, result.to_s)
+  end
+
+  test "a missing id is indistinguishable from a denied read" do
+    missing = with_authorize(->(**) { true }) do
+      call_tool(resource: "mcp_get_record_widget", id: "999999")
+    end
+    denied = with_authorize(->(**) { false }) do
+      call_tool(resource: "mcp_get_record_widget", id: "1")
+    end
+
+    assert_equal missing.dig("result", "content"), denied.dig("result", "content")
+  end
+end

data/test/integration/mcp_instrumentation_test.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module McpInstrumentationFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new([])
+  end
+end
+
+module Admin
+  module Resources
+    class McpInstrumentationWidgetResource < Admin::Base::Resource
+      model McpInstrumentationFixtures::Widget
+      portal :ops
+      section :observability
+      index { columns { column :name } }
+    end
+  end
+end
+
+class McpInstrumentationTest < McpIntegrationTest
+  AuditActor = Struct.new(:id)
+  def call_tool(arguments = { resource: "mcp_instrumentation_widget" })
+    post "/internal/admin_suite/mcp",
+      params: { jsonrpc: "2.0", id: 1, method: "tools/call", params: {
+        name: "list_records", arguments: arguments
+      } }.to_json,
+      headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+  end
+
+  test "every tool call emits one complete event whether allowed or denied" do
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("admin_suite.mcp.tool_call") do |*args|
+      events << ActiveSupport::Notifications::Event.new(*args).payload
+    end
+
+    with_authorize(->(**) { true }) { call_tool }
+    with_authorize(nil) { AdminSuite::Mcp::Tools::ListRecords.call(
+      resource: "mcp_instrumentation_widget", server_context: { actor: nil }
+    ) }
+
+    assert_equal [true, false], events.map { |event| event[:allowed] }
+    assert events.all? { |event| event[:tool] == "list_records" }
+    assert events.all? { |event| event[:action] == :read }
+    assert events.all? { |event| event[:duration_ms].is_a?(Numeric) }
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  test "a raise inside authorize_resource! is not logged as an authorized read" do
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("admin_suite.mcp.tool_call") do |*args|
+      events << ActiveSupport::Notifications::Event.new(*args).payload
+    end
+
+    AdminSuite::Mcp::Authorization.stub(:authorize_resource!, proc { raise "boom" }) do
+      AdminSuite::Mcp::Tools::ListRecords.call(
+        resource: "mcp_instrumentation_widget",
+        server_context: { actor: "x" }
+      )
+    end
+
+    assert_equal false, events.last[:allowed]
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  test "audit metadata identifies the operator and distinguishes tool failures" do
+    actor = AuditActor.new(42)
+    request = Struct.new(:request_id).new("audit-request-123")
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("admin_suite.mcp.tool_call") do |*args|
+      events << ActiveSupport::Notifications::Event.new(*args).payload
+    end
+
+    AdminSuite::Mcp.instrument(tool: "list_records", actor: actor, request: request) do
+      [MCP::Tool::Response.new([{ type: "text", text: "failed" }], error: true), nil, true]
+    end
+
+    assert_equal "42", events.first.fetch(:actor_id)
+    assert_equal actor.class.name, events.first.fetch(:actor_type)
+    assert_equal "audit-request-123", events.first.fetch(:request_id)
+    assert_equal true, events.first.fetch(:error)
+    assert_equal true, events.first.fetch(:allowed)
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+
+  test "the audit event carries the applied filter set" do
+    events = []
+    subscriber = ActiveSupport::Notifications.subscribe("admin_suite.mcp.tool_call") do |*args|
+      events << ActiveSupport::Notifications::Event.new(*args).payload
+    end
+
+    with_authorize(->(**) { true }) do
+      call_tool(resource: "mcp_instrumentation_widget", q: "alpha", filters: { state: "open" })
+    end
+
+    assert_equal "alpha", events.last.fetch(:q)
+    assert_equal({ state: "open" }, events.last.fetch(:filters))
+  ensure
+    ActiveSupport::Notifications.unsubscribe(subscriber) if subscriber
+  end
+end

data/test/integration/mcp_list_records_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module McpListRecordsFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name, :secret_token
+
+    def initialize(id: 1, name: "Widget", secret_token: "sh-hh")
+      @id = id
+      @name = name
+      @secret_token = secret_token
+    end
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new([new])
+  end
+end
+
+module Admin
+  module Resources
+    class McpListRecordsWidgetResource < Admin::Base::Resource
+      model McpListRecordsFixtures::Widget
+      portal :ops
+      section :observability
+      index do
+        columns do
+          column :id
+          column :name
+        end
+      end
+    end
+  end
+end
+
+class McpListRecordsTest < McpIntegrationTest
+  def call_tool(name, arguments)
+    post "/internal/admin_suite/mcp",
+      params: { jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: name, arguments: arguments } }.to_json,
+      headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+    JSON.parse(response.body)
+  end
+
+  test "returns rows limited to declared columns" do
+    result = with_authorize(->(**) { true }) do
+      call_tool("list_records", { resource: "mcp_list_records_widget" })
+    end
+
+    refute result.dig("result", "isError"), result.inspect
+    assert_match(/Widget/, result.to_s)
+    refute_match(/sh-hh/, result.to_s)
+  end
+
+  test "clamps per_page to the configured maximum and says so" do
+    result = with_authorize(->(**) { true }) do
+      call_tool("list_records", { resource: "mcp_list_records_widget", per_page: 5000 })
+    end
+
+    payload = JSON.parse(result.dig("result", "content", 0, "text"))
+    assert_equal 100, payload.fetch("applied_per_page")
+  end
+
+  test "an unknown resource and a denied resource return identical errors" do
+    unknown = with_authorize(->(**) { true }) do
+      call_tool("list_records", { resource: "no_such_thing" })
+    end
+    denied = with_authorize(->(**) { false }) do
+      call_tool("list_records", { resource: "mcp_list_records_widget" })
+    end
+
+    assert_equal unknown.dig("result", "content"), denied.dig("result", "content"),
+      "an existence oracle: an unknown resource must be indistinguishable from a denied one"
+  end
+end

data/test/integration/mcp_parity_test.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module McpParityFixtures
+  class Relation
+    include Enumerable
+
+    def initialize(records, offset: 0)
+      @records = records
+      @offset = offset
+    end
+
+    def each(&block) = @records.each(&block)
+    def count(*) = @records.size
+    def offset(value) = self.class.new(@records, offset: value)
+    def limit(value) = @records[@offset, value] || []
+
+    def where(condition, search:)
+      fields = condition.scan(/(\w+) ILIKE/).flatten
+      term = search.delete("%").downcase
+      self.class.new(@records.select do |record|
+        fields.any? { |field| record.public_send(field).to_s.downcase.include?(term) }
+      end)
+    end
+
+    def order(ordering)
+      field, direction = ordering.first
+      rows = @records.sort_by { |record| record.public_send(field).to_s }
+      rows.reverse! if direction.to_sym == :desc
+      self.class.new(rows)
+    end
+  end
+
+  class Application < ActiveRecord::Base
+    attr_reader :id, :name
+
+    def initialize(id:, name:)
+      @id = id
+      @name = name
+    end
+
+    def to_param = id.to_s
+  end
+
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name, :created_at, :application
+
+    def initialize(id:, name:, created_at: Time.utc(2026, 9, 10, 12, 0, 0), application: Application.new(id: 7, name: "Acme"))
+      @id = id
+      @name = name
+      @created_at = created_at
+      @application = application
+    end
+
+    ROWS = [new(id: 1, name: "Zulu"), new(id: 2, name: "Alpha"), new(id: 3, name: "Bravo")].freeze
+
+    def self.all = Relation.new(ROWS)
+    def self.column_names = %w[id name]
+    def self.primary_key = "id"
+    def self.columns_hash = { "id" => Struct.new(:type).new(:integer) }
+    def to_param = id.to_s
+  end
+end
+
+module Admin
+  module Resources
+    class McpParityWidgetResource < Admin::Base::Resource
+      model McpParityFixtures::Widget
+      portal :ops
+      section :observability
+      index do
+        searchable :name
+        sortable :name, default: :name, direction: :asc
+        columns do
+          column :id
+          column :name, sortable: true
+          column :listings_count, ->(_r) { 42 }
+          column :status, ->(_r) { "active" }, type: :label
+          column :created_at
+          column :application
+        end
+      end
+    end
+  end
+end
+
+class McpParityTest < McpIntegrationTest
+  PATH = "/internal/admin_suite/ops/mcp_parity_widgets"
+
+  def mcp_payload(tool, arguments)
+    post "/internal/admin_suite/mcp",
+      params: { jsonrpc: "2.0", id: 1, method: "tools/call", params: {
+        name: tool, arguments: arguments
+      } }.to_json,
+      headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+    rpc = JSON.parse(response.body)
+    JSON.parse(rpc.dig("result", "content", 0, "text"))
+  end
+
+  test "list_records and the index return identical ids for one query" do
+    with_authorize(->(**) { true }) do
+      get PATH, params: { sort: "name", direction: "asc" }
+      assert_response :success
+      ui_ids = css_select("tbody tr").map { |row| row["data-record-id"] }
+
+      mcp_ids = mcp_payload("list_records", {
+        resource: "mcp_parity_widget", sort: "name", direction: "asc"
+      }).fetch("rows").map { |row| row.fetch("id").to_s }
+
+      assert_equal %w[2 3 1], ui_ids
+      assert_equal ui_ids, mcp_ids
+
+      get PATH, params: { search: "alpha" }
+      search_ui_ids = css_select("tbody tr").map { |row| row["data-record-id"] }
+      search_mcp_ids = mcp_payload("list_records", {
+        resource: "mcp_parity_widget", q: "alpha"
+      }).fetch("rows").map { |row| row.fetch("id").to_s }
+      assert_equal search_ui_ids, search_mcp_ids
+    end
+  end
+
+  test "lambda columns match the index cell and object fields serialize as primitives" do
+    with_authorize(->(**) { true }) do
+      get PATH
+      assert_response :success
+      cells = css_select("tbody tr[data-record-id='1'] td")
+      row = mcp_payload("list_records", { resource: "mcp_parity_widget" })
+        .fetch("rows").find { |item| item.fetch("id") == 1 }
+
+      assert_equal "42", cells[2].text.strip
+      assert_equal 42, row.fetch("listings_count")
+      assert_includes cells[3].text, "active"
+      assert_equal "active", row.fetch("status")
+      assert_equal Time.utc(2026, 9, 10, 12, 0, 0), Time.iso8601(row.fetch("created_at"))
+      assert_equal "Acme", row.fetch("application")
+      refute_match(/#<|0x[0-9a-f]+/i, row.fetch("application"))
+    end
+  end
+
+  test "aggregate count matches the shared query's index total" do
+    with_authorize(->(**) { true }) do
+      get PATH, params: { search: "alpha" }
+      ui_total = css_select("tbody tr").size
+
+      mcp_total = mcp_payload("aggregate", {
+        resource: "mcp_parity_widget", q: "alpha"
+      }).fetch("count")
+
+      assert_equal ui_total, mcp_total
+    end
+  end
+end

data/test/integration/mcp_release_test.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module McpReleaseFixtures
+  Record = Struct.new(:id, :state)
+
+  class Relation
+    include Enumerable
+    def initialize(rows) = @rows = rows
+    def each(&block) = @rows.each(&block)
+    def count = @rows.size
+    def offset(n) = self.class.new(@rows.drop(n))
+    def limit(n) = self.class.new(@rows.first(n))
+    def where(conditions)
+      self.class.new(@rows.select { |row| conditions.all? { |key, value| row.public_send(key) == value } })
+    end
+  end
+
+  class Widget
+    extend ActiveModel::Naming
+    def self.all = Relation.new([Record.new(1, "open"), Record.new(2, "closed")])
+    def self.find_by(id:) = all.find { |row| row.id.to_s == id.to_s }
+  end
+end
+
+module Admin
+  module Resources
+    class McpReleaseWidgetResource < Admin::Base::Resource
+      model McpReleaseFixtures::Widget
+      portal :ops
+      section :observability
+      index do
+        paginate 500
+        columns { column :id }
+        filters { filter :state, type: :select }
+      end
+      show { panel :identity, fields: %i[id state] }
+    end
+  end
+end
+
+class McpReleaseTest < ActionDispatch::IntegrationTest
+  setup do
+    @previous_actor = AdminSuite.config.current_actor
+    AdminSuite.config.current_actor = ->(_) { "release-test-operator" }
+  end
+
+  teardown { AdminSuite.config.current_actor = @previous_actor }
+
+  def call_tool(name, **arguments)
+    post "/internal/admin_suite/mcp", params: {
+      jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: name, arguments: arguments }
+    }.to_json, headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+    JSON.parse(response.body)
+  end
+
+  test "JSON filters affect both records and aggregates" do
+    with_authorize(->(**) { true }) do
+      result = call_tool("list_records", resource: "mcp_release_widget", filters: { state: "open" })
+      payload = JSON.parse(result.dig("result", "content", 0, "text"))
+      assert_equal [1], payload.fetch("rows").map { |row| row.fetch("id") }
+      assert_equal 100, payload.fetch("applied_per_page")
+      result = call_tool("aggregate", resource: "mcp_release_widget", filters: { state: "closed" })
+      assert_equal 1, JSON.parse(result.dig("result", "content", 0, "text")).fetch("count")
+    end
+  end
+
+  test "an anonymous MCP request is rejected even in the development escape hatch" do
+    AdminSuite.config.current_actor = nil
+    with_authorize(->(**) { true }) do
+      post "/internal/admin_suite/mcp", params: { jsonrpc: "2.0", id: 1, method: "tools/list" }.to_json,
+        headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+      assert_response :unauthorized
+    end
+  end
+
+  test "get_record checks record policy and passes the HTTP request to authorization" do
+    seen_requests = []
+    policy = ->(record:, context:, **) do
+      seen_requests << context.request
+      record.nil? || record.id != 1
+    end
+    with_authorize(policy) do
+      denied = call_tool("get_record", resource: "mcp_release_widget", id: "1")
+      missing = call_tool("get_record", resource: "mcp_release_widget", id: "999")
+      assert denied.dig("result", "isError")
+      assert_equal missing.dig("result", "content"), denied.dig("result", "content")
+      assert seen_requests.all? { |request| request.is_a?(ActionDispatch::Request) }
+    end
+  end
+
+  test "MCP rejects foreign origins while allowing same-origin and headless clients" do
+    with_authorize(->(**) { true }) do
+      ["https://attacker.example", "null", ""].each do |origin|
+        post "/internal/admin_suite/mcp", params: { jsonrpc: "2.0", id: 1, method: "tools/list" }.to_json,
+          headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream", "HTTP_ORIGIN" => origin }
+        assert_response :forbidden
+      end
+      post "/internal/admin_suite/mcp", params: { jsonrpc: "2.0", id: 1, method: "tools/list" }.to_json,
+        headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream", "HTTP_ORIGIN" => "http://www.example.com" }
+      assert_response :success
+    end
+  end
+
+  test "the stateless transport accepts notifications and declines GET streams" do
+    with_authorize(->(**) { true }) do
+      post "/internal/admin_suite/mcp", params: { jsonrpc: "2.0", method: "notifications/initialized" }.to_json,
+        headers: { "CONTENT_TYPE" => "application/json", "HTTP_ACCEPT" => "application/json, text/event-stream" }
+      assert_response :accepted
+      assert_empty response.body
+      get "/internal/admin_suite/mcp"
+      assert_response :method_not_allowed
+      delete "/internal/admin_suite/mcp"
+      assert_response :method_not_allowed
+    end
+  end
+
+  test "forgery protection allows the JSON transport but rejects tokenless forms" do
+    previous = AdminSuite::McpController.allow_forgery_protection
+    AdminSuite::McpController.allow_forgery_protection = true
+    with_authorize(->(**) { true }) do
+      call_tool("list_records", resource: "mcp_release_widget")
+      assert_response :success
+      post "/internal/admin_suite/mcp", params: { method: "tools/list" }
+      assert_response :unprocessable_entity
+    end
+  ensure
+    AdminSuite::McpController.allow_forgery_protection = previous
+  end
+end

data/test/integration/read_only_resource_test.rb

@@ -35,6 +35,10 @@ module ReadOnlyResourceFixtures
       new
     end
 
+    def self.where(id:)
+      id.filter_map { |value| find(value) }
+    end
+
     def to_param
       id.to_s
     end
@@ -43,7 +47,16 @@ module ReadOnlyResourceFixtures
       { "id" => id, "name" => name }
     end
 
+    def self.ping_calls
+      @ping_calls || 0
+    end
+
+    def self.ping_calls=(value)
+      @ping_calls = value
+    end
+
     def ping
+      self.class.ping_calls += 1
       true
     end
   end
@@ -65,6 +78,88 @@ module Admin
 
       actions do
         action :ping
+        bulk_action :ping
+      end
+    end
+  end
+end
+
+module WritableResourceFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name
+
+    def initialize(id: 1, name: "Writable widget")
+      @id = id
+      @name = name
+    end
+
+    def self.all
+      ReadOnlyResourceFixtures::Relation.new([ new ])
+    end
+
+    def self.column_names
+      %w[id name]
+    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 self.where(id:)
+      id.filter_map { |value| find(value) }
+    end
+
+    def self.ping_calls
+      @ping_calls || 0
+    end
+
+    def self.ping_calls=(value)
+      @ping_calls = value
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    def attributes
+      { "id" => id, "name" => name }
+    end
+
+    def ping
+      self.class.ping_calls += 1
+      true
+    end
+  end
+end
+
+module Admin
+  module Resources
+    class WritableWidgetResource < Admin::Base::Resource
+      model WritableResourceFixtures::Widget
+      portal :ops
+      section :observability
+
+      index do
+        columns do
+          column :name
+        end
+      end
+
+      actions do
+        action :ping
+        bulk_action :ping
       end
     end
   end
@@ -73,6 +168,12 @@ end
 module AdminSuite
   class ReadOnlyResourceTest < ActionDispatch::IntegrationTest
     BASE_PATH = "/internal/admin_suite/ops/read_only_widgets"
+    WRITABLE_PATH = "/internal/admin_suite/ops/writable_widgets"
+
+    setup do
+      ReadOnlyResourceFixtures::Widget.ping_calls = 0
+      WritableResourceFixtures::Widget.ping_calls = 0
+    end
 
     test "direct built in mutation endpoints are rejected" do
       get "#{BASE_PATH}/new"
@@ -122,9 +223,34 @@ module AdminSuite
       assert_response :not_found
     end
 
-    test "declared member actions remain allowed on read_only resources" do
+    test "declared member actions are rejected on read_only resources" do
       post "#{BASE_PATH}/1/execute_action/ping"
-      refute_equal 404, response.status
+
+      assert_response :not_found
+      assert_equal 0, ReadOnlyResourceFixtures::Widget.ping_calls
+    end
+
+    test "declared bulk actions are rejected on read_only resources" do
+      post "#{BASE_PATH}/bulk_action/ping", params: { ids: [ "1" ] }
+
+      assert_response :not_found
+      assert_equal 0, ReadOnlyResourceFixtures::Widget.ping_calls
+    end
+
+    test "declared member actions still execute on writable resources" do
+      post "#{WRITABLE_PATH}/1/execute_action/ping"
+
+      assert_redirected_to "#{WRITABLE_PATH}/1"
+      assert_equal 1, WritableResourceFixtures::Widget.ping_calls
+    end
+
+    test "declared bulk actions still execute on writable resources" do
+      post "#{WRITABLE_PATH}/bulk_action/ping", params: { ids: [ "1" ] }
+
+      assert_redirected_to WRITABLE_PATH
+      follow_redirect!
+      assert_includes response.body, "Successfully processed 1 records"
+      assert_equal 1, WritableResourceFixtures::Widget.ping_calls
     end
   end
 end