Merge branch 'develop' into psg-863/dm-learn-more-rename

test/stores/room-list/SlidingRoomListStore-test.ts

@@ -0,0 +1,319 @@
+/*
+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 { SlidingSync, SlidingSyncEvent } from 'matrix-js-sdk/src/sliding-sync';
+import { Room } from 'matrix-js-sdk/src/matrix';
+
+import {
+    LISTS_UPDATE_EVENT,
+    SlidingRoomListStoreClass,
+    SlidingSyncSortToFilter,
+} from "../../../src/stores/room-list/SlidingRoomListStore";
+import { SpaceStoreClass } from "../../../src/stores/spaces/SpaceStore";
+import { MockEventEmitter, stubClient, untilEmission } from "../../test-utils";
+import { TestSdkContext } from '../../TestSdkContext';
+import { SlidingSyncManager } from '../../../src/SlidingSyncManager';
+import { RoomViewStore } from '../../../src/stores/RoomViewStore';
+import { MatrixDispatcher } from '../../../src/dispatcher/dispatcher';
+import { SortAlgorithm } from '../../../src/stores/room-list/algorithms/models';
+import { DefaultTagID, TagID } from '../../../src/stores/room-list/models';
+import { UPDATE_SELECTED_SPACE } from '../../../src/stores/spaces';
+import { LISTS_LOADING_EVENT } from '../../../src/stores/room-list/RoomListStore';
+import { UPDATE_EVENT } from '../../../src/stores/AsyncStore';
+
+jest.mock('../../../src/SlidingSyncManager');
+const MockSlidingSyncManager = <jest.Mock<SlidingSyncManager>><unknown>SlidingSyncManager;
+
+describe("SlidingRoomListStore", () => {
+    let store: SlidingRoomListStoreClass;
+    let context: TestSdkContext;
+    let dis: MatrixDispatcher;
+    let activeSpace: string;
+    let tagIdToIndex = {};
+
+    beforeEach(async () => {
+        context = new TestSdkContext();
+        context.client = stubClient();
+        context._SpaceStore = new MockEventEmitter<SpaceStoreClass>({
+            traverseSpace: jest.fn(),
+            get activeSpace() {
+                return activeSpace;
+            },
+        }) as SpaceStoreClass;
+        context._SlidingSyncManager = new MockSlidingSyncManager();
+        context._SlidingSyncManager.slidingSync = mocked(new MockEventEmitter({
+            getListData: jest.fn(),
+        }) as unknown as SlidingSync);
+        context._RoomViewStore = mocked(new MockEventEmitter({
+            getRoomId: jest.fn(),
+        }) as unknown as RoomViewStore);
+
+        // mock implementations to allow the store to map tag IDs to sliding sync list indexes and vice versa
+        let index = 0;
+        tagIdToIndex = {};
+        mocked(context._SlidingSyncManager.getOrAllocateListIndex).mockImplementation((listId: string): number => {
+            if (tagIdToIndex[listId] != null) {
+                return tagIdToIndex[listId];
+            }
+            tagIdToIndex[listId] = index;
+            index++;
+            return index;
+        });
+        mocked(context.slidingSyncManager.listIdForIndex).mockImplementation((i) => {
+            for (const tagId in tagIdToIndex) {
+                const j = tagIdToIndex[tagId];
+                if (i === j) {
+                    return tagId;
+                }
+            }
+            return null;
+        });
+        mocked(context._SlidingSyncManager.ensureListRegistered).mockResolvedValue({
+            ranges: [[0, 10]],
+        });
+
+        dis = new MatrixDispatcher();
+        store = new SlidingRoomListStoreClass(dis, context);
+    });
+
+    describe("spaces", () => {
+        it("alters 'filters.spaces' on the DefaultTagID.Untagged list when the selected space changes", async () => {
+            await store.start(); // call onReady
+            const spaceRoomId = "!foo:bar";
+
+            const p = untilEmission(store, LISTS_LOADING_EVENT, (listName, isLoading) => {
+                return listName === DefaultTagID.Untagged && !isLoading;
+            });
+
+            // change the active space
+            activeSpace = spaceRoomId;
+            context._SpaceStore.emit(UPDATE_SELECTED_SPACE, spaceRoomId, false);
+            await p;
+
+            expect(context._SlidingSyncManager.ensureListRegistered).toHaveBeenCalledWith(
+                tagIdToIndex[DefaultTagID.Untagged],
+                {
+                    filters: expect.objectContaining({
+                        spaces: [spaceRoomId],
+                    }),
+                },
+            );
+        });
+
+        it("alters 'filters.spaces' on the DefaultTagID.Untagged list if it loads with an active space", async () => {
+            // change the active space before we are ready
+            const spaceRoomId = "!foo2:bar";
+            activeSpace = spaceRoomId;
+            const p = untilEmission(store, LISTS_LOADING_EVENT, (listName, isLoading) => {
+                return listName === DefaultTagID.Untagged && !isLoading;
+            });
+            await store.start(); // call onReady
+            await p;
+            expect(context._SlidingSyncManager.ensureListRegistered).toHaveBeenCalledWith(
+                tagIdToIndex[DefaultTagID.Untagged],
+                expect.objectContaining({
+                    filters: expect.objectContaining({
+                        spaces: [spaceRoomId],
+                    }),
+                }),
+            );
+        });
+
+        it("includes subspaces in 'filters.spaces' when the selected space has subspaces", async () => {
+            await store.start(); // call onReady
+            const spaceRoomId = "!foo:bar";
+            const subSpace1 = "!ss1:bar";
+            const subSpace2 = "!ss2:bar";
+
+            const p = untilEmission(store, LISTS_LOADING_EVENT, (listName, isLoading) => {
+                return listName === DefaultTagID.Untagged && !isLoading;
+            });
+
+            mocked(context._SpaceStore.traverseSpace).mockImplementation(
+                (spaceId: string, fn: (roomId: string) => void) => {
+                    if (spaceId === spaceRoomId) {
+                        fn(subSpace1);
+                        fn(subSpace2);
+                    }
+                },
+            );
+
+            // change the active space
+            activeSpace = spaceRoomId;
+            context._SpaceStore.emit(UPDATE_SELECTED_SPACE, spaceRoomId, false);
+            await p;
+
+            expect(context._SlidingSyncManager.ensureListRegistered).toHaveBeenCalledWith(
+                tagIdToIndex[DefaultTagID.Untagged],
+                {
+                    filters: expect.objectContaining({
+                        spaces: [spaceRoomId, subSpace1, subSpace2],
+                    }),
+                },
+            );
+        });
+    });
+
+    it("setTagSorting alters the 'sort' option in the list", async () => {
+        mocked(context._SlidingSyncManager.getOrAllocateListIndex).mockReturnValue(0);
+        const tagId: TagID = "foo";
+        await store.setTagSorting(tagId, SortAlgorithm.Alphabetic);
+        expect(context._SlidingSyncManager.ensureListRegistered).toBeCalledWith(0, {
+            sort: SlidingSyncSortToFilter[SortAlgorithm.Alphabetic],
+        });
+        expect(store.getTagSorting(tagId)).toEqual(SortAlgorithm.Alphabetic);
+
+        await store.setTagSorting(tagId, SortAlgorithm.Recent);
+        expect(context._SlidingSyncManager.ensureListRegistered).toBeCalledWith(0, {
+            sort: SlidingSyncSortToFilter[SortAlgorithm.Recent],
+        });
+        expect(store.getTagSorting(tagId)).toEqual(SortAlgorithm.Recent);
+    });
+
+    it("getTagsForRoom gets the tags for the room", async () => {
+        await store.start();
+        const untaggedIndex = context._SlidingSyncManager.getOrAllocateListIndex(DefaultTagID.Untagged);
+        const favIndex = context._SlidingSyncManager.getOrAllocateListIndex(DefaultTagID.Favourite);
+        const roomA = "!a:localhost";
+        const roomB = "!b:localhost";
+        const indexToListData = {
+            [untaggedIndex]: {
+                joinedCount: 10,
+                roomIndexToRoomId: {
+                    0: roomA,
+                    1: roomB,
+                },
+            },
+            [favIndex]: {
+                joinedCount: 2,
+                roomIndexToRoomId: {
+                    0: roomB,
+                },
+            },
+        };
+        mocked(context._SlidingSyncManager.slidingSync.getListData).mockImplementation((i: number) => {
+            return indexToListData[i] || null;
+        });
+
+        expect(store.getTagsForRoom(new Room(roomA, context.client, context.client.getUserId()))).toEqual(
+            [DefaultTagID.Untagged],
+        );
+        expect(store.getTagsForRoom(new Room(roomB, context.client, context.client.getUserId()))).toEqual(
+            [DefaultTagID.Favourite, DefaultTagID.Untagged],
+        );
+    });
+
+    it("emits LISTS_UPDATE_EVENT when slidingSync lists update", async () => {
+        await store.start();
+        const roomA = "!a:localhost";
+        const roomB = "!b:localhost";
+        const roomC = "!c:localhost";
+        const tagId = DefaultTagID.Favourite;
+        const listIndex = context.slidingSyncManager.getOrAllocateListIndex(tagId);
+        const joinCount = 10;
+        const roomIndexToRoomId = { // mixed to ensure we sort
+            1: roomB,
+            2: roomC,
+            0: roomA,
+        };
+        const rooms = [
+            new Room(roomA, context.client, context.client.getUserId()),
+            new Room(roomB, context.client, context.client.getUserId()),
+            new Room(roomC, context.client, context.client.getUserId()),
+        ];
+        mocked(context.client.getRoom).mockImplementation((roomId: string) => {
+            switch (roomId) {
+                case roomA:
+                    return rooms[0];
+                case roomB:
+                    return rooms[1];
+                case roomC:
+                    return rooms[2];
+            }
+            return null;
+        });
+        const p = untilEmission(store, LISTS_UPDATE_EVENT);
+        context.slidingSyncManager.slidingSync.emit(SlidingSyncEvent.List, listIndex, joinCount, roomIndexToRoomId);
+        await p;
+        expect(store.getCount(tagId)).toEqual(joinCount);
+        expect(store.orderedLists[tagId]).toEqual(rooms);
+    });
+
+    it("sets the sticky room on the basis of the viewed room in RoomViewStore", async () => {
+        await store.start();
+        // seed the store with 3 rooms
+        const roomIdA = "!a:localhost";
+        const roomIdB = "!b:localhost";
+        const roomIdC = "!c:localhost";
+        const tagId = DefaultTagID.Favourite;
+        const listIndex = context.slidingSyncManager.getOrAllocateListIndex(tagId);
+        const joinCount = 10;
+        const roomIndexToRoomId = { // mixed to ensure we sort
+            1: roomIdB,
+            2: roomIdC,
+            0: roomIdA,
+        };
+        const roomA = new Room(roomIdA, context.client, context.client.getUserId());
+        const roomB = new Room(roomIdB, context.client, context.client.getUserId());
+        const roomC = new Room(roomIdC, context.client, context.client.getUserId());
+        mocked(context.client.getRoom).mockImplementation((roomId: string) => {
+            switch (roomId) {
+                case roomIdA:
+                    return roomA;
+                case roomIdB:
+                    return roomB;
+                case roomIdC:
+                    return roomC;
+            }
+            return null;
+        });
+        mocked(context._SlidingSyncManager.slidingSync.getListData).mockImplementation((i: number) => {
+            if (i !== listIndex) {
+                return null;
+            }
+            return {
+                roomIndexToRoomId: roomIndexToRoomId,
+                joinedCount: joinCount,
+            };
+        });
+        let p = untilEmission(store, LISTS_UPDATE_EVENT);
+        context.slidingSyncManager.slidingSync.emit(SlidingSyncEvent.List, listIndex, joinCount, roomIndexToRoomId);
+        await p;
+        expect(store.orderedLists[tagId]).toEqual([roomA, roomB, roomC]);
+
+        // make roomB sticky and inform the store
+        mocked(context.roomViewStore.getRoomId).mockReturnValue(roomIdB);
+        context.roomViewStore.emit(UPDATE_EVENT);
+
+        // bump room C to the top, room B should not move from i=1 despite the list update saying to
+        roomIndexToRoomId[0] = roomIdC;
+        roomIndexToRoomId[1] = roomIdA;
+        roomIndexToRoomId[2] = roomIdB;
+        p = untilEmission(store, LISTS_UPDATE_EVENT);
+        context.slidingSyncManager.slidingSync.emit(SlidingSyncEvent.List, listIndex, joinCount, roomIndexToRoomId);
+        await p;
+
+        // check that B didn't move and that A was put below B
+        expect(store.orderedLists[tagId]).toEqual([roomC, roomB, roomA]);
+
+        // make room C sticky: rooms should move as a result, without needing an additional list update
+        mocked(context.roomViewStore.getRoomId).mockReturnValue(roomIdC);
+        p = untilEmission(store, LISTS_UPDATE_EVENT);
+        context.roomViewStore.emit(UPDATE_EVENT);
+        await p;
+        expect(store.orderedLists[tagId].map((r) => r.roomId)).toEqual([roomC, roomA, roomB].map((r) => r.roomId));
+    });
+});

test/test-utils/client.ts

@@ -21,6 +21,26 @@ import { MatrixClient, User } from "matrix-js-sdk/src/matrix";
 
 import { MatrixClientPeg } from "../../src/MatrixClientPeg";
 
+/**
+ * Mocked generic class with a real EventEmitter.
+ * Useful for mocks which need event emitters.
+ */
+export class MockEventEmitter<T> extends EventEmitter {
+    /**
+     * Construct a new event emitter with additional properties/functions. The event emitter functions
+     * like .emit and .on will be real.
+     * @param mockProperties An object with the mock property or function implementations. 'getters'
+     * are correctly cloned to this event emitter.
+     */
+    constructor(mockProperties: Partial<Record<MethodKeysOf<T>|PropertyKeysOf<T>, unknown>> = {}) {
+        super();
+        // We must use defineProperties and not assign as the former clones getters correctly,
+        // whereas the latter invokes the getter and sets the return value permanently on the
+        // destination object.
+        Object.defineProperties(this, Object.getOwnPropertyDescriptors(mockProperties));
+    }
+}
+
 /**
  * Mock client with real event emitter
  * useful for testing code that listens

test/voice-broadcast/components/molecules/VoiceBroadcastRecordingBody-test.tsx

@@ -50,7 +50,7 @@ describe("VoiceBroadcastRecordingBody", () => {
             room: roomId,
             user: userId,
         });
-        recording = new VoiceBroadcastRecording(infoEvent, client, VoiceBroadcastInfoState.Running);
+        recording = new VoiceBroadcastRecording(infoEvent, client, VoiceBroadcastInfoState.Resumed);
     });
 
     describe("when rendering a live broadcast", () => {

test/voice-broadcast/components/molecules/VoiceBroadcastRecordingPip-test.tsx

@@ -118,7 +118,7 @@ describe("VoiceBroadcastRecordingPip", () => {
             });
 
             it("should resume the recording", () => {
-                expect(recording.getState()).toBe(VoiceBroadcastInfoState.Running);
+                expect(recording.getState()).toBe(VoiceBroadcastInfoState.Resumed);
             });
         });
     });

test/voice-broadcast/components/molecules/__snapshots__/VoiceBroadcastPlaybackBody-test.tsx.snap

@@ -3,7 +3,7 @@
 exports[`VoiceBroadcastPlaybackBody when rendering a 0 broadcast should render as expected 1`] = `
 <div>
   <div
-    class="mx_VoiceBroadcastPlaybackBody"
+    class="mx_VoiceBroadcastBody"
   >
     <div
       class="mx_VoiceBroadcastHeader"
@@ -51,7 +51,7 @@ exports[`VoiceBroadcastPlaybackBody when rendering a 0 broadcast should render a
       </div>
     </div>
     <div
-      class="mx_VoiceBroadcastPlaybackBody_controls"
+      class="mx_VoiceBroadcastBody_controls"
     >
       <div
         aria-label="resume voice broadcast"
@@ -71,7 +71,7 @@ exports[`VoiceBroadcastPlaybackBody when rendering a 0 broadcast should render a
 exports[`VoiceBroadcastPlaybackBody when rendering a 1 broadcast should render as expected 1`] = `
 <div>
   <div
-    class="mx_VoiceBroadcastPlaybackBody"
+    class="mx_VoiceBroadcastBody"
   >
     <div
       class="mx_VoiceBroadcastHeader"
@@ -119,7 +119,7 @@ exports[`VoiceBroadcastPlaybackBody when rendering a 1 broadcast should render a
       </div>
     </div>
     <div
-      class="mx_VoiceBroadcastPlaybackBody_controls"
+      class="mx_VoiceBroadcastBody_controls"
     >
       <div
         aria-label="pause voice broadcast"
@@ -139,7 +139,7 @@ exports[`VoiceBroadcastPlaybackBody when rendering a 1 broadcast should render a
 exports[`VoiceBroadcastPlaybackBody when rendering a buffering voice broadcast should render as expected 1`] = `
 <div>
   <div
-    class="mx_VoiceBroadcastPlaybackBody"
+    class="mx_VoiceBroadcastBody"
   >
     <div
       class="mx_VoiceBroadcastHeader"
@@ -187,7 +187,7 @@ exports[`VoiceBroadcastPlaybackBody when rendering a buffering voice broadcast s
       </div>
     </div>
     <div
-      class="mx_VoiceBroadcastPlaybackBody_controls"
+      class="mx_VoiceBroadcastBody_controls"
     >
       <div
         class="mx_Spinner"

test/voice-broadcast/components/molecules/__snapshots__/VoiceBroadcastRecordingBody-test.tsx.snap

@@ -3,7 +3,7 @@
 exports[`VoiceBroadcastRecordingBody when rendering a live broadcast should render the expected HTML 1`] = `
 <div>
   <div
-    class="mx_VoiceBroadcastRecordingBody"
+    class="mx_VoiceBroadcastBody"
   >
     <div
       class="mx_VoiceBroadcastHeader"

test/voice-broadcast/components/molecules/__snapshots__/VoiceBroadcastRecordingPip-test.tsx.snap

@@ -3,7 +3,7 @@
 exports[`VoiceBroadcastRecordingPip when rendering a paused recording should render as expected 1`] = `
 <div>
   <div
-    class="mx_VoiceBroadcastRecordingPip"
+    class="mx_VoiceBroadcastBody mx_VoiceBroadcastBody--pip"
   >
     <div
       class="mx_VoiceBroadcastHeader"
@@ -43,10 +43,10 @@ exports[`VoiceBroadcastRecordingPip when rendering a paused recording should ren
       </div>
     </div>
     <hr
-      class="mx_VoiceBroadcastRecordingPip_divider"
+      class="mx_VoiceBroadcastBody_divider"
     />
     <div
-      class="mx_VoiceBroadcastRecordingPip_controls"
+      class="mx_VoiceBroadcastBody_controls"
     >
       <div
         aria-label="resume voice broadcast"
@@ -76,7 +76,7 @@ exports[`VoiceBroadcastRecordingPip when rendering a paused recording should ren
 exports[`VoiceBroadcastRecordingPip when rendering a started recording should render as expected 1`] = `
 <div>
   <div
-    class="mx_VoiceBroadcastRecordingPip"
+    class="mx_VoiceBroadcastBody mx_VoiceBroadcastBody--pip"
   >
     <div
       class="mx_VoiceBroadcastHeader"
@@ -116,10 +116,10 @@ exports[`VoiceBroadcastRecordingPip when rendering a started recording should re
       </div>
     </div>
     <hr
-      class="mx_VoiceBroadcastRecordingPip_divider"
+      class="mx_VoiceBroadcastBody_divider"
     />
     <div
-      class="mx_VoiceBroadcastRecordingPip_controls"
+      class="mx_VoiceBroadcastBody_controls"
     >
       <div
         aria-label="pause voice broadcast"

test/voice-broadcast/models/VoiceBroadcastPlayback-test.ts

@@ -190,9 +190,9 @@ describe("VoiceBroadcastPlayback", () => {
         onStateChanged = jest.fn();
     });
 
-    describe("when there is a running broadcast without chunks yet", () => {
+    describe(`when there is a ${VoiceBroadcastInfoState.Resumed} broadcast without chunks yet`, () => {
         beforeEach(() => {
-            infoEvent = mkInfoEvent(VoiceBroadcastInfoState.Running);
+            infoEvent = mkInfoEvent(VoiceBroadcastInfoState.Resumed);
             playback = mkPlayback();
             setUpChunkEvents([]);
         });
@@ -236,9 +236,9 @@ describe("VoiceBroadcastPlayback", () => {
         });
     });
 
-    describe("when there is a running voice broadcast with some chunks", () => {
+    describe(`when there is a ${VoiceBroadcastInfoState.Resumed} voice broadcast with some chunks`, () => {
         beforeEach(() => {
-            infoEvent = mkInfoEvent(VoiceBroadcastInfoState.Running);
+            infoEvent = mkInfoEvent(VoiceBroadcastInfoState.Resumed);
             playback = mkPlayback();
             setUpChunkEvents([chunk2Event, chunk0Event, chunk1Event]);
         });

test/voice-broadcast/models/VoiceBroadcastRecording-test.ts

@@ -423,15 +423,15 @@ describe("VoiceBroadcastRecording", () => {
                     await action();
                 });
 
-                itShouldBeInState(VoiceBroadcastInfoState.Running);
-                itShouldSendAnInfoEvent(VoiceBroadcastInfoState.Running);
+                itShouldBeInState(VoiceBroadcastInfoState.Resumed);
+                itShouldSendAnInfoEvent(VoiceBroadcastInfoState.Resumed);
 
                 it("should start the recorder", () => {
                     expect(mocked(voiceBroadcastRecorder.start)).toHaveBeenCalled();
                 });
 
-                it("should emit a running state changed event", () => {
-                    expect(onStateChanged).toHaveBeenCalledWith(VoiceBroadcastInfoState.Running);
+                it(`should emit a ${VoiceBroadcastInfoState.Resumed} state changed event`, () => {
+                    expect(onStateChanged).toHaveBeenCalledWith(VoiceBroadcastInfoState.Resumed);
                 });
             });
         });

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

@@ -121,7 +121,7 @@ describe("hasRoomLiveVoiceBroadcast", () => {
         // all there are kind of live states
         VoiceBroadcastInfoState.Started,
         VoiceBroadcastInfoState.Paused,
-        VoiceBroadcastInfoState.Running,
+        VoiceBroadcastInfoState.Resumed,
     ])("when there is a live broadcast (%s) from the current user", (state: VoiceBroadcastInfoState) => {
         beforeEach(() => {
             addVoiceBroadcastInfoEvent(state, client.getUserId());
@@ -132,7 +132,7 @@ describe("hasRoomLiveVoiceBroadcast", () => {
 
     describe("when there was a live broadcast, that has been stopped", () => {
         beforeEach(() => {
-            addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Running, client.getUserId());
+            addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Resumed, client.getUserId());
             addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Stopped, client.getUserId());
         });
 
@@ -141,7 +141,7 @@ describe("hasRoomLiveVoiceBroadcast", () => {
 
     describe("when there is a live broadcast from another user", () => {
         beforeEach(() => {
-            addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Running, otherUserId);
+            addVoiceBroadcastInfoEvent(VoiceBroadcastInfoState.Resumed, otherUserId);
         });
 
         itShouldReturnTrueFalse();

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

@@ -40,7 +40,7 @@ const testCases = [
     [
         "@user1:example.com",
         "@user1:example.com",
-        VoiceBroadcastInfoState.Running,
+        VoiceBroadcastInfoState.Resumed,
         true,
     ],
     [

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

@@ -128,7 +128,7 @@ describe("shouldDisplayAsVoiceBroadcastTile", () => {
     describe.each(
         [
             VoiceBroadcastInfoState.Paused,
-            VoiceBroadcastInfoState.Running,
+            VoiceBroadcastInfoState.Resumed,
             VoiceBroadcastInfoState.Stopped,
         ],
     )("when a voice broadcast info event in state %s occurs", (state: VoiceBroadcastInfoState) => {

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

@@ -161,7 +161,7 @@ describe("startNewVoiceBroadcastRecording", () => {
                 room.currentState.setStateEvents([
                     mkVoiceBroadcastInfoStateEvent(
                         roomId,
-                        VoiceBroadcastInfoState.Running,
+                        VoiceBroadcastInfoState.Resumed,
                         client.getUserId(),
                         client.getDeviceId(),
                     ),
@@ -184,7 +184,7 @@ describe("startNewVoiceBroadcastRecording", () => {
                 room.currentState.setStateEvents([
                     mkVoiceBroadcastInfoStateEvent(
                         roomId,
-                        VoiceBroadcastInfoState.Running,
+                        VoiceBroadcastInfoState.Resumed,
                         otherUserId,
                         "ASD123",
                     ),