Prepare for repo merge

Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>

test/unit-tests/voice-broadcast/utils/VoiceBroadcastResumer-test.ts

@@ -0,0 +1,179 @@
+/*
+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 { ClientEvent, MatrixClient, MatrixEvent, RelationType, Room, SyncState } from "matrix-js-sdk/src/matrix";
+
+import {
+    VoiceBroadcastInfoEventContent,
+    VoiceBroadcastInfoEventType,
+    VoiceBroadcastInfoState,
+    VoiceBroadcastResumer,
+} from "../../../src/voice-broadcast";
+import { stubClient } from "../../test-utils";
+import { mkVoiceBroadcastInfoStateEvent } from "./test-utils";
+
+describe("VoiceBroadcastResumer", () => {
+    const roomId = "!room:example.com";
+    let client: MatrixClient;
+    let room: Room;
+    let resumer: VoiceBroadcastResumer;
+    let startedInfoEvent: MatrixEvent;
+    let pausedInfoEvent: MatrixEvent;
+
+    const itShouldNotSendAStateEvent = (): void => {
+        it("should not send a state event", () => {
+            expect(client.sendStateEvent).not.toHaveBeenCalled();
+        });
+    };
+
+    const itShouldSendAStoppedStateEvent = (): void => {
+        it("should send a stopped state event", () => {
+            expect(client.sendStateEvent).toHaveBeenCalledWith(
+                startedInfoEvent.getRoomId(),
+                VoiceBroadcastInfoEventType,
+                {
+                    "device_id": client.getDeviceId(),
+                    "state": VoiceBroadcastInfoState.Stopped,
+                    "m.relates_to": {
+                        rel_type: RelationType.Reference,
+                        event_id: startedInfoEvent.getId(),
+                    },
+                } as VoiceBroadcastInfoEventContent,
+                client.getUserId()!,
+            );
+        });
+    };
+
+    const itShouldDeregisterFromTheClient = () => {
+        it("should deregister from the client", () => {
+            expect(client.off).toHaveBeenCalledWith(ClientEvent.Sync, expect.any(Function));
+        });
+    };
+
+    beforeEach(() => {
+        client = stubClient();
+        jest.spyOn(client, "off");
+        room = new Room(roomId, client, client.getUserId()!);
+        mocked(client.getRoom).mockImplementation((getRoomId: string | undefined) => {
+            if (getRoomId === roomId) return room;
+
+            return null;
+        });
+        mocked(client.getRooms).mockReturnValue([room]);
+        startedInfoEvent = mkVoiceBroadcastInfoStateEvent(
+            roomId,
+            VoiceBroadcastInfoState.Started,
+            client.getUserId()!,
+            client.getDeviceId()!,
+        );
+        pausedInfoEvent = mkVoiceBroadcastInfoStateEvent(
+            roomId,
+            VoiceBroadcastInfoState.Paused,
+            client.getUserId()!,
+            client.getDeviceId()!,
+            startedInfoEvent,
+        );
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    describe("when the initial sync is completed", () => {
+        beforeEach(() => {
+            mocked(client.isInitialSyncComplete).mockReturnValue(true);
+        });
+
+        describe("and there is no info event", () => {
+            beforeEach(() => {
+                resumer = new VoiceBroadcastResumer(client);
+            });
+
+            itShouldNotSendAStateEvent();
+
+            describe("and calling destroy", () => {
+                beforeEach(() => {
+                    resumer.destroy();
+                });
+
+                itShouldDeregisterFromTheClient();
+            });
+        });
+
+        describe("and there is a started info event", () => {
+            beforeEach(() => {
+                room.currentState.setStateEvents([startedInfoEvent]);
+            });
+
+            describe("and the client knows about the user and device", () => {
+                beforeEach(() => {
+                    resumer = new VoiceBroadcastResumer(client);
+                });
+
+                itShouldSendAStoppedStateEvent();
+            });
+
+            describe("and the client doesn't know about the user", () => {
+                beforeEach(() => {
+                    mocked(client.getUserId).mockReturnValue(null);
+                    resumer = new VoiceBroadcastResumer(client);
+                });
+
+                itShouldNotSendAStateEvent();
+            });
+
+            describe("and the client doesn't know about the device", () => {
+                beforeEach(() => {
+                    mocked(client.getDeviceId).mockReturnValue(null);
+                    resumer = new VoiceBroadcastResumer(client);
+                });
+
+                itShouldNotSendAStateEvent();
+            });
+        });
+
+        describe("and there is a paused info event", () => {
+            beforeEach(() => {
+                room.currentState.setStateEvents([pausedInfoEvent]);
+                resumer = new VoiceBroadcastResumer(client);
+            });
+
+            itShouldSendAStoppedStateEvent();
+        });
+    });
+
+    describe("when the initial sync is not completed", () => {
+        beforeEach(() => {
+            room.currentState.setStateEvents([pausedInfoEvent]);
+            mocked(client.isInitialSyncComplete).mockReturnValue(false);
+            mocked(client.getSyncState).mockReturnValue(SyncState.Prepared);
+            resumer = new VoiceBroadcastResumer(client);
+        });
+
+        itShouldNotSendAStateEvent();
+
+        describe("and a sync event appears", () => {
+            beforeEach(() => {
+                client.emit(ClientEvent.Sync, SyncState.Prepared, SyncState.Stopped);
+            });
+
+            itShouldNotSendAStateEvent();
+
+            describe("and the initial sync completed and a sync event appears", () => {
+                beforeEach(() => {
+                    mocked(client.getSyncState).mockReturnValue(SyncState.Syncing);
+                    client.emit(ClientEvent.Sync, SyncState.Syncing, SyncState.Prepared);
+                });
+
+                itShouldSendAStoppedStateEvent();
+                itShouldDeregisterFromTheClient();
+            });
+        });
+    });
+});