Add LocalRoom (#9023)

test/utils/local-room-test.ts

@@ -0,0 +1,241 @@
+/*
+Copyright 2022 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { mocked } from "jest-mock";
+import { EventType, MatrixClient, Room } from "matrix-js-sdk/src/matrix";
+
+import { LocalRoom, LocalRoomState, LOCAL_ROOM_ID_PREFIX } from "../../src/models/LocalRoom";
+import * as localRoomModule from "../../src/utils/local-room";
+import defaultDispatcher from "../../src/dispatcher/dispatcher";
+import { createTestClient, makeMembershipEvent, mkEvent } from "../test-utils";
+import { DirectoryMember } from "../../src/utils/direct-messages";
+
+describe("local-room", () => {
+    const userId1 = "@user1:example.com";
+    const member1 = new DirectoryMember({ user_id: userId1 });
+    const userId2 = "@user2:example.com";
+    let room1: Room;
+    let localRoom: LocalRoom;
+    let client: MatrixClient;
+
+    beforeEach(() => {
+        client = createTestClient();
+        room1 = new Room("!room1:example.com", client, userId1);
+        room1.getMyMembership = () => "join";
+        localRoom = new LocalRoom(LOCAL_ROOM_ID_PREFIX + "test", client, "@test:example.com");
+        mocked(client.getRoom).mockImplementation((roomId: string) => {
+            if (roomId === localRoom.roomId) {
+                return localRoom;
+            }
+            return null;
+        });
+    });
+
+    describe("doMaybeLocalRoomAction", () => {
+        let callback: jest.Mock;
+
+        beforeEach(() => {
+            callback = jest.fn();
+            callback.mockReturnValue(Promise.resolve());
+            localRoom.actualRoomId = "@new:example.com";
+        });
+
+        it("should invoke the callback for a non-local room", () => {
+            localRoomModule.doMaybeLocalRoomAction("!room:example.com", callback, client);
+            expect(callback).toHaveBeenCalled();
+        });
+
+        it("should invoke the callback with the new room ID for a created room", () => {
+            localRoom.state = LocalRoomState.CREATED;
+            localRoomModule.doMaybeLocalRoomAction(localRoom.roomId, callback, client);
+            expect(callback).toHaveBeenCalledWith(localRoom.actualRoomId);
+        });
+
+        describe("for a local room", () => {
+            let prom;
+
+            beforeEach(() => {
+                jest.spyOn(defaultDispatcher, "dispatch");
+                prom = localRoomModule.doMaybeLocalRoomAction(localRoom.roomId, callback, client);
+            });
+
+            it("dispatch a local_room_event", () => {
+                expect(defaultDispatcher.dispatch).toHaveBeenCalledWith({
+                    action: "local_room_event",
+                    roomId: localRoom.roomId,
+                });
+            });
+
+            it("should resolve the promise after invoking the callback", async () => {
+                localRoom.afterCreateCallbacks.forEach((callback) => {
+                    callback(localRoom.actualRoomId);
+                });
+                await prom;
+            });
+        });
+    });
+
+    describe("isRoomReady", () => {
+        beforeEach(() => {
+            localRoom.targets = [member1];
+        });
+
+        it("should return false if the room has no actual room id", () => {
+            expect(localRoomModule.isRoomReady(client, localRoom)).toBe(false);
+        });
+
+        describe("for a room with an actual room id", () => {
+            beforeEach(() => {
+                localRoom.actualRoomId = room1.roomId;
+                mocked(client.getRoom).mockReturnValue(null);
+            });
+
+            it("it should return false", () => {
+                expect(localRoomModule.isRoomReady(client, localRoom)).toBe(false);
+            });
+
+            describe("and the room is known to the client", () => {
+                beforeEach(() => {
+                    mocked(client.getRoom).mockImplementation((roomId: string) => {
+                        if (roomId === room1.roomId) return room1;
+                    });
+                });
+
+                it("it should return false", () => {
+                    expect(localRoomModule.isRoomReady(client, localRoom)).toBe(false);
+                });
+
+                describe("and all members have been invited or joined", () => {
+                    beforeEach(() => {
+                        room1.currentState.setStateEvents([
+                            makeMembershipEvent(room1.roomId, userId1, "join"),
+                            makeMembershipEvent(room1.roomId, userId2, "invite"),
+                        ]);
+                    });
+
+                    it("it should return false", () => {
+                        expect(localRoomModule.isRoomReady(client, localRoom)).toBe(false);
+                    });
+
+                    describe("and a RoomHistoryVisibility event", () => {
+                        beforeEach(() => {
+                            room1.currentState.setStateEvents([mkEvent({
+                                user: userId1,
+                                event: true,
+                                type: EventType.RoomHistoryVisibility,
+                                room: room1.roomId,
+                                content: {},
+                            })]);
+                        });
+
+                        it("it should return true", () => {
+                            expect(localRoomModule.isRoomReady(client, localRoom)).toBe(true);
+                        });
+
+                        describe("and an encrypted room", () => {
+                            beforeEach(() => {
+                                localRoom.encrypted = true;
+                            });
+
+                            it("it should return false", () => {
+                                expect(localRoomModule.isRoomReady(client, localRoom)).toBe(false);
+                            });
+
+                            describe("and a room encryption state event", () => {
+                                beforeEach(() => {
+                                    room1.currentState.setStateEvents([mkEvent({
+                                        user: userId1,
+                                        event: true,
+                                        type: EventType.RoomEncryption,
+                                        room: room1.roomId,
+                                        content: {},
+                                    })]);
+                                });
+
+                                it("it should return true", () => {
+                                    expect(localRoomModule.isRoomReady(client, localRoom)).toBe(true);
+                                });
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+
+    describe("waitForRoomReadyAndApplyAfterCreateCallbacks", () => {
+        let localRoomCallbackRoomId: string;
+
+        beforeEach(() => {
+            localRoom.actualRoomId = room1.roomId;
+            localRoom.afterCreateCallbacks.push((roomId: string) => {
+                localRoomCallbackRoomId = roomId;
+                return Promise.resolve();
+            });
+            jest.useFakeTimers();
+        });
+
+        describe("for an immediate ready room", () => {
+            beforeEach(() => {
+                jest.spyOn(localRoomModule, "isRoomReady").mockReturnValue(true);
+            });
+
+            it("should invoke the callbacks, set the room state to created and return the actual room id", async () => {
+                const result = await localRoomModule.waitForRoomReadyAndApplyAfterCreateCallbacks(client, localRoom);
+                expect(localRoom.state).toBe(LocalRoomState.CREATED);
+                expect(localRoomCallbackRoomId).toBe(room1.roomId);
+                expect(result).toBe(room1.roomId);
+            });
+        });
+
+        describe("for a room running into the create timeout", () => {
+            beforeEach(() => {
+                jest.spyOn(localRoomModule, "isRoomReady").mockReturnValue(false);
+            });
+
+            it("should invoke the callbacks, set the room state to created and return the actual room id", (done) => {
+                const prom = localRoomModule.waitForRoomReadyAndApplyAfterCreateCallbacks(client, localRoom);
+                jest.advanceTimersByTime(5000);
+                prom.then((roomId: string) => {
+                    expect(localRoom.state).toBe(LocalRoomState.CREATED);
+                    expect(localRoomCallbackRoomId).toBe(room1.roomId);
+                    expect(roomId).toBe(room1.roomId);
+                    expect(jest.getTimerCount()).toBe(0);
+                    done();
+                });
+            });
+        });
+
+        describe("for a room that is ready after a while", () => {
+            beforeEach(() => {
+                jest.spyOn(localRoomModule, "isRoomReady").mockReturnValue(false);
+            });
+
+            it("should invoke the callbacks, set the room state to created and return the actual room id", (done) => {
+                const prom = localRoomModule.waitForRoomReadyAndApplyAfterCreateCallbacks(client, localRoom);
+                jest.spyOn(localRoomModule, "isRoomReady").mockReturnValue(true);
+                jest.advanceTimersByTime(500);
+                prom.then((roomId: string) => {
+                    expect(localRoom.state).toBe(LocalRoomState.CREATED);
+                    expect(localRoomCallbackRoomId).toBe(room1.roomId);
+                    expect(roomId).toBe(room1.roomId);
+                    expect(jest.getTimerCount()).toBe(0);
+                    done();
+                });
+            });
+        });
+    });
+});