fix tests

Signed-off-by: Timo K <[email protected]>

Author: toger5

spec/unit/matrixrtc/MatrixRTCSessionManager.spec.ts

@@ -23,25 +23,30 @@ import { logger } from "../../../src/logger";
 describe("MatrixRTCSessionManager", () => {
     let client: MatrixClient;
 
-    beforeEach(() => {
+    beforeEach(async () => {
         client = new MatrixClient({ baseUrl: "base_url" });
-        client.matrixRTC.start();
+        await client.matrixRTC.start();
     });
 
     afterEach(() => {
         client.stopClient();
         client.matrixRTC.stop();
     });
 
-    it("Fires event when session starts", () => {
+    it("Fires event when session starts", async () => {
         const onStarted = jest.fn();
-        client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
+        const { promise, resolve } = Promise.withResolvers<void>();
+        client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionStarted, (...v) => {
+            onStarted(...v);
+            resolve();
+        });
 
         try {
             const room1 = makeMockRoom([membershipTemplate]);
             jest.spyOn(client, "getRooms").mockReturnValue([room1]);
 
             client.emit(ClientEvent.Room, room1);
+            await promise;
             expect(onStarted).toHaveBeenCalledWith(room1.roomId, client.matrixRTC.getActiveRoomSession(room1));
         } finally {
             client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
@@ -63,34 +68,48 @@ describe("MatrixRTCSessionManager", () => {
         }
     });
 
-    it("Fires event when session ends", () => {
+    it("Fires event when session ends", async () => {
         const onEnded = jest.fn();
-        client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
+        const { promise: endPromise, resolve: rEnd } = Promise.withResolvers();
+        client.matrixRTC.once(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
+        const { promise: startPromise, resolve: rStart } = Promise.withResolvers();
+        client.matrixRTC.once(MatrixRTCSessionManagerEvents.SessionEnded, rEnd);
+        client.matrixRTC.once(MatrixRTCSessionManagerEvents.SessionStarted, rStart);
+
         const room1 = makeMockRoom([membershipTemplate]);
         jest.spyOn(client, "getRooms").mockReturnValue([room1]);
         jest.spyOn(client, "getRoom").mockReturnValue(room1);
 
         client.emit(ClientEvent.Room, room1);
+        await startPromise;
 
         mockRoomState(room1, [{ user_id: membershipTemplate.user_id }]);
-
         const roomState = room1.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
         const membEvent = roomState.getStateEvents("org.matrix.msc3401.call.member")[0];
         client.emit(RoomStateEvent.Events, membEvent, roomState, null);
-
+        await endPromise;
         expect(onEnded).toHaveBeenCalledWith(room1.roomId, client.matrixRTC.getActiveRoomSession(room1));
     });
 
-    it("Fires correctly with for with custom sessionDescription", () => {
+    it("Fires correctly with for with custom sessionDescription", async () => {
         const onStarted = jest.fn();
         const onEnded = jest.fn();
         // create a session manager with a custom session description
         const sessionManager = new MatrixRTCSessionManager(logger, client, { id: "test", application: "m.notCall" });
 
         // manually start the session manager (its not the default one started by the client)
-        sessionManager.start();
-        sessionManager.on(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
-        sessionManager.on(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
+        await sessionManager.start();
+        const { promise: startPromise, resolve: rStart } = Promise.withResolvers<void>();
+        const { promise: endPromise, resolve: rEnd } = Promise.withResolvers<void>();
+
+        sessionManager.on(MatrixRTCSessionManagerEvents.SessionEnded, (v) => {
+            onEnded(v);
+            rEnd();
+        });
+        sessionManager.on(MatrixRTCSessionManagerEvents.SessionStarted, (v) => {
+            onStarted(v);
+            rStart();
+        });
 
         try {
             const room1 = makeMockRoom([{ ...membershipTemplate, application: "m.other" }]);
@@ -104,6 +123,7 @@ describe("MatrixRTCSessionManager", () => {
             jest.spyOn(client, "getRooms").mockReturnValue([room1, room2]);
 
             client.emit(ClientEvent.Room, room2);
+            await startPromise;
             expect(onStarted).toHaveBeenCalled();
             onStarted.mockClear();
 
@@ -113,6 +133,7 @@ describe("MatrixRTCSessionManager", () => {
             const roomState = room2.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
             const membEvent = roomState.getStateEvents("org.matrix.msc3401.call.member")[0];
             client.emit(RoomStateEvent.Events, membEvent, roomState, null);
+            await endPromise;
             expect(onEnded).toHaveBeenCalled();
             onEnded.mockClear();
 

spec/unit/matrixrtc/MembershipManager.spec.ts

@@ -33,6 +33,7 @@ import {
 } from "../../../src/matrixrtc";
 import { makeMockClient, makeMockRoom, membershipTemplate, mockCallMembership, type MockClient } from "./mocks";
 import { MembershipManager } from "../../../src/matrixrtc/MembershipManager.ts";
+import { waitFor } from "../../test-utils/test-utils.ts";
 
 /**
  * Create a promise that will resolve once a mocked method is called.
@@ -923,18 +924,18 @@ describe("MembershipManager", () => {
     });
 });
 
-it("Should prefix log with MembershipManager used", () => {
+it("Should prefix log with MembershipManager used", async () => {
+    const spy = jest.spyOn(console, "error");
     const client = makeMockClient("@alice:example.org", "AAAAAAA");
     const room = makeMockRoom([membershipTemplate]);
 
     const membershipManager = new MembershipManager(undefined, room, client, callSession);
 
-    const spy = jest.spyOn(console, "error");
     // Double join
     membershipManager.join([]);
     membershipManager.join([]);
 
-    expect(spy).toHaveBeenCalled();
+    await waitFor(() => expect(spy).toHaveBeenCalled());
     const logline: string = spy.mock.calls[0][0];
     expect(logline.startsWith("[MembershipManager]")).toBe(true);
 });

spec/unit/matrixrtc/RoomKeyTransport.spec.ts

@@ -31,7 +31,7 @@ describe("RoomKeyTransport", () => {
     let mockLogger: Mocked<Logger>;
 
     const onCallEncryptionMock = jest.fn();
-    beforeEach(() => {
+    beforeEach(async () => {
         onCallEncryptionMock.mockReset();
         mockLogger = {
             debug: jest.fn(),
@@ -50,7 +50,7 @@ describe("RoomKeyTransport", () => {
         };
         room = makeMockRoom([membershipTemplate]);
         client = new MatrixClient({ baseUrl: "base_url" });
-        client.matrixRTC.start();
+        await client.matrixRTC.start();
         transport = new RoomKeyTransport(room, client, statistics, {
             getChild: jest.fn().mockReturnValue(mockLogger),
         } as unknown as Mocked<Logger>);

src/matrixrtc/MatrixRTCSession.ts

@@ -363,8 +363,8 @@ export class MatrixRTCSession extends TypedEventEmitter<
                     return eventData ? new MatrixEvent(eventData) : undefined;
                 };
                 const relatedEvent = relatedEventId
-                    ? room.findEventById(relatedEventId)
-                    : await getRelatedMatrixEvent();
+                    ? (room.findEventById(relatedEventId) ?? (await getRelatedMatrixEvent()))
+                    : undefined;
 
                 try {
                     membership = new CallMembership(memberEvent, relatedEvent);