matrix/matrix-js-sdk
1
0
Fork 0
mirror of https://github.com/matrix-org/matrix-js-sdk.git synced 2025-07-30 04:23:07 +03:00
Code Activity

Add CallEventHandler tests (#2696)

Browse Source 
* Add `CallEventHandler` tests

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

* Avoid tests hanging

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>

Signed-off-by: Šimon Brandner <simon.bra.ag@gmail.com>
This commit is contained in:
Šimon Brandner
2022-09-26 12:02:19 +02:00
committed by GitHub
parent a2981efac3
commit af6f9d49f4
1 changed files with 130 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

130
spec/unit/webrtc/callEventHandler.spec.ts
View File

@ -20,24 +20,33 @@ import {
EventTimeline,
EventTimelineSet,
EventType,
GroupCallIntent,
GroupCallType,
IRoomTimelineData,
MatrixCall,
MatrixEvent,
Room,
RoomEvent,
RoomMember,
} from "../../../src";
import { MatrixClient } from "../../../src/client";
import { CallEventHandler, CallEventHandlerEvent } from "../../../src/webrtc/callEventHandler";
import { GroupCallEventHandler } from "../../../src/webrtc/groupCallEventHandler";
import { SyncState } from "../../../src/sync";
import { installWebRTCMocks, MockRTCPeerConnection } from "../../test-utils/webrtc";
import { sleep } from "../../../src/utils";
describe("CallEventHandler", () => {
let client: MatrixClient;
beforeEach(() => {
installWebRTCMocks();
client = new TestClient("@alice:foo", "somedevice", "token", undefined, {}).client;
client.callEventHandler = new CallEventHandler(client);
client.callEventHandler.start();
client.groupCallEventHandler = new GroupCallEventHandler(client);
client.groupCallEventHandler.start();
client.sendStateEvent = jest.fn().mockResolvedValue({});
});
afterEach(() => {
@ -45,6 +54,14 @@ describe("CallEventHandler", () => {
client.groupCallEventHandler.stop();
});
const sync = async () => {
client.getSyncState = jest.fn().mockReturnValue(SyncState.Syncing);
client.emit(ClientEvent.Sync, SyncState.Syncing);
// We can't await the event processing
await sleep(10);
};
it("should enforce inbound toDevice message ordering", async () => {
const callEventHandler = client.callEventHandler;
const event1 = new MatrixEvent({
@ -140,4 +157,117 @@ describe("CallEventHandler", () => {
expect(incomingCallEmitted).not.toHaveBeenCalled();
});
it("should ignore non-call events", async () => {
// @ts-ignore Mock handleCallEvent is private
jest.spyOn(client.callEventHandler, "handleCallEvent");
jest.spyOn(client, "checkTurnServers").mockReturnValue(undefined);
const room = new Room("!room:id", client, "@user:id");
const timelineData: IRoomTimelineData = { timeline: new EventTimeline(new EventTimelineSet(room, {})) };
client.emit(RoomEvent.Timeline, new MatrixEvent({
type: EventType.RoomMessage,
room_id: "!room:id",
content: {
text: "hello",
},
}), room, false, false, timelineData);
await sync();
// @ts-ignore Mock handleCallEvent is private
expect(client.callEventHandler.handleCallEvent).not.toHaveBeenCalled();
});
describe("handleCallEvent()", () => {
const incomingCallListener = jest.fn();
let timelineData: IRoomTimelineData;
let room: Room;
beforeEach(() => {
room = new Room("!room:id", client, client.getUserId());
timelineData = { timeline: new EventTimeline(new EventTimelineSet(room, {})) };
jest.spyOn(client, "checkTurnServers").mockReturnValue(undefined);
jest.spyOn(client, "getRoom").mockReturnValue(room);
jest.spyOn(room, "getMember").mockReturnValue({ user_id: client.getUserId() } as unknown as RoomMember);
client.on(CallEventHandlerEvent.Incoming, incomingCallListener);
});
afterEach(() => {
MockRTCPeerConnection.resetInstances();
jest.resetAllMocks();
});
it("should create a call when receiving an invite", async () => {
client.emit(RoomEvent.Timeline, new MatrixEvent({
type: EventType.CallInvite,
room_id: "!room:id",
content: {
call_id: "123",
},
}), room, false, false, timelineData);
await sync();
expect(incomingCallListener).toHaveBeenCalled();
});
it("should handle group call event", async () => {
let call: MatrixCall;
const groupCall = await client.createGroupCall(
room.roomId,
GroupCallType.Voice,
false,
GroupCallIntent.Ring,
);
const SESSION_ID = "sender_session_id";
const GROUP_CALL_ID = "group_call_id";
const DEVICE_ID = "device_id";
incomingCallListener.mockImplementation((c) => call = c);
jest.spyOn(client.groupCallEventHandler, "getGroupCallById").mockReturnValue(groupCall);
// @ts-ignore Mock onIncomingCall is private
jest.spyOn(groupCall, "onIncomingCall");
await groupCall.enter();
client.emit(RoomEvent.Timeline, new MatrixEvent({
type: EventType.CallInvite,
room_id: "!room:id",
content: {
call_id: "123",
conf_id: GROUP_CALL_ID,
device_id: DEVICE_ID,
sender_session_id: SESSION_ID,
dest_session_id: client.getSessionId(),
},
}), room, false, false, timelineData);
await sync();
expect(incomingCallListener).toHaveBeenCalled();
expect(call.groupCallId).toBe(GROUP_CALL_ID);
// @ts-ignore Mock opponentDeviceId is private
expect(call.opponentDeviceId).toBe(DEVICE_ID);
expect(call.getOpponentSessionId()).toBe(SESSION_ID);
// @ts-ignore Mock onIncomingCall is private
expect(groupCall.onIncomingCall).toHaveBeenCalledWith(call);
groupCall.terminate(false);
});
it("ignores a call with a different invitee than us", async () => {
client.emit(RoomEvent.Timeline, new MatrixEvent({
type: EventType.CallInvite,
room_id: "!room:id",
content: {
call_id: "123",
invitee: "@bob:bar",
},
}), room, false, false, timelineData);
await sync();
expect(incomingCallListener).not.toHaveBeenCalled();
});
});
});