Skip to content

A platform for community discussion. Free, open, simple.

13.7 KB
Raw Blame
# frozen_string_literal: true

describe "MCP category tools" do
  fab!(:user) { Fabricate(:user, refresh_auto_groups: true) }
  fab!(:admin)
  fab!(:scope_group, :group)

  before do
    SiteSetting.mcp_server_enabled = true
    scope_group.add(user)
    %w[
      discourse_create_category
      discourse_get_category
      discourse_update_category
      discourse_delete_category
    ].each { |identifier| McpPrimitive.create!(kind: "tool", identifier:, enabled: true) }
  end

  def authorize(*extra_scopes, auth_user: user)
    scope_group.add(auth_user)
    scopes = [DiscourseMcp::INITIAL_SCOPE, *extra_scopes]
    scopes.each { |scope| McpGroupScope.find_or_create_by!(group: scope_group, scope:) }
    client =
      McpOauthClient.create!(
        client_id: SecureRandom.hex,
        name: "Category tool test client",
        registration_type: "pre_registered",
        trust_state: "approved",
        redirect_uris: ["http://127.0.0.1/callback"],
      )
    authorization =
      DiscourseMcp::OAuth::AuthorizationGrant.create!(
        user: auth_user,
        client:,
        redirect_uri: client.redirect_uris.first,
        requested_scopes: scopes,
      )
    @token = McpOauthAccessToken.issue!(authorization:)
  end

  def call_tool(name, arguments)
    post "/mcp",
         params: {
           jsonrpc: "2.0",
           id: 1,
           method: "tools/call",
           params: {
             name:,
             arguments:,
           },
         }.to_json,
         headers: {
           "HTTP_AUTHORIZATION" => "Bearer #{@token}",
           "CONTENT_TYPE" => "application/json",
           "HTTP_ACCEPT" => "application/json, text/event-stream",
           "HTTP_MCP_PROTOCOL_VERSION" => DiscourseMcp::LEGACY_PROTOCOL_VERSION,
         }
  end

  def call_create_category(arguments)
    call_tool("discourse_create_category", arguments)
  end

  it "requires the category write scope" do
    authorize

    call_create_category(name: "Missing scope")

    expect(response.status).to eq(403)
    expect(response.headers["WWW-Authenticate"]).to include(
      'error="insufficient_scope"',
      'scope="mcp:categories:write"',
    )
    expect(Category.find_by(name: "Missing scope")).to be_nil
  end

  it "does not let a regular user create a category when the token has scope" do
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE)

    call_create_category(name: "Not allowed", parent_category_id: 999_999_999)

    expect(response.status).to eq(403)
    expect(Category.find_by(name: "Not allowed")).to be_nil
  end

  it "creates a subcategory and logs the action for an authorized admin" do
    parent_category = Fabricate(:category)
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    expect do
      call_create_category(
        name: "猫 support",
        description: "Help with cats",
        parent_category_id: parent_category.id,
        color: "0088CC",
        text_color: "FFFFFF",
        emoji: "cat",
        icon: "paw",
      )
    end.to change {
      UserHistory.where(
        action: UserHistory.actions[:create_category],
        acting_user_id: admin.id,
      ).count
    }.by(1)

    expect(response.status).to eq(200)
    result = response.parsed_body.dig("result", "structuredContent")
    category = Category.find(result.fetch("id"))
    expect(result).to include("name" => "猫 support", "slug" => category.slug)
    expect(category).to have_attributes(
      parent_category_id: parent_category.id,
      user_id: admin.id,
      style_type: "emoji",
      emoji: "cat",
      icon: "paw",
    )
  end

  it "rejects a public subcategory beneath a private parent" do
    group = Fabricate(:group)
    parent = Fabricate(:private_category, group:)
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    expect do
      call_create_category(name: "Public child", parent_category_id: parent.id)
    end.not_to change(Category, :count)

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "isError")).to eq(true)
    expect(Guardian.new.can_see?(parent)).to eq(false)
  end

  it "rejects moving a public category beneath a private parent" do
    group = Fabricate(:group)
    parent = Fabricate(:private_category, group:)
    category = Fabricate(:category)
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    call_tool("discourse_update_category", category_id: category.id, parent_category_id: parent.id)

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "isError")).to eq(true)
    expect(category.reload.parent_category_id).to be_nil
    expect(Guardian.new.can_see?(category)).to eq(true)
    expect(Guardian.new.can_see?(parent)).to eq(false)
  end

  it "does not create a category with an invalid emoji" do
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    call_create_category(name: "Invalid emoji", emoji: "not-a-real-emoji")

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "isError")).to eq(true)
    expect(Category.find_by(name: "Invalid emoji")).to be_nil
  end

  it "does not create a subcategory under a deleted category" do
    parent_category = Fabricate(:category)
    parent_category.destroy!
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    call_create_category(name: "Orphaned", parent_category_id: parent_category.id)

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "isError")).to eq(true)
    expect(response.parsed_body.dig("result", "content")).to eq(
      [{ "type" => "text", "text" => I18n.t("category.errors.not_found") }],
    )
    expect(Category.find_by(name: "Orphaned")).to be_nil
  end

  it "requires the category read scope for management details" do
    category = Fabricate(:category)
    authorize

    call_tool("discourse_get_category", category_id: category.id)

    expect(response.status).to eq(403)
    expect(response.headers["WWW-Authenticate"]).to include(
      'error="insufficient_scope"',
      'scope="mcp:categories:read"',
    )
  end

  it "returns a tool error when a category has been deleted" do
    category = Fabricate(:category)
    category.destroy!
    authorize(DiscourseMcp::Scopes::CATEGORIES_READ, auth_user: admin)

    call_tool("discourse_get_category", category_id: category.id)

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "isError")).to eq(true)
    expect(response.parsed_body.dig("result", "content")).to eq(
      [{ "type" => "text", "text" => I18n.t("mcp.errors.category_not_found") }],
    )
  end

  it "requires the category write scope to update a category" do
    category = Fabricate(:category, name: "Original")
    authorize(DiscourseMcp::Scopes::CATEGORIES_READ, auth_user: admin)

    call_tool("discourse_update_category", category_id: category.id, name: "Changed")

    expect(response.status).to eq(403)
    expect(response.headers["WWW-Authenticate"]).to include(
      'error="insufficient_scope"',
      'scope="mcp:categories:write"',
    )
    expect(category.reload.name).to eq("Original")
  end

  it "requires the category write scope to delete a category" do
    category = Fabricate(:category)
    authorize(DiscourseMcp::Scopes::CATEGORIES_READ, auth_user: admin)

    call_tool(
      "discourse_delete_category",
      category_id: category.id,
      expected_name: category.name,
      confirm: true,
    )

    expect(response.status).to eq(403)
    expect(response.headers["WWW-Authenticate"]).to include(
      'error="insufficient_scope"',
      'scope="mcp:categories:write"',
    )
    expect(Category.exists?(category.id)).to eq(true)
  end

  it "does not let a regular user manage categories when the token has scope" do
    category = Fabricate(:category, name: "Original")
    authorize(DiscourseMcp::Scopes::CATEGORIES_READ, DiscourseMcp::Scopes::CATEGORIES_WRITE)

    call_create_category(name: "Not allowed")
    expect(response.status).to eq(403)

    call_tool("discourse_get_category", category_id: category.id)
    expect(response.status).to eq(403)

    call_tool("discourse_update_category", category_id: category.id, name: "Changed")
    expect(response.status).to eq(403)

    call_tool(
      "discourse_delete_category",
      category_id: category.id,
      expected_name: category.name,
      confirm: true,
    )
    expect(response.status).to eq(403)

    expect(Category.find_by(name: "Not allowed")).to be_nil
    expect(category.reload.name).to eq("Original")
  end

  it "lets an authorized admin read and update basic category details" do
    parent_category = Fabricate(:category)
    category = Fabricate(:category_with_definition, name: "Original", user: admin)
    authorize(
      DiscourseMcp::Scopes::CATEGORIES_READ,
      DiscourseMcp::Scopes::CATEGORIES_WRITE,
      auth_user: admin,
    )

    call_tool("discourse_get_category", category_id: category.id)

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "structuredContent", "category")).to include(
      "id" => category.id,
      "name" => "Original",
      "can_delete" => true,
    )

    call_tool(
      "discourse_update_category",
      category_id: category.id,
      name: "猫 support",
      description: "Updated **description**",
      parent_category_id: parent_category.id,
      emoji: "cat",
    )

    expect(response.status).to eq(200)
    result = response.parsed_body.dig("result", "structuredContent", "category")
    expect(result).to include(
      "id" => category.id,
      "name" => "猫 support",
      "parent_category_id" => parent_category.id,
      "description" => "Updated **description**",
      "style_type" => "emoji",
      "emoji" => "cat",
    )
    expect(category.reload.topic.first_post.raw).to eq("Updated **description**")
    history =
      UserHistory.find_by(
        action: UserHistory.actions[:change_category_settings],
        acting_user_id: admin.id,
        category_id: category.id,
        subject: "name",
      )
    expect(history).to have_attributes(previous_value: "Original", new_value: "猫 support")
  end

  it "does not persist or log an invalid category update" do
    category = Fabricate(:category, name: "Original")
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    expect do
      call_tool("discourse_update_category", category_id: category.id, emoji: "not-an-emoji")
    end.not_to change {
      UserHistory.where(
        action: UserHistory.actions[:change_category_settings],
        category_id: category.id,
      ).count
    }

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "isError")).to eq(true)
    expect(category.reload.style_type).to eq("square")
  end

  it "uses moderator category permissions in addition to OAuth scope" do
    SiteSetting.moderators_manage_categories = true
    moderator = Fabricate(:moderator)
    visible_category = Fabricate(:category, name: "Visible")
    group = Fabricate(:group)
    hidden_category = Fabricate(:private_category, group:)
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: moderator)

    call_tool(
      "discourse_update_category",
      category_id: visible_category.id,
      name: "Updated by moderator",
    )
    expect(response.status).to eq(200)

    call_tool("discourse_update_category", category_id: hidden_category.id, name: "Not visible")
    expect(response.status).to eq(403)

    call_tool(
      "discourse_update_category",
      category_id: visible_category.id,
      parent_category_id: hidden_category.id,
    )
    expect(response.status).to eq(403)

    call_tool(
      "discourse_delete_category",
      category_id: hidden_category.id,
      expected_name: "Guessed name",
      confirm: true,
    )
    expect(response.status).to eq(403)

    expect(visible_category.reload.name).to eq("Updated by moderator")
    expect(visible_category.parent_category_id).to be_nil
    expect(hidden_category.reload.name).not_to eq("Not visible")
  end

  it "requires explicit confirmation and the current name before deleting" do
    category = Fabricate(:category)
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    call_tool(
      "discourse_delete_category",
      category_id: category.id,
      expected_name: category.name,
      confirm: false,
    )
    expect(response.parsed_body.dig("result", "isError")).to eq(true)

    call_tool(
      "discourse_delete_category",
      category_id: category.id,
      expected_name: "Wrong name",
      confirm: true,
    )
    expect(response.parsed_body.dig("result", "isError")).to eq(true)

    expect(Category.exists?(category.id)).to eq(true)
  end

  it "deletes an empty category and logs the action for an authorized admin" do
    category = Fabricate(:category)
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    expect do
      call_tool(
        "discourse_delete_category",
        category_id: category.id,
        expected_name: category.name,
        confirm: true,
      )
    end.to change {
      UserHistory.where(
        action: UserHistory.actions[:delete_category],
        acting_user_id: admin.id,
        category_id: category.id,
      ).count
    }.by(1)

    expect(response.status).to eq(200)
    expect(response.parsed_body.dig("result", "structuredContent")).to eq(
      "deleted" => true,
      "category_id" => category.id,
    )
    expect(Category.exists?(category.id)).to eq(false)
  end

  it "does not delete a category that contains topics" do
    category = Fabricate(:category)
    category.update!(topic_count: 1)
    authorize(DiscourseMcp::Scopes::CATEGORIES_WRITE, auth_user: admin)

    call_tool(
      "discourse_delete_category",
      category_id: category.id,
      expected_name: category.name,
      confirm: true,
    )

    expect(response.status).to eq(403)
    expect(Category.exists?(category.id)).to eq(true)
  end
end