Prepare utils for local rooms (#9084)

* Prepare utils for local rooms

* Split up direct-messages module

test/utils/direct-messages-test.ts

@@ -0,0 +1,175 @@
+/*
+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 { ClientEvent, MatrixClient, Room } from "matrix-js-sdk/src/matrix";
+
+import DMRoomMap from "../../src/utils/DMRoomMap";
+import { createTestClient } from "../test-utils";
+import { LocalRoom, LocalRoomState, LOCAL_ROOM_ID_PREFIX } from "../../src/models/LocalRoom";
+import * as dmModule from "../../src/utils/direct-messages";
+import dis from "../../src/dispatcher/dispatcher";
+import { Action } from "../../src/dispatcher/actions";
+import { MatrixClientPeg } from "../../src/MatrixClientPeg";
+import { waitForRoomReadyAndApplyAfterCreateCallbacks } from "../../src/utils/local-room";
+import { findDMRoom } from "../../src/utils/dm/findDMRoom";
+import { createDmLocalRoom } from "../../src/utils/dm/createDmLocalRoom";
+import { startDm } from "../../src/utils/dm/startDm";
+
+jest.mock("../../src/utils/rooms", () => ({
+    ...(jest.requireActual("../../src/utils/rooms") as object),
+    privateShouldBeEncrypted: jest.fn(),
+}));
+
+jest.mock("../../src/createRoom", () => ({
+    ...(jest.requireActual("../../src/createRoom") as object),
+    canEncryptToAllUsers: jest.fn(),
+}));
+
+jest.mock("../../src/utils/local-room", () => ({
+    waitForRoomReadyAndApplyAfterCreateCallbacks: jest.fn(),
+}));
+
+jest.mock("../../src/utils/dm/findDMForUser", () => ({
+    findDMForUser: jest.fn(),
+}));
+
+jest.mock("../../src/utils/dm/findDMRoom", () => ({
+    findDMRoom: jest.fn(),
+}));
+
+jest.mock("../../src/utils/dm/createDmLocalRoom", () => ({
+    createDmLocalRoom: jest.fn(),
+}));
+
+jest.mock("../../src/utils/dm/startDm", () => ({
+    startDm: jest.fn(),
+}));
+
+describe("direct-messages", () => {
+    const userId1 = "@user1:example.com";
+    const member1 = new dmModule.DirectoryMember({ user_id: userId1 });
+    let room1: Room;
+    let localRoom: LocalRoom;
+    let dmRoomMap: DMRoomMap;
+    let mockClient: MatrixClient;
+    let roomEvents: Room[];
+
+    beforeEach(() => {
+        jest.restoreAllMocks();
+
+        mockClient = createTestClient();
+        jest.spyOn(MatrixClientPeg, "get").mockReturnValue(mockClient);
+        roomEvents = [];
+        mockClient.on(ClientEvent.Room, (room: Room) => {
+            roomEvents.push(room);
+        });
+
+        room1 = new Room("!room1:example.com", mockClient, userId1);
+        room1.getMyMembership = () => "join";
+
+        localRoom = new LocalRoom(LOCAL_ROOM_ID_PREFIX + "test", mockClient, userId1);
+
+        dmRoomMap = {
+            getDMRoomForIdentifiers: jest.fn(),
+            getDMRoomsForUserId: jest.fn(),
+        } as unknown as DMRoomMap;
+        jest.spyOn(DMRoomMap, "shared").mockReturnValue(dmRoomMap);
+        jest.spyOn(dis, "dispatch");
+
+        jest.setSystemTime(new Date(2022, 7, 4, 11, 12, 30, 42));
+    });
+
+    describe("startDmOnFirstMessage", () => {
+        describe("if no room exists", () => {
+            beforeEach(() => {
+                mocked(findDMRoom).mockReturnValue(null);
+            });
+
+            it("should create a local room and dispatch a view room event", async () => {
+                mocked(createDmLocalRoom).mockResolvedValue(localRoom);
+                const room = await dmModule.startDmOnFirstMessage(mockClient, [member1]);
+                expect(room).toBe(localRoom);
+                expect(dis.dispatch).toHaveBeenCalledWith({
+                    action: Action.ViewRoom,
+                    room_id: room.roomId,
+                    joining: false,
+                    targets: [member1],
+                });
+            });
+        });
+
+        describe("if a room exists", () => {
+            beforeEach(() => {
+                mocked(findDMRoom).mockReturnValue(room1);
+            });
+
+            it("should return the room and dispatch a view room event", async () => {
+                const room = await dmModule.startDmOnFirstMessage(mockClient, [member1]);
+                expect(room).toBe(room1);
+                expect(dis.dispatch).toHaveBeenCalledWith({
+                    action: Action.ViewRoom,
+                    room_id: room1.roomId,
+                    should_peek: false,
+                    joining: false,
+                    metricsTrigger: "MessageUser",
+                });
+            });
+        });
+    });
+
+    describe("createRoomFromLocalRoom", () => {
+        [LocalRoomState.CREATING, LocalRoomState.CREATED, LocalRoomState.ERROR].forEach((state: LocalRoomState) => {
+            it(`should do nothing for room in state ${state}`, async () => {
+                localRoom.state = state;
+                await dmModule.createRoomFromLocalRoom(mockClient, localRoom);
+                expect(localRoom.state).toBe(state);
+                expect(startDm).not.toHaveBeenCalled();
+            });
+        });
+
+        describe("on startDm error", () => {
+            beforeEach(() => {
+                mocked(startDm).mockRejectedValue(true);
+            });
+
+            it("should set the room state to error", async () => {
+                await dmModule.createRoomFromLocalRoom(mockClient, localRoom);
+                expect(localRoom.state).toBe(LocalRoomState.ERROR);
+            });
+        });
+
+        describe("on startDm success", () => {
+            beforeEach(() => {
+                mocked(waitForRoomReadyAndApplyAfterCreateCallbacks).mockResolvedValue(room1.roomId);
+                mocked(startDm).mockResolvedValue(room1.roomId);
+            });
+
+            it(
+                "should set the room into creating state and call waitForRoomReadyAndApplyAfterCreateCallbacks",
+                async () => {
+                    const result = await dmModule.createRoomFromLocalRoom(mockClient, localRoom);
+                    expect(result).toBe(room1.roomId);
+                    expect(localRoom.state).toBe(LocalRoomState.CREATING);
+                    expect(waitForRoomReadyAndApplyAfterCreateCallbacks).toHaveBeenCalledWith(
+                        mockClient,
+                        localRoom,
+                    );
+                },
+            );
+        });
+    });
+});

test/utils/dm/createDmLocalRoom-test.ts

@@ -0,0 +1,114 @@
+/*
+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, KNOWN_SAFE_ROOM_VERSION, MatrixClient } from "matrix-js-sdk/src/matrix";
+
+import { canEncryptToAllUsers } from "../../../src/createRoom";
+import { LocalRoom, LOCAL_ROOM_ID_PREFIX } from "../../../src/models/LocalRoom";
+import { DirectoryMember, Member, ThreepidMember } from "../../../src/utils/direct-messages";
+import { createDmLocalRoom } from "../../../src/utils/dm/createDmLocalRoom";
+import { privateShouldBeEncrypted } from "../../../src/utils/rooms";
+import { createTestClient } from "../../test-utils";
+
+jest.mock("../../../src/utils/rooms", () => ({
+    privateShouldBeEncrypted: jest.fn(),
+}));
+
+jest.mock("../../../src/createRoom", () => ({
+    canEncryptToAllUsers: jest.fn(),
+}));
+
+function assertLocalRoom(room: LocalRoom, targets: Member[], encrypted: boolean) {
+    expect(room.roomId).toBe(LOCAL_ROOM_ID_PREFIX + "t1");
+    expect(room.name).toBe(targets.length ? targets[0].name : "Empty Room");
+    expect(room.encrypted).toBe(encrypted);
+    expect(room.targets).toEqual(targets);
+    expect(room.getMyMembership()).toBe("join");
+
+    const roomCreateEvent = room.currentState.getStateEvents(EventType.RoomCreate)[0];
+    expect(roomCreateEvent).toBeDefined();
+    expect(roomCreateEvent.getContent()["room_version"]).toBe(KNOWN_SAFE_ROOM_VERSION);
+
+    // check that the user and all targets are joined
+    expect(room.getMember("@userId:matrix.org").membership).toBe("join");
+    targets.forEach((target: Member) => {
+        expect(room.getMember(target.userId).membership).toBe("join");
+    });
+
+    if (encrypted) {
+        const encryptionEvent = room.currentState.getStateEvents(EventType.RoomEncryption)[0];
+        expect(encryptionEvent).toBeDefined();
+    }
+}
+
+describe("createDmLocalRoom", () => {
+    let mockClient: MatrixClient;
+    const userId1 = "@user1:example.com";
+    const member1 = new DirectoryMember({ user_id: userId1 });
+    const member2 = new ThreepidMember("user2");
+
+    beforeEach(() => {
+        mockClient = createTestClient();
+    });
+
+    describe("when rooms should be encrypted", () => {
+        beforeEach(() => {
+            mocked(privateShouldBeEncrypted).mockReturnValue(true);
+        });
+
+        it("should create an unencrypted room for 3PID targets", async () => {
+            const room = await createDmLocalRoom(mockClient, [member2]);
+            expect(mockClient.store.storeRoom).toHaveBeenCalledWith(room);
+            assertLocalRoom(room, [member2], false);
+        });
+
+        describe("for MXID targets with encryption available", () => {
+            beforeEach(() => {
+                mocked(canEncryptToAllUsers).mockResolvedValue(true);
+            });
+
+            it("should create an encrypted room", async () => {
+                const room = await createDmLocalRoom(mockClient, [member1]);
+                expect(mockClient.store.storeRoom).toHaveBeenCalledWith(room);
+                assertLocalRoom(room, [member1], true);
+            });
+        });
+
+        describe("for MXID targets with encryption unavailable", () => {
+            beforeEach(() => {
+                mocked(canEncryptToAllUsers).mockResolvedValue(false);
+            });
+
+            it("should create an unencrypted room", async () => {
+                const room = await createDmLocalRoom(mockClient, [member1]);
+                expect(mockClient.store.storeRoom).toHaveBeenCalledWith(room);
+                assertLocalRoom(room, [member1], false);
+            });
+        });
+    });
+
+    describe("if rooms should not be encrypted", () => {
+        beforeEach(() => {
+            mocked(privateShouldBeEncrypted).mockReturnValue(false);
+        });
+
+        it("should create an unencrypted room", async () => {
+            const room = await createDmLocalRoom(mockClient, [member1]);
+            assertLocalRoom(room, [member1], false);
+        });
+    });
+});

test/utils/dm/findDMForUser-test.ts

@@ -0,0 +1,72 @@
+/*
+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 { MatrixClient, Room } from "matrix-js-sdk/src/matrix";
+
+import { DirectoryMember, ThreepidMember } from "../../../src/utils/direct-messages";
+import { MatrixClientPeg } from "../../../src/MatrixClientPeg";
+import DMRoomMap from "../../../src/utils/DMRoomMap";
+import { createTestClient } from "../../test-utils";
+import { findDMRoom } from "../../../src/utils/dm/findDMRoom";
+import { findDMForUser } from "../../../src/utils/dm/findDMForUser";
+
+jest.mock("../../../src/utils/dm/findDMForUser", () => ({
+    findDMForUser: jest.fn(),
+}));
+
+describe("findDMRoom", () => {
+    const userId1 = "@user1:example.com";
+    const member1 = new DirectoryMember({ user_id: userId1 });
+    const member2 = new ThreepidMember("user2");
+    let mockClient: MatrixClient;
+    let room1: Room;
+    let dmRoomMap: DMRoomMap;
+
+    beforeEach(() => {
+        mockClient = createTestClient();
+        jest.spyOn(MatrixClientPeg, "get").mockReturnValue(mockClient);
+
+        room1 = new Room("!room1:example.com", mockClient, userId1);
+        room1.getMyMembership = () => "join";
+
+        dmRoomMap = {
+            getDMRoomForIdentifiers: jest.fn(),
+            getDMRoomsForUserId: jest.fn(),
+        } as unknown as DMRoomMap;
+        jest.spyOn(DMRoomMap, "shared").mockReturnValue(dmRoomMap);
+    });
+
+    it("should return the room for a single target with a room", () => {
+        mocked(findDMForUser).mockReturnValue(room1);
+        expect(findDMRoom(mockClient, [member1])).toBe(room1);
+    });
+
+    it("should return null for a single target without a room", () => {
+        mocked(findDMForUser).mockReturnValue(null);
+        expect(findDMRoom(mockClient, [member1])).toBeNull();
+    });
+
+    it("should return the room for 2 targets with a room", () => {
+        mocked(dmRoomMap.getDMRoomForIdentifiers).mockReturnValue(room1);
+        expect(findDMRoom(mockClient, [member1, member2])).toBe(room1);
+    });
+
+    it("should return null for 2 targets without a room", () => {
+        mocked(dmRoomMap.getDMRoomForIdentifiers).mockReturnValue(null);
+        expect(findDMRoom(mockClient, [member1, member2])).toBeNull();
+    });
+});

test/utils/dm/findDMRoom-test.ts

@@ -0,0 +1,70 @@
+/*
+   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 { MatrixClient, Room } from "matrix-js-sdk/src/matrix";
+
+import { MatrixClientPeg } from "../../../src/MatrixClientPeg";
+import { DirectoryMember, ThreepidMember } from "../../../src/utils/direct-messages";
+import { findDMForUser } from "../../../src/utils/dm/findDMForUser";
+import { findDMRoom } from "../../../src/utils/dm/findDMRoom";
+import DMRoomMap from "../../../src/utils/DMRoomMap";
+import { createTestClient } from "../../test-utils";
+
+jest.mock("../../../src/utils/dm/findDMForUser", () => ({
+    findDMForUser: jest.fn(),
+}));
+
+describe("findDMRoom", () => {
+    const userId1 = "@user1:example.com";
+    const member1 = new DirectoryMember({ user_id: userId1 });
+    const member2 = new ThreepidMember("user2");
+    let mockClient: MatrixClient;
+    let room1: Room;
+    let dmRoomMap: DMRoomMap;
+
+    beforeEach(() => {
+        mockClient = createTestClient();
+        jest.spyOn(MatrixClientPeg, "get").mockReturnValue(mockClient);
+        room1 = new Room("!room1:example.com", mockClient, userId1);
+
+        dmRoomMap = {
+            getDMRoomForIdentifiers: jest.fn(),
+            getDMRoomsForUserId: jest.fn(),
+        } as unknown as DMRoomMap;
+        jest.spyOn(DMRoomMap, "shared").mockReturnValue(dmRoomMap);
+    });
+
+    it("should return the room for a single target with a room", () => {
+        mocked(findDMForUser).mockReturnValue(room1);
+        expect(findDMRoom(mockClient, [member1])).toBe(room1);
+    });
+
+    it("should return null for a single target without a room", () => {
+        mocked(findDMForUser).mockReturnValue(null);
+        expect(findDMRoom(mockClient, [member1])).toBeNull();
+    });
+
+    it("should return the room for 2 targets with a room", () => {
+        mocked(dmRoomMap.getDMRoomForIdentifiers).mockReturnValue(room1);
+        expect(findDMRoom(mockClient, [member1, member2])).toBe(room1);
+    });
+
+    it("should return null for 2 targets without a room", () => {
+        mocked(dmRoomMap.getDMRoomForIdentifiers).mockReturnValue(null);
+        expect(findDMRoom(mockClient, [member1, member2])).toBeNull();
+    });
+});

test/utils/local-room-test.ts

@@ -15,18 +15,20 @@ limitations under the License.
 */
 
 import { mocked } from "jest-mock";
-import { EventType, MatrixClient, Room } from "matrix-js-sdk/src/matrix";
+import { 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";
+import { createTestClient } from "../test-utils";
+import { isRoomReady } from "../../src/utils/localRoom/isRoomReady";
+
+jest.mock("../../src/utils/localRoom/isRoomReady", () => ({
+    isRoomReady: jest.fn(),
+}));
 
 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;
@@ -88,94 +90,6 @@ describe("local-room", () => {
         });
     });
 
