Wait for async functions in tests

Author: AndrewFerr

spec/unit/matrixrtc/MatrixRTCSession.spec.ts

@@ -244,35 +244,64 @@ describe("MatrixRTCSession", () => {
             foci_preferred: [mockFocus],
         };
 
-        function testSession(
+        let sendStateEventMock: jest.Mock;
+        let sendStateFutureMock: jest.Mock;
+
+        let sentStateEvent: Promise<void>;
+        let sentStateFuture: Promise<void>;
+
+        beforeEach(() => {
+            sentStateEvent = new Promise((resolve) => {
+                sendStateEventMock = jest.fn(resolve);
+            });
+            sentStateFuture = new Promise((resolve) => {
+                sendStateFutureMock = jest.fn(() => {
+                    resolve();
+                    return {
+                        future_group_id: "g",
+                        send_token: "s",
+                        cancel_token: "c",
+                        refresh_token: "r",
+                    };
+                });
+            });
+            client.sendStateEvent = sendStateEventMock;
+            client._unstable_sendStateFuture = sendStateFutureMock;
+        });
+
+        async function testSession(
             membershipData: CallMembershipData[] | SessionMembershipData,
             shouldUseLegacy: boolean,
-        ): void {
+        ): Promise<void> {
             sess = MatrixRTCSession.roomSessionForRoom(client, makeMockRoom(membershipData));
 
             const makeNewLegacyMembershipsMock = jest.spyOn(sess as any, "makeNewLegacyMemberships");
             const makeNewMembershipMock = jest.spyOn(sess as any, "makeNewMembership");
 
             sess.joinRoomSession([mockFocus], mockFocus, joinSessionConfig);
+            await Promise.race([sentStateEvent, new Promise((resolve) => setTimeout(resolve, 500))]);
 
             expect(makeNewLegacyMembershipsMock).toHaveBeenCalledTimes(shouldUseLegacy ? 1 : 0);
             expect(makeNewMembershipMock).toHaveBeenCalledTimes(shouldUseLegacy ? 0 : 1);
+
+            await Promise.race([sentStateFuture, new Promise((resolve) => setTimeout(resolve, 500))]);
+            expect(client._unstable_sendStateFuture).toHaveBeenCalledTimes(shouldUseLegacy ? 0 : 1);
         }
 
-        it("uses legacy events if there are any active legacy calls", () => {
-            testSession([expiredLegacyMembershipData, legacyMembershipData, sessionMembershipData], true);
+        it("uses legacy events if there are any active legacy calls", async () => {
+            await testSession([expiredLegacyMembershipData, legacyMembershipData, sessionMembershipData], true);
         });
 
-        it('uses legacy events if a non-legacy call is in a "memberships" array', () => {
-            testSession([sessionMembershipData], true);
+        it('uses legacy events if a non-legacy call is in a "memberships" array', async () => {
+            await testSession([sessionMembershipData], true);
         });
 
-        it("uses non-legacy events if all legacy calls are expired", () => {
-            testSession([expiredLegacyMembershipData], false);
+        it("uses non-legacy events if all legacy calls are expired", async () => {
+            await testSession([expiredLegacyMembershipData], false);
         });
 
-        it("uses non-legacy events if there are only non-legacy calls", () => {
-            testSession(sessionMembershipData, false);
+        it("uses non-legacy events if there are only non-legacy calls", async () => {
+            await testSession(sessionMembershipData, false);
         });
     });
 
@@ -350,12 +379,30 @@ describe("MatrixRTCSession", () => {
     describe("joining", () => {
         let mockRoom: Room;
         let sendStateEventMock: jest.Mock;
+        let sendStateFutureMock: jest.Mock;
         let sendEventMock: jest.Mock;
 
+        let sentStateEvent: Promise<void>;
+        let sentStateFuture: Promise<void>;
+
         beforeEach(() => {
-            sendStateEventMock = jest.fn();
+            sentStateEvent = new Promise((resolve) => {
+                sendStateEventMock = jest.fn(resolve);
+            });
+            sentStateFuture = new Promise((resolve) => {
+                sendStateFutureMock = jest.fn(() => {
+                    resolve();
+                    return {
+                        future_group_id: "g",
+                        send_token: "s",
+                        cancel_token: "c",
+                        refresh_token: "r",
+                    };
+                });
+            });
             sendEventMock = jest.fn();
             client.sendStateEvent = sendStateEventMock;
+            client._unstable_sendStateFuture = sendStateFutureMock;
             client.sendEvent = sendEventMock;
 
             mockRoom = makeMockRoom([]);
@@ -376,9 +423,11 @@ describe("MatrixRTCSession", () => {
             expect(sess!.isJoined()).toEqual(true);
         });
 
-        it("sends a membership event when joining a call", () => {
+        it("sends a membership event when joining a call", async () => {
+            const realSetTimeout = setTimeout;
             jest.useFakeTimers();
             sess!.joinRoomSession([mockFocus], mockFocus);
+            await Promise.race([sentStateEvent, new Promise((resolve) => realSetTimeout(resolve, 500))]);
             expect(client.sendStateEvent).toHaveBeenCalledWith(
                 mockRoom!.roomId,
                 EventType.GroupCallMemberPrefix,
@@ -399,20 +448,24 @@ describe("MatrixRTCSession", () => {
                 },
                 "@alice:example.org",
             );
+            await Promise.race([sentStateFuture, new Promise((resolve) => realSetTimeout(resolve, 500))]);
+            expect(client._unstable_sendStateFuture).toHaveBeenCalledTimes(0);
             jest.useRealTimers();
         });
 
         describe("non-legacy calls", () => {
             const activeFocusConfig = { type: "livekit", livekit_service_url: "https://active.url" };
             const activeFocus = { type: "livekit", focus_selection: "oldest_membership" };
 
-            function testJoin(useOwnedStateEvents: boolean): void {
+            async function testJoin(useOwnedStateEvents: boolean): Promise<void> {
+                const realSetTimeout = setTimeout;
                 if (useOwnedStateEvents) {
                     mockRoom.getVersion = jest.fn().mockReturnValue("org.matrix.msc3779.default");
                 }
 
                 jest.useFakeTimers();
                 sess!.joinRoomSession([activeFocusConfig], activeFocus, { useLegacyMemberEvents: false });
+                await Promise.race([sentStateEvent, new Promise((resolve) => realSetTimeout(resolve, 500))]);
                 expect(client.sendStateEvent).toHaveBeenCalledWith(
                     mockRoom!.roomId,
                     EventType.GroupCallMemberPrefix,
@@ -426,15 +479,17 @@ describe("MatrixRTCSession", () => {
                     } satisfies SessionMembershipData,
                     `${!useOwnedStateEvents ? "_" : ""}@alice:example.org_AAAAAAA`,
                 );
+                await Promise.race([sentStateFuture, new Promise((resolve) => realSetTimeout(resolve, 500))]);
+                expect(client._unstable_sendStateFuture).toHaveBeenCalledTimes(1);
                 jest.useRealTimers();
             }
 
-            it("sends a membership event with session payload when joining a non-legacy call", () => {
-                testJoin(false);
+            it("sends a membership event with session payload when joining a non-legacy call", async () => {
+                await testJoin(false);
             });
 
-            it("does not prefix the state key with _ for rooms that support user-owned state events", () => {
-                testJoin(true);
+            it("does not prefix the state key with _ for rooms that support user-owned state events", async () => {
+                await testJoin(true);
             });
         });