feat: show call participants in room list (Discord-style)

2026-05-10 14:25:35 +02:00
parent b797925316
commit 3da363517f
4610 changed files with 827237 additions and 1 deletions
@@ -0,0 +1,376 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import { type Mocked, mocked } from "jest-mock";
+import {
+    EventStatus,
+    EventTimeline,
+    EventType,
+    type MatrixClient,
+    type MatrixEvent,
+    PendingEventOrdering,
+    RelationType,
+    Room,
+} from "matrix-js-sdk/src/matrix";
+
+import { MessagePreviewStore } from "../../../../src/stores/message-preview";
+import { mkEvent, mkMessage, mkReaction, setupAsyncStoreWithClient, stubClient } from "../../../test-utils";
+import { DefaultTagID } from "../../../../src/stores/room-list-v3/skip-list/tag";
+import { mkThread } from "../../../test-utils/threads";
+
+describe("MessagePreviewStore", () => {
+    let client: Mocked<MatrixClient>;
+    let room: Room;
+    let nonRenderedRoom: Room;
+    let store: MessagePreviewStore;
+
+    async function addEvent(
+        store: MessagePreviewStore,
+        room: Room,
+        event: MatrixEvent,
+        fireAction = true,
+    ): Promise<void> {
+        room.addLiveEvents([event], { addToState: true });
+        if (fireAction) {
+            // @ts-ignore private access
+            await store.onAction({
+                action: "MatrixActions.Room.timeline",
+                event,
+                isLiveEvent: true,
+                isLiveUnfilteredRoomTimelineEvent: true,
+                room,
+            });
+        }
+    }
+
+    async function addPendingEvent(
+        store: MessagePreviewStore,
+        room: Room,
+        event: MatrixEvent,
+        fireAction = true,
+    ): Promise<void> {
+        room.addPendingEvent(event, "txid");
+        if (fireAction) {
+            // @ts-ignore private access
+            await store.onLocalEchoUpdated(event, room);
+        }
+    }
+
+    async function updatePendingEvent(event: MatrixEvent, eventStatus: EventStatus, fireAction = true): Promise<void> {
+        room.updatePendingEvent(event, eventStatus);
+        if (fireAction) {
+            // @ts-ignore private access
+            await store.onLocalEchoUpdated(event, room);
+        }
+    }
+
+    beforeEach(async () => {
+        client = mocked(stubClient());
+        room = new Room("!roomId:server", client, client.getSafeUserId(), {
+            pendingEventOrdering: PendingEventOrdering.Detached,
+        });
+        nonRenderedRoom = new Room("!roomId2:server", client, client.getSafeUserId(), {
+            pendingEventOrdering: PendingEventOrdering.Detached,
+        });
+        mocked(client.getRoom).mockReturnValue(room);
+
+        store = MessagePreviewStore.testInstance();
+        await store.start();
+        await setupAsyncStoreWithClient(store, client);
+    });
+
+    it("should ignore edits for events other than the latest one", async () => {
+        const firstMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "First message",
+        });
+        await addEvent(store, room, firstMessage, false);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: First message"`,
+        );
+
+        const secondMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "Second message",
+        });
+        await addEvent(store, room, secondMessage);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: Second message"`,
+        );
+
+        const firstMessageEdit = mkEvent({
+            event: true,
+            type: EventType.RoomMessage,
+            user: "@sender:server",
+            room: room.roomId,
+            content: {
+                "body": "* First Message Edit",
+                "m.new_content": {
+                    body: "First Message Edit",
+                },
+                "m.relates_to": {
+                    rel_type: RelationType.Replace,
+                    event_id: firstMessage.getId()!,
+                },
+            },
+        });
+        await addEvent(store, room, firstMessageEdit);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: Second message"`,
+        );
+
+        const secondMessageEdit = mkEvent({
+            event: true,
+            type: EventType.RoomMessage,
+            user: "@sender:server",
+            room: room.roomId,
+            content: {
+                "body": "* Second Message Edit",
+                "m.new_content": {
+                    body: "Second Message Edit",
+                },
+                "m.relates_to": {
+                    rel_type: RelationType.Replace,
+                    event_id: secondMessage.getId()!,
+                },
+            },
+        });
+        await addEvent(store, room, secondMessageEdit);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: Second Message Edit"`,
+        );
+    });
+
+    it("should not display a redacted edit", async () => {
+        const firstMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "First message",
+        });
+        await addEvent(store, room, firstMessage, false);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: First message"`,
+        );
+
+        const secondMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "Second message",
+        });
+        await addEvent(store, room, secondMessage);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: Second message"`,
+        );
+
+        const secondMessageEdit = mkEvent({
+            event: true,
+            type: EventType.RoomMessage,
+            user: "@sender:server",
+            room: room.roomId,
+            content: {
+                "body": "* Second Message Edit",
+                "m.new_content": {
+                    body: "Second Message Edit",
+                },
+                "m.relates_to": {
+                    rel_type: RelationType.Replace,
+                    event_id: secondMessage.getId()!,
+                },
+            },
+        });
+        await addEvent(store, room, secondMessageEdit);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: Second Message Edit"`,
+        );
+
+        secondMessage.makeRedacted(secondMessage, room);
+
+        await addEvent(store, room, secondMessage);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: First message"`,
+        );
+    });
+
+    it("should ignore edits to unknown events", async () => {
+        await expect(store.getPreviewForRoom(room, DefaultTagID.DM)).resolves.toBeNull();
+
+        const firstMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "First message",
+        });
+        await addEvent(store, room, firstMessage, true);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.DM))?.text).toMatchInlineSnapshot(
+            `"@sender:server: First message"`,
+        );
+
+        const randomEdit = mkEvent({
+            event: true,
+            type: EventType.RoomMessage,
+            user: "@sender:server",
+            room: room.roomId,
+            content: {
+                "body": "* Second Message Edit",
+                "m.new_content": {
+                    body: "Second Message Edit",
+                },
+                "m.relates_to": {
+                    rel_type: RelationType.Replace,
+                    event_id: "!other-event:server",
+                },
+            },
+        });
+        await addEvent(store, room, randomEdit);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: First message"`,
+        );
+    });
+
+    it("should generate correct preview for message events in DMs", async () => {
+        room.getLiveTimeline().getState(EventTimeline.FORWARDS)!.getJoinedMemberCount = jest.fn().mockReturnValue(2);
+
+        await expect(store.getPreviewForRoom(room, DefaultTagID.DM)).resolves.toBeNull();
+
+        const firstMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "First message",
+        });
+        await addEvent(store, room, firstMessage);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.DM))?.text).toMatchInlineSnapshot(
+            `"@sender:server: First message"`,
+        );
+
+        const secondMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "Second message",
+        });
+        await addEvent(store, room, secondMessage);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.DM))?.text).toMatchInlineSnapshot(
+            `"@sender:server: Second message"`,
+        );
+    });
+
+    it("should generate the correct preview for a reaction", async () => {
+        const firstMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "First message",
+        });
+        await addEvent(store, room, firstMessage);
+
+        const reaction = mkReaction(firstMessage);
+        await addEvent(store, room, reaction);
+
+        const preview = await store.getPreviewForRoom(room, DefaultTagID.Untagged);
+        expect(preview).toBeDefined();
+        expect(preview?.isThreadReply).toBe(false);
+        expect(preview?.text).toMatchInlineSnapshot(`"@sender:server reacted 🙃 to First message"`);
+    });
+
+    it("should generate the correct preview for a reaction on a thread root", async () => {
+        const { rootEvent, thread } = mkThread({
+            room,
+            client,
+            authorId: client.getSafeUserId(),
+            participantUserIds: [client.getSafeUserId()],
+        });
+        await addEvent(store, room, rootEvent);
+
+        const reaction = mkReaction(rootEvent, { ts: 42 });
+        reaction.setThread(thread);
+        await addEvent(store, room, reaction);
+
+        const preview = await store.getPreviewForRoom(room, DefaultTagID.Untagged);
+        expect(preview).toBeDefined();
+        expect(preview?.isThreadReply).toBe(false);
+        expect(preview?.text).toContain("You reacted 🙃 to root event message");
+    });
+
+    it("should handle local echos correctly", async () => {
+        const firstMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "First message",
+        });
+
+        await addEvent(store, room, firstMessage);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: First message"`,
+        );
+
+        const secondMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: room.roomId,
+            msg: "Second message",
+        });
+        secondMessage.status = EventStatus.NOT_SENT;
+
+        await addPendingEvent(store, room, secondMessage);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: Second message"`,
+        );
+
+        await updatePendingEvent(secondMessage, EventStatus.CANCELLED);
+
+        expect((await store.getPreviewForRoom(room, DefaultTagID.Untagged))?.text).toMatchInlineSnapshot(
+            `"@sender:server: First message"`,
+        );
+    });
+
+    it("should not generate previews for rooms not rendered", async () => {
+        const firstMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: nonRenderedRoom.roomId,
+            msg: "First message",
+        });
+
+        await addEvent(store, room, firstMessage);
+
+        const secondMessage = mkMessage({
+            user: "@sender:server",
+            event: true,
+            room: nonRenderedRoom.roomId,
+            msg: "Second message",
+        });
+        secondMessage.status = EventStatus.NOT_SENT;
+
+        await addPendingEvent(store, room, secondMessage);
+
+        // @ts-ignore private access
+        expect(store.previews.has(nonRenderedRoom.roomId)).toBeFalsy();
+    });
+});
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+import { Room } from "matrix-js-sdk/src/matrix";
+import { mocked } from "jest-mock";
+
+import { LegacyCallAnswerEventPreview } from "../../../../../src/stores/message-preview/previews/LegacyCallAnswerEventPreview";
+import { DefaultTagID } from "../../../../../src/stores/room-list-v3/skip-list/tag";
+import { mkEvent, stubClient } from "../../../../test-utils";
+import { MatrixClientPeg } from "../../../../../src/MatrixClientPeg";
+
+describe("LegacyCallAnswerEventPreview", () => {
+    const preview = new LegacyCallAnswerEventPreview();
+    const roomId = "!room:example.com";
+
+    beforeAll(() => {
+        stubClient();
+    });
+
+    describe("getTextFor", () => {
+        describe("in a room that should be prefixed (non-DM)", () => {
+            // Default stub: getRoom returns null → shouldPrefixMessagesIn returns true
+
+            it("returns 'You joined the call' when the event is from self", () => {
+                const selfUserId = MatrixClientPeg.safeGet().getSafeUserId();
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.answer",
+                    content: {},
+                    user: selfUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event)).toBe("You joined the call");
+            });
+
+            it("returns '<sender> joined the call' when the event is from someone else", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.answer",
+                    content: {},
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event)).toBe(`${otherUserId} joined the call`);
+            });
+        });
+
+        describe("in a DM room (should not be prefixed)", () => {
+            beforeEach(() => {
+                const cli = MatrixClientPeg.safeGet();
+                // Make a 1:1 room so shouldPrefixMessagesIn returns false
+                const room = new Room(roomId, cli, cli.getSafeUserId());
+                jest.spyOn(room.currentState, "getJoinedMemberCount").mockReturnValue(2);
+                mocked(cli.getRoom).mockReturnValue(room);
+            });
+
+            afterEach(() => {
+                mocked(MatrixClientPeg.safeGet().getRoom).mockReturnValue(null);
+            });
+
+            it("returns 'Call in progress' regardless of sender", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.answer",
+                    content: {},
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event, DefaultTagID.DM)).toBe("Call in progress");
+            });
+        });
+    });
+});
@@ -0,0 +1,77 @@
+/*
+ * Copyright 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+import { Room } from "matrix-js-sdk/src/matrix";
+import { mocked } from "jest-mock";
+
+import { LegacyCallHangupEvent } from "../../../../../src/stores/message-preview/previews/LegacyCallHangupEvent";
+import { DefaultTagID } from "../../../../../src/stores/room-list-v3/skip-list/tag";
+import { mkEvent, stubClient } from "../../../../test-utils";
+import { MatrixClientPeg } from "../../../../../src/MatrixClientPeg";
+
+describe("LegacyCallHangupEvent", () => {
+    const preview = new LegacyCallHangupEvent();
+    const roomId = "!room:example.com";
+
+    beforeAll(() => {
+        stubClient();
+    });
+
+    describe("getTextFor", () => {
+        describe("in a room that should be prefixed (non-DM)", () => {
+            it("returns 'You ended the call' when the event is from self", () => {
+                const selfUserId = MatrixClientPeg.safeGet().getSafeUserId();
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.hangup",
+                    content: {},
+                    user: selfUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event)).toBe("You ended the call");
+            });
+
+            it("returns '<sender> ended the call' when the event is from someone else", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.hangup",
+                    content: {},
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event)).toBe(`${otherUserId} ended the call`);
+            });
+        });
+
+        describe("in a DM room (should not be prefixed)", () => {
+            beforeEach(() => {
+                const cli = MatrixClientPeg.safeGet();
+                // Make a 1:1 room so shouldPrefixMessagesIn returns false
+                const room = new Room(roomId, cli, cli.getSafeUserId());
+                jest.spyOn(room.currentState, "getJoinedMemberCount").mockReturnValue(2);
+                mocked(cli.getRoom).mockReturnValue(room);
+            });
+
+            afterEach(() => {
+                mocked(MatrixClientPeg.safeGet().getRoom).mockReturnValue(null);
+            });
+
+            it("returns 'Call ended' regardless of sender", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.hangup",
+                    content: {},
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event, DefaultTagID.DM)).toBe("Call ended");
+            });
+        });
+    });
+});
@@ -0,0 +1,89 @@
+/*
+ * Copyright 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+import { Room } from "matrix-js-sdk/src/matrix";
+import { mocked } from "jest-mock";
+
+import { LegacyCallInviteEventPreview } from "../../../../../src/stores/message-preview/previews/LegacyCallInviteEventPreview";
+import { DefaultTagID } from "../../../../../src/stores/room-list-v3/skip-list/tag";
+import { mkEvent, stubClient } from "../../../../test-utils";
+import { MatrixClientPeg } from "../../../../../src/MatrixClientPeg";
+
+describe("LegacyCallInviteEventPreview", () => {
+    const preview = new LegacyCallInviteEventPreview();
+    const roomId = "!room:example.com";
+
+    beforeAll(() => {
+        stubClient();
+    });
+
+    describe("getTextFor", () => {
+        describe("in a room that should be prefixed (non-DM)", () => {
+            it("returns 'You started a call' when the event is from self", () => {
+                const selfUserId = MatrixClientPeg.safeGet().getSafeUserId();
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.invite",
+                    content: {},
+                    user: selfUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event)).toBe("You started a call");
+            });
+
+            it("returns '<sender> started a call' when the event is from someone else", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.invite",
+                    content: {},
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event)).toBe(`${otherUserId} started a call`);
+            });
+        });
+
+        describe("in a DM room (should not be prefixed)", () => {
+            beforeEach(() => {
+                const cli = MatrixClientPeg.safeGet();
+                // Make a 1:1 room so shouldPrefixMessagesIn returns false
+                const room = new Room(roomId, cli, cli.getSafeUserId());
+                jest.spyOn(room.currentState, "getJoinedMemberCount").mockReturnValue(2);
+                mocked(cli.getRoom).mockReturnValue(room);
+            });
+
+            afterEach(() => {
+                mocked(MatrixClientPeg.safeGet().getRoom).mockReturnValue(null);
+            });
+
+            it("returns 'Waiting for answer' when the event is from self", () => {
+                const selfUserId = MatrixClientPeg.safeGet().getSafeUserId();
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.invite",
+                    content: {},
+                    user: selfUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event, DefaultTagID.DM)).toBe("Waiting for answer");
+            });
+
+            it("returns '<sender> is calling' when the event is from someone else", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.call.invite",
+                    content: {},
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event, DefaultTagID.DM)).toBe(`${otherUserId} is calling`);
+            });
+        });
+    });
+});
@@ -0,0 +1,76 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import { RelationType } from "matrix-js-sdk/src/matrix";
+
+// Import directly from the file to avoid circular dependencies with MessagePreviewStore
+import { MessageEventPreview } from "../../../../../src/stores/message-preview/previews/MessageEventPreview";
+import { mkEvent, stubClient } from "../../../../test-utils";
+
+describe("MessageEventPreview", () => {
+    const preview = new MessageEventPreview();
+    const userId = "@user:example.com";
+
+    beforeAll(() => {
+        stubClient();
+    });
+
+    describe("getTextFor", () => {
+        it("when called with an event with empty content should return null", () => {
+            const event = mkEvent({
+                event: true,
+                content: {},
+                user: userId,
+                type: "m.room.message",
+            });
+            expect(preview.getTextFor(event)).toBeNull();
+        });
+
+        it("when called with an event with empty body should return null", () => {
+            const event = mkEvent({
+                event: true,
+                content: {
+                    body: "",
+                },
+                user: userId,
+                type: "m.room.message",
+            });
+            expect(preview.getTextFor(event)).toBeNull();
+        });
+
+        it("when called with an event with body should return »user: body«", () => {
+            const event = mkEvent({
+                event: true,
+                content: {
+                    body: "test body",
+                },
+                user: userId,
+                type: "m.room.message",
+            });
+            expect(preview.getTextFor(event)).toBe(`${userId}: test body`);
+        });
+
+        it("when called for a replaced event with new content should return the new content body", () => {
+            const event = mkEvent({
+                event: true,
+                content: {
+                    ["m.new_content"]: {
+                        body: "test new content body",
+                    },
+                    ["m.relates_to"]: {
+                        rel_type: RelationType.Replace,
+                        event_id: "$asd123",
+                    },
+                },
+                user: userId,
+                type: "m.room.message",
+            });
+            expect(preview.getTextFor(event)).toBe(`${userId}: test new content body`);
+        });
+    });
+});
@@ -0,0 +1,37 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2021 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import { type MatrixClient } from "matrix-js-sdk/src/matrix";
+
+// Import directly from the file to avoid circular dependencies with MessagePreviewStore
+import { PollStartEventPreview } from "../../../../../src/stores/message-preview/previews/PollStartEventPreview";
+import { MatrixClientPeg } from "../../../../../src/MatrixClientPeg";
+import { makePollStartEvent } from "../../../../test-utils";
+
+jest.spyOn(MatrixClientPeg, "get").mockReturnValue({
+    getUserId: () => "@me:example.com",
+    getSafeUserId: () => "@me:example.com",
+} as unknown as MatrixClient);
+jest.spyOn(MatrixClientPeg, "safeGet").mockReturnValue({
+    getUserId: () => "@me:example.com",
+    getSafeUserId: () => "@me:example.com",
+} as unknown as MatrixClient);
+
+describe("PollStartEventPreview", () => {
+    it("shows the question for a poll I created", async () => {
+        const pollStartEvent = makePollStartEvent("My Question", "@me:example.com");
+        const preview = new PollStartEventPreview();
+        expect(preview.getTextFor(pollStartEvent)).toBe("My Question");
+    });
+
+    it("shows the sender and question for a poll created by someone else", async () => {
+        const pollStartEvent = makePollStartEvent("Your Question", "@yo:example.com");
+        const preview = new PollStartEventPreview();
+        expect(preview.getTextFor(pollStartEvent)).toBe("@yo:example.com: Your Question");
+    });
+});
@@ -0,0 +1,132 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import { RelationType, Room, RoomMember } from "matrix-js-sdk/src/matrix";
+import { mocked } from "jest-mock";
+
+import { mkEvent, stubClient } from "../../../../test-utils";
+// Import directly from the file to avoid circular dependencies with MessagePreviewStore
+import { ReactionEventPreview } from "../../../../../src/stores/message-preview/previews/ReactionEventPreview";
+import { MatrixClientPeg } from "../../../../../src/MatrixClientPeg";
+
+describe("ReactionEventPreview", () => {
+    const preview = new ReactionEventPreview();
+    const userId = "@user:example.com";
+    const roomId = "!room:example.com";
+
+    beforeAll(() => {
+        stubClient();
+    });
+
+    describe("getTextFor", () => {
+        it("should return null for non-relations", () => {
+            const event = mkEvent({
+                event: true,
+                content: {},
+                user: userId,
+                type: "m.room.message",
+                room: roomId,
+            });
+            expect(preview.getTextFor(event)).toBeNull();
+        });
+
+        it("should return null for non-reactions", () => {
+            const event = mkEvent({
+                event: true,
+                content: {
+                    "body": "",
+                    "m.relates_to": {
+                        rel_type: RelationType.Thread,
+                        event_id: "$foo:bar",
+                    },
+                },
+                user: userId,
+                type: "m.room.message",
+                room: roomId,
+            });
+            expect(preview.getTextFor(event)).toBeNull();
+        });
+
+        it("should use 'You' for your own reactions", () => {
+            const cli = MatrixClientPeg.safeGet();
+            const room = new Room(roomId, cli, userId);
+            mocked(cli.getRoom).mockReturnValue(room);
+
+            const message = mkEvent({
+                event: true,
+                content: {
+                    "body": "duck duck goose",
+                    "m.relates_to": {
+                        rel_type: RelationType.Thread,
+                        event_id: "$foo:bar",
+                    },
+                },
+                user: userId,
+                type: "m.room.message",
+                room: roomId,
+            });
+
+            room.getUnfilteredTimelineSet().addLiveEvent(message, { addToState: true });
+
+            const event = mkEvent({
+                event: true,
+                content: {
+                    "m.relates_to": {
+                        rel_type: RelationType.Annotation,
+                        key: "🪿",
+                        event_id: message.getId(),
+                    },
+                },
+                user: cli.getSafeUserId(),
+                type: "m.reaction",
+                room: roomId,
+            });
+            expect(preview.getTextFor(event)).toMatchInlineSnapshot(`"You reacted 🪿 to duck duck goose"`);
+        });
+
+        it("should use display name for your others' reactions", () => {
+            const cli = MatrixClientPeg.safeGet();
+            const room = new Room(roomId, cli, userId);
+            mocked(cli.getRoom).mockReturnValue(room);
+
+            const message = mkEvent({
+                event: true,
+                content: {
+                    "body": "duck duck goose",
+                    "m.relates_to": {
+                        rel_type: RelationType.Thread,
+                        event_id: "$foo:bar",
+                    },
+                },
+                user: userId,
+                type: "m.room.message",
+                room: roomId,
+            });
+
+            room.getUnfilteredTimelineSet().addLiveEvent(message, { addToState: true });
+
+            const event = mkEvent({
+                event: true,
+                content: {
+                    "m.relates_to": {
+                        rel_type: RelationType.Annotation,
+                        key: "🪿",
+                        event_id: message.getId(),
+                    },
+                },
+                user: userId,
+                type: "m.reaction",
+                room: roomId,
+            });
+            event.sender = new RoomMember(roomId, userId);
+            event.sender.name = "Bob";
+
+            expect(preview.getTextFor(event)).toMatchInlineSnapshot(`"Bob reacted 🪿 to duck duck goose"`);
+        });
+    });
+});
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2026 Element Creations Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+import { Room } from "matrix-js-sdk/src/matrix";
+import { mocked } from "jest-mock";
+
+import { StickerEventPreview } from "../../../../../src/stores/message-preview/previews/StickerEventPreview";
+import { DefaultTagID } from "../../../../../src/stores/room-list-v3/skip-list/tag";
+import { mkEvent, stubClient } from "../../../../test-utils";
+import { MatrixClientPeg } from "../../../../../src/MatrixClientPeg";
+
+describe("StickerEventPreview", () => {
+    const preview = new StickerEventPreview();
+    const roomId = "!room:example.com";
+
+    beforeAll(() => {
+        stubClient();
+    });
+
+    describe("getTextFor", () => {
+        it("returns null when the event has no body", () => {
+            const event = mkEvent({
+                event: true,
+                type: "m.sticker",
+                content: {},
+                user: "@other:example.com",
+                room: roomId,
+            });
+            expect(preview.getTextFor(event)).toBeNull();
+        });
+
+        it("returns null when the body is an empty string", () => {
+            const event = mkEvent({
+                event: true,
+                type: "m.sticker",
+                content: { body: "" },
+                user: "@other:example.com",
+                room: roomId,
+            });
+            expect(preview.getTextFor(event)).toBeNull();
+        });
+
+        describe("in a room that should be prefixed (non-DM)", () => {
+            // Default stub: getRoom returns null → shouldPrefixMessagesIn returns true
+
+            it("returns '<sender>: <stickerName>' when the event is from someone else", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.sticker",
+                    content: { body: "wave" },
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event)).toBe(`${otherUserId}: wave`);
+            });
+
+            it("returns just the sticker name when the event is from self", () => {
+                const selfUserId = MatrixClientPeg.safeGet().getSafeUserId();
+                const event = mkEvent({
+                    event: true,
+                    type: "m.sticker",
+                    content: { body: "wave" },
+                    user: selfUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event)).toBe("wave");
+            });
+        });
+
+        describe("in a DM room (should not be prefixed)", () => {
+            beforeEach(() => {
+                const cli = MatrixClientPeg.safeGet();
+                // Make a 1:1 room so shouldPrefixMessagesIn returns false
+                const room = new Room(roomId, cli, cli.getSafeUserId());
+                jest.spyOn(room.currentState, "getJoinedMemberCount").mockReturnValue(2);
+                mocked(cli.getRoom).mockReturnValue(room);
+            });
+
+            afterEach(() => {
+                mocked(MatrixClientPeg.safeGet().getRoom).mockReturnValue(null);
+            });
+
+            it("returns just the sticker name regardless of sender", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.sticker",
+                    content: { body: "wave" },
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event, DefaultTagID.DM)).toBe("wave");
+            });
+        });
+
+        describe("in a thread", () => {
+            it("returns just the sticker name regardless of sender", () => {
+                const otherUserId = "@other:example.com";
+                const event = mkEvent({
+                    event: true,
+                    type: "m.sticker",
+                    content: { body: "wave" },
+                    user: otherUserId,
+                    room: roomId,
+                });
+                expect(preview.getTextFor(event, undefined, true)).toBe("wave");
+            });
+        });
+    });
+});