-    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;
 
@@ -190,7 +104,7 @@ describe("local-room", () => {
 
         describe("for an immediate ready room", () => {
             beforeEach(() => {
-                jest.spyOn(localRoomModule, "isRoomReady").mockReturnValue(true);
+                mocked(isRoomReady).mockReturnValue(true);
             });
 
             it("should invoke the callbacks, set the room state to created and return the actual room id", async () => {
@@ -203,7 +117,7 @@ describe("local-room", () => {
 
         describe("for a room running into the create timeout", () => {
             beforeEach(() => {
-                jest.spyOn(localRoomModule, "isRoomReady").mockReturnValue(false);
+                mocked(isRoomReady).mockReturnValue(false);
             });
 
             it("should invoke the callbacks, set the room state to created and return the actual room id", (done) => {
@@ -221,12 +135,12 @@ describe("local-room", () => {
 
         describe("for a room that is ready after a while", () => {
             beforeEach(() => {
-                jest.spyOn(localRoomModule, "isRoomReady").mockReturnValue(false);
+                mocked(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);
+                mocked(isRoomReady).mockReturnValue(true);
                 jest.advanceTimersByTime(500);
                 prom.then((roomId: string) => {
                     expect(localRoom.state).toBe(LocalRoomState.CREATED);

test/utils/localRoom/isRoomReady-test.ts

@@ -0,0 +1,126 @@
+/*
+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, LOCAL_ROOM_ID_PREFIX } from "../../../src/models/LocalRoom";
+import { DirectoryMember } from "../../../src/utils/direct-messages";
+import { isRoomReady } from "../../../src/utils/localRoom/isRoomReady";
+import { createTestClient, makeMembershipEvent, mkEvent } from "../../test-utils";
+
+describe("isRoomReady", () => {
+    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");
+    });
+
+    beforeEach(() => {
+        localRoom.targets = [member1];
+    });
+
+    it("should return false if the room has no actual room id", () => {
+        expect(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(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(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(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(isRoomReady(client, localRoom)).toBe(true);
+                    });
+
+                    describe("and an encrypted room", () => {
+                        beforeEach(() => {
+                            localRoom.encrypted = true;
+                        });
+
+                        it("it should return false", () => {
+                            expect(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(isRoomReady(client, localRoom)).toBe(true);
+                            });
+                        });
+                    });
+                });
+            });
+        });
+    });
+});
+