Confirm listen to a broadcast while recording (#9831)

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

@@ -15,10 +15,13 @@ limitations under the License.
 */
 
 import { mocked } from "jest-mock";
+import { screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
 import { MatrixClient, MatrixEvent, Room } from "matrix-js-sdk/src/matrix";
 
 import { Playback, PlaybackState } from "../../../src/audio/Playback";
 import { PlaybackManager } from "../../../src/audio/PlaybackManager";
+import { SdkContextClass } from "../../../src/contexts/SDKContext";
 import { MediaEventHelper } from "../../../src/utils/MediaEventHelper";
 import {
     VoiceBroadcastInfoState,
@@ -26,6 +29,7 @@ import {
     VoiceBroadcastPlayback,
     VoiceBroadcastPlaybackEvent,
     VoiceBroadcastPlaybackState,
+    VoiceBroadcastRecording,
 } from "../../../src/voice-broadcast";
 import { flushPromises, stubClient } from "../../test-utils";
 import { createTestPlayback } from "../../test-utils/audio";
@@ -65,6 +69,17 @@ describe("VoiceBroadcastPlayback", () => {
     let chunk2Playback: Playback;
     let chunk3Playback: Playback;
 
+    const queryConfirmListeningDialog = () => {
+        return screen.queryByText(
+            "If you start listening to this live broadcast, your current live broadcast recording will be ended.",
+        );
+    };
+
+    const waitForDialog = async () => {
+        await flushPromises();
+        await flushPromises();
+    };
+
     const itShouldSetTheStateTo = (state: VoiceBroadcastPlaybackState) => {
         it(`should set the state to ${state}`, () => {
             expect(playback.getState()).toBe(state);
@@ -119,7 +134,11 @@ describe("VoiceBroadcastPlayback", () => {
     };
 
     const mkPlayback = async () => {
-        const playback = new VoiceBroadcastPlayback(infoEvent, client);
+        const playback = new VoiceBroadcastPlayback(
+            infoEvent,
+            client,
+            SdkContextClass.instance.voiceBroadcastRecordingsStore,
+        );
         jest.spyOn(playback, "removeAllListeners");
         jest.spyOn(playback, "destroy");
         playback.on(VoiceBroadcastPlaybackEvent.StateChanged, onStateChanged);
@@ -178,7 +197,11 @@ describe("VoiceBroadcastPlayback", () => {
         onStateChanged = jest.fn();
     });
 
-    afterEach(() => {
+    afterEach(async () => {
+        SdkContextClass.instance.voiceBroadcastPlaybacksStore.getCurrent()?.stop();
+        SdkContextClass.instance.voiceBroadcastPlaybacksStore.clearCurrent();
+        await SdkContextClass.instance.voiceBroadcastRecordingsStore.getCurrent()?.stop();
+        SdkContextClass.instance.voiceBroadcastRecordingsStore.clearCurrent();
         playback.destroy();
     });
 
@@ -347,6 +370,59 @@ describe("VoiceBroadcastPlayback", () => {
                 });
             });
         });
+
+        describe("and currently recording a broadcast", () => {
+            let recording: VoiceBroadcastRecording;
+
+            beforeEach(async () => {
+                recording = new VoiceBroadcastRecording(
+                    mkVoiceBroadcastInfoStateEvent(
+                        roomId,
+                        VoiceBroadcastInfoState.Started,
+                        client.getSafeUserId(),
+                        client.deviceId,
+                    ),
+                    client,
+                );
+                jest.spyOn(recording, "stop");
+                SdkContextClass.instance.voiceBroadcastRecordingsStore.setCurrent(recording);
+                playback.start();
+                await waitForDialog();
+            });
+
+            it("should display a confirm modal", () => {
+                expect(queryConfirmListeningDialog()).toBeInTheDocument();
+            });
+
+            describe("when confirming the dialog", () => {
+                beforeEach(async () => {
+                    await userEvent.click(screen.getByText("Yes, end my recording"));
+                });
+
+                it("should stop the recording", () => {
+                    expect(recording.stop).toHaveBeenCalled();
+                    expect(SdkContextClass.instance.voiceBroadcastRecordingsStore.getCurrent()).toBeNull();
+                });
+
+                it("should not start the playback", () => {
+                    expect(playback.getState()).toBe(VoiceBroadcastPlaybackState.Playing);
+                });
+            });
+
+            describe("when not confirming the dialog", () => {
+                beforeEach(async () => {
+                    await userEvent.click(screen.getByText("No"));
+                });
+
+                it("should not stop the recording", () => {
+                    expect(recording.stop).not.toHaveBeenCalled();
+                });
+
+                it("should start the playback", () => {
+                    expect(playback.getState()).toBe(VoiceBroadcastPlaybackState.Stopped);
+                });
+            });
+        });
     });
 
     describe("when there is a stopped voice broadcast", () => {
@@ -375,6 +451,12 @@ describe("VoiceBroadcastPlayback", () => {
                 expect(chunk2Playback.play).not.toHaveBeenCalled();
             });
 
+            describe("and calling start again", () => {
+                it("should not play the first chunk a second time", () => {
+                    expect(chunk1Playback.play).toHaveBeenCalledTimes(1);
+                });
+            });
+
             describe("and the chunk playback progresses", () => {
                 beforeEach(() => {
                     chunk1Playback.clockInfo.liveData.update([11]);

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

@@ -40,8 +40,8 @@ describe("VoiceBroadcastPreRecording", () => {
         client = stubClient();
         room = new Room(roomId, client, client.getUserId() || "");
         sender = new RoomMember(roomId, client.getUserId() || "");
-        playbacksStore = new VoiceBroadcastPlaybacksStore();
         recordingsStore = new VoiceBroadcastRecordingsStore();
+        playbacksStore = new VoiceBroadcastPlaybacksStore(recordingsStore);
     });
 
     beforeEach(() => {