Implement broadcast message preview (#9762)

test/TextForEvent-test.ts

@@ -19,12 +19,13 @@ import TestRenderer from "react-test-renderer";
 import { ReactElement } from "react";
 import { mocked } from "jest-mock";
 
-import { getSenderName, textForEvent } from "../src/TextForEvent";
+import { textForEvent } from "../src/TextForEvent";
 import SettingsStore from "../src/settings/SettingsStore";
 import { createTestClient, stubClient } from "./test-utils";
 import { MatrixClientPeg } from "../src/MatrixClientPeg";
 import UserIdentifierCustomisations from "../src/customisations/UserIdentifier";
 import { ElementCall } from "../src/models/Call";
+import { getSenderName } from "../src/utils/event/getSenderName";
 
 jest.mock("../src/settings/SettingsStore");
 jest.mock("../src/customisations/UserIdentifier", () => ({

test/stores/room-list/previews/MessageEventPreview-test.ts

@@ -0,0 +1,96 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { RelationType } from "matrix-js-sdk/src/matrix";
+
+import { MessageEventPreview } from "../../../../src/stores/room-list/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`);
+        });
+
+        it("when called with a broadcast chunk event it should return null", () => {
+            const event = mkEvent({
+                event: true,
+                content: {
+                    body: "test body",
+                    ["io.element.voice_broadcast_chunk"]: {},
+                },
+                user: userId,
+                type: "m.room.message",
+            });
+            expect(preview.getTextFor(event)).toBeNull();
+        });
+    });
+});

test/stores/room-list/previews/VoiceBroadcastPreview-test.ts

@@ -0,0 +1,57 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { VoiceBroadcastPreview } from "../../../../src/stores/room-list/previews/VoiceBroadcastPreview";
+import { VoiceBroadcastInfoState } from "../../../../src/voice-broadcast";
+import { mkEvent } from "../../../test-utils";
+import { mkVoiceBroadcastInfoStateEvent } from "../../../voice-broadcast/utils/test-utils";
+
+describe("VoiceBroadcastPreview.getTextFor", () => {
+    const roomId = "!room:example.com";
+    const userId = "@user:example.com";
+    const deviceId = "d42";
+    let preview: VoiceBroadcastPreview;
+
+    beforeAll(() => {
+        preview = new VoiceBroadcastPreview();
+    });
+
+    it("when passing an event with empty content, it should return null", () => {
+        const event = mkEvent({
+            event: true,
+            content: {},
+            user: userId,
+            type: "m.room.message",
+        });
+        expect(preview.getTextFor(event)).toBeNull();
+    });
+
+    it("when passing a broadcast started event, it should return null", () => {
+        const event = mkVoiceBroadcastInfoStateEvent(roomId, VoiceBroadcastInfoState.Started, userId, deviceId);
+        expect(preview.getTextFor(event)).toBeNull();
+    });
+
+    it("when passing a broadcast stopped event, it should return the expected text", () => {
+        const event = mkVoiceBroadcastInfoStateEvent(roomId, VoiceBroadcastInfoState.Stopped, userId, deviceId);
+        expect(preview.getTextFor(event)).toBe("@user:example.com ended a voice broadcast");
+    });
+
+    it("when passing a redacted broadcast stopped event, it should return null", () => {
+        const event = mkVoiceBroadcastInfoStateEvent(roomId, VoiceBroadcastInfoState.Stopped, userId, deviceId);
+        event.makeRedacted(mkEvent({ event: true, content: {}, user: userId, type: "m.room.redaction" }));
+        expect(preview.getTextFor(event)).toBeNull();
+    });
+});

test/test-utils/test-utils.ts

@@ -88,6 +88,7 @@ export function createTestClient(): MatrixClient {
         getIdentityServerUrl: jest.fn(),
         getDomain: jest.fn().mockReturnValue("matrix.org"),
         getUserId: jest.fn().mockReturnValue("@userId:matrix.org"),
+        getSafeUserId: jest.fn().mockReturnValue("@userId:matrix.org"),
         getUserIdLocalpart: jest.fn().mockResolvedValue("userId"),
         getUser: jest.fn().mockReturnValue({ on: jest.fn() }),
         getDeviceId: jest.fn().mockReturnValue("ABCDEFGHI"),

test/voice-broadcast/utils/textForVoiceBroadcastStoppedEventWithoutLink-test.ts

@@ -0,0 +1,55 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { mocked } from "jest-mock";
+import { MatrixClient } from "matrix-js-sdk/src/client";
+
+import { textForVoiceBroadcastStoppedEventWithoutLink, VoiceBroadcastInfoState } from "../../../src/voice-broadcast";
+import { stubClient } from "../../test-utils";
+import { mkVoiceBroadcastInfoStateEvent } from "./test-utils";
+
+describe("textForVoiceBroadcastStoppedEventWithoutLink", () => {
+    const otherUserId = "@other:example.com";
+    const roomId = "!room:example.com";
+    let client: MatrixClient;
+
+    beforeAll(() => {
+        client = stubClient();
+    });
+
+    const getText = (senderId: string, startEventId?: string) => {
+        const event = mkVoiceBroadcastInfoStateEvent(
+            roomId,
+            VoiceBroadcastInfoState.Stopped,
+            senderId,
+            client.deviceId!,
+        );
+        return textForVoiceBroadcastStoppedEventWithoutLink(event);
+    };
+
+    it("when called for an own broadcast it should return the expected text", () => {
+        expect(getText(client.getUserId()!)).toBe("You ended a voice broadcast");
+    });
+
+    it("when called for other ones broadcast it should return the expected text", () => {
+        expect(getText(otherUserId)).toBe(`${otherUserId} ended a voice broadcast`);
+    });
+
+    it("when not logged in it should return the exptected text", () => {
+        mocked(client.getUserId).mockReturnValue(null);
+        expect(getText(otherUserId)).toBe(`${otherUserId} ended a voice broadcast`);
+    });
+});