element-web/test/voice-broadcast/utils/hasRoomLiveVoiceBroadcast-test.ts

/*
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
Please see LICENSE files in the repository root for full details.
*/

import { mocked } from "jest-mock";
import { MatrixClient, MatrixEvent, Room } from "matrix-js-sdk/src/matrix";

import {
    hasRoomLiveVoiceBroadcast,
    VoiceBroadcastInfoEventType,
    VoiceBroadcastInfoState,
} from "../../../src/voice-broadcast";
import { mkEvent, stubClient } from "../../test-utils";
import { mkVoiceBroadcastInfoStateEvent } from "./test-utils";

describe("hasRoomLiveVoiceBroadcast", () => {
    const otherUserId = "@other:example.com";
    const otherDeviceId = "ASD123";
    const roomId = "!room:example.com";
    let client: MatrixClient;
    let room: Room;
    let expectedEvent: MatrixEvent | null = null;

    const addVoiceBroadcastInfoEvent = (
        state: VoiceBroadcastInfoState,
        userId: string,
        deviceId: string,
        startedEvent?: MatrixEvent,
    ): MatrixEvent => {
        const infoEvent = mkVoiceBroadcastInfoStateEvent(room.roomId, state, userId, deviceId, startedEvent);
        room.addLiveEvents([infoEvent]);
        room.currentState.setStateEvents([infoEvent]);
        room.relations.aggregateChildEvent(infoEvent);
        return infoEvent;
    };

    const itShouldReturnTrueTrue = () => {
        it("should return true/true", async () => {
            expect(await hasRoomLiveVoiceBroadcast(client, room, client.getSafeUserId())).toEqual({
                hasBroadcast: true,
                infoEvent: expectedEvent,
                startedByUser: true,
            });
        });
    };

    const itShouldReturnTrueFalse = () => {
        it("should return true/false", async () => {
            expect(await hasRoomLiveVoiceBroadcast(client, room, client.getSafeUserId())).toEqual({
                hasBroadcast: true,
                infoEvent: expectedEvent,
                startedByUser: false,
            });
        });
    };

    const itShouldReturnFalseFalse = () => {
        it("should return false/false", async () => {
            expect(await hasRoomLiveVoiceBroadcast(client, room, client.getSafeUserId())).toEqual({
                hasBroadcast: false,
                infoEvent: null,
                startedByUser: false,
            });
        });
    };

    beforeEach(() => {
        client = stubClient();
        room = new Room(roomId, client, client.getSafeUserId());
        mocked(client.getRoom).mockImplementation((roomId: string): Room | null => {
            return roomId === room.roomId ? room : null;
        });
        expectedEvent = null;
    });

    describe("when there is no voice broadcast info at all", () => {
        itShouldReturnFalseFalse();
    });

    describe("when the »state« prop is missing", () => {
        beforeEach(() => {
            room.currentState.setStateEvents([
                mkEvent({
                    event: true,
                    room: room.roomId,
                    user: client.getSafeUserId(),
                    type: VoiceBroadcastInfoEventType,
                    skey: client.getSafeUserId(),
                    content: {},
                }),
            ]);
        });
        itShouldReturnFalseFalse();
    });

    describe("when there is a live broadcast from the current and another user", () => {
        beforeEach(() => {
            expectedEvent = addVoiceBroadcastInfoEvent(
                VoiceBroadcastInfoState.Started,
                client.getSafeUserId(),
                client.getDeviceId()!,
            );
            addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Started, otherUserId, otherDeviceId);
        });

        itShouldReturnTrueTrue();
    });

    describe("when there are only stopped info events", () => {
        beforeEach(() => {
            addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Stopped, client.getSafeUserId(), client.getDeviceId()!);
            addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Stopped, otherUserId, otherDeviceId);
        });

        itShouldReturnFalseFalse();
    });

    describe("when there is a live, started broadcast from the current user", () => {
        beforeEach(() => {
            expectedEvent = addVoiceBroadcastInfoEvent(
                VoiceBroadcastInfoState.Started,
                client.getSafeUserId(),
                client.getDeviceId()!,
            );
        });

        itShouldReturnTrueTrue();
    });

    describe("when there is a live, paused broadcast from the current user", () => {
        beforeEach(() => {
            expectedEvent = addVoiceBroadcastInfoEvent(
                VoiceBroadcastInfoState.Started,
                client.getSafeUserId(),
                client.getDeviceId()!,
            );
            addVoiceBroadcastInfoEvent(
                VoiceBroadcastInfoState.Paused,
                client.getSafeUserId(),
                client.getDeviceId()!,
                expectedEvent,
            );
        });

        itShouldReturnTrueTrue();
    });

    describe("when there is a live, resumed broadcast from the current user", () => {
        beforeEach(() => {
            expectedEvent = addVoiceBroadcastInfoEvent(
                VoiceBroadcastInfoState.Started,
                client.getSafeUserId(),
                client.getDeviceId()!,
            );
            addVoiceBroadcastInfoEvent(
                VoiceBroadcastInfoState.Resumed,
                client.getSafeUserId(),
                client.getDeviceId()!,
                expectedEvent,
            );
        });

        itShouldReturnTrueTrue();
    });

    describe("when there was a live broadcast, that has been stopped", () => {
        beforeEach(() => {
            const startedEvent = addVoiceBroadcastInfoEvent(
                VoiceBroadcastInfoState.Started,
                client.getSafeUserId(),
                client.getDeviceId()!,
            );
            addVoiceBroadcastInfoEvent(
                VoiceBroadcastInfoState.Stopped,
                client.getSafeUserId(),
                client.getDeviceId()!,
                startedEvent,
            );
        });

        itShouldReturnFalseFalse();
    });

    describe("when there is a live broadcast from another user", () => {
        beforeEach(() => {
            expectedEvent = addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Started, otherUserId, otherDeviceId);
        });

        itShouldReturnTrueFalse();
    });
});