Skip to content

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

20.3 KB
Raw Blame
# frozen_string_literal: true

describe TopicsController do
  fab!(:topic)
  fab!(:llm_model, :fake_model)
  fab!(:summarization_agent) do
    Fabricate(:ai_agent, allowed_group_ids: [Group::AUTO_GROUPS[:admins]])
  end
  fab!(:first_post) { Fabricate(:post, topic: topic, post_number: 1) }

  let(:summary_phrase) { "concise overview" }
  let(:summary_text) { "A **#{summary_phrase}** of this discussion." }
  let(:crawler_headers) { { "User-Agent" => "Googlebot" } }
  let(:browser_headers) { { "User-Agent" => "Mozilla/5.0 Chrome/130.0.0.0 Safari/537.36" } }

  before do
    enable_current_plugin
    SiteSetting.ai_default_llm_model = llm_model.id
    SiteSetting.ai_summarization_agent = summarization_agent.id
    SiteSetting.ai_summarization_enabled = true
    SiteSetting.enable_markdown_endpoints = true
    SiteSetting.ai_summary_backfill_maximum_topics_per_hour = 10
    SiteSetting.ai_summaries_for_crawlers = true
  end

  def create_summary(locale: "en", text: summary_text)
    strategy = DiscourseAi::Summarization::Strategies::TopicSummary.new(topic, locale:)
    Fabricate(
      :ai_summary,
      target: topic,
      locale:,
      summarized_text: text,
      original_content_sha: strategy.summary_fingerprint[:original_content_sha],
      highest_target_number: topic.highest_post_number,
    )
  end

  describe "#show" do
    it "keeps forced crawler translations consistent on misses and shared cache hits" do
      global_setting :anon_cache_store_threshold, 1
      Middleware::AnonymousCache.enable_anon_cache
      SiteSetting.content_localization_enabled = true
      SiteSetting.content_localization_supported_locales = "fr"
      SiteSetting.default_locale = "fr"
      topic.update!(locale: "en")
      first_post.update!(locale: "en")
      Fabricate(:post_localization, post: first_post, locale: "fr", cooked: "<p>Bonjour</p>")
      create_summary
      french = create_summary(locale: "fr", text: "Un résumé de cette discussion.")
      forced_headers = browser_headers.merge("Discourse-Render" => "crawler")
      bot_headers = { "User-Agent" => "#{browser_headers["User-Agent"]} Googlebot" }

      %w[true false].each do |translate|
        cookies[ContentLocalization::AUTOMATICALLY_TRANSLATE_COOKIE] = translate
        [[forced_headers, bot_headers], [bot_headers, forced_headers]].each do |headers|
          Middleware::AnonymousCache.clear_all_cache!
          headers.each_with_index do |request_headers, index|
            get topic.relative_url, headers: request_headers

            expect(response.status).to eq(200)
            expect(response.headers["X-Discourse-Cached"]).to eq(index.zero? ? "store" : "true")
            document = Nokogiri.HTML5(response.body)
            expect(document.at_css('[itemprop="abstract"]').text).to include(
              translate == "true" ? french.summarized_text : summary_phrase,
            )
            expect(document.at_css("#post_1 .post").text).to include(
              translate == "true" ? "Bonjour" : first_post.raw,
            )
          end
        end
      end
    end

    it "publishes a cached summary as the discussion abstract in crawler HTML" do
      create_summary

      get topic.relative_url, headers: crawler_headers

      expect(response.status).to eq(200)
      document = Nokogiri.HTML5(response.body)
      abstract =
        document.at_css(
          '[itemtype="http://schema.org/DiscussionForumPosting"] > section [itemprop="abstract"]',
        )
      expect(abstract&.text).to include("A #{summary_phrase} of this discussion.")
      expect(abstract.at_css("strong").text).to eq(summary_phrase)
      expect(document.at_css("#post_1 .post").text).to include(first_post.raw)
    end

    it "adds the summary before the posts in Markdown for crawlers and agents" do
      create_summary
      heading = "## #{I18n.t("discourse_ai.summarization.published_summary_heading")}"

      [
        ["#{topic.relative_url}.md", crawler_headers],
        ["#{topic.relative_url}.md", browser_headers],
        [topic.relative_url, browser_headers.merge("Accept" => "text/markdown")],
      ].each do |path, headers|
        get path, headers: headers

        expect(response.status).to eq(200)
        body = response.body
        expect(body).to include("#{heading}\n\nA **#{summary_phrase}** of this discussion.")
        expect(body.index(heading)).to be < body.index(first_post.raw)
      end
    end

    it "publishes the stored Markdown without requiring cooked content" do
      text = "An overview of 猫.\n\n[Reference][source]\n\n[source]: https://example.com"
      summary = create_summary(text:)

      get "#{topic.relative_url}.md", headers: browser_headers

      expect(response.status).to eq(200)
      expect(response.body).to include(text)

      summary.update_columns(summarized_cooked: nil)

      get "#{topic.relative_url}.md", headers: browser_headers

      expect(response.status).to eq(200)
      expect(response.body).to include(text)
      expect(summary.reload.summarized_cooked).to be_nil
    end

    it "reads the Markdown summary with one query and no LLM lookup whether or not one exists" do
      path = "#{topic.relative_url}.md"

      queries = track_sql_queries { get path, headers: browser_headers }

      expect(response.status).to eq(200)
      expect(queries.grep(/FROM "ai_summaries"/).size).to eq(1)

      create_summary
      queries = track_sql_queries { get path, headers: browser_headers }

      expect(response.body).to include(summary_phrase)
      expect(queries.grep(/FROM "ai_summaries"/).size).to eq(1)
      expect(queries.grep(/FROM "llm_models"/)).to be_empty
    end

    it "leaves the summary out of later Markdown pages and single posts" do
      2.upto(TopicView::CHUNK_SIZE + 1) { |post_number| Fabricate(:post, topic:, post_number:) }
      topic.update!(highest_post_number: TopicView::CHUNK_SIZE + 1)
      create_summary

      ["#{topic.relative_url}.md?page=2", "#{topic.relative_url}/1.md"].each do |path|
        get path, headers: crawler_headers

        expect(response.status).to eq(200)
        expect(response.body).not_to include(summary_phrase)
      end
    end

    it "leaves an outdated summary out of Markdown" do
      summary = create_summary
      first_post.update!(last_version_at: summary.updated_at + 1.minute)

      get "#{topic.relative_url}.md", headers: crawler_headers

      expect(response.status).to eq(200)
      expect(response.body).not_to include(summary_phrase)
    end

    it "uses the same crawler classification as the anonymous cache" do
      global_setting :anon_cache_store_threshold, 1
      Middleware::AnonymousCache.enable_anon_cache
      Middleware::AnonymousCache.clear_all_cache!
      create_summary

      get topic.relative_url, headers: browser_headers.merge("Discourse-Render" => "crawler")

      expect(response.headers["X-Discourse-Cached"]).to eq("store")
      expect(response.body).to include(summary_phrase)

      get topic.relative_url,
          headers: {
            "User-Agent" => "#{browser_headers["User-Agent"]} Googlebot",
          }

      expect(response.headers["X-Discourse-Cached"]).to eq("true")
      expect(response.body).to include(summary_phrase)
    end

    context "with HTML publication" do
      def request_topic(path: topic.relative_url, params: {})
        get path, params:, headers: crawler_headers
      end

      it "serves stored cooked content rather than cooking the source on request" do
        summary = create_summary
        stored_content = "Previously cooked overview"
        summary.update_columns(summarized_cooked: "<p>#{stored_content}</p>")

        request_topic

        expect(response.status).to eq(200)
        expect(response.body).to include(stored_content)
        expect(response.body).not_to include(summary_phrase)
      end

      it "omits uncooked summaries without cooking them on request" do
        summary = create_summary
        summary.update_columns(summarized_cooked: nil)

        request_topic

        expect(response.status).to eq(200)
        expect(response.body).to include(first_post.raw)
        expect(response.body).not_to include(summary_phrase)
        expect(summary.reload.summarized_cooked).to be_nil

        summary.update_columns(summarized_cooked: "<p>#{summary_phrase}</p>")
        request_topic

        expect(response.body).to include(summary_phrase)
      end

      it "leaves browser and print responses unchanged" do
        create_summary
        path = topic.relative_url

        [{}, { print: true }].each do |params|
          SiteSetting.ai_summaries_for_crawlers = false
          get path, params: params, headers: browser_headers
          original_last_modified = response.headers["Last-Modified"]
          SiteSetting.ai_summaries_for_crawlers = true

          get path, params: params, headers: browser_headers

          expect(response.status).to eq(200)
          expect(response.body).not_to include(summary_phrase)
          expect(response.headers["Last-Modified"]).to eq(original_last_modified)
        end
      end

      it "adds one summary lookup per request without retaining it across requests" do
        create_summary
        SiteSetting.ai_summaries_for_crawlers = false
        baseline_queries = track_sql_queries { request_topic }
        SiteSetting.ai_summaries_for_crawlers = true

        queries = track_sql_queries { request_topic }

        expect(response.status).to eq(200)
        expect(response.body).to include(summary_phrase)
        summary_query = /SELECT.*FROM "ai_summaries"/
        expect(queries.grep(summary_query).size).to eq(
          baseline_queries.grep(summary_query).size + 1,
        )

        AiSummary.where(target: topic).delete_all
        request_topic

        expect(response.status).to eq(200)
        expect(response.body).not_to include(summary_phrase)

        create_summary
        request_topic

        expect(response.status).to eq(200)
        expect(response.body).to include(summary_phrase)
      end

      it "serves summaries through the existing anonymous topic cache" do
        global_setting :anon_cache_store_threshold, 1
        Middleware::AnonymousCache.enable_anon_cache
        Middleware::AnonymousCache.clear_all_cache!
        summary = create_summary

        request_topic

        expect(response.headers["X-Discourse-Cached"]).to eq("store")
        expect(request.env["ANON_CACHE_DURATION"]).to eq(1.minute)
        expect(response.body).to include(summary_phrase)

        path = topic.relative_url
        get path, headers: browser_headers
        expect(response.headers["X-Discourse-Cached"]).to eq("store")
        expect(response.body).not_to include(summary_phrase)

        get path, headers: browser_headers
        expect(response.headers["X-Discourse-Cached"]).to eq("true")
        expect(response.body).not_to include(summary_phrase)

        first_post.update!(last_version_at: summary.updated_at + 1.minute)
        queries = track_sql_queries { request_topic }

        expect(response.headers["X-Discourse-Cached"]).to eq("true")
        expect(response.body).to include(summary_phrase)
        expect(queries.grep(/\b(?:ai_summaries|posts|topics)\b/)).to be_empty

        Middleware::AnonymousCache.clear_all_cache!
        request_topic

        expect(response.headers["X-Discourse-Cached"]).to eq("store")
        expect(response.body).not_to include(summary_phrase)

        request_topic

        expect(response.headers["X-Discourse-Cached"]).to eq("true")
        expect(response.body).not_to include(summary_phrase)
      end

      it "omits summaries when publication, summarization, or the plugin is disabled" do
        summary = create_summary

        %i[
          ai_summaries_for_crawlers
          ai_summarization_enabled
          discourse_ai_enabled
        ].each do |setting|
          SiteSetting.public_send("#{setting}=", false)
          request_topic

          expect(response.status).to eq(200)
          expect(response.body).not_to include(summary.summarized_text, summary_phrase)
          SiteSetting.public_send("#{setting}=", true)
        end
      end

      it "leaves a missing summary absent without generating one" do
        DiscourseAi::Completions::Llm.with_prepared_responses([]) do
          expect { request_topic }.not_to change(AiSummary, :count)
        end

        expect(response.status).to eq(200)
        expect(response.body).to include(first_post.raw)
        expect(response.body).not_to include(
          I18n.t("discourse_ai.summarization.published_summary_heading"),
        )
        expect(response.headers["Last-Modified"]).to eq(first_post.updated_at.httpdate)
        expect(request.env["ANON_CACHE_DURATION"]).to eq(1.minute)
      end

      it "omits an edited summary even for an admin and preserves the post freshness hint" do
        summary = create_summary
        sign_in(Fabricate(:admin))
        request_topic
        expect(response.body).to include(summary_phrase)

        first_post.update!(last_version_at: summary.updated_at + 1.minute)
        request_topic

        expect(response.status).to eq(200)
        expect(response.body).not_to include(summary_phrase)
        expect(response.headers["Last-Modified"]).to eq(first_post.reload.updated_at.httpdate)
      end

      it "omits a summary after new replies or hidden source posts change the input" do
        summary = create_summary
        reply = Fabricate(:post, topic:, post_number: 2)
        topic.update!(highest_post_number: 2)
        request_topic
        expect(response.body).not_to include(summary_phrase)

        summary.destroy!
        create_summary
        request_topic
        expect(response.body).to include(summary_phrase)

        reply.update!(hidden: true)
        request_topic
        expect(response.body).not_to include(summary_phrase)
      end

      it "omits a summary after a source post is deleted" do
        reply = Fabricate(:post, topic:, post_number: 2)
        topic.update!(highest_post_number: 2)
        create_summary
        request_topic
        expect(response.body).to include(summary_phrase)

        reply.trash!
        request_topic

        expect(response.status).to eq(200)
        expect(response.body).not_to include(summary_phrase)
        expect(response.headers["Last-Modified"]).to eq(first_post.reload.updated_at.httpdate)
      end

      it "omits restricted topics even when the requester is an admin" do
        create_summary
        topic.update!(category: Fabricate(:private_category, group: Fabricate(:group)))
        sign_in(Fabricate(:admin))

        request_topic

        expect(response.status).to eq(200)
        expect(response.body).to include(first_post.raw)
        expect(response.body).not_to include(summary_phrase)
      end

      it "omits summaries when the site requires login" do
        create_summary
        SiteSetting.login_required = true
        sign_in(Fabricate(:admin))

        request_topic

        expect(response.status).to eq(200)
        expect(response.body).not_to include(summary_phrase)
      end

      it "omits personal messages even when their participant can summarize" do
        admin = Fabricate(:admin)
        message = Fabricate(:private_message_topic, user: admin)
        message_post = Fabricate(:post, topic: message)
        strategy = DiscourseAi::Summarization::Strategies::TopicSummary.new(message, locale: "en")
        Fabricate(
          :ai_summary,
          target: message,
          locale: "en",
          summarized_text: summary_text,
          original_content_sha: strategy.summary_fingerprint[:original_content_sha],
        )
        SiteSetting.ai_pm_summarization_allowed_groups = Group::AUTO_GROUPS[:admins].to_s
        sign_in(admin)

        request_topic(path: message.relative_url)

        expect(response.status).to eq(200)
        expect(response.body).to include(message_post.raw)
        expect(response.body).not_to include(summary_phrase)
      end

      it "omits summaries from later pages and single-post responses" do
        Fabricate.times(TopicView.chunk_size, :post, topic: topic, user: first_post.user)
        topic.update!(highest_post_number: TopicView.chunk_size + 1)
        create_summary

        request_topic(params: { page: 2 })
        expect(response.status).to eq(200)
        expect(response.body).not_to include(summary_phrase)

        request_topic(path: "#{topic.relative_url}/2")
        expect(response.status).to eq(200)
        expect(response.body).not_to include(summary_phrase)
      end

      it "leaves Last-Modified and topic activity unchanged when a summary is regenerated" do
        freeze_time
        topic.update!(last_posted_at: first_post.created_at)
        summary = create_summary
        request_topic
        previous_last_modified = response.headers["Last-Modified"]
        topic_activity = topic.reload.last_posted_at

        freeze_time 2.minutes.from_now
        summary.update!(summarized_text: "An updated overview")
        request_topic

        expect(response.body).to include(summary.summarized_text)
        expect(response.headers["Last-Modified"]).to eq(previous_last_modified)
        expect(topic.reload.last_posted_at).to eq_time(topic_activity)
        expect(request.env["ANON_CACHE_DURATION"]).to eq(1.minute)
      end

      it "uses the source-language summary instead of another cached locale" do
        topic.update!(locale: "fr")
        english = create_summary
        french = create_summary(locale: "fr", text: "Un résumé de cette discussion.")

        request_topic

        expect(response.status).to eq(200)
        expect(response.body).to include(french.summarized_text)
        expect(response.body).not_to include(english.summarized_text, summary_phrase)
      end

      it "uses a localized summary when the discussion is shown translated" do
        SiteSetting.content_localization_enabled = true
        SiteSetting.content_localization_supported_locales = "fr"
        SiteSetting.default_locale = "fr"
        topic.update!(locale: "en")
        first_post.update!(locale: "en")
        Fabricate(:post_localization, post: first_post, locale: "fr", cooked: "<p>Bonjour</p>")
        english = create_summary
        french = create_summary(locale: "fr", text: "Un résumé de cette discussion.")

        request_topic

        expect(response.status).to eq(200)
        expect(response.body).to include(french.summarized_text)
        expect(response.body).not_to include(english.summarized_text, summary_phrase)

        cookies[ContentLocalization::AUTOMATICALLY_TRANSLATE_COOKIE] = "false"
        request_topic

        expect(response.body).to include(summary_phrase, first_post.raw)
        expect(response.body).not_to include(french.summarized_text, "Bonjour")

        cookies[ContentLocalization::AUTOMATICALLY_TRANSLATE_COOKIE] = "true"
        french.destroy!
        request_topic
        expect(response.body).not_to include(
          english.summarized_text,
          french.summarized_text,
          summary_phrase,
        )
      end
    end

    it "sanitizes summary markup in HTML" do
      create_summary(
        text: 'Overview <script>alert("xss")</script> <a href="javascript:alert(1)">unsafe</a>',
      )

      get topic.relative_url, headers: crawler_headers
      abstract = Nokogiri.HTML5(response.body).at_css('[itemprop="abstract"]')
      expect(abstract.text).to include("Overview")
      expect(abstract.css("script, [href^='javascript:']")).to be_empty
    end

    it "leaves topic JSON unchanged" do
      summary = create_summary
      summary.update!(updated_at: first_post.updated_at + 1.minute)

      get "#{topic.relative_url}.json", headers: crawler_headers

      expect(response.status).to eq(200)
      expect(response.parsed_body["has_cached_summary"]).to eq(true)
      expect(response.parsed_body).not_to have_key("ai_summary")
      expect(response.headers["Last-Modified"]).to be_nil
    end

    it "keeps the abstract on QAPage rather than the nested question or answers" do
      SiteSetting.allow_solved_on_all_topics = true
      SiteSetting.solved_add_schema_markup = "always"
      Fabricate(:post, topic:, post_number: 2)
      topic.update!(highest_post_number: 2)
      create_summary

      get topic.relative_url, headers: crawler_headers

      expect(response.status).to eq(200)
      document = Nokogiri.HTML5(response.body)
      abstract = document.at_css('[itemprop="abstract"]')
      expect(abstract.ancestors("[itemscope]").first["itemtype"]).to eq("https://schema.org/QAPage")
      expect(
        document.css('[itemtype="https://schema.org/Question"] [itemprop="abstract"]'),
      ).to be_empty
    end
  end
end