A platform for community discussion. Free, open, simple.
# frozen_string_literal: true
describe DiscourseMcp::Tools do
def request_context(user)
instance_double(DiscourseMcp::RequestContext, user:, user_id: user.id, guardian: user.guardian)
end
fab!(:user) { Fabricate(:user, refresh_auto_groups: true) }
fab!(:other_user, :user)
fab!(:moderator)
fab!(:admin)
describe DiscourseMcp::Tools::Search do
fab!(:post) { Fabricate(:post, user:, raw: "regular parity search needle") }
before do
SearchIndexer.enable
SearchIndexer.index(post, force: true)
end
after { SearchIndexer.disable }
it "returns the compatible topic search contract" do
result =
described_class.call(
arguments: {
"query" => "regular parity search needle",
"max_results" => 1,
},
request_context:
instance_double(
DiscourseMcp::RequestContext,
user:,
guardian: user.guardian,
has_scopes?: true,
),
).fetch(:structuredContent)
expect(result[:results].sole).to eq(
id: post.topic_id,
slug: post.topic.slug,
title: post.topic.title,
)
expect(result[:meta]).to eq(total: 1, has_more: false)
end
end
describe DiscourseMcp::Tools::GetTopic do
fab!(:post) { Fabricate(:post, user:) }
fab!(:reply) { Fabricate(:post, topic: post.topic, user: other_user) }
it "returns the compatible bounded topic contract" do
result =
described_class.call(
arguments: {
"topic_id" => post.topic_id,
"post_limit" => 1,
"start_post_number" => reply.post_number,
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to include(id: post.topic_id, posts_count: 2)
expect(result[:posts].sole).to include(id: reply.id, raw: reply.raw)
expect(result[:meta]).to eq(start_post: reply.post_number, returned: 1, has_more: false)
end
it "does not expose a topic from a private category" do
group = Fabricate(:group)
private_category = Fabricate(:private_category, group:)
private_post = Fabricate(:post, topic: Fabricate(:topic, category: private_category))
expect do
described_class.call(
arguments: {
"topic_id" => private_post.topic_id,
},
request_context: request_context(user),
)
end.to raise_error(DiscourseMcp::ToolError)
group.add(user)
result =
described_class.call(
arguments: {
"topic_id" => private_post.topic_id,
},
request_context: request_context(user),
)
expect(result.dig(:structuredContent, :id)).to eq(private_post.topic_id)
end
end
describe DiscourseMcp::Tools::ListTopics do
it "does not expose tags hidden from the caller" do
hidden_tag = Fabricate(:tag)
Fabricate(:tag_group, permissions: { "staff" => 1 }, tag_names: [hidden_tag.name])
topic = Fabricate(:topic, user:, tags: [hidden_tag])
Fabricate(:post, topic:, user:)
result =
described_class.call(
arguments: {
"limit" => 50,
},
request_context: request_context(user),
).fetch(:structuredContent)
listed_topic = result.fetch(:topics).find { |listed| listed[:id] == topic.id }
expect(listed_topic.fetch(:tags)).not_to include(hidden_tag.name)
end
end
describe DiscourseMcp::Tools::ListCategories do
it "lists only categories visible to the caller" do
public_category = Fabricate(:category)
private_category = Fabricate(:private_category, group: Fabricate(:group))
result =
described_class.call(arguments: {}, request_context: request_context(user)).fetch(
:structuredContent,
)
category_ids = result.fetch(:categories).pluck(:id)
expect(category_ids).to include(public_category.id)
expect(category_ids).not_to include(private_category.id)
end
end
describe DiscourseMcp::Tools::ListTags do
it "lists only tags visible to the caller" do
visible_tag = Fabricate(:tag)
hidden_tag = Fabricate(:tag)
Fabricate(:tag_group, permissions: { "staff" => 1 }, tag_names: [hidden_tag.name])
result =
described_class.call(
arguments: {
"limit" => 200,
},
request_context: request_context(user),
).fetch(:structuredContent)
tag_ids = result.fetch(:tags).pluck(:id)
expect(tag_ids).to include(visible_tag.id)
expect(tag_ids).not_to include(hidden_tag.id)
end
end
describe DiscourseMcp::Resources::Topic do
it "does not expose tags hidden from the caller" do
hidden_tag = Fabricate(:tag)
Fabricate(:tag_group, permissions: { "staff" => 1 }, tag_names: [hidden_tag.name])
topic = Fabricate(:topic, user:, tags: [hidden_tag])
result =
described_class.call(
uri: "discourse://topic/#{topic.id}",
request_context: request_context(user),
)
tags = JSON.parse(result.fetch(:text)).fetch("tags")
expect(tags).not_to include(hidden_tag.name)
end
end
describe DiscourseMcp::Tools::GetPost do
fab!(:post) { Fabricate(:post, user:) }
it "returns the compatible post contract" do
result =
described_class.call(
arguments: {
"post_id" => post.id,
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to include(
id: post.id,
topic_id: post.topic_id,
topic_slug: post.topic.slug,
raw: post.raw,
truncated: false,
)
end
end
describe DiscourseMcp::Tools::GetUser do
it "returns profile fields visible to the caller" do
user.user_profile.update!(bio_raw: "Hello")
result =
described_class.call(
arguments: {
"username" => user.username,
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to include(
id: user.id,
username: user.username,
bio: "Hello",
admin: false,
moderator: false,
)
end
end
describe DiscourseMcp::Tools::ListBookmarks do
it "lists only the caller's visible bookmarks" do
visible_bookmark = Fabricate(:bookmark, user:)
Fabricate(:bookmark, user: other_user)
private_post =
Fabricate(
:post,
topic:
Fabricate(:topic, category: Fabricate(:private_category, group: Fabricate(:group))),
)
hidden_bookmark = Fabricate(:bookmark, user:, bookmarkable: private_post)
context = request_context(user)
allow(context).to receive(:has_scopes?).with(
DiscourseMcp::Scopes::PRIVATE_MESSAGES_READ,
).and_return(false)
result =
described_class.call(arguments: {}, request_context: context).fetch(:structuredContent)
bookmark_ids = result.fetch(:bookmarks).pluck(:id)
expect(bookmark_ids).to include(visible_bookmark.id)
expect(bookmark_ids).not_to include(hidden_bookmark.id)
end
end
describe DiscourseMcp::Tools::ListNotifications do
it "hides reviewable mentions after moderator access is revoked" do
SiteSetting.enable_mentions = true
reviewable = Fabricate(:reviewable_flagged_post)
ReviewableNote.create!(reviewable: reviewable, user: admin, content: "@#{moderator.username}")
context = request_context(moderator)
allow(context).to receive(:has_scopes?).and_return(true)
result =
described_class.call(arguments: {}, request_context: context).fetch(:structuredContent)
expect(result.fetch(:notifications).size).to eq(1)
reviewable.update!(reviewable_by_moderator: false)
result =
described_class.call(arguments: {}, request_context: context).fetch(:structuredContent)
expect(result.fetch(:notifications)).to be_empty
end
it "lists reviewable mentions only for tokens with the moderation scope" do
SiteSetting.enable_mentions = true
reviewable = Fabricate(:reviewable_flagged_post)
ReviewableNote.create!(reviewable: reviewable, user: admin, content: "@#{moderator.username}")
topic_notification = Fabricate(:notification, user: moderator)
context = request_context(moderator)
allow(context).to receive(:has_scopes?).and_return(true)
allow(context).to receive(:has_scopes?).with(
DiscourseMcp::Scopes::MODERATION_READ,
).and_return(false)
result =
described_class.call(arguments: {}, request_context: context).fetch(:structuredContent)
expect(result.fetch(:notifications).pluck(:id)).to contain_exactly(topic_notification.id)
end
it "hides mentions on private message reviewables from tokens without the private messages scope" do
SiteSetting.enable_mentions = true
private_message_reviewable, trashed_private_message_reviewable =
Array.new(2) do
private_message_post = Fabricate(:private_message_post)
Fabricate(
:reviewable_flagged_post,
target: private_message_post,
topic: private_message_post.topic,
)
end
trashed_private_message_reviewable.topic.trash!
topic_reviewable = Fabricate(:reviewable_flagged_post)
other_admin = Fabricate(:admin)
[
private_message_reviewable,
trashed_private_message_reviewable,
topic_reviewable,
].each do |reviewable|
ReviewableNote.create!(reviewable:, user: admin, content: "@#{other_admin.username}")
end
context = request_context(other_admin)
allow(context).to receive(:has_scopes?).and_return(true)
allow(context).to receive(:has_scopes?).with(
DiscourseMcp::Scopes::PRIVATE_MESSAGES_READ,
).and_return(false)
result =
described_class.call(arguments: {}, request_context: context).fetch(:structuredContent)
expect(
result.fetch(:notifications).map { |notification| notification[:data][:reviewable_id] },
).to contain_exactly(topic_reviewable.id)
end
it "lists only the caller's notifications from visible topics" do
visible_notification = Fabricate(:notification, user:)
Fabricate(:notification, user: other_user)
private_topic =
Fabricate(:topic, category: Fabricate(:private_category, group: Fabricate(:group)))
hidden_notification = Fabricate(:notification, user:, topic: private_topic)
context = request_context(user)
allow(context).to receive(:has_scopes?).with(
DiscourseMcp::Scopes::PRIVATE_MESSAGES_READ,
).and_return(true)
result =
described_class.call(arguments: {}, request_context: context).fetch(:structuredContent)
notification_ids = result.fetch(:notifications).pluck(:id)
expect(notification_ids).to include(visible_notification.id)
expect(notification_ids).not_to include(hidden_notification.id)
end
end
describe DiscourseMcp::Tools::UpdateTopic do
fab!(:topic) { Fabricate(:topic, user:) }
fab!(:post) { Fabricate(:post, topic:, user:) }
it "lets an author update an editable topic" do
result =
described_class.call(
arguments: {
"topic_id" => post.topic_id,
"title" => "A much better topic title",
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to include(success: true, updated_fields: ["title"])
expect(post.topic.reload.title).to eq("A much better topic title")
end
it "does not let another regular user update the topic" do
expect do
described_class.call(
arguments: {
"topic_id" => post.topic_id,
"title" => "Not allowed",
},
request_context: request_context(other_user),
)
end.to raise_error(Discourse::InvalidAccess)
end
it "preserves and does not expose tags hidden from the caller" do
hidden_tag = Fabricate(:tag)
Fabricate(:tag_group, permissions: { "staff" => 1 }, tag_names: [hidden_tag.name])
topic.tags << hidden_tag
result =
described_class.call(
arguments: {
"topic_id" => post.topic_id,
"title" => "A title changed without seeing hidden tags",
"original_tags" => [],
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result.dig(:topic, :tags)).to be_empty
expect(topic.reload.tags).to contain_exactly(hidden_tag)
end
it "does not reveal a hidden tag when a category change is rejected" do
hidden_tag = Fabricate(:tag)
Fabricate(:tag_group, permissions: { "staff" => 1 }, tag_names: [hidden_tag.name])
topic.tags << hidden_tag
allowed_tag = Fabricate(:tag)
category = Fabricate(:category, allow_global_tags: false)
category.allowed_tags = [allowed_tag.name]
expect do
described_class.call(
arguments: {
"topic_id" => topic.id,
"category_id" => category.id,
},
request_context: request_context(user),
)
end.to raise_error(DiscourseMcp::ToolError) { |error|
expect(error.message).not_to include(hidden_tag.name)
}
end
it "changes a shared draft destination without moving the draft topic" do
shared_drafts_category = Fabricate(:category)
original_destination = Fabricate(:category)
new_destination = Fabricate(:category)
SiteSetting.shared_drafts_category = shared_drafts_category.id
SiteSetting.shared_drafts_allowed_groups = Group::AUTO_GROUPS[:staff]
topic.update!(category: shared_drafts_category)
shared_draft = Fabricate(:shared_draft, topic:, category: original_destination)
result =
described_class.call(
arguments: {
"topic_id" => topic.id,
"category_id" => new_destination.id,
},
request_context: request_context(admin),
).fetch(:structuredContent)
expect(result[:updated_fields]).to eq(["category_id"])
expect(result.dig(:topic, :destination_category_id)).to eq(new_destination.id)
expect(topic.reload.category).to eq(shared_drafts_category)
expect(shared_draft.reload.category).to eq(new_destination)
end
end
describe "authored content" do
fab!(:topic) { Fabricate(:topic, user:) }
fab!(:post) { Fabricate(:post, topic:, user:) }
it "does not allow author_username to impersonate another user" do
expect do
DiscourseMcp::Tools::ReplyTopic.call(
arguments: {
"topic_id" => topic.id,
"raw" => "A complete reply body.",
"author_username" => other_user.username,
},
request_context: request_context(user),
)
end.to raise_error(Discourse::InvalidAccess)
end
it "creates a compatible topic and post response as the current user" do
created_topic =
DiscourseMcp::Tools::CreateTopic.call(
arguments: {
"title" => "A valid regular user topic",
"raw" => "A complete topic body for this test.",
"author_username" => user.username,
},
request_context: request_context(user),
).fetch(:structuredContent)
created_post =
DiscourseMcp::Tools::ReplyTopic.call(
arguments: {
"topic_id" => created_topic[:topic_id],
"raw" => "A complete reply body for this test.",
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(created_topic[:id]).to be_a(Integer)
expect(created_topic).to include(username: user.username, author_applied: true)
expect(created_post).to include(topic_id: created_topic[:topic_id], post_number: 2)
end
it "updates a post only when the caller may edit it" do
result =
DiscourseMcp::Tools::EditPost.call(
arguments: {
"post_id" => post.id,
"raw" => "An updated complete post body.",
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to include(id: post.id, raw: "An updated complete post body.")
expect do
DiscourseMcp::Tools::EditPost.call(
arguments: {
"post_id" => post.id,
"raw" => "An unauthorized complete post body.",
},
request_context: request_context(other_user),
)
end.to raise_error(DiscourseMcp::ToolError)
end
end
describe DiscourseMcp::Tools::SetPostDeleted do
fab!(:topic) { Fabricate(:post, user:).topic }
fab!(:post) { Fabricate(:post, topic:, user:) }
it "deletes and recovers only the caller's post" do
result =
described_class.call(
arguments: {
"post_id" => post.id,
"deleted" => true,
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to eq(post_id: post.id, deleted: true)
expect(post.reload.user_deleted).to eq(true)
described_class.call(
arguments: {
"post_id" => post.id,
"deleted" => false,
},
request_context: request_context(user),
)
expect(post.reload.user_deleted).to eq(false)
[other_user, moderator, admin].each do |other_actor|
expect do
described_class.call(
arguments: {
"post_id" => post.id,
"deleted" => true,
},
request_context: request_context(other_actor),
)
end.to raise_error(DiscourseMcp::ToolError)
end
end
end
describe DiscourseMcp::Tools::UpdateUser do
it "lets a user update their own profile" do
result =
described_class.call(
arguments: {
"username" => user.username,
"bio_raw" => "Updated profile",
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to include(success: true, username: user.username)
expect(user.user_profile.reload.bio_raw).to eq("Updated profile")
end
it "does not turn staff access into permission to edit another profile" do
[moderator, admin].each do |staff_user|
expect do
described_class.call(
arguments: {
"username" => user.username,
"bio_raw" => "Staff edit",
},
request_context: request_context(staff_user),
)
end.to raise_error(Discourse::InvalidAccess)
end
end
end
describe DiscourseMcp::Tools::SetUserStatus do
before { SiteSetting.enable_user_status = true }
it "sets and clears only the caller's status" do
result =
described_class.call(
arguments: {
"description" => "Reviewing MCP tools",
"emoji" => "mag",
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to eq(success: true)
expect(user.reload.user_status).to have_attributes(
description: "Reviewing MCP tools",
emoji: "mag",
)
expect(other_user.user_status).to be_nil
described_class.call(arguments: { "clear" => true }, request_context: request_context(user))
expect(user.reload.user_status).to be_nil
end
end
describe DiscourseMcp::Tools::UploadFile do
it "creates a composer upload owned by the authenticated user" do
image_data = Base64.strict_encode64(file_from_fixtures("logo.png").read)
result =
described_class.call(
arguments: {
"upload_type" => "composer",
"image_data" => image_data,
"filename" => "logo.png",
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result[:id]).to be_a(Integer)
expect(result[:original_filename]).to eq("logo.png")
expect(Upload.find(result[:id]).user_id).to eq(user.id)
end
it "does not accept another user's id" do
expect do
described_class.call(
arguments: {
"upload_type" => "avatar",
"image_data" => Base64.strict_encode64("image"),
"filename" => "image.png",
"user_id" => other_user.id,
},
request_context: request_context(user),
)
end.to raise_error(Discourse::InvalidAccess)
end
end
describe "private messages" do
fab!(:message) { Fabricate(:private_message_post, user:, recipient: other_user) }
before { SiteSetting.personal_message_enabled_groups = Group::AUTO_GROUPS[:everyone] }
it "lists only a mailbox the caller may access" do
result =
DiscourseMcp::Tools::ListPrivateMessages.call(
arguments: {
"username" => other_user.username,
},
request_context: request_context(other_user),
).fetch(:structuredContent)
expect(result[:messages].pluck(:topic_id)).to include(message.topic_id)
expect do
DiscourseMcp::Tools::ListPrivateMessages.call(
arguments: {
"username" => other_user.username,
},
request_context: request_context(moderator),
)
end.to raise_error(Discourse::InvalidAccess)
end
it "paginates a mailbox without skipping messages" do
newer_message = Fabricate(:private_message_post, user:, recipient: other_user)
newer_message.topic.update!(bumped_at: 1.minute.from_now)
first_page =
DiscourseMcp::Tools::ListPrivateMessages.call(
arguments: {
"per_page" => 1,
},
request_context: request_context(other_user),
).fetch(:structuredContent)
second_page =
DiscourseMcp::Tools::ListPrivateMessages.call(
arguments: {
"page" => 1,
"per_page" => 1,
},
request_context: request_context(other_user),
).fetch(:structuredContent)
expect(first_page[:messages].sole[:topic_id]).to eq(newer_message.topic_id)
expect(first_page[:meta][:has_more]).to eq(true)
expect(second_page[:messages].sole[:topic_id]).to eq(message.topic_id)
end
it "lists a group mailbox only for group members and admins" do
group = Fabricate(:group, has_messages: true)
group.add(other_user)
group_message = Fabricate(:group_private_message_post, user:, recipients: group)
[other_user, admin].each do |viewer|
result =
DiscourseMcp::Tools::ListPrivateMessages.call(
arguments: {
"username" => viewer.username,
"group_name" => group.name,
},
request_context: request_context(viewer),
).fetch(:structuredContent)
expect(result[:messages].pluck(:topic_id)).to include(group_message.topic_id)
end
expect do
DiscourseMcp::Tools::ListPrivateMessages.call(
arguments: {
"username" => moderator.username,
"group_name" => group.name,
},
request_context: request_context(moderator),
)
end.to raise_error(Discourse::InvalidAccess)
end
it "reads a private message only for participants and admins" do
expectations = { user => true, other_user => true, moderator => false, admin => true }
expectations.each do |viewer, allowed|
operation =
lambda do
DiscourseMcp::Tools::ReadPrivateMessage.call(
arguments: {
"topic_id" => message.topic_id,
},
request_context: request_context(viewer),
)
end
if allowed
expect(operation.call.dig(:structuredContent, :posts).sole[:id]).to eq(message.id)
else
expect(&operation).to raise_error(DiscourseMcp::ToolError)
end
end
end
it "rejects a public topic as a private message" do
topic = Fabricate(:topic)
expect do
DiscourseMcp::Tools::ReadPrivateMessage.call(
arguments: {
"topic_id" => topic.id,
},
request_context: request_context(user),
)
end.to raise_error(DiscourseMcp::ToolError)
end
it "creates and replies to a private message as the authenticated user" do
created =
DiscourseMcp::Tools::CreatePrivateMessage.call(
arguments: {
"title" => "Private hello",
"raw" => "First message",
"usernames" => [other_user.username],
},
request_context: request_context(user),
).fetch(:structuredContent)
reply =
DiscourseMcp::Tools::ReplyPrivateMessage.call(
arguments: {
"topic_id" => created[:topic_id],
"raw" => "A complete private reply.",
},
request_context: request_context(other_user),
).fetch(:structuredContent)
expect(created).to include(title: "Private hello")
expect(reply).to include(topic_id: created[:topic_id], post_number: 2)
end
it "limits all recipient types together when creating a message" do
group = Fabricate(:group, messageable_level: Group::ALIAS_LEVELS[:everyone])
SiteSetting.max_allowed_message_recipients = 1
expect do
DiscourseMcp::Tools::CreatePrivateMessage.call(
arguments: {
"title" => "Too many recipients",
"raw" => "This message has too many recipients.",
"usernames" => [other_user.username],
"group_names" => [group.name],
},
request_context: request_context(user),
)
end.to raise_error(DiscourseMcp::ToolError, I18n.t(:max_pm_recipients, recipients_limit: 1))
end
it "invites a user only when the caller may invite to the message" do
invited_user = Fabricate(:user)
result =
DiscourseMcp::Tools::InviteToPrivateMessage.call(
arguments: {
"topic_id" => message.topic_id,
"username" => invited_user.username,
},
request_context: request_context(user),
).fetch(:structuredContent)
expect(result).to include(topic_id: message.topic_id, recipient_type: "user", status: "added")
expect(message.topic.reload.allowed_users).to include(invited_user)
expect do
DiscourseMcp::Tools::InviteToPrivateMessage.call(
arguments: {
"topic_id" => message.topic_id,
"username" => Fabricate(:user).username,
},
request_context: request_context(moderator),
)
end.to raise_error(DiscourseMcp::ToolError)
end
it "does not let a regular user invite a group after reaching the recipient limit" do
group = Fabricate(:group, messageable_level: Group::ALIAS_LEVELS[:everyone])
SiteSetting.max_allowed_message_recipients = 2
expect do
DiscourseMcp::Tools::InviteToPrivateMessage.call(
arguments: {
"topic_id" => message.topic_id,
"group_name" => group.name,
},
request_context: request_context(user),
)
end.to raise_error(
DiscourseMcp::ToolError,
I18n.t("pm_reached_recipients_limit", recipients_limit: 2),
)
expect(message.topic.reload.allowed_groups).to be_empty
end
it "lets staff invite a group after reaching the recipient limit" do
group = Fabricate(:group, messageable_level: Group::ALIAS_LEVELS[:everyone])
SiteSetting.max_allowed_message_recipients = 2
result =
DiscourseMcp::Tools::InviteToPrivateMessage.call(
arguments: {
"topic_id" => message.topic_id,
"group_name" => group.name,
},
request_context: request_context(admin),
).fetch(:structuredContent)
expect(result).to include(recipient_type: "group", status: "added")
expect(message.topic.reload.allowed_groups).to contain_exactly(group)
end
end
end
describe DiscourseMcp::CorePrimitives do
it "declares an output schema for every tool" do
tools_without_output_schema =
DiscourseMcp.registry.all(:tool).reject(&:output_schema).map(&:identifier)
expect(tools_without_output_schema).to be_empty
end
it "registers every primitive with the scopes declared by its implementation" do
primitives_with_different_scopes =
DiscourseMcp.registry.all.reject do |primitive|
primitive.implementation.const_defined?(:REQUIRED_SCOPES, false) &&
primitive.required_scopes == primitive.implementation::REQUIRED_SCOPES
end
expect(primitives_with_different_scopes.map(&:identifier)).to be_empty
end
it "registers the compatible regular-user tool names" do
expected_names = %w[
discourse_create_post
discourse_create_private_message
discourse_create_topic
discourse_get_user
discourse_invite_to_private_message
discourse_list_private_messages
discourse_read_post
discourse_read_private_message
discourse_read_topic
discourse_reply_private_message
discourse_update_post
discourse_update_topic
discourse_update_user
discourse_upload_file
]
expect(expected_names).to all(satisfy { |name| DiscourseMcp.registry.find(:tool, name) })
expect(DiscourseMcp.registry.find(:tool, "discourse_topic_get")).to be_nil
end
it "uses a separate write scope for profile updates" do
primitive = DiscourseMcp.registry.find(:tool, "discourse_update_user")
expect(primitive.required_scopes).to eq(["mcp:profile:write"])
end
it "uses separate scopes for private messages and drafts" do
private_message_scopes =
%w[
discourse_list_private_messages
discourse_read_private_message
discourse_create_private_message
discourse_reply_private_message
discourse_invite_to_private_message
].to_h do |identifier|
primitive = DiscourseMcp.registry.find(:tool, identifier)
[identifier, primitive.required_scopes]
end
draft_scopes =
%w[discourse_get_draft discourse_save_draft discourse_delete_draft].to_h do |identifier|
primitive = DiscourseMcp.registry.find(:tool, identifier)
[identifier, primitive.required_scopes]
end
expect(private_message_scopes).to eq(
"discourse_list_private_messages" => ["mcp:private-messages:read"],
"discourse_read_private_message" => ["mcp:private-messages:read"],
"discourse_create_private_message" => ["mcp:private-messages:write"],
"discourse_reply_private_message" => ["mcp:private-messages:write"],
"discourse_invite_to_private_message" => ["mcp:private-messages:write"],
)
expect(draft_scopes).to eq(
"discourse_get_draft" => ["mcp:drafts:read"],
"discourse_save_draft" => ["mcp:drafts:write"],
"discourse_delete_draft" => ["mcp:drafts:write"],
)
end
it "requires renewed consent for tools that can affect external systems" do
primitive_names = %w[
discourse_create_private_message
discourse_invite_to_private_message
discourse_upload_file
]
primitives = primitive_names.map { |name| DiscourseMcp.registry.find(:tool, name) }
expect(primitives.map(&:risk)).to all(eq(:external_side_effect))
expect(primitives.map { |primitive| primitive.annotations["openWorldHint"] }).to all(eq(true))
expect(primitives).to all(be_consent_relevant)
end
end