Skip to content

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

14.9 KB
Raw Blame
# frozen_string_literal: true

RSpec.describe DiscourseAi::Summarization::SummaryController do
  describe "#summary" do
    fab!(:topic) { Fabricate(:topic, highest_post_number: 2) }
    fab!(:post_1) { Fabricate(:post, topic: topic, post_number: 1) }
    fab!(:post_2) { Fabricate(:post, topic: topic, post_number: 2) }

    def create_cached_summary(topic, locale: SiteSetting.default_locale)
      strategy = DiscourseAi::Summarization::Strategies::TopicSummary.new(topic, locale: locale)
      content_sha = AiSummary.build_sha(strategy.targets_data.map { |target| target[:id] }.join)

      Fabricate(
        :ai_summary,
        target: topic,
        locale: locale,
        original_content_sha: content_sha,
        highest_target_number: topic.highest_post_number,
      )
    end

    before do
      enable_current_plugin
      assign_fake_provider_to(:ai_default_llm_model)
      SiteSetting.ai_summarization_enabled = true
    end

    context "when streaming" do
      it "return a cached summary with json payload and does not trigger job if it exists" do
        summary = create_cached_summary(topic)
        sign_in(Fabricate(:admin))

        get "/discourse-ai/summarization/t/#{topic.id}.json?stream=true"

        expect(response.status).to eq(200)
        expect(Jobs::StreamTopicAiSummary.jobs.size).to eq(0)

        response_summary = response.parsed_body
        expect(response_summary.dig("ai_topic_summary", "summarized_text")).to eq(
          summary.summarized_text,
        )
      end
    end

    describe "CSRF protection for state-changing summary requests" do
      fab!(:user, :leader)

      before do
        sign_in(user)
        Group.find(Group::AUTO_GROUPS[:trust_level_3]).add(user)
      end

      it "does not enqueue a streaming job via GET when no cached summary exists" do
        expect { get "/discourse-ai/summarization/t/#{topic.id}.json?stream=true" }.not_to change {
          Jobs::StreamTopicAiSummary.jobs.size
        }

        expect(response.status).to eq(404)
        expect(response.parsed_body["error_type"]).to eq("not_found")
      end

      it "does not generate a summary via GET when no cached summary exists" do
        DiscourseAi::Completions::Llm.with_prepared_responses(["This is a summary"]) do
          expect { get "/discourse-ai/summarization/t/#{topic.id}.json" }.not_to change {
            AiSummary.where(target: topic).count
          }
        end

        expect(response.status).to eq(404)
        expect(response.parsed_body["error_type"]).to eq("not_found")
      end

      it "enqueues a streaming job via POST" do
        post "/discourse-ai/summarization/t/#{topic.id}.json", params: { stream: true }

        expect(response.status).to eq(200)
        expect(response.parsed_body["success"]).to eq("OK")
        expect(Jobs::StreamTopicAiSummary.jobs.size).to eq(1)
      end

      it "generates a summary via POST" do
        summary_text = "This is a summary"

        DiscourseAi::Completions::Llm.with_prepared_responses([summary_text]) do
          post "/discourse-ai/summarization/t/#{topic.id}.json"
        end

        expect(response.status).to eq(200)
        expect(AiSummary.where(target: topic).count).to eq(1)
        expect(response.parsed_body.dig("ai_topic_summary", "summarized_text")).to eq(summary_text)
      end
    end

    context "for anons" do
      it "returns a 404 if there is no cached summary" do
        get "/discourse-ai/summarization/t/#{topic.id}.json"

        expect(response.status).to eq(404)
      end

      it "returns a fresh cached summary" do
        summary = create_cached_summary(topic)
        queries = track_sql_queries { get "/discourse-ai/summarization/t/#{topic.id}.json" }

        expect(response.status).to eq(200)
        expect(queries.grep(/FROM "llm_models"/)).to be_empty

        response_summary = response.parsed_body
        expect(response_summary.dig("ai_topic_summary", "summarized_text")).to eq(
          summary.summarized_text,
        )
      end

      it "returns a 404 for outdated cached summaries" do
        create_cached_summary(topic)
        Fabricate(:post, topic: topic, post_number: 3)
        topic.update!(highest_post_number: 3)

        get "/discourse-ai/summarization/t/#{topic.id}.json"

        expect(response.status).to eq(404)
      end
    end

    context "when the user is a member of an allowlisted group" do
      fab!(:user, :leader)

      before do
        sign_in(user)
        Group.find(Group::AUTO_GROUPS[:trust_level_3]).add(user)
      end

      it "returns a 404 if there is no topic" do
        invalid_topic_id = 999

        get "/discourse-ai/summarization/t/#{invalid_topic_id}.json"

        expect(response.status).to eq(404)
      end

      it "returns a 403 if not allowed to see the topic" do
        pm = Fabricate(:private_message_topic)

        get "/discourse-ai/summarization/t/#{pm.id}.json"

        expect(response.status).to eq(403)
      end

      it "does not expose a cached summary after a post is soft-deleted" do
        sensitive_content = "Content removed by staff"
        post_2.update!(raw: sensitive_content)
        summary = create_cached_summary(topic)
        summary.update!(summarized_text: sensitive_content)

        PostDestroyer.new(Fabricate(:admin), post_2).destroy

        get "/discourse-ai/summarization/t/#{topic.id}.json"

        expect(response.status).to eq(404)
      end

      it "returns a summary" do
        summary_text = "This is a summary"

        DiscourseAi::Completions::Llm.with_prepared_responses([summary_text]) do
          post "/discourse-ai/summarization/t/#{topic.id}.json"

          expect(response.status).to eq(200)
          response_summary = response.parsed_body["ai_topic_summary"]
          summary = AiSummary.last

          expect(summary.summarized_text).to eq(summary_text)
          expect(response_summary["summarized_text"]).to eq(summary.summarized_text)
          expect(response_summary["algorithm"]).to eq("fake")
          expect(response_summary["outdated"]).to eq(false)
          expect(response_summary["can_regenerate"]).to eq(true)
          expect(response_summary["new_posts_since_summary"]).to be_zero
        end
      end

      it "creates and returns a summary in the displayed language" do
        SiteSetting.content_localization_enabled = true
        SiteSetting.content_localization_supported_locales = "he"
        topic.update!(locale: "en")
        user.update!(locale: "he")
        english_summary = create_cached_summary(topic, locale: "en")
        english_summary.update!(summarized_text: "English summary")

        get "/discourse-ai/summarization/t/#{topic.id}.json"

        expect(response.status).to eq(404)

        hebrew_summary_text = "זהו סיכום בעברית"
        DiscourseAi::Completions::Llm.with_prepared_responses([hebrew_summary_text]) do
          post "/discourse-ai/summarization/t/#{topic.id}.json"
        end

        expect(response.status).to eq(200)
        expect(response.parsed_body.dig("ai_topic_summary", "summarized_text")).to eq(
          hebrew_summary_text,
        )
        expect(
          AiSummary.complete.where(target: topic).pluck(:locale, :summarized_text),
        ).to contain_exactly(["en", "English summary"], ["he", hebrew_summary_text])
      end

      it "signals the summary is outdated" do
        DiscourseAi::Completions::Llm.with_prepared_responses(["This is a summary"]) do
          post "/discourse-ai/summarization/t/#{topic.id}.json"
        end

        Fabricate(:post, topic: topic, post_number: 3)
        topic.update!(highest_post_number: 3)

        get "/discourse-ai/summarization/t/#{topic.id}.json"
        expect(response.status).to eq(200)
        summary = response.parsed_body["ai_topic_summary"]

        expect(summary["outdated"]).to eq(true)
        expect(summary["new_posts_since_summary"]).to eq(1)
      end
    end

    context "when the user is not a member of an allowlisted group" do
      fab!(:user)

      before { sign_in(user) }

      it "return a 404 if there is no cached summary" do
        get "/discourse-ai/summarization/t/#{topic.id}.json"

        expect(response.status).to eq(404)
      end

      it "returns a fresh cached summary" do
        summary = create_cached_summary(topic)

        get "/discourse-ai/summarization/t/#{topic.id}.json"

        expect(response.status).to eq(200)

        response_summary = response.parsed_body
        expect(response_summary.dig("ai_topic_summary", "summarized_text")).to eq(
          summary.summarized_text,
        )
      end

      it "returns a 404 for outdated cached summaries" do
        create_cached_summary(topic)
        Fabricate(:post, topic: topic, post_number: 3)
        topic.update!(highest_post_number: 3)

        get "/discourse-ai/summarization/t/#{topic.id}.json"

        expect(response.status).to eq(404)
      end
    end
  end

  describe "#regen_gist" do
    fab!(:admin)
    fab!(:group)
    fab!(:topic)
    fab!(:post_1) { Fabricate(:post, topic: topic, post_number: 1) }
    fab!(:post_2) { Fabricate(:post, topic: topic, post_number: 2) }

    fab!(:topic_1, :topic)
    fab!(:post_3) { Fabricate(:post, topic: topic_1, post_number: 1) }
    fab!(:post_4) { Fabricate(:post, topic: topic_1, post_number: 2) }

    before do
      enable_current_plugin
      assign_fake_provider_to(:ai_default_llm_model)
      SiteSetting.ai_summarization_enabled = true
      SiteSetting.ai_summary_gists_enabled = true

      group.add(admin)
      assign_agent_to(:ai_summary_gists_agent, [group.id])
      Jobs.run_immediately!
    end

    def gist_tool_call(summary, id:)
      DiscourseAi::Completions::ToolCall.new(
        id:,
        name: "set_topic_summary",
        parameters: {
          summary:,
        },
      )
    end

    context "when a single topic id is provided" do
      before { sign_in(admin) }

      it "regenerates the gist" do
        DiscourseAi::Completions::Llm.with_prepared_responses(
          [gist_tool_call("Topic gist", id: "gist_1")],
        ) { put "/discourse-ai/summarization/regen_gist", params: { topic_id: topic.id } }

        expect(response.status).to eq(200)
        expect(AiSummary.gist.where(target: topic, locale: SiteSetting.default_locale).count).to eq(
          1,
        )
      end
    end

    context "when multiple topic ids are provided" do
      before { sign_in(admin) }

      it "regenerates the gists" do
        DiscourseAi::Completions::Llm.with_prepared_responses(
          [
            gist_tool_call("First topic gist", id: "gist_1"),
            gist_tool_call("Second topic gist", id: "gist_2"),
          ],
        ) do
          put "/discourse-ai/summarization/regen_gist",
              params: {
                topic_ids: [topic.id, topic_1.id],
              }
        end

        expect(response.status).to eq(200)
        expect(AiSummary.gist.where(target: topic).count).to eq(1)
        expect(AiSummary.gist.where(target: topic_1).count).to eq(1)
      end
    end

    context "when more than 30 topics are provided" do
      before { sign_in(admin) }

      it "raises an error" do
        topic_ids = (1..31).to_a

        put "/discourse-ai/summarization/regen_gist", params: { topic_ids: topic_ids }

        expect(response.status).to eq(400)
      end
    end

    context "when user is not allowed to regenerate gists" do
      fab!(:user)

      before { sign_in(user) }

      it "returns a 403" do
        put "/discourse-ai/summarization/regen_gist", params: { topic_id: topic.id }

        expect(response.status).to eq(403)
      end
    end
  end

  describe "#regen_summary" do
    fab!(:admin)
    fab!(:group)
    fab!(:topic)
    fab!(:post_1) { Fabricate(:post, topic: topic, post_number: 1) }
    fab!(:post_2) { Fabricate(:post, topic: topic, post_number: 2) }

    fab!(:topic_1, :topic)
    fab!(:post_3) { Fabricate(:post, topic: topic_1, post_number: 1) }
    fab!(:post_4) { Fabricate(:post, topic: topic_1, post_number: 2) }

    before do
      enable_current_plugin
      assign_fake_provider_to(:ai_default_llm_model)
      SiteSetting.ai_summarization_enabled = true

      group.add(admin)
      assign_agent_to(:ai_summarization_agent, [group.id])
    end

    context "when a single topic id is provided" do
      before { sign_in(admin) }

      it "preserves the cached summary and enqueues a forced regeneration job" do
        existing_summary = Fabricate(:ai_summary, target: topic, locale: SiteSetting.default_locale)

        put "/discourse-ai/summarization/regen_summary", params: { topic_id: topic.id }

        expect(response.status).to eq(200)
        expect(AiSummary.find_by(id: existing_summary.id)).to eq(existing_summary)
        expect(Jobs::StreamTopicAiSummary.jobs.size).to eq(1)

        job_args = Jobs::StreamTopicAiSummary.jobs.first["args"].first
        expect(job_args).to include(
          "topic_id" => topic.id,
          "user_id" => admin.id,
          "locale" => SiteSetting.default_locale,
          "force_regenerate" => true,
        )
        expect(job_args).not_to have_key("skip_age_check")
      end

      it "enqueues job even when there is no existing summary" do
        put "/discourse-ai/summarization/regen_summary", params: { topic_id: topic.id }

        expect(response.status).to eq(200)
        expect(Jobs::StreamTopicAiSummary.jobs.size).to eq(1)
      end
    end

    context "when multiple topic ids are provided" do
      before { sign_in(admin) }

      it "regenerates the summaries" do
        put "/discourse-ai/summarization/regen_summary",
            params: {
              topic_ids: [topic.id, topic_1.id],
            }

        expect(response.status).to eq(200)
        expect(Jobs::StreamTopicAiSummary.jobs.size).to eq(2)

        job_topic_ids = Jobs::StreamTopicAiSummary.jobs.map { |j| j["args"].first["topic_id"] }
        expect(job_topic_ids).to contain_exactly(topic.id, topic_1.id)
      end
    end

    context "when more than 30 topics are provided" do
      before { sign_in(admin) }

      it "raises an error" do
        topic_ids = (1..31).to_a

        put "/discourse-ai/summarization/regen_summary", params: { topic_ids: topic_ids }

        expect(response.status).to eq(400)
      end
    end

    context "when user is not allowed to regenerate summaries" do
      fab!(:user)

      before { sign_in(user) }

      it "returns a 403" do
        put "/discourse-ai/summarization/regen_summary", params: { topic_id: topic.id }

        expect(response.status).to eq(403)
      end
    end

    context "when user cannot see the topic" do
      fab!(:moderator)

      before do
        group.add(moderator)
        sign_in(moderator)
      end

      it "returns a 403 for private topics user cannot access" do
        private_group = Fabricate(:group)
        private_category = Fabricate(:private_category, group: private_group)
        private_topic = Fabricate(:topic, category: private_category)

        put "/discourse-ai/summarization/regen_summary", params: { topic_id: private_topic.id }

        expect(response.status).to eq(403)
      end
    end
  end
end