feat: show call participants in room list (Discord-style)

apps/web/test/unit-tests/SlidingSyncManager-test.ts

@@ -0,0 +1,243 @@
+/*
+Copyright 2024 New Vector Ltd.
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only OR LicenseRef-Element-Commercial
+Please see LICENSE files in the repository root for full details.
+*/
+
+import { type SlidingSync, SlidingSyncEvent, SlidingSyncState } from "matrix-js-sdk/src/sliding-sync";
+import { mocked } from "jest-mock";
+import { ClientEvent, type MatrixClient, MatrixEvent, Room } from "matrix-js-sdk/src/matrix";
+import fetchMock from "@fetch-mock/jest";
+import EventEmitter from "events";
+import { waitFor } from "jest-matrix-react";
+
+import { SlidingSyncManager } from "../../src/SlidingSyncManager";
+import { mkStubRoom, stubClient } from "../test-utils";
+
+class MockSlidingSync extends EventEmitter {
+    lists = {};
+    listModifiedCount = 0;
+    terminated = false;
+    needsResend = false;
+    modifyRoomSubscriptions = jest.fn();
+    getRoomSubscriptions = jest.fn();
+    useCustomSubscription = jest.fn();
+    getListParams = jest.fn();
+    setList = jest.fn();
+    setListRanges = jest.fn();
+    getListData = jest.fn();
+    extensions = jest.fn();
+    desiredRoomSubscriptions = jest.fn();
+}
+
+describe("SlidingSyncManager", () => {
+    let manager: SlidingSyncManager;
+    let slidingSync: SlidingSync;
+    let client: MatrixClient;
+
+    beforeEach(() => {
+        slidingSync = new MockSlidingSync() as unknown as SlidingSync;
+        manager = new SlidingSyncManager();
+        client = stubClient();
+        // by default the client has no rooms: stubClient magically makes rooms annoyingly.
+        mocked(client.getRoom).mockReturnValue(null);
+        (manager as any).configure(client, "invalid");
+        manager.slidingSync = slidingSync;
+        fetchMock.get("https://proxy/client/server.json", {});
+    });
+
+    describe("setRoomVisible", () => {
+        it("adds a subscription for the room", async () => {
+            const roomId = "!room:id";
+            mocked(client.getRoom).mockReturnValue(mkStubRoom(roomId, "foo", client));
+            const subs = new Set<string>();
+            mocked(slidingSync.getRoomSubscriptions).mockReturnValue(subs);
+            await manager.setRoomVisible(roomId);
+            expect(slidingSync.modifyRoomSubscriptions).toHaveBeenCalledWith(new Set<string>([roomId]));
+        });
+
+        it("adds a custom subscription for a lazy-loadable room", async () => {
+            const roomId = "!lazy:id";
+            const room = new Room(roomId, client, client.getUserId()!);
+            room.getLiveTimeline().initialiseState([
+                new MatrixEvent({
+                    type: "m.room.create",
+                    state_key: "",
+                    event_id: "$abc123",
+                    sender: client.getUserId()!,
+                    content: {
+                        creator: client.getUserId()!,
+                    },
+                }),
+            ]);
+            mocked(client.getRoom).mockImplementation((r: string): Room | null => {
+                if (roomId === r) {
+                    return room;
+                }
+                return null;
+            });
+            const subs = new Set<string>();
+            mocked(slidingSync.getRoomSubscriptions).mockReturnValue(subs);
+            await manager.setRoomVisible(roomId);
+            expect(slidingSync.modifyRoomSubscriptions).toHaveBeenCalledWith(new Set<string>([roomId]));
+            // we aren't prescriptive about what the sub name is.
+            expect(slidingSync.useCustomSubscription).toHaveBeenCalledWith(roomId, expect.anything());
+        });
+
+        it("waits if the room is not yet known", async () => {
+            const roomId = "!room:id";
+            mocked(client.getRoom).mockReturnValue(null);
+            const subs = new Set<string>();
+            mocked(slidingSync.getRoomSubscriptions).mockReturnValue(subs);
+
+            const setVisibleDone = jest.fn();
+            manager.setRoomVisible(roomId).then(setVisibleDone);
+
+            await waitFor(() => expect(client.getRoom).toHaveBeenCalledWith(roomId));
+
+            expect(setVisibleDone).not.toHaveBeenCalled();
+
+            const stubRoom = mkStubRoom(roomId, "foo", client);
+            mocked(client.getRoom).mockReturnValue(stubRoom);
+            client.emit(ClientEvent.Room, stubRoom);
+
+            await waitFor(() => expect(setVisibleDone).toHaveBeenCalled());
+        });
+    });
+
+    describe("ensureListRegistered", () => {
+        it("creates a new list based on the key", async () => {
+            const listKey = "key";
+            mocked(slidingSync.getListParams).mockReturnValue(null);
+            await manager.ensureListRegistered(listKey, {
+                sort: ["by_recency"],
+            });
+            expect(slidingSync.setList).toHaveBeenCalledWith(
+                listKey,
+                expect.objectContaining({
+                    sort: ["by_recency"],
+                }),
+            );
+        });
+
+        it("updates an existing list based on the key", async () => {
+            const listKey = "key";
+            mocked(slidingSync.getListParams).mockReturnValue({
+                ranges: [[0, 42]],
+            });
+            await manager.ensureListRegistered(listKey, {
+                sort: ["by_recency"],
+            });
+            expect(slidingSync.setList).toHaveBeenCalledWith(
+                listKey,
+                expect.objectContaining({
+                    sort: ["by_recency"],
+                    ranges: [[0, 42]],
+                }),
+            );
+        });
+
+        it("updates ranges on an existing list based on the key if there's no other changes", async () => {
+            const listKey = "key";
+            mocked(slidingSync.getListParams).mockReturnValue({
+                ranges: [[0, 42]],
+            });
+            await manager.ensureListRegistered(listKey, {
+                ranges: [[0, 52]],
+            });
+            expect(slidingSync.setList).not.toHaveBeenCalled();
+            expect(slidingSync.setListRanges).toHaveBeenCalledWith(listKey, [[0, 52]]);
+        });
+
+        it("no-ops for idential changes", async () => {
+            const listKey = "key";
+            mocked(slidingSync.getListParams).mockReturnValue({
+                ranges: [[0, 42]],
+                sort: ["by_recency"],
+            });
+            await manager.ensureListRegistered(listKey, {
+                ranges: [[0, 42]],
+                sort: ["by_recency"],
+            });
+            expect(slidingSync.setList).not.toHaveBeenCalled();
+            expect(slidingSync.setListRanges).not.toHaveBeenCalled();
+        });
+    });
+
+    describe("startSpidering", () => {
+        it("requests in expanding batchSizes", async () => {
+            const gapMs = 1;
+            const batchSize = 10;
+            mocked(slidingSync.getListData).mockImplementation((key) => {
+                return {
+                    joinedCount: 64,
+                    roomIndexToRoomId: {},
+                };
+            });
+            await (manager as any).startSpidering(slidingSync, batchSize, gapMs);
+
+            // we expect calls for 10,19 -> 20,29 -> 30,39 -> 40,49 -> 50,59 -> 60,69
+            const wantWindows = [
+                [0, 10],
+                [0, 20],
+                [0, 30],
+                [0, 40],
+                [0, 50],
+                [0, 60],
+                [0, 70],
+            ];
+
+            for (let i = 1; i < wantWindows.length; ++i) {
+                // each time we emit, it should expand the range of all 5 lists by 10 until
+                // they all include all the rooms (64), which is 6 emits.
+                slidingSync.emit(SlidingSyncEvent.Lifecycle, SlidingSyncState.Complete, null, undefined);
+                await waitFor(() => expect(slidingSync.getListData).toHaveBeenCalledTimes(i * 5));
+                expect(slidingSync.setListRanges).toHaveBeenCalledTimes(i * 5);
+                expect(slidingSync.setListRanges).toHaveBeenCalledWith("spaces", [wantWindows[i]]);
+            }
+        });
+        it("handles accounts with zero rooms", async () => {
+            const gapMs = 1;
+            const batchSize = 10;
+            mocked(slidingSync.getListData).mockImplementation((key) => {
+                return {
+                    joinedCount: 0,
+                    roomIndexToRoomId: {},
+                };
+            });
+            await (manager as any).startSpidering(slidingSync, batchSize, gapMs);
+            slidingSync.emit(SlidingSyncEvent.Lifecycle, SlidingSyncState.Complete, null, undefined);
+            await waitFor(() => expect(slidingSync.getListData).toHaveBeenCalledTimes(5));
+            // should not have needed to expand the range
+            expect(slidingSync.setListRanges).not.toHaveBeenCalled();
+        });
+    });
+    describe("checkSupport", () => {
+        beforeEach(() => {
+            SlidingSyncManager.serverSupportsSlidingSync = false;
+        });
+        it("shorts out if the server has 'native' sliding sync support", async () => {
+            jest.spyOn(manager, "nativeSlidingSyncSupport").mockResolvedValue(true);
+            expect(SlidingSyncManager.serverSupportsSlidingSync).toBeFalsy();
+            await manager.checkSupport(client);
+            expect(SlidingSyncManager.serverSupportsSlidingSync).toBeTruthy();
+        });
+    });
+    describe("setup", () => {
+        let untypedManager: any;
+
+        beforeEach(() => {
+            untypedManager = manager;
+            jest.spyOn(untypedManager, "configure");
+            jest.spyOn(untypedManager, "startSpidering");
+        });
+        it("uses the baseUrl", async () => {
+            await manager.setup(client);
+            expect(untypedManager.configure).toHaveBeenCalled();
+            expect(untypedManager.configure).toHaveBeenCalledWith(client, client.baseUrl);
+            expect(untypedManager.startSpidering).toHaveBeenCalled();
+        });
+    });
+});