Skip to content

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

10.2 KB
Raw Blame
import { getOwner } from "@ember/owner";
import { setupTest } from "ember-qunit";
import { module, test } from "qunit";
import sinon from "sinon";
import ChatChannelSubscriptionManager from "discourse/plugins/chat/discourse/lib/chat-channel-subscription-manager";
import ChatChannelThreadSubscriptionManager from "discourse/plugins/chat/discourse/lib/chat-channel-thread-subscription-manager";
import ChatFabricators from "discourse/plugins/chat/discourse/lib/fabricators";

module("Unit | Lib | chat subscription managers", function (hooks) {
  setupTest(hooks);

  hooks.beforeEach(function () {
    const owner = getOwner(this);

    this.fabricators = new ChatFabricators(owner);

    const messageBus = owner.lookup("service:message-bus");
    sinon.stub(messageBus, "subscribe");
    sinon.stub(messageBus, "unsubscribe");
  });

  hooks.afterEach(function () {
    sinon.restore();
  });

  test("channel manager updates model attribution when streaming finishes", function (assert) {
    const channel = this.fabricators.channel();
    const message = this.fabricators.message({ channel, streaming: true });
    channel.messagesManager.addMessages([message]);
    const manager = new ChatChannelSubscriptionManager(this, channel);

    manager.handleEditMessage({
      chat_message: {
        id: message.id,
        streaming: false,
        ai_llm_name: "Model 猫",
      },
    });

    assert.strictEqual(message.aiLlmName, "Model 猫");
  });

  test("thread manager updates model attribution when streaming finishes", function (assert) {
    const channel = this.fabricators.channel();
    const thread = this.fabricators.thread({ channel });
    const message = this.fabricators.message({ channel, streaming: true });
    thread.messagesManager.addMessages([message]);
    const manager = new ChatChannelThreadSubscriptionManager(this, thread);

    manager.handleEditMessage({
      chat_message: {
        id: message.id,
        streaming: false,
        ai_llm_name: "Model 猫",
      },
    });

    assert.strictEqual(message.aiLlmName, "Model 猫");
  });

  test("channel manager syncs uploads when matching staged message is sent", function (assert) {
    const channel = this.fabricators.channel({ id: 11 });
    const manager = new ChatChannelSubscriptionManager(this, channel);
    manager.currentUser = { id: 1 };

    const stagedMessage = this.fabricators.message({
      id: "staged-1",
      channel,
      staged: true,
      processed: false,
      message: "",
      cooked: "",
      user: { id: 1, username: "current_user" },
      uploads: [{ id: 1, url: "/uploads/local.png", width: 16, height: 16 }],
    });
    channel.messagesManager.addMessages([stagedMessage]);

    manager.handleSentMessage({
      type: "sent",
      staged_id: "staged-1",
      chat_message: buildChatMessagePayload({
        id: 99,
        uploads: [
          {
            id: 1,
            url: "/uploads/server.png",
            short_path: "/uploads/short-url/server",
            width: 300,
            height: 200,
          },
        ],
      }),
    });

    assert.strictEqual(channel.messagesManager.messages.length, 1);
    assert.strictEqual(stagedMessage.id, 99);
    assert.false(stagedMessage.staged);
    assert.strictEqual(stagedMessage.uploads[0].url, "/uploads/server.png");
    assert.strictEqual(
      stagedMessage.uploads[0].short_path,
      "/uploads/short-url/server"
    );
  });

  test("thread manager syncs uploads when matching staged message is sent", function (assert) {
    const channel = this.fabricators.channel({ id: 12 });
    const thread = this.fabricators.thread({ id: 222, channel });
    const manager = new ChatChannelThreadSubscriptionManager(this, thread);
    manager.currentUser = { id: 1 };

    const stagedMessage = this.fabricators.message({
      id: "staged-2",
      channel,
      staged: true,
      processed: false,
      message: "",
      cooked: "",
      user: { id: 1, username: "current_user" },
      uploads: [
        { id: 2, url: "/uploads/local-thread.png", width: 20, height: 20 },
      ],
    });
    thread.messagesManager.addMessages([stagedMessage]);

    manager.handleSentMessage({
      type: "sent",
      staged_id: "staged-2",
      chat_message: buildChatMessagePayload({
        id: 109,
        uploads: [
          {
            id: 2,
            url: "/uploads/server-thread.png",
            short_path: "/uploads/short-url/server-thread",
            width: 640,
            height: 480,
          },
        ],
      }),
    });

    assert.strictEqual(thread.messagesManager.messages.length, 1);
    assert.strictEqual(stagedMessage.id, 109);
    assert.false(stagedMessage.staged);
    assert.strictEqual(
      stagedMessage.uploads[0].url,
      "/uploads/server-thread.png"
    );
    assert.strictEqual(
      stagedMessage.uploads[0].short_path,
      "/uploads/short-url/server-thread"
    );
  });

  test("channel manager moves a confirmed message to its server position", function (assert) {
    const channel = this.fabricators.channel({ id: 15 });
    const manager = new ChatChannelSubscriptionManager(this, channel);
    manager.currentUser = { id: 1 };

    const stagedMessage = this.fabricators.message({
      id: "staged-3",
      channel,
      staged: true,
      user: { id: 1, username: "current_user" },
    });
    const laterMessage = this.fabricators.message({
      id: 101,
      channel,
      created_at: "2024-01-01T00:00:01.000Z",
      user: { id: 2, username: "other_user" },
    });
    channel.messagesManager.addMessages([stagedMessage, laterMessage]);

    manager.handleSentMessage({
      type: "sent",
      staged_id: "staged-3",
      chat_message: buildChatMessagePayload({ id: 100, uploads: [] }),
    });

    assert.deepEqual(
      channel.messagesManager.messages.map((message) => message.id),
      [100, 101],
      "the confirmed message moves above the message created after it"
    );
  });

  test("thread manager moves a confirmed message to its server position", function (assert) {
    const channel = this.fabricators.channel({ id: 16 });
    const thread = this.fabricators.thread({ id: 224, channel });
    const manager = new ChatChannelThreadSubscriptionManager(this, thread);
    manager.currentUser = { id: 1 };

    const stagedMessage = this.fabricators.message({
      id: "staged-4",
      channel,
      staged: true,
      user: { id: 1, username: "current_user" },
    });
    const laterMessage = this.fabricators.message({
      id: 111,
      channel,
      created_at: "2024-01-01T00:00:01.000Z",
      user: { id: 2, username: "other_user" },
    });
    thread.messagesManager.addMessages([stagedMessage, laterMessage]);

    manager.handleSentMessage({
      type: "sent",
      staged_id: "staged-4",
      chat_message: buildChatMessagePayload({ id: 110, uploads: [] }),
    });

    assert.deepEqual(
      thread.messagesManager.messages.map((message) => message.id),
      [110, 111],
      "the confirmed message moves above the message created after it"
    );
  });

  test("channel manager keeps deleted messages visible for category moderators", function (assert) {
    const channel = this.fabricators.channel({
      id: 13,
      meta: { can_moderate: true },
    });
    const message = this.fabricators.message({
      id: 201,
      channel,
      user: { id: 2, username: "other_user" },
    });
    channel.messagesManager.addMessages([message]);

    const manager = new ChatChannelSubscriptionManager(this, channel);
    manager.currentUser = { id: 1, staff: false };

    manager.handleDeleteMessage({
      deleted_id: message.id,
      deleted_at: "2026-03-11T10:00:00.000Z",
      deleted_by_id: 1,
    });

    assert.strictEqual(channel.messagesManager.messages.length, 1);
    assert.strictEqual(message.deletedById, 1);
    assert.strictEqual(message.deletedAt, "2026-03-11T10:00:00.000Z");
    assert.false(message.expanded);
  });

  test("thread manager keeps deleted messages visible for category moderators", function (assert) {
    const channel = this.fabricators.channel({
      id: 14,
      meta: { can_moderate: true },
    });
    const thread = this.fabricators.thread({ id: 223, channel });
    const message = this.fabricators.message({
      id: 202,
      channel,
      user: { id: 2, username: "other_user" },
    });
    thread.messagesManager.addMessages([message]);

    const manager = new ChatChannelThreadSubscriptionManager(this, thread);
    manager.currentUser = { id: 1, staff: false };

    manager.handleDeleteMessage({
      deleted_id: message.id,
      deleted_at: "2026-03-11T10:00:00.000Z",
      deleted_by_id: 1,
    });

    assert.strictEqual(thread.messagesManager.messages.length, 1);
    assert.strictEqual(message.deletedById, 1);
    assert.strictEqual(message.deletedAt, "2026-03-11T10:00:00.000Z");
    assert.false(message.expanded);
  });

  for (const [label, build] of [
    ["channel", (channel) => [channel, ChatChannelSubscriptionManager]],
    [
      "thread",
      (channel, fabricators) => [
        fabricators.thread({ channel }),
        ChatChannelThreadSubscriptionManager,
      ],
    ],
  ]) {
    test(`${label} manager notifies before removing a message deleted for this user`, function (assert) {
      const channel = this.fabricators.channel();
      const [model, Manager] = build(channel, this.fabricators);
      const message = this.fabricators.message({
        channel,
        user: { id: 2, username: "other_user" },
      });
      model.messagesManager.addMessages([message]);

      const onRemoveMessage = sinon.spy((removed) =>
        assert.true(
          model.messagesManager.messages.includes(removed),
          "still in the list when notified"
        )
      );
      const manager = new Manager(this, model, { onRemoveMessage });
      manager.currentUser = { id: 1, staff: false };

      manager.handleDeleteMessage({
        deleted_id: message.id,
        deleted_at: "2026-03-11T10:00:00.000Z",
      });

      assert.true(onRemoveMessage.calledOnceWith(message));
      assert.strictEqual(model.messagesManager.messages.length, 0);
    });
  }
});

function buildChatMessagePayload({ id, uploads }) {
  return {
    id,
    message: "",
    cooked: "",
    excerpt: "",
    created_at: "2024-01-01T00:00:00.000Z",
    user: {
      id: 1,
      username: "current_user",
    },
    uploads,
  };
}