Skip to content

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

12.4 KB
Raw Blame
import { settled, waitUntil } from "@ember/test-helpers";
import { setupTest } from "ember-qunit";
import { module, test } from "qunit";
import { translateResults } from "discourse/lib/search";
import pretender, { response } from "discourse/tests/helpers/create-pretender";

function searchResults(ids) {
  return {
    posts: ids.map((id) => ({ id, topic_id: id, blurb: "Battery expansion" })),
    topics: ids.map((id) => ({ id, title: "Battery expansion" })),
    grouped_search_result: {},
  };
}

module("Unit | Service | ai-search-session", function (hooks) {
  setupTest(hooks);

  module("with a deferred answer", function (nestedHooks) {
    let replies;
    let tabReports;

    nestedHooks.beforeEach(function () {
      replies = [];
      tabReports = [];
      this.session = this.owner.lookup("service:ai-search-session");
      this.owner.lookup("service:search").activeGlobalSearchTerm =
        "in:messages";

      pretender.get("/search/query", () => response(searchResults([1])));
      pretender.post("/discourse-ai/discoveries/reply", (request) => {
        const body = new URLSearchParams(request.requestBody);
        replies.push(Object.fromEntries(body));
        return response({
          request_id: body.get("request_id"),
          ask_log_id: 7,
          ...(replies.length === 1 && { answer_deferred: true }),
        });
      });
      pretender.put("/discourse-ai/discoveries/tabs", (request) => {
        tabReports.push(
          Object.fromEntries(new URLSearchParams(request.requestBody))
        );
        return response({});
      });
    });

    nestedHooks.afterEach(function () {
      this.owner
        .lookup("service:discobot-discoveries")
        .cancelDiscoveryTimeout();
    });

    test("opens on results and requests nothing further", async function (assert) {
      this.session.start("in:messages");
      await settled();

      assert.strictEqual(this.session.selectedTab, "topics");
      assert.strictEqual(replies.length, 1, "only the search itself was sent");
      assert.strictEqual(replies[0].defer_if_precise, "true");
      assert.false(
        this.session.discoveries.loadingDiscoveries,
        "nothing is shown as being generated"
      );
    });

    test("requests the answer on the search's log when Ask is opened", async function (assert) {
      this.session.start("in:messages");
      await settled();

      this.session.selectTab("ask");
      assert.true(
        this.session.discoveries.loadingDiscoveries,
        "the answer is now on its way"
      );
      await waitUntil(() => replies.length === 2);

      assert.strictEqual(replies[1].deferred_ask_log_id, "7");
      assert.strictEqual(replies[1].defer_if_precise, undefined);

      this.session.selectTab("topics");
      this.session.selectTab("ask");
      this.session.discoveries.cancelDiscoveryTimeout();
      await settled();
      assert.strictEqual(replies.length, 2, "it is requested only once");
    });

    test("reports when the tab opened and the first result opened", async function (assert) {
      this.session.start("in:messages");
      await settled();

      this.session.recordResultClick("in:messages");
      this.session.recordResultClick("in:messages");
      await settled();

      const opened = tabReports.find((report) => report.tab_opened);
      assert.true(Number(opened.tab_opened_after_ms) >= 0);
      assert.deepEqual(
        tabReports
          .filter((report) => report.result_clicked_tab)
          .map((report) => report.result_clicked_tab),
        ["topics"],
        "only the first click is reported"
      );
    });

    test("ignores a click once the term no longer matches the search", async function (assert) {
      this.session.start("in:messages");
      await settled();

      this.session.recordResultClick("something else");
      await settled();

      assert.false(tabReports.some((report) => report.result_clicked_tab));
    });
  });

  test("reports when an answer is first seen on the Ask tab", async function (assert) {
    const session = this.owner.lookup("service:ai-search-session");
    const discoveries = this.owner.lookup("service:discobot-discoveries");
    const tabReports = [];
    this.owner.lookup("service:search").activeGlobalSearchTerm = "password";

    pretender.get("/search/query", () => response(searchResults([1])));
    pretender.post("/discourse-ai/discoveries/reply", (request) =>
      response({
        request_id: new URLSearchParams(request.requestBody).get("request_id"),
        ask_log_id: 7,
      })
    );
    pretender.put("/discourse-ai/discoveries/tabs", (request) => {
      tabReports.push(
        Object.fromEntries(new URLSearchParams(request.requestBody))
      );
      return response({});
    });

    const seen = () => tabReports.filter((r) => r.answer_seen_after_ms);

    session.start("password");
    await waitUntil(() => session.selectedTab);
    assert.strictEqual(session.selectedTab, "topics");

    session.onDiscovery({
      query: "password",
      request_id: discoveries.activeRequestId,
      ai_discover_reply: "Reset it from your profile.",
    });
    discoveries.cancelDiscoveryTimeout();
    discoveries.smoothStreamer.resetStreaming();
    await waitUntil(() => tabReports.some((report) => report.tab_opened));
    assert.strictEqual(seen().length, 0, "not while another tab is showing");

    session.selectTab("ask");
    session.selectTab("topics");
    session.selectTab("ask");
    await waitUntil(() => seen().length > 0);
    await settled();
    assert.strictEqual(seen().length, 1, "once the reader is on the answer");
  });

  test("keeps original matches when a larger rewrite result omits one", async function (assert) {
    const session = this.owner.lookup("service:ai-search-session");
    const search = this.owner.lookup("service:search");
    const discoveries = this.owner.lookup("service:discobot-discoveries");
    const original = await translateResults(searchResults([1, 64334]));
    session.query = "Batterie erweiterung";
    session.scope = { key: "category:1" };
    session.selectedTab = "topics";
    session.topicsResults = original;
    session.contextResults = original;
    search.activeGlobalSearchTerm = session.query;
    search.results = original;
    discoveries.activeRequestId = "current-request";

    pretender.get("/search/query", () => response(searchResults([1, 2, 3])));

    session.onDiscovery({
      query: session.query,
      request_id: discoveries.activeRequestId,
      phase: "rewritten",
      keyword_query: "battery expansion",
    });
    discoveries.cancelDiscoveryTimeout();
    await settled();

    assert.deepEqual(
      search.results.posts.map((post) => post.id),
      [1, 64334],
      "the menu preserves original keyword matches"
    );
    assert.deepEqual(
      search.results.resultTypes[0]?.results.map((post) => post.id),
      [1, 64334],
      "the rendered topic group uses the chosen matches"
    );

    session.selectTab("context");
    assert.deepEqual(
      search.results.posts.map((post) => post.id),
      [1, 64334],
      "scoped keyword results preserve original matches too"
    );
  });

  test("accepts a rewrite that retains all original matches", async function (assert) {
    const session = this.owner.lookup("service:ai-search-session");
    const search = this.owner.lookup("service:search");
    const discoveries = this.owner.lookup("service:discobot-discoveries");
    const original = await translateResults(searchResults([1, 64334]));
    session.query = "Batterie erweiterung";
    session.scope = { key: "category:1" };
    session.selectedTab = "topics";
    session.topicsResults = original;
    session.contextResults = original;
    search.activeGlobalSearchTerm = session.query;
    search.results = original;
    discoveries.activeRequestId = "current-request";

    pretender.get("/search/query", () =>
      response(searchResults([1, 2, 64334]))
    );

    session.onDiscovery({
      query: session.query,
      request_id: discoveries.activeRequestId,
      phase: "rewritten",
      keyword_query: "battery expansion",
    });
    discoveries.cancelDiscoveryTimeout();
    await settled();

    assert.deepEqual(
      search.results.posts.map((post) => post.id),
      [1, 2, 64334],
      "the menu preserves original keyword matches"
    );
    assert.deepEqual(
      search.results.resultTypes[0]?.results.map((post) => post.id),
      [1, 2, 64334],
      "the rendered topic group uses the chosen matches"
    );

    session.selectTab("context");
    assert.deepEqual(
      search.results.posts.map((post) => post.id),
      [1, 2, 64334],
      "scoped keyword results preserve original matches too"
    );
  });

  test("uses rewritten matches when the original query finds nothing", async function (assert) {
    const session = this.owner.lookup("service:ai-search-session");
    const search = this.owner.lookup("service:search");
    const discoveries = this.owner.lookup("service:discobot-discoveries");
    const original = await translateResults(searchResults([]));
    session.query = "Batterie erweiterung";
    session.scope = { key: "category:1" };
    session.selectedTab = "topics";
    session.topicsResults = original;
    session.contextResults = original;
    search.activeGlobalSearchTerm = session.query;
    search.results = original;
    discoveries.activeRequestId = "current-request";

    pretender.get("/search/query", () => response(searchResults([1, 2])));

    session.onDiscovery({
      query: session.query,
      request_id: discoveries.activeRequestId,
      phase: "rewritten",
      keyword_query: "battery expansion",
    });
    discoveries.cancelDiscoveryTimeout();
    await settled();

    assert.deepEqual(
      search.results.posts.map((post) => post.id),
      [1, 2],
      "the menu preserves original keyword matches"
    );
    assert.deepEqual(
      search.results.resultTypes[0]?.results.map((post) => post.id),
      [1, 2],
      "the rendered topic group uses the chosen matches"
    );

    session.selectTab("context");
    assert.deepEqual(
      search.results.posts.map((post) => post.id),
      [1, 2],
      "scoped keyword results preserve original matches too"
    );
  });

  test("opens on results when a deferred reply lands after the wait but before the results", async function (assert) {
    const session = this.owner.lookup("service:ai-search-session");
    const query = "how do I get a refund for my order?";
    this.owner.lookup("service:search").activeGlobalSearchTerm = query;

    // the reply outlasts the wait for it, and the results outlast the reply
    pretender.get("/search/query", () => response(searchResults([1])), 1400);
    pretender.post("/discourse-ai/discoveries/reply", (request) => {
      const reply = response({
        request_id: new URLSearchParams(request.requestBody).get("request_id"),
        ask_log_id: 7,
        answer_deferred: true,
      });
      return new Promise((resolve) => setTimeout(resolve, 1150, reply));
    });
    pretender.put("/discourse-ai/discoveries/tabs", () => response({}));

    session.start(query);
    await waitUntil(() => session.selectedTab, { timeout: 5000 });

    assert.notStrictEqual(
      session.selectedTab,
      "ask",
      "no answer was queued, so the search does not open on one"
    );
  });

  test("asks again for a deferred answer whose request failed", async function (assert) {
    const session = this.owner.lookup("service:ai-search-session");
    const discoveries = this.owner.lookup("service:discobot-discoveries");
    const replies = [];
    this.owner.lookup("service:search").activeGlobalSearchTerm = "in:messages";

    pretender.get("/search/query", () => response(searchResults([1])));
    pretender.post("/discourse-ai/discoveries/reply", (request) => {
      const body = new URLSearchParams(request.requestBody);
      replies.push(Object.fromEntries(body));
      if (replies.length === 2) {
        return response(429, {});
      }
      return response({
        request_id: body.get("request_id"),
        ask_log_id: 7,
        ...(replies.length === 1 && { answer_deferred: true }),
      });
    });
    pretender.put("/discourse-ai/discoveries/tabs", () => response({}));

    session.start("in:messages");
    await settled();

    session.selectTab("ask");
    await waitUntil(() => discoveries.errorMessage);
    session.selectTab("topics");
    session.selectTab("ask");
    await waitUntil(() => replies.length === 3);
    discoveries.cancelDiscoveryTimeout();

    assert.strictEqual(
      replies[2].deferred_ask_log_id,
      "7",
      "the retry still answers on the search's log"
    );
  });
});