2022-10-14 21:12:26 +03:00
|
|
|
/*
|
|
|
|
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 React from "react";
|
2022-11-28 17:16:44 +03:00
|
|
|
import { act, render, RenderResult, screen } from "@testing-library/react";
|
2022-10-18 10:12:28 +03:00
|
|
|
import userEvent from "@testing-library/user-event";
|
2022-10-14 21:12:26 +03:00
|
|
|
import { MatrixClient, MatrixEvent } from "matrix-js-sdk/src/matrix";
|
2022-10-18 10:12:28 +03:00
|
|
|
import { sleep } from "matrix-js-sdk/src/utils";
|
2022-11-28 17:16:44 +03:00
|
|
|
import { mocked } from "jest-mock";
|
2022-10-14 21:12:26 +03:00
|
|
|
|
|
|
|
import {
|
2022-10-18 10:12:28 +03:00
|
|
|
VoiceBroadcastInfoState,
|
2022-10-14 21:12:26 +03:00
|
|
|
VoiceBroadcastRecording,
|
|
|
|
VoiceBroadcastRecordingPip,
|
|
|
|
} from "../../../../src/voice-broadcast";
|
2022-11-28 17:16:44 +03:00
|
|
|
import { filterConsole, flushPromises, stubClient } from "../../../test-utils";
|
2022-10-20 15:44:41 +03:00
|
|
|
import { mkVoiceBroadcastInfoStateEvent } from "../../utils/test-utils";
|
2022-11-28 17:16:44 +03:00
|
|
|
import { requestMediaPermissions } from "../../../../src/utils/media/requestMediaPermissions";
|
|
|
|
import MediaDeviceHandler, { MediaDeviceKindEnum } from "../../../../src/MediaDeviceHandler";
|
2022-12-13 15:32:19 +03:00
|
|
|
import dis from "../../../../src/dispatcher/dispatcher";
|
|
|
|
import { Action } from "../../../../src/dispatcher/actions";
|
2022-11-28 17:16:44 +03:00
|
|
|
|
2022-12-13 15:32:19 +03:00
|
|
|
jest.mock("../../../../src/dispatcher/dispatcher");
|
2022-11-28 17:16:44 +03:00
|
|
|
jest.mock("../../../../src/utils/media/requestMediaPermissions");
|
2022-10-14 21:12:26 +03:00
|
|
|
|
|
|
|
// mock RoomAvatar, because it is doing too much fancy stuff
|
|
|
|
jest.mock("../../../../src/components/views/avatars/RoomAvatar", () => ({
|
|
|
|
__esModule: true,
|
|
|
|
default: jest.fn().mockImplementation(({ room }) => {
|
2022-12-12 14:24:14 +03:00
|
|
|
return <div data-testid="room-avatar">room avatar: {room.name}</div>;
|
2022-10-14 21:12:26 +03:00
|
|
|
}),
|
|
|
|
}));
|
|
|
|
|
2022-11-10 13:53:49 +03:00
|
|
|
// mock VoiceRecording because it contains all the audio APIs
|
|
|
|
jest.mock("../../../../src/audio/VoiceRecording", () => ({
|
|
|
|
VoiceRecording: jest.fn().mockReturnValue({
|
|
|
|
disableMaxLength: jest.fn(),
|
|
|
|
liveData: {
|
|
|
|
onUpdate: jest.fn(),
|
|
|
|
},
|
|
|
|
start: jest.fn(),
|
|
|
|
}),
|
|
|
|
}));
|
2022-10-20 15:44:41 +03:00
|
|
|
|
2022-10-14 21:12:26 +03:00
|
|
|
describe("VoiceBroadcastRecordingPip", () => {
|
|
|
|
const roomId = "!room:example.com";
|
|
|
|
let client: MatrixClient;
|
|
|
|
let infoEvent: MatrixEvent;
|
|
|
|
let recording: VoiceBroadcastRecording;
|
2022-10-20 15:44:41 +03:00
|
|
|
let renderResult: RenderResult;
|
2022-11-28 17:16:44 +03:00
|
|
|
let restoreConsole: () => void;
|
2022-10-20 15:44:41 +03:00
|
|
|
|
2022-11-28 17:16:44 +03:00
|
|
|
const renderPip = async (state: VoiceBroadcastInfoState) => {
|
2022-12-12 14:24:14 +03:00
|
|
|
infoEvent = mkVoiceBroadcastInfoStateEvent(roomId, state, client.getUserId() || "", client.getDeviceId() || "");
|
2022-10-21 10:30:02 +03:00
|
|
|
recording = new VoiceBroadcastRecording(infoEvent, client, state);
|
2022-11-28 17:16:44 +03:00
|
|
|
jest.spyOn(recording, "pause");
|
|
|
|
jest.spyOn(recording, "resume");
|
2022-10-20 15:44:41 +03:00
|
|
|
renderResult = render(<VoiceBroadcastRecordingPip recording={recording} />);
|
2022-11-28 17:16:44 +03:00
|
|
|
await act(async () => {
|
|
|
|
flushPromises();
|
|
|
|
});
|
2022-10-20 15:44:41 +03:00
|
|
|
};
|
2022-10-14 21:12:26 +03:00
|
|
|
|
2022-12-13 15:32:19 +03:00
|
|
|
const itShouldShowTheBroadcastRoom = () => {
|
|
|
|
it("should show the broadcast room", () => {
|
|
|
|
expect(dis.dispatch).toHaveBeenCalledWith({
|
|
|
|
action: Action.ViewRoom,
|
|
|
|
room_id: roomId,
|
|
|
|
metricsTrigger: undefined,
|
|
|
|
});
|
|
|
|
});
|
|
|
|
};
|
|
|
|
|
2022-10-14 21:12:26 +03:00
|
|
|
beforeAll(() => {
|
|
|
|
client = stubClient();
|
2022-12-13 15:32:19 +03:00
|
|
|
mocked(requestMediaPermissions).mockResolvedValue({
|
|
|
|
getTracks: (): Array<MediaStreamTrack> => [],
|
|
|
|
} as unknown as MediaStream);
|
2022-11-28 17:16:44 +03:00
|
|
|
jest.spyOn(MediaDeviceHandler, "getDevices").mockResolvedValue({
|
|
|
|
[MediaDeviceKindEnum.AudioInput]: [
|
|
|
|
{
|
|
|
|
deviceId: "d1",
|
|
|
|
label: "Device 1",
|
|
|
|
} as MediaDeviceInfo,
|
|
|
|
{
|
|
|
|
deviceId: "d2",
|
|
|
|
label: "Device 2",
|
|
|
|
} as MediaDeviceInfo,
|
|
|
|
],
|
|
|
|
[MediaDeviceKindEnum.AudioOutput]: [],
|
|
|
|
[MediaDeviceKindEnum.VideoInput]: [],
|
|
|
|
});
|
|
|
|
jest.spyOn(MediaDeviceHandler.instance, "setDevice").mockImplementation();
|
|
|
|
restoreConsole = filterConsole("Starting load of AsyncWrapper for modal");
|
|
|
|
});
|
|
|
|
|
|
|
|
afterAll(() => {
|
|
|
|
restoreConsole();
|
2022-10-14 21:12:26 +03:00
|
|
|
});
|
|
|
|
|
2022-10-20 15:44:41 +03:00
|
|
|
describe("when rendering a started recording", () => {
|
2022-11-28 17:16:44 +03:00
|
|
|
beforeEach(async () => {
|
|
|
|
await renderPip(VoiceBroadcastInfoState.Started);
|
2022-10-14 21:12:26 +03:00
|
|
|
});
|
|
|
|
|
2022-10-20 15:44:41 +03:00
|
|
|
it("should render as expected", () => {
|
2022-10-14 21:12:26 +03:00
|
|
|
expect(renderResult.container).toMatchSnapshot();
|
|
|
|
});
|
2022-10-18 10:12:28 +03:00
|
|
|
|
2022-11-28 17:16:44 +03:00
|
|
|
describe("and selecting another input device", () => {
|
|
|
|
beforeEach(async () => {
|
|
|
|
await act(async () => {
|
|
|
|
await userEvent.click(screen.getByLabelText("Change input device"));
|
|
|
|
await userEvent.click(screen.getByText("Device 1"));
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
it("should select the device and pause and resume the broadcast", () => {
|
|
|
|
expect(MediaDeviceHandler.instance.setDevice).toHaveBeenCalledWith(
|
|
|
|
"d1",
|
|
|
|
MediaDeviceKindEnum.AudioInput,
|
|
|
|
);
|
|
|
|
expect(recording.pause).toHaveBeenCalled();
|
|
|
|
expect(recording.resume).toHaveBeenCalled();
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
2022-12-13 15:32:19 +03:00
|
|
|
describe("and clicking the room name", () => {
|
|
|
|
beforeEach(async () => {
|
|
|
|
await userEvent.click(screen.getByText("My room"));
|
|
|
|
});
|
|
|
|
|
|
|
|
itShouldShowTheBroadcastRoom();
|
|
|
|
});
|
|
|
|
|
|
|
|
describe("and clicking the room avatar", () => {
|
|
|
|
beforeEach(async () => {
|
|
|
|
await userEvent.click(screen.getByText("room avatar: My room"));
|
|
|
|
});
|
|
|
|
|
|
|
|
itShouldShowTheBroadcastRoom();
|
|
|
|
});
|
|
|
|
|
2022-10-20 15:44:41 +03:00
|
|
|
describe("and clicking the pause button", () => {
|
|
|
|
beforeEach(async () => {
|
|
|
|
await userEvent.click(screen.getByLabelText("pause voice broadcast"));
|
|
|
|
});
|
|
|
|
|
|
|
|
it("should pause the recording", () => {
|
|
|
|
expect(recording.getState()).toBe(VoiceBroadcastInfoState.Paused);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
2022-10-18 10:12:28 +03:00
|
|
|
describe("and clicking the stop button", () => {
|
|
|
|
beforeEach(async () => {
|
2022-10-20 11:04:14 +03:00
|
|
|
await userEvent.click(screen.getByLabelText("Stop Recording"));
|
2022-10-18 10:12:28 +03:00
|
|
|
// modal rendering has some weird sleeps
|
|
|
|
await sleep(100);
|
|
|
|
});
|
|
|
|
|
|
|
|
it("should display the confirm end dialog", () => {
|
|
|
|
screen.getByText("Stop live broadcasting?");
|
|
|
|
});
|
|
|
|
|
|
|
|
describe("and confirming the dialog", () => {
|
|
|
|
beforeEach(async () => {
|
|
|
|
await userEvent.click(screen.getByText("Yes, stop broadcast"));
|
|
|
|
});
|
|
|
|
|
|
|
|
it("should end the recording", () => {
|
|
|
|
expect(recording.getState()).toBe(VoiceBroadcastInfoState.Stopped);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2022-10-14 21:12:26 +03:00
|
|
|
});
|
2022-10-20 15:44:41 +03:00
|
|
|
|
|
|
|
describe("when rendering a paused recording", () => {
|
2022-11-28 17:16:44 +03:00
|
|
|
beforeEach(async () => {
|
|
|
|
await renderPip(VoiceBroadcastInfoState.Paused);
|
2022-10-20 15:44:41 +03:00
|
|
|
});
|
|
|
|
|
|
|
|
it("should render as expected", () => {
|
|
|
|
expect(renderResult.container).toMatchSnapshot();
|
|
|
|
});
|
|
|
|
|
|
|
|
describe("and clicking the resume button", () => {
|
|
|
|
beforeEach(async () => {
|
|
|
|
await userEvent.click(screen.getByLabelText("resume voice broadcast"));
|
|
|
|
});
|
|
|
|
|
|
|
|
it("should resume the recording", () => {
|
2022-10-26 15:54:44 +03:00
|
|
|
expect(recording.getState()).toBe(VoiceBroadcastInfoState.Resumed);
|
2022-10-20 15:44:41 +03:00
|
|
|
});
|
|
|
|
});
|
|
|
|
});
|
2022-10-14 21:12:26 +03:00
|
|
|
});
|