Skip to content

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

7.0 KB
Raw Blame
import { getOwner } from "@ember/owner";
import { clearRender, render } from "@ember/test-helpers";
import { module, test } from "qunit";
import CoreFabricators from "discourse/lib/fabricators";
import { setupRenderingTest } from "discourse/tests/helpers/component-test";
import ChatMessage from "discourse/plugins/chat/discourse/components/chat-message";
import ChatFabricators from "discourse/plugins/chat/discourse/lib/fabricators";

module("Component | ChatMessage", function (hooks) {
  setupRenderingTest(hooks);

  test("Confirmation messages render their body once inside the card", async function (assert) {
    this.message = new ChatFabricators(getOwner(this)).message({
      cooked: "<p>Changing name from Storm → Wind &amp; Rain</p>",
      blocks: [
        {
          type: "confirmation",
          title: "Edit category",
          cooked_question: "<p>Do you want to make this change?</p>",
          parameters: [],
          elements: [
            { type: "button", action_id: "approve", text: { text: "Yes" } },
          ],
        },
      ],
    });

    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert
      .dom(".chat-confirmation__description")
      .hasText(
        "Changing name from Storm → Wind & Rain",
        "renders the change inside the card"
      );
    assert
      .dom(".chat-message-content > .chat-message-text")
      .doesNotExist("does not repeat the body outside the card");
  });

  test("Message with edits", async function (assert) {
    this.message = new ChatFabricators(getOwner(this)).message({
      edited: true,
    });
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert.dom(".chat-message-edited").exists("has the correct css class");
  });

  test("Deleted message", async function (assert) {
    this.message = new ChatFabricators(getOwner(this)).message({
      user: this.currentUser,
      deleted_at: moment(),
    });
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert
      .dom(".chat-message-text.-deleted .chat-message-expand")
      .exists("has the correct css class and expand button within");
  });

  test("Hidden message", async function (assert) {
    this.message = new ChatFabricators(getOwner(this)).message({
      hidden: true,
    });
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert
      .dom(".chat-message-text.-hidden .chat-message-expand")
      .exists("has the correct css class and expand button within");
  });

  test("Message by a bot", async function (assert) {
    this.message = new ChatFabricators(getOwner(this)).message({
      message: "what <mark>test</mark>",
      user: new CoreFabricators(getOwner(this)).user({ id: -10 }),
    });
    await this.message.cook();
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert.dom(".chat-message-container.is-bot").exists("has the bot class");
  });

  test("Message with mark html tag", async function (assert) {
    this.message = new ChatFabricators(getOwner(this)).message({
      message: "what <mark>test</mark>",
    });
    await this.message.cook();
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert
      .dom(".chat-message-text")
      .includesHtml("<p>what <mark>test</mark></p>");
  });

  test("Message with reply", async function (assert) {
    this.message = new ChatFabricators(getOwner(this)).message({
      inReplyTo: new ChatFabricators(getOwner(this)).message(),
    });
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert
      .dom(".chat-message-container.has-reply")
      .exists("has the correct css class");
  });

  test("Non-interactive message", async function (assert) {
    this.message = new ChatFabricators(getOwner(this)).message();
    await render(
      <template>
        <ChatMessage @interactive={{false}} @message={{this.message}} />
      </template>
    );

    assert.dom(".chat-message-container.-not-interactive").exists();
  });

  test("Action messages render without user info and break message grouping", async function (assert) {
    const fabricators = new ChatFabricators(getOwner(this));
    const channel = fabricators.channel();
    const user = new CoreFabricators(getOwner(this)).user();
    const actionMessage = fabricators.message({
      channel,
      user,
      is_action: true,
      cooked: `<p><em class="chat-message-action">${user.username} waves</em></p>`,
      created_at: "2026-07-29T12:00:00Z",
    });
    const nextMessage = fabricators.message({
      channel,
      user,
      cooked: "<p>Hello again</p>",
      created_at: "2026-07-29T12:01:00Z",
    });

    channel.messagesManager.addMessages([actionMessage, nextMessage]);
    actionMessage.manager = channel.messagesManager;
    nextMessage.manager = channel.messagesManager;

    this.message = actionMessage;
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert.dom(".chat-message-avatar").doesNotExist();
    assert.dom(".chat-message-info").doesNotExist();
    assert.dom(".chat-message-left-gutter").exists();

    await clearRender();
    this.message = nextMessage;
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert.dom(".chat-message-avatar").exists();
    assert.dom(".chat-message-info").exists();
  });

  test("Message with streaming", async function (assert) {
    // admin
    this.currentUser.admin = true;

    this.message = new ChatFabricators(getOwner(this)).message({
      inReplyTo: new ChatFabricators(getOwner(this)).message(),
      streaming: true,
    });
    await this.message.cook();
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert
      .dom(".stop-streaming-btn")
      .exists("when admin, it has the stop streaming button");

    await clearRender();

    // not admin - not replying to current user
    this.currentUser.admin = false;

    this.message = new ChatFabricators(getOwner(this)).message({
      inReplyTo: new ChatFabricators(getOwner(this)).message(),
      streaming: true,
    });
    await this.message.cook();
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert
      .dom(".stop-streaming-btn")
      .doesNotExist("when admin, it doesn't have the stop streaming button");

    await clearRender();

    // not admin - replying to current user
    this.currentUser.admin = false;

    this.message = new ChatFabricators(getOwner(this)).message({
      inReplyTo: new ChatFabricators(getOwner(this)).message({
        user: this.currentUser,
      }),
      streaming: true,
    });
    await this.message.cook();
    await render(
      <template><ChatMessage @message={{this.message}} /></template>
    );

    assert
      .dom(".stop-streaming-btn")
      .exists(
        "when replying to current user, it has the stop streaming button"
      );
  });
});