Add more tests for coverage

Author: Half-Shot

spec/unit/matrixrtc/MatrixRTCSession.spec.ts

@@ -36,7 +36,8 @@ import {
     mockRTCEvent,
 } from "./mocks";
 import { RTCEncryptionManager } from "../../../src/matrixrtc/RTCEncryptionManager.ts";
-import { type StickyMatrixEvent } from "../../../src/models/room-sticky-events.ts";
+import { RoomStickyEventsEvent, type StickyMatrixEvent } from "../../../src/models/room-sticky-events.ts";
+import { StickyEventMembershipManager } from "../../../src/matrixrtc/MembershipManager.ts";
 
 const mockFocus = { type: "mock" };
 
@@ -395,6 +396,31 @@ describe("MatrixRTCSession", () => {
 
             expect(sess?.sessionDescription.id).toEqual("");
         });
+        it("handles an incoming sticky event to an existing session", () => {
+            const mockRoom = makeMockRoom([membershipTemplate]);
+            const stickyUserId = "@stickyev:user.example";
+
+            sess = MatrixRTCSession.sessionForRoom(client, mockRoom, callSession, {
+                listenForStickyEvents: true,
+                listenForMemberStateEvents: true,
+            });
+            expect(sess.memberships.length).toEqual(1);
+            const stickyEv = mockRTCEvent(
+                {
+                    ...membershipTemplate,
+                    user_id: stickyUserId,
+                    msc4354_sticky_key: `_${stickyUserId}_${membershipTemplate.device_id}`,
+                },
+                mockRoom.roomId,
+                15000,
+                Date.now() - 1000, // Sticky event comes first.
+            ) as StickyMatrixEvent;
+            mockRoom._unstable_getStickyEvents.mockImplementation(() => {
+                return [stickyEv];
+            });
+            mockRoom.emit(RoomStickyEventsEvent.Update, [stickyEv], [], []);
+            expect(sess.memberships.length).toEqual(2);
+        });
     });
 
     describe("getOldestMembership", () => {
@@ -521,6 +547,12 @@ describe("MatrixRTCSession", () => {
             expect(sess!.isJoined()).toEqual(true);
         });
 
+        it("uses the sticky events membership manager implementation", () => {
+            sess!.joinRoomSession([mockFocus], mockFocus, { unstableSendStickyEvents: true });
+            expect(sess!.isJoined()).toEqual(true);
+            expect(sess!["membershipManager"] instanceof StickyEventMembershipManager).toEqual(true);
+        });
+
         it("sends a notification when starting a call and emit DidSendCallNotification", async () => {
             // Simulate a join, including the update to the room state
             // Ensure sendEvent returns event IDs so the DidSendCallNotification payload includes them

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", () => {

src/matrixrtc/MatrixRTCSession.ts

@@ -811,14 +811,14 @@ export class MatrixRTCSession extends TypedEventEmitter<
     /**
      * Call this when the Matrix room members have changed.
      */
-    private onRoomMemberUpdate = (): void => {
+    private readonly onRoomMemberUpdate = (): void => {
         this.recalculateSessionMembers();
     };
 
     /**
      * Call this when a sticky event update has occured.
      */
-    private onStickyEventUpdate: RoomStickyEventsMap[RoomStickyEventsEvent.Update] = (
+    private readonly onStickyEventUpdate: RoomStickyEventsMap[RoomStickyEventsEvent.Update] = (
         added,
         updated,
         removed,

src/matrixrtc/MembershipManager.ts

@@ -679,8 +679,14 @@ export class MembershipManager
     }
 
     protected clientSendMembership: (myMembership: SessionMembershipData | EmptyObject) => Promise<ISendEventResponse> =
-        (myMembership) =>
-            this.client.sendStateEvent(this.room.roomId, EventType.GroupCallMemberPrefix, myMembership, this.stateKey);
+        (myMembership) => {
+            return this.client.sendStateEvent(
+                this.room.roomId,
+                EventType.GroupCallMemberPrefix,
+                myMembership,
+                this.stateKey,
+            );
+        };
 
     private async sendJoinEvent(): Promise<ActionUpdate> {
         return await this.clientSendMembership(this.makeMyMembership(this.membershipEventExpiryMs))
@@ -1030,7 +1036,7 @@ export class StickyEventMembershipManager extends MembershipManager {
         super(joinConfig, room, clientWithSticky, getOldestMembership, sessionDescription, parentLogger);
     }
 
-    protected clientSendDelayedEvent: () => Promise<SendDelayedEventResponse> = () =>
+    protected clientSendDelayedDisconnectMembership: () => Promise<SendDelayedEventResponse> = () =>
         this.clientWithSticky._unstable_sendStickyDelayedEvent(
             this.room.roomId,
             STICK_DURATION_MS,
@@ -1041,14 +1047,15 @@ export class StickyEventMembershipManager extends MembershipManager {
         );
 
     protected clientSendMembership: (myMembership: SessionMembershipData | EmptyObject) => Promise<ISendEventResponse> =
-        (myMembership) =>
-            this.clientWithSticky._unstable_sendStickyEvent(
+        (myMembership) => {
+            return this.clientWithSticky._unstable_sendStickyEvent(
                 this.room.roomId,
                 STICK_DURATION_MS,
                 null,
                 EventType.GroupCallMemberPrefix,
                 { ...myMembership, msc4354_sticky_key: this.stateKey },
             );
+        };
 
     protected actionUpdateFromErrors(
         error: unknown,