[MatrixRTC] Sticky Events support (MSC4354)

spec/unit/matrixrtc/MatrixRTCSessionManager.spec.ts

@@ -14,136 +14,145 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { ClientEvent, EventTimeline, MatrixClient } from "../../../src";
+import { ClientEvent, EventTimeline, MatrixClient, type Room } from "../../../src";
 import { RoomStateEvent } from "../../../src/models/room-state";
 import { MatrixRTCSessionManager, MatrixRTCSessionManagerEvents } from "../../../src/matrixrtc/MatrixRTCSessionManager";
-import { makeMockRoom, membershipTemplate, mockRoomState } from "./mocks";
+import { makeMockRoom, type MembershipData, membershipTemplate, mockRoomState, mockRTCEvent } from "./mocks";
 import { logger } from "../../../src/logger";
 
-describe("MatrixRTCSessionManager", () => {
-    let client: MatrixClient;
-
-    beforeEach(() => {
-        client = new MatrixClient({ baseUrl: "base_url" });
-        client.matrixRTC.start();
-    });
-
-    afterEach(() => {
-        client.stopClient();
-        client.matrixRTC.stop();
-    });
-
-    it("Fires event when session starts", () => {
-        const onStarted = jest.fn();
-        client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
-
-        try {
-            const room1 = makeMockRoom([membershipTemplate]);
-            jest.spyOn(client, "getRooms").mockReturnValue([room1]);
-
-            client.emit(ClientEvent.Room, room1);
-            expect(onStarted).toHaveBeenCalledWith(room1.roomId, client.matrixRTC.getActiveRoomSession(room1));
-        } finally {
-            client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
+describe.each([{ eventKind: "sticky" }, { eventKind: "memberState" }])(
+    "MatrixRTCSessionManager ($eventKind)",
+    ({ eventKind }) => {
+        let client: MatrixClient;
+
+        function sendLeaveMembership(room: Room, membershipData: MembershipData[]): void {
+            if (eventKind === "memberState") {
+                mockRoomState(room, [{ user_id: membershipTemplate.user_id }]);
+                const roomState = room.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
+                const membEvent = roomState.getStateEvents("org.matrix.msc3401.call.member")[0];
+                client.emit(RoomStateEvent.Events, membEvent, roomState, null);
+            } else {
+                membershipData.splice(0, 1, { user_id: membershipTemplate.user_id });
+                client.emit(ClientEvent.Event, mockRTCEvent(membershipData[0], room.roomId, 10000));
+            }
         }
-    });
-
-    it("Doesn't fire event if unrelated sessions starts", () => {
-        const onStarted = jest.fn();
-        client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
 
-        try {
-            const room1 = makeMockRoom([{ ...membershipTemplate, application: "m.other" }]);
+        beforeEach(() => {
+            client = new MatrixClient({ baseUrl: "base_url" });
+            client.matrixRTC.start();
+        });
+
+        afterEach(() => {
+            client.stopClient();
+            client.matrixRTC.stop();
+        });
+
+        it("Fires event when session starts", () => {
+            const onStarted = jest.fn();
+            client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
+
+            try {
+                const room1 = makeMockRoom([membershipTemplate], eventKind === "sticky");
+                jest.spyOn(client, "getRooms").mockReturnValue([room1]);
+
+                client.emit(ClientEvent.Room, room1);
+                expect(onStarted).toHaveBeenCalledWith(room1.roomId, client.matrixRTC.getActiveRoomSession(room1));
+            } finally {
+                client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
+            }
+        });
+
+        it("Doesn't fire event if unrelated sessions starts", () => {
+            const onStarted = jest.fn();
+            client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
+
+            try {
+                const room1 = makeMockRoom([{ ...membershipTemplate, application: "m.other" }], eventKind === "sticky");
+                jest.spyOn(client, "getRooms").mockReturnValue([room1]);
+
+                client.emit(ClientEvent.Room, room1);
+                expect(onStarted).not.toHaveBeenCalled();
+            } finally {
+                client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
+            }
+        });
+
+        it("Fires event when session ends", () => {
+            const onEnded = jest.fn();
+            client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
+            const membershipData: MembershipData[] = [membershipTemplate];
+            const room1 = makeMockRoom(membershipData, eventKind === "sticky");
             jest.spyOn(client, "getRooms").mockReturnValue([room1]);
-
+            jest.spyOn(client, "getRoom").mockReturnValue(room1);
             client.emit(ClientEvent.Room, room1);
-            expect(onStarted).not.toHaveBeenCalled();
-        } finally {
-            client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
-        }
-    });
-
-    it("Fires event when session ends", () => {
-        const onEnded = jest.fn();
-        client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
-        const room1 = makeMockRoom([membershipTemplate]);
-        jest.spyOn(client, "getRooms").mockReturnValue([room1]);
-        jest.spyOn(client, "getRoom").mockReturnValue(room1);
-
-        client.emit(ClientEvent.Room, room1);
-
-        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);
 
-        expect(onEnded).toHaveBeenCalledWith(room1.roomId, client.matrixRTC.getActiveRoomSession(room1));
-    });
-
-    it("Fires correctly with for with custom sessionDescription", () => {
-        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);
-
-        try {
-            const room1 = makeMockRoom([{ ...membershipTemplate, application: "m.other" }]);
+            sendLeaveMembership(room1, membershipData);
+
+            expect(onEnded).toHaveBeenCalledWith(room1.roomId, client.matrixRTC.getActiveRoomSession(room1));
+        });
+
+        it("Fires correctly with custom sessionDescription", () => {
+            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);
+
+            try {
+                // Create a session for applicaation m.other, we ignore this session ecause it lacks a call_id
+                const room1MembershipData: MembershipData[] = [{ ...membershipTemplate, application: "m.other" }];
+                const room1 = makeMockRoom(room1MembershipData, eventKind === "sticky");
+                jest.spyOn(client, "getRooms").mockReturnValue([room1]);
+                client.emit(ClientEvent.Room, room1);
+                expect(onStarted).not.toHaveBeenCalled();
+                onStarted.mockClear();
+
+                // Create a session for applicaation m.notCall. We expect this call to be tracked because it has a call_id
+                const room2MembershipData: MembershipData[] = [
+                    { ...membershipTemplate, application: "m.notCall", call_id: "test" },
+                ];
+                const room2 = makeMockRoom(room2MembershipData, eventKind === "sticky");
+                jest.spyOn(client, "getRooms").mockReturnValue([room1, room2]);
+                client.emit(ClientEvent.Room, room2);
+                expect(onStarted).toHaveBeenCalled();
+                onStarted.mockClear();
+
+                // Stop room1's RTC session. Tracked.
+                jest.spyOn(client, "getRoom").mockReturnValue(room2);
+                sendLeaveMembership(room2, room2MembershipData);
+                expect(onEnded).toHaveBeenCalled();
+                onEnded.mockClear();
+
+                // Stop room1's RTC session. Not tracked.
+                jest.spyOn(client, "getRoom").mockReturnValue(room1);
+                sendLeaveMembership(room1, room1MembershipData);
+                expect(onEnded).not.toHaveBeenCalled();
+            } finally {
+                client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
+                client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
+            }
+        });
+
+        it("Doesn't fire event if unrelated sessions ends", () => {
+            const onEnded = jest.fn();
+            client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
+            const membership: MembershipData[] = [{ ...membershipTemplate, application: "m.other_app" }];
+            const room1 = makeMockRoom(membership, eventKind === "sticky");
             jest.spyOn(client, "getRooms").mockReturnValue([room1]);
-
-            client.emit(ClientEvent.Room, room1);
-            expect(onStarted).not.toHaveBeenCalled();
-            onStarted.mockClear();
-
-            const room2 = makeMockRoom([{ ...membershipTemplate, application: "m.notCall", call_id: "test" }]);
-            jest.spyOn(client, "getRooms").mockReturnValue([room1, room2]);
-
-            client.emit(ClientEvent.Room, room2);
-            expect(onStarted).toHaveBeenCalled();
-            onStarted.mockClear();
-
-            mockRoomState(room2, [{ user_id: membershipTemplate.user_id }]);
-            jest.spyOn(client, "getRoom").mockReturnValue(room2);
-
-            const roomState = room2.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
-            const membEvent = roomState.getStateEvents("org.matrix.msc3401.call.member")[0];
-            client.emit(RoomStateEvent.Events, membEvent, roomState, null);
-            expect(onEnded).toHaveBeenCalled();
-            onEnded.mockClear();
-
-            mockRoomState(room1, [{ user_id: membershipTemplate.user_id }]);
             jest.spyOn(client, "getRoom").mockReturnValue(room1);
 
-            const roomStateOther = room1.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
-            const membEventOther = roomStateOther.getStateEvents("org.matrix.msc3401.call.member")[0];
-            client.emit(RoomStateEvent.Events, membEventOther, roomStateOther, null);
-            expect(onEnded).not.toHaveBeenCalled();
-        } finally {
-            client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionStarted, onStarted);
-            client.matrixRTC.off(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
-        }
-    });
-
-    it("Doesn't fire event if unrelated sessions ends", () => {
-        const onEnded = jest.fn();
-        client.matrixRTC.on(MatrixRTCSessionManagerEvents.SessionEnded, onEnded);
-        const room1 = makeMockRoom([{ ...membershipTemplate, application: "m.other_app" }]);
-        jest.spyOn(client, "getRooms").mockReturnValue([room1]);
-        jest.spyOn(client, "getRoom").mockReturnValue(room1);
-
-        client.emit(ClientEvent.Room, room1);
-
-        mockRoomState(room1, [{ user_id: membershipTemplate.user_id }]);
+            client.emit(ClientEvent.Room, room1);
 
-        const roomState = room1.getLiveTimeline().getState(EventTimeline.FORWARDS)!;
-        const membEvent = roomState.getStateEvents("org.matrix.msc3401.call.member")[0];
-        client.emit(RoomStateEvent.Events, membEvent, roomState, null);
+            sendLeaveMembership(room1, membership);
 
-        expect(onEnded).not.toHaveBeenCalledWith(room1.roomId, client.matrixRTC.getActiveRoomSession(room1));
-    });
-});
+            expect(onEnded).not.toHaveBeenCalledWith(room1.roomId, client.matrixRTC.getActiveRoomSession(room1));
+        });
+    },
+);

spec/unit/matrixrtc/MembershipManager.spec.ts

@@ -23,6 +23,7 @@ import {
     MatrixError,
     UnsupportedDelayedEventsEndpointError,
     type Room,
+    MAX_STICKY_DURATION_MS,
 } from "../../../src";
 import {
     MembershipManagerEvent,
@@ -33,7 +34,7 @@ import {
 } from "../../../src/matrixrtc";
 import { makeMockClient, makeMockRoom, membershipTemplate, mockCallMembership, type MockClient } from "./mocks";
 import { logger } from "../../../src/logger.ts";
-import { MembershipManager } from "../../../src/matrixrtc/MembershipManager.ts";
+import { MembershipManager, StickyEventMembershipManager } from "../../../src/matrixrtc/MembershipManager.ts";
 
 /**
  * Create a promise that will resolve once a mocked method is called.
@@ -474,7 +475,7 @@ describe("MembershipManager", () => {
 
         it("does not provide focus if the selection method is unknown", () => {
             const manager = new MembershipManager({}, room, client, () => undefined, callSession);
-            manager.join([focus], Object.assign(focusActive, { type: "unknown_type" }));
+            manager.join([focus], { ...focusActive, type: "unknown_type" });
             expect(manager.getActiveFocus()).toBe(undefined);
         });
     });
@@ -938,6 +939,67 @@ describe("MembershipManager", () => {
             expect(client.sendStateEvent).toHaveBeenCalledTimes(0);
         });
     });
+
+    describe("StickyEventMembershipManager", () => {
+        beforeEach(() => {
+            // Provide a default mock that is like the default "non error" server behaviour.
+            (client._unstable_sendStickyDelayedEvent as Mock<any>).mockResolvedValue({ delay_id: "id" });
+            (client._unstable_sendStickyEvent as Mock<any>).mockResolvedValue(undefined);
+        });
+
+        describe("join()", () => {
+            describe("sends a membership event", () => {
+                it("sends a membership event and schedules delayed leave when joining a call", async () => {
+                    const updateDelayedEventHandle = createAsyncHandle<void>(
+                        client._unstable_updateDelayedEvent as Mock,
+                    );
+                    const memberManager = new StickyEventMembershipManager(
+                        undefined,
+                        room,
+                        client,
+                        () => undefined,
+                        callSession,
+                    );
+
+                    memberManager.join([focus], focusActive);
+
+                    await waitForMockCall(client._unstable_sendStickyEvent, Promise.resolve({ event_id: "id" }));
+                    // Test we sent the initial join
+                    expect(client._unstable_sendStickyEvent).toHaveBeenCalledWith(
+                        room.roomId,
+                        MAX_STICKY_DURATION_MS,
+                        null,
+                        "org.matrix.msc3401.call.member",
+                        {
+                            application: "m.call",
+                            call_id: "",
+                            device_id: "AAAAAAA",
+                            expires: 14400000,
+                            foci_preferred: [focus],
+                            focus_active: focusActive,
+                            scope: "m.room",
+                            msc4354_sticky_key: "_@alice:example.org_AAAAAAA_m.call",
+                        } satisfies SessionMembershipData,
+                    );
+                    updateDelayedEventHandle.resolve?.();
+
+                    // Ensure we have sent the delayed disconnect event.
+                    expect(client._unstable_sendStickyDelayedEvent).toHaveBeenCalledWith(
+                        room.roomId,
+                        MAX_STICKY_DURATION_MS,
+                        { delay: 8000 },
+                        null,
+                        "org.matrix.msc3401.call.member",
+                        {
+                            msc4354_sticky_key: "_@alice:example.org_AAAAAAA_m.call",
+                        },
+                    );
+                    // ..once
+                    expect(client._unstable_sendStickyDelayedEvent).toHaveBeenCalledTimes(1);
+                });
+            });
+        });
+    });
 });
 
 it("Should prefix log with MembershipManager used", () => {