Add voice broadcast recording stores (#9319)

* Add voice broadcast recording stores

* Refactor startNewVoiceBroadcastRecording

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

@@ -0,0 +1,140 @@
+/*
+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 { EventType, MatrixClient, MatrixEvent, Room, RoomStateEvent } from "matrix-js-sdk/src/matrix";
+
+import {
+    startNewVoiceBroadcastRecording,
+    VoiceBroadcastInfoEventType,
+    VoiceBroadcastInfoState,
+    VoiceBroadcastRecordingsStore,
+    VoiceBroadcastRecording,
+} from "../../../src/voice-broadcast";
+import { mkEvent, stubClient } from "../../test-utils";
+
+jest.mock("../../../src/voice-broadcast/models/VoiceBroadcastRecording", () => ({
+    VoiceBroadcastRecording: jest.fn(),
+}));
+
+describe("startNewVoiceBroadcastRecording", () => {
+    const roomId = "!room:example.com";
+    let client: MatrixClient;
+    let recordingsStore: VoiceBroadcastRecordingsStore;
+    let room: Room;
+    let roomOnStateEventsCallbackRegistered: Promise<void>;
+    let roomOnStateEventsCallbackRegisteredResolver: Function;
+    let roomOnStateEventsCallback: () => void;
+    let infoEvent: MatrixEvent;
+    let otherEvent: MatrixEvent;
+    let stateEvent: MatrixEvent;
+
+    beforeEach(() => {
+        roomOnStateEventsCallbackRegistered = new Promise((resolve) => {
+            roomOnStateEventsCallbackRegisteredResolver = resolve;
+        });
+
+        room = {
+            currentState: {
+                getStateEvents: jest.fn().mockImplementation((type, userId) => {
+                    if (type === VoiceBroadcastInfoEventType && userId === client.getUserId()) {
+                        return stateEvent;
+                    }
+                }),
+            },
+            on: jest.fn().mockImplementation((eventType, callback) => {
+                if (eventType === RoomStateEvent.Events) {
+                    roomOnStateEventsCallback = callback;
+                    roomOnStateEventsCallbackRegisteredResolver();
+                }
+            }),
+            off: jest.fn(),
+        } as unknown as Room;
+
+        client = stubClient();
+        mocked(client.getRoom).mockImplementation((getRoomId: string) => {
+            if (getRoomId === roomId) {
+                return room;
+            }
+        });
+        mocked(client.sendStateEvent).mockImplementation((
+            sendRoomId: string,
+            eventType: string,
+            _content: any,
+            _stateKey: string,
+        ) => {
+            if (sendRoomId === roomId && eventType === VoiceBroadcastInfoEventType) {
+                return Promise.resolve({ event_id: infoEvent.getId() });
+            }
+        });
+
+        recordingsStore = {
+            setCurrent: jest.fn(),
+        } as unknown as VoiceBroadcastRecordingsStore;
+
+        infoEvent = mkEvent({
+            event: true,
+            type: VoiceBroadcastInfoEventType,
+            content: {
+                state: VoiceBroadcastInfoState.Started,
+            },
+            user: client.getUserId(),
+            room: roomId,
+        });
+        otherEvent = mkEvent({
+            event: true,
+            type: EventType.RoomMember,
+            content: {},
+            user: client.getUserId(),
+            room: roomId,
+        });
+
+        mocked(VoiceBroadcastRecording).mockImplementation((
+            infoEvent: MatrixEvent,
+            client: MatrixClient,
+        ) => {
+            return {
+                infoEvent,
+                client,
+            } as unknown as VoiceBroadcastRecording;
+        });
+    });
+
+    it("should create a new Voice Broadcast", (done) => {
+        let ok = false;
+
+        startNewVoiceBroadcastRecording(roomId, client, recordingsStore).then((recording) => {
+            expect(ok).toBe(true);
+            expect(mocked(room.off)).toHaveBeenCalledWith(RoomStateEvent.Events, roomOnStateEventsCallback);
+            expect(recording.infoEvent).toBe(infoEvent);
+            done();
+        });
+
+        roomOnStateEventsCallbackRegistered.then(() => {
+            // no state event, yet
+            roomOnStateEventsCallback();
+
+            // other state event
+            stateEvent = otherEvent;
+            roomOnStateEventsCallback();
+
+            // the expected Voice Broadcast Info event
+            stateEvent = infoEvent;
+            ok = true;
+            roomOnStateEventsCallback();
+        });
+    });
+});