/* 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 Please see LICENSE files in the repository root for full details. */ import { Room, Beacon, BeaconEvent, getBeaconInfoIdentifier, MatrixEvent, RoomStateEvent, RoomMember, ContentHelpers, M_BEACON, } from "matrix-js-sdk/src/matrix"; import { KnownMembership } from "matrix-js-sdk/src/types"; import { logger } from "matrix-js-sdk/src/logger"; import { Mocked } from "jest-mock"; import { OwnBeaconStore, OwnBeaconStoreEvent } from "../../src/stores/OwnBeaconStore"; import { advanceDateAndTime, flushPromisesWithFakeTimers, makeMembershipEvent, resetAsyncStoreWithClient, setupAsyncStoreWithClient, } from "../test-utils"; import { makeBeaconInfoEvent, mockGeolocation, watchPositionMockImplementation } from "../test-utils/beacon"; import { getMockClientWithEventEmitter } from "../test-utils/client"; import SettingsStore from "../../src/settings/SettingsStore"; // modern fake timers and lodash.debounce are a faff // short circuit it jest.mock("lodash", () => ({ ...(jest.requireActual("lodash") as object), debounce: jest.fn().mockImplementation((callback) => callback), })); jest.useFakeTimers(); describe("OwnBeaconStore", () => { let geolocation: Mocked; // 14.03.2022 16:15 const now = 1647270879403; const HOUR_MS = 3600000; const aliceId = "@alice:server.org"; const bobId = "@bob:server.org"; const mockClient = getMockClientWithEventEmitter({ getUserId: jest.fn().mockReturnValue(aliceId), getSafeUserId: jest.fn().mockReturnValue(aliceId), getVisibleRooms: jest.fn().mockReturnValue([]), unstable_setLiveBeacon: jest.fn().mockResolvedValue({ event_id: "1" }), sendEvent: jest.fn().mockResolvedValue({ event_id: "1" }), unstable_createLiveBeacon: jest.fn().mockResolvedValue({ event_id: "1" }), isGuest: jest.fn().mockReturnValue(false), }); const room1Id = "$room1:server.org"; const room2Id = "$room2:server.org"; // returned by default geolocation mocks const defaultLocationUri = "geo:54.001927,-8.253491;u=1"; // beacon_info events // created 'an hour ago' // with timeout of 3 hours // event creation sets timestamp to Date.now() jest.spyOn(global.Date, "now").mockReturnValue(now - HOUR_MS); const alicesRoom1BeaconInfo = makeBeaconInfoEvent(aliceId, room1Id, { isLive: true }, "$alice-room1-1"); const alicesRoom2BeaconInfo = makeBeaconInfoEvent(aliceId, room2Id, { isLive: true }, "$alice-room2-1"); const alicesOldRoomIdBeaconInfo = makeBeaconInfoEvent(aliceId, room1Id, { isLive: false }, "$alice-room1-2"); const bobsRoom1BeaconInfo = makeBeaconInfoEvent(bobId, room1Id, { isLive: true }, "$bob-room1-1"); const bobsOldRoom1BeaconInfo = makeBeaconInfoEvent(bobId, room1Id, { isLive: false }, "$bob-room1-2"); // make fresh rooms every time // as we update room state const makeRoomsWithStateEvents = (stateEvents: MatrixEvent[] = []): [Room, Room] => { const room1 = new Room(room1Id, mockClient, aliceId); const room2 = new Room(room2Id, mockClient, aliceId); room1.currentState.setStateEvents(stateEvents); room2.currentState.setStateEvents(stateEvents); mockClient.getVisibleRooms.mockReturnValue([room1, room2]); return [room1, room2]; }; const makeOwnBeaconStore = async () => { const store = OwnBeaconStore.instance; await setupAsyncStoreWithClient(store, mockClient); return store; }; const expireBeaconAndEmit = (store: OwnBeaconStore, beaconInfoEvent: MatrixEvent): void => { const beacon = store.getBeaconById(getBeaconInfoIdentifier(beaconInfoEvent))!; // time travel until beacon is expired advanceDateAndTime(beacon.beaconInfo!.timeout + 100); // force an update on the beacon // @ts-ignore beacon.setBeaconInfo(beaconInfoEvent); mockClient.emit(BeaconEvent.LivenessChange, false, beacon); }; const updateBeaconLivenessAndEmit = ( store: OwnBeaconStore, beaconInfoEvent: MatrixEvent, isLive: boolean, ): void => { const beacon = store.getBeaconById(getBeaconInfoIdentifier(beaconInfoEvent))!; // matches original state of event content // except for live property const updateEvent = makeBeaconInfoEvent( beaconInfoEvent.getSender()!, beaconInfoEvent.getRoomId()!, { isLive, timeout: beacon.beaconInfo!.timeout }, "update-event-id", ); beacon.update(updateEvent); mockClient.emit(BeaconEvent.Update, beaconInfoEvent, beacon); mockClient.emit(BeaconEvent.LivenessChange, false, beacon); }; const addNewBeaconAndEmit = (beaconInfoEvent: MatrixEvent): void => { const beacon = new Beacon(beaconInfoEvent); mockClient.emit(BeaconEvent.New, beaconInfoEvent, beacon); }; const localStorageGetSpy = jest.spyOn(localStorage.__proto__, "getItem").mockReturnValue(undefined); const localStorageSetSpy = jest.spyOn(localStorage.__proto__, "setItem").mockImplementation(() => {}); beforeEach(() => { geolocation = mockGeolocation(); mockClient.getVisibleRooms.mockReturnValue([]); mockClient.unstable_setLiveBeacon.mockClear().mockResolvedValue({ event_id: "1" }); mockClient.sendEvent.mockReset().mockResolvedValue({ event_id: "1" }); jest.spyOn(global.Date, "now").mockReturnValue(now); jest.spyOn(OwnBeaconStore.instance, "emit").mockRestore(); jest.spyOn(logger, "error").mockRestore(); localStorageGetSpy.mockClear().mockReturnValue(undefined); localStorageSetSpy.mockClear(); }); afterEach(async () => { await resetAsyncStoreWithClient(OwnBeaconStore.instance); jest.clearAllTimers(); }); afterAll(() => { localStorageGetSpy.mockRestore(); }); describe("onReady()", () => { it("initialises correctly with no beacons", async () => { makeRoomsWithStateEvents(); const store = await makeOwnBeaconStore(); expect(store.hasLiveBeacons()).toBe(false); expect(store.getLiveBeaconIds()).toEqual([]); }); it("does not add other users beacons to beacon state", async () => { makeRoomsWithStateEvents([bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.hasLiveBeacons()).toBe(false); expect(store.getLiveBeaconIds()).toEqual([]); }); it("adds own users beacons to state", async () => { makeRoomsWithStateEvents([ alicesRoom1BeaconInfo, alicesRoom2BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo, ]); const store = await makeOwnBeaconStore(); expect(store.beaconsByRoomId.get(room1Id)).toEqual( new Set([getBeaconInfoIdentifier(alicesRoom1BeaconInfo)]), ); expect(store.beaconsByRoomId.get(room2Id)).toEqual( new Set([getBeaconInfoIdentifier(alicesRoom2BeaconInfo)]), ); }); it("updates live beacon ids when users own beacons were created on device", async () => { localStorageGetSpy.mockReturnValue( JSON.stringify([alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId()]), ); makeRoomsWithStateEvents([ alicesRoom1BeaconInfo, alicesRoom2BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo, ]); const store = await makeOwnBeaconStore(); expect(store.hasLiveBeacons(room1Id)).toBeTruthy(); expect(store.getLiveBeaconIds()).toEqual([ getBeaconInfoIdentifier(alicesRoom1BeaconInfo), getBeaconInfoIdentifier(alicesRoom2BeaconInfo), ]); }); it("does not do any geolocation when user has no live beacons", async () => { makeRoomsWithStateEvents([bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.hasLiveBeacons()).toBe(false); await flushPromisesWithFakeTimers(); expect(geolocation.watchPosition).not.toHaveBeenCalled(); expect(mockClient.sendEvent).not.toHaveBeenCalled(); }); it("does geolocation and sends location immediately when user has live beacons", async () => { localStorageGetSpy.mockReturnValue( JSON.stringify([alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId()]), ); makeRoomsWithStateEvents([alicesRoom1BeaconInfo, alicesRoom2BeaconInfo]); await makeOwnBeaconStore(); await flushPromisesWithFakeTimers(); expect(geolocation.watchPosition).toHaveBeenCalled(); expect(mockClient.sendEvent).toHaveBeenCalledWith( room1Id, M_BEACON.name, ContentHelpers.makeBeaconContent(defaultLocationUri, now, alicesRoom1BeaconInfo.getId()!), ); expect(mockClient.sendEvent).toHaveBeenCalledWith( room2Id, M_BEACON.name, ContentHelpers.makeBeaconContent(defaultLocationUri, now, alicesRoom2BeaconInfo.getId()!), ); }); }); describe("onNotReady()", () => { it("removes listeners", async () => { const store = await makeOwnBeaconStore(); const removeSpy = jest.spyOn(mockClient, "removeListener"); // @ts-ignore store.onNotReady(); expect(removeSpy.mock.calls[0]).toEqual(expect.arrayContaining([BeaconEvent.LivenessChange])); expect(removeSpy.mock.calls[1]).toEqual(expect.arrayContaining([BeaconEvent.New])); expect(removeSpy.mock.calls[2]).toEqual(expect.arrayContaining([BeaconEvent.Update])); expect(removeSpy.mock.calls[3]).toEqual(expect.arrayContaining([BeaconEvent.Destroy])); expect(removeSpy.mock.calls[4]).toEqual(expect.arrayContaining([RoomStateEvent.Members])); }); it("destroys beacons", async () => { const [room1] = makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const beacon = room1.currentState.beacons.get(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))!; const destroySpy = jest.spyOn(beacon, "destroy"); // @ts-ignore store.onNotReady(); expect(destroySpy).toHaveBeenCalled(); }); }); describe("hasLiveBeacons()", () => { beforeEach(() => { makeRoomsWithStateEvents([ alicesRoom1BeaconInfo, alicesRoom2BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo, ]); localStorageGetSpy.mockReturnValue( JSON.stringify([alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId()]), ); }); it("returns true when user has live beacons", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.hasLiveBeacons()).toBe(true); }); it("returns false when user does not have live beacons", async () => { makeRoomsWithStateEvents([alicesOldRoomIdBeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.hasLiveBeacons()).toBe(false); }); it("returns true when user has live beacons for roomId", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.hasLiveBeacons(room1Id)).toBe(true); }); it("returns false when user does not have live beacons for roomId", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.hasLiveBeacons(room2Id)).toBe(false); }); }); describe("getLiveBeaconIds()", () => { beforeEach(() => { makeRoomsWithStateEvents([ alicesRoom1BeaconInfo, alicesRoom2BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo, ]); localStorageGetSpy.mockReturnValue( JSON.stringify([alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId()]), ); }); it("returns live beacons when user has live beacons", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.getLiveBeaconIds()).toEqual([getBeaconInfoIdentifier(alicesRoom1BeaconInfo)]); }); it("returns empty array when user does not have live beacons", async () => { makeRoomsWithStateEvents([alicesOldRoomIdBeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.getLiveBeaconIds()).toEqual([]); }); it("returns beacon ids for room when user has live beacons for roomId", async () => { makeRoomsWithStateEvents([ alicesRoom1BeaconInfo, alicesRoom2BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo, ]); const store = await makeOwnBeaconStore(); expect(store.getLiveBeaconIds(room1Id)).toEqual([getBeaconInfoIdentifier(alicesRoom1BeaconInfo)]); expect(store.getLiveBeaconIds(room2Id)).toEqual([getBeaconInfoIdentifier(alicesRoom2BeaconInfo)]); }); it("returns empty array when user does not have live beacons for roomId", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo, bobsRoom1BeaconInfo, bobsOldRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); expect(store.getLiveBeaconIds(room2Id)).toEqual([]); }); }); describe("on new beacon event", () => { // assume all beacons were created on this device beforeEach(() => { localStorageGetSpy.mockReturnValue( JSON.stringify([alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId()]), ); }); it("ignores events for irrelevant beacons", async () => { makeRoomsWithStateEvents([]); const store = await makeOwnBeaconStore(); const bobsLiveBeacon = new Beacon(bobsRoom1BeaconInfo); const monitorSpy = jest.spyOn(bobsLiveBeacon, "monitorLiveness"); mockClient.emit(BeaconEvent.New, bobsRoom1BeaconInfo, bobsLiveBeacon); // we dont care about bob expect(monitorSpy).not.toHaveBeenCalled(); expect(store.hasLiveBeacons()).toBe(false); }); it("adds users beacons to state and monitors liveness", async () => { makeRoomsWithStateEvents([]); const store = await makeOwnBeaconStore(); const alicesLiveBeacon = new Beacon(alicesRoom1BeaconInfo); const monitorSpy = jest.spyOn(alicesLiveBeacon, "monitorLiveness"); mockClient.emit(BeaconEvent.New, alicesRoom1BeaconInfo, alicesLiveBeacon); expect(monitorSpy).toHaveBeenCalled(); expect(store.hasLiveBeacons()).toBe(true); expect(store.hasLiveBeacons(room1Id)).toBe(true); }); it("emits a liveness change event when new beacons change live state", async () => { makeRoomsWithStateEvents([]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); const alicesLiveBeacon = new Beacon(alicesRoom1BeaconInfo); mockClient.emit(BeaconEvent.New, alicesRoom1BeaconInfo, alicesLiveBeacon); expect(emitSpy).toHaveBeenCalledWith(OwnBeaconStoreEvent.LivenessChange, [alicesLiveBeacon.identifier]); }); it("emits a liveness change event when new beacons do not change live state", async () => { makeRoomsWithStateEvents([alicesRoom2BeaconInfo]); const store = await makeOwnBeaconStore(); // already live expect(store.hasLiveBeacons()).toBe(true); const emitSpy = jest.spyOn(store, "emit"); const alicesLiveBeacon = new Beacon(alicesRoom1BeaconInfo); mockClient.emit(BeaconEvent.New, alicesRoom1BeaconInfo, alicesLiveBeacon); expect(emitSpy).toHaveBeenCalled(); }); }); describe("on liveness change event", () => { // assume all beacons were created on this device beforeEach(() => { localStorageGetSpy.mockReturnValue( JSON.stringify([ alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId(), alicesOldRoomIdBeaconInfo.getId(), "update-event-id", ]), ); }); it("ignores events for irrelevant beacons", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); const oldLiveBeaconIds = store.getLiveBeaconIds(); const bobsLiveBeacon = new Beacon(bobsRoom1BeaconInfo); mockClient.emit(BeaconEvent.LivenessChange, true, bobsLiveBeacon); expect(emitSpy).not.toHaveBeenCalled(); // strictly equal expect(store.getLiveBeaconIds()).toBe(oldLiveBeaconIds); }); it("updates state and emits beacon liveness changes from true to false", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); // live before expect(store.hasLiveBeacons()).toBe(true); const emitSpy = jest.spyOn(store, "emit"); await expireBeaconAndEmit(store, alicesRoom1BeaconInfo); expect(store.hasLiveBeacons()).toBe(false); expect(store.hasLiveBeacons(room1Id)).toBe(false); expect(emitSpy).toHaveBeenCalledWith(OwnBeaconStoreEvent.LivenessChange, []); }); it("stops beacon when liveness changes from true to false and beacon is expired", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const prevEventContent = alicesRoom1BeaconInfo.getContent(); await expireBeaconAndEmit(store, alicesRoom1BeaconInfo); // matches original state of event content // except for live property const expectedUpdateContent = { ...prevEventContent, live: false, }; expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalledWith(room1Id, expectedUpdateContent); }); it("updates state and when beacon liveness changes from false to true", async () => { makeRoomsWithStateEvents([alicesOldRoomIdBeaconInfo]); const store = await makeOwnBeaconStore(); // not live before expect(store.hasLiveBeacons()).toBe(false); const emitSpy = jest.spyOn(store, "emit"); updateBeaconLivenessAndEmit(store, alicesOldRoomIdBeaconInfo, true); expect(store.hasLiveBeacons()).toBe(true); expect(store.hasLiveBeacons(room1Id)).toBe(true); expect(emitSpy).toHaveBeenCalledWith(OwnBeaconStoreEvent.LivenessChange, [ getBeaconInfoIdentifier(alicesOldRoomIdBeaconInfo), ]); }); }); describe("on room membership changes", () => { // assume all beacons were created on this device beforeEach(() => { localStorageGetSpy.mockReturnValue( JSON.stringify([alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId()]), ); }); it("ignores events for rooms without beacons", async () => { const membershipEvent = makeMembershipEvent(room2Id, aliceId); // no beacons for room2 const [, room2] = makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); const oldLiveBeaconIds = store.getLiveBeaconIds(); mockClient.emit( RoomStateEvent.Members, membershipEvent, room2.currentState, new RoomMember(room2Id, aliceId), ); expect(emitSpy).not.toHaveBeenCalled(); // strictly equal expect(store.getLiveBeaconIds()).toBe(oldLiveBeaconIds); }); it("ignores events for membership changes that are not current user", async () => { // bob joins room1 const membershipEvent = makeMembershipEvent(room1Id, bobId); const member = new RoomMember(room1Id, bobId); member.setMembershipEvent(membershipEvent); const [room1] = makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); const oldLiveBeaconIds = store.getLiveBeaconIds(); mockClient.emit(RoomStateEvent.Members, membershipEvent, room1.currentState, member); expect(emitSpy).not.toHaveBeenCalled(); // strictly equal expect(store.getLiveBeaconIds()).toBe(oldLiveBeaconIds); }); it("ignores events for membership changes that are not leave/ban", async () => { // alice joins room1 const membershipEvent = makeMembershipEvent(room1Id, aliceId); const member = new RoomMember(room1Id, aliceId); member.setMembershipEvent(membershipEvent); const [room1] = makeRoomsWithStateEvents([alicesRoom1BeaconInfo, alicesRoom2BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); const oldLiveBeaconIds = store.getLiveBeaconIds(); mockClient.emit(RoomStateEvent.Members, membershipEvent, room1.currentState, member); expect(emitSpy).not.toHaveBeenCalled(); // strictly equal expect(store.getLiveBeaconIds()).toBe(oldLiveBeaconIds); }); it("destroys and removes beacons when current user leaves room", async () => { // alice leaves room1 const membershipEvent = makeMembershipEvent(room1Id, aliceId, KnownMembership.Leave); const member = new RoomMember(room1Id, aliceId); member.setMembershipEvent(membershipEvent); const [room1] = makeRoomsWithStateEvents([alicesRoom1BeaconInfo, alicesRoom2BeaconInfo]); const store = await makeOwnBeaconStore(); const room1BeaconInstance = store.beacons.get(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))!; const beaconDestroySpy = jest.spyOn(room1BeaconInstance, "destroy"); const emitSpy = jest.spyOn(store, "emit"); mockClient.emit(RoomStateEvent.Members, membershipEvent, room1.currentState, member); expect(emitSpy).toHaveBeenCalledWith( OwnBeaconStoreEvent.LivenessChange, // other rooms beacons still live [getBeaconInfoIdentifier(alicesRoom2BeaconInfo)], ); expect(beaconDestroySpy).toHaveBeenCalledTimes(1); expect(store.getLiveBeaconIds(room1Id)).toEqual([]); }); }); describe("on destroy event", () => { // assume all beacons were created on this device beforeEach(() => { localStorageGetSpy.mockReturnValue( JSON.stringify([ alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId(), alicesOldRoomIdBeaconInfo.getId(), "update-event-id", ]), ); }); it("ignores events for irrelevant beacons", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); const oldLiveBeaconIds = store.getLiveBeaconIds(); const bobsLiveBeacon = new Beacon(bobsRoom1BeaconInfo); mockClient.emit(BeaconEvent.Destroy, bobsLiveBeacon.identifier); expect(emitSpy).not.toHaveBeenCalled(); // strictly equal expect(store.getLiveBeaconIds()).toBe(oldLiveBeaconIds); }); it("updates state and emits beacon liveness changes from true to false", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); // live before expect(store.hasLiveBeacons()).toBe(true); const emitSpy = jest.spyOn(store, "emit"); const beacon = store.getBeaconById(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))!; beacon.destroy(); mockClient.emit(BeaconEvent.Destroy, beacon.identifier); expect(store.hasLiveBeacons()).toBe(false); expect(store.hasLiveBeacons(room1Id)).toBe(false); expect(emitSpy).toHaveBeenCalledWith(OwnBeaconStoreEvent.LivenessChange, []); }); }); describe("stopBeacon()", () => { beforeEach(() => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo, alicesOldRoomIdBeaconInfo]); }); it("does nothing for an unknown beacon id", async () => { const store = await makeOwnBeaconStore(); await store.stopBeacon("randomBeaconId"); expect(mockClient.unstable_setLiveBeacon).not.toHaveBeenCalled(); }); it("does nothing for a beacon that is already not live", async () => { const store = await makeOwnBeaconStore(); await store.stopBeacon(getBeaconInfoIdentifier(alicesOldRoomIdBeaconInfo)); expect(mockClient.unstable_setLiveBeacon).not.toHaveBeenCalled(); }); it("updates beacon to live:false when it is unexpired", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const prevEventContent = alicesRoom1BeaconInfo.getContent(); await store.stopBeacon(getBeaconInfoIdentifier(alicesRoom1BeaconInfo)); // matches original state of event content // except for live property const expectedUpdateContent = { ...prevEventContent, live: false, }; expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalledWith(room1Id, expectedUpdateContent); }); it("records error when stopping beacon event fails to send", async () => { jest.spyOn(logger, "error").mockImplementation(() => {}); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); const error = new Error("oups"); mockClient.unstable_setLiveBeacon.mockRejectedValue(error); await expect(store.stopBeacon(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).rejects.toEqual(error); expect(store.beaconUpdateErrors.get(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toEqual(error); expect(emitSpy).toHaveBeenCalledWith( OwnBeaconStoreEvent.BeaconUpdateError, getBeaconInfoIdentifier(alicesRoom1BeaconInfo), true, ); }); it("clears previous error and emits when stopping beacon works on retry", async () => { jest.spyOn(logger, "error").mockImplementation(() => {}); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); const error = new Error("oups"); mockClient.unstable_setLiveBeacon.mockRejectedValueOnce(error); await expect(store.stopBeacon(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).rejects.toEqual(error); expect(store.beaconUpdateErrors.get(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toEqual(error); await store.stopBeacon(getBeaconInfoIdentifier(alicesRoom1BeaconInfo)); // error cleared expect(store.beaconUpdateErrors.get(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toBeFalsy(); // emit called for error clearing expect(emitSpy).toHaveBeenCalledWith( OwnBeaconStoreEvent.BeaconUpdateError, getBeaconInfoIdentifier(alicesRoom1BeaconInfo), false, ); }); it("does not emit BeaconUpdateError when stopping succeeds and beacon did not have errors", async () => { jest.spyOn(logger, "error").mockImplementation(() => {}); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); // error cleared expect(store.beaconUpdateErrors.get(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toBeFalsy(); // emit called for error clearing expect(emitSpy).not.toHaveBeenCalledWith( OwnBeaconStoreEvent.BeaconUpdateError, getBeaconInfoIdentifier(alicesRoom1BeaconInfo), false, ); }); it("updates beacon to live:false when it is expired but live property is true", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const prevEventContent = alicesRoom1BeaconInfo.getContent(); // time travel until beacon is expired advanceDateAndTime(HOUR_MS * 3); await store.stopBeacon(getBeaconInfoIdentifier(alicesRoom1BeaconInfo)); // matches original state of event content // except for live property const expectedUpdateContent = { ...prevEventContent, live: false, }; expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalledWith(room1Id, expectedUpdateContent); }); it("removes beacon event id from local store", async () => { localStorageGetSpy.mockReturnValue( JSON.stringify([alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId()]), ); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); await store.stopBeacon(getBeaconInfoIdentifier(alicesRoom1BeaconInfo)); expect(localStorageSetSpy).toHaveBeenCalledWith( "mx_live_beacon_created_id", // stopped beacon's event_id was removed JSON.stringify([alicesRoom2BeaconInfo.getId()]), ); }); }); describe("publishing positions", () => { // assume all beacons were created on this device beforeEach(() => { localStorageGetSpy.mockReturnValue( JSON.stringify([ alicesRoom1BeaconInfo.getId(), alicesRoom2BeaconInfo.getId(), alicesOldRoomIdBeaconInfo.getId(), "update-event-id", ]), ); }); it("stops watching position when user has no more live beacons", async () => { // geolocation is only going to emit 1 position geolocation.watchPosition.mockImplementation(watchPositionMockImplementation([0])); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); // two locations were published expect(mockClient.sendEvent).toHaveBeenCalledTimes(1); // expire the beacon // user now has no live beacons await expireBeaconAndEmit(store, alicesRoom1BeaconInfo); // stop watching location expect(geolocation.clearWatch).toHaveBeenCalled(); expect(store.isMonitoringLiveLocation).toEqual(false); }); describe("when store is initialised with live beacons", () => { it("starts watching position", async () => { makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); expect(geolocation.watchPosition).toHaveBeenCalled(); expect(store.isMonitoringLiveLocation).toEqual(true); }); it("kills live beacon when geolocation is unavailable", async () => { const errorLogSpy = jest.spyOn(logger, "error").mockImplementation(() => {}); // remove the mock we set // @ts-ignore navigator.geolocation = undefined; makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); expect(store.isMonitoringLiveLocation).toEqual(false); expect(errorLogSpy).toHaveBeenCalledWith("Geolocation failed", "Unavailable"); }); it("kills live beacon when geolocation permissions are not granted", async () => { // similar case to the test above // but these errors are handled differently // above is thrown by element, this passed to error callback by geolocation // return only a permission denied error geolocation.watchPosition.mockImplementation(watchPositionMockImplementation([0], [1])); const errorLogSpy = jest.spyOn(logger, "error").mockImplementation(() => {}); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); expect(store.isMonitoringLiveLocation).toEqual(false); expect(errorLogSpy).toHaveBeenCalledWith("Geolocation failed", "PermissionDenied"); }); }); describe("adding a new beacon", () => { it("publishes position for new beacon immediately", async () => { makeRoomsWithStateEvents([]); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); addNewBeaconAndEmit(alicesRoom1BeaconInfo); // wait for store to settle await flushPromisesWithFakeTimers(); expect(mockClient.sendEvent).toHaveBeenCalled(); expect(store.isMonitoringLiveLocation).toEqual(true); }); it("kills live beacons when geolocation is unavailable", async () => { jest.spyOn(logger, "error").mockImplementation(() => {}); // @ts-ignore navigator.geolocation = undefined; makeRoomsWithStateEvents([]); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); addNewBeaconAndEmit(alicesRoom1BeaconInfo); // wait for store to settle await flushPromisesWithFakeTimers(); // stop beacon expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalled(); expect(store.isMonitoringLiveLocation).toEqual(false); }); it("publishes position for new beacon immediately when there were already live beacons", async () => { makeRoomsWithStateEvents([alicesRoom2BeaconInfo]); await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); expect(mockClient.sendEvent).toHaveBeenCalledTimes(1); addNewBeaconAndEmit(alicesRoom1BeaconInfo); // wait for store to settle await flushPromisesWithFakeTimers(); expect(geolocation.getCurrentPosition).toHaveBeenCalled(); // once for original event, // then both live beacons get current position published // after new beacon is added expect(mockClient.sendEvent).toHaveBeenCalledTimes(3); }); }); describe("when publishing position fails", () => { beforeEach(() => { geolocation.watchPosition.mockImplementation( watchPositionMockImplementation([0, 1000, 3000, 3000, 3000]), ); // eat expected console error logs jest.spyOn(logger, "error").mockImplementation(() => {}); }); // we need to advance time and then flush promises // individually for each call to sendEvent // otherwise the sendEvent doesn't reject/resolve and update state // before the next call // advance and flush every 1000ms // until given ms is 'elapsed' const advanceAndFlushPromises = async (timeMs: number) => { while (timeMs > 0) { jest.advanceTimersByTime(1000); await flushPromisesWithFakeTimers(); timeMs -= 1000; } }; it("continues publishing positions after one publish error", async () => { // fail to send first event, then succeed mockClient.sendEvent.mockRejectedValueOnce(new Error("oups")).mockResolvedValue({ event_id: "1" }); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); await advanceAndFlushPromises(50000); // called for each position from watchPosition expect(mockClient.sendEvent).toHaveBeenCalledTimes(5); expect(store.beaconHasLocationPublishError(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toBe(false); expect(store.getLiveBeaconIdsWithLocationPublishError()).toEqual([]); expect(store.hasLocationPublishErrors()).toBe(false); }); it("continues publishing positions when a beacon fails intermittently", async () => { // every second event rejects // meaning this beacon has more errors than the threshold // but they are not consecutive mockClient.sendEvent .mockRejectedValueOnce(new Error("oups")) .mockResolvedValueOnce({ event_id: "1" }) .mockRejectedValueOnce(new Error("oups")) .mockResolvedValueOnce({ event_id: "1" }) .mockRejectedValueOnce(new Error("oups")); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); // wait for store to settle await flushPromisesWithFakeTimers(); await advanceAndFlushPromises(50000); // called for each position from watchPosition expect(mockClient.sendEvent).toHaveBeenCalledTimes(5); expect(store.beaconHasLocationPublishError(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toBe(false); expect(store.hasLocationPublishErrors()).toBe(false); expect(emitSpy).not.toHaveBeenCalledWith( OwnBeaconStoreEvent.LocationPublishError, getBeaconInfoIdentifier(alicesRoom1BeaconInfo), ); }); it("stops publishing positions when a beacon fails consistently", async () => { // always fails to send events mockClient.sendEvent.mockRejectedValue(new Error("oups")); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); // wait for store to settle await flushPromisesWithFakeTimers(); // 5 positions from watchPosition in this period await advanceAndFlushPromises(50000); // only two allowed failures expect(mockClient.sendEvent).toHaveBeenCalledTimes(2); expect(store.beaconHasLocationPublishError(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toBe(true); expect(store.getLiveBeaconIdsWithLocationPublishError()).toEqual([ getBeaconInfoIdentifier(alicesRoom1BeaconInfo), ]); expect(store.getLiveBeaconIdsWithLocationPublishError(room1Id)).toEqual([ getBeaconInfoIdentifier(alicesRoom1BeaconInfo), ]); expect(store.hasLocationPublishErrors()).toBe(true); expect(emitSpy).toHaveBeenCalledWith( OwnBeaconStoreEvent.LocationPublishError, getBeaconInfoIdentifier(alicesRoom1BeaconInfo), ); }); it("stops publishing positions when a beacon has a stopping error", async () => { // reject stopping beacon const error = new Error("oups"); mockClient.unstable_setLiveBeacon.mockRejectedValue(error); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); // 2 positions from watchPosition in this period await advanceAndFlushPromises(5000); // attempt to stop the beacon await expect(store.stopBeacon(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).rejects.toEqual(error); expect(store.beaconUpdateErrors.get(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toEqual(error); // 2 more positions in this period await advanceAndFlushPromises(50000); // only two positions pre-stopping were sent expect(mockClient.sendEvent).toHaveBeenCalledTimes(3); }); it("restarts publishing a beacon after resetting location publish error", async () => { // always fails to send events mockClient.sendEvent.mockRejectedValue(new Error("oups")); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); const store = await makeOwnBeaconStore(); const emitSpy = jest.spyOn(store, "emit"); // wait for store to settle await flushPromisesWithFakeTimers(); // 3 positions from watchPosition in this period await advanceAndFlushPromises(4000); // only two allowed failures expect(mockClient.sendEvent).toHaveBeenCalledTimes(2); expect(store.beaconHasLocationPublishError(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toBe(true); expect(store.hasLocationPublishErrors()).toBe(true); expect(store.hasLocationPublishErrors(room1Id)).toBe(true); expect(emitSpy).toHaveBeenCalledWith( OwnBeaconStoreEvent.LocationPublishError, getBeaconInfoIdentifier(alicesRoom1BeaconInfo), ); // reset emitSpy mock counts to assert on locationPublishError again emitSpy.mockClear(); store.resetLocationPublishError(getBeaconInfoIdentifier(alicesRoom1BeaconInfo)); expect(store.beaconHasLocationPublishError(getBeaconInfoIdentifier(alicesRoom1BeaconInfo))).toBe(false); // 2 more positions from watchPosition in this period await advanceAndFlushPromises(10000); // 2 from before, 2 new ones expect(mockClient.sendEvent).toHaveBeenCalledTimes(4); expect(emitSpy).toHaveBeenCalledWith( OwnBeaconStoreEvent.LocationPublishError, getBeaconInfoIdentifier(alicesRoom1BeaconInfo), ); }); }); it("publishes subsequent positions", async () => { // modern fake timers + debounce + promises are not friends // just testing that positions are published // not that the debounce works geolocation.watchPosition.mockImplementation(watchPositionMockImplementation([0, 1000, 3000])); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); expect(mockClient.sendEvent).toHaveBeenCalledTimes(0); await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); jest.advanceTimersByTime(5000); expect(mockClient.sendEvent).toHaveBeenCalledTimes(3); }); it("stops live beacons when geolocation permissions are revoked", async () => { jest.spyOn(logger, "error").mockImplementation(() => {}); // return two good positions, then a permission denied error geolocation.watchPosition.mockImplementation(watchPositionMockImplementation([0, 1000, 3000], [0, 0, 1])); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); expect(mockClient.sendEvent).toHaveBeenCalledTimes(0); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); jest.advanceTimersByTime(5000); // first two events were sent successfully expect(mockClient.sendEvent).toHaveBeenCalledTimes(2); // stop beacon expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalled(); expect(store.isMonitoringLiveLocation).toEqual(false); }); it("keeps sharing positions when geolocation has a non fatal error", async () => { const errorLogSpy = jest.spyOn(logger, "error").mockImplementation(() => {}); // return good position, timeout error, good position geolocation.watchPosition.mockImplementation(watchPositionMockImplementation([0, 1000, 3000], [0, 3, 0])); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); expect(mockClient.sendEvent).toHaveBeenCalledTimes(0); const store = await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); jest.advanceTimersByTime(5000); // two good locations were sent expect(mockClient.sendEvent).toHaveBeenCalledTimes(2); // still sharing expect(mockClient.unstable_setLiveBeacon).not.toHaveBeenCalled(); expect(store.isMonitoringLiveLocation).toEqual(true); expect(errorLogSpy).toHaveBeenCalledWith( "Geolocation failed", expect.objectContaining({ message: "error message" }), ); }); it("publishes last known position after 30s of inactivity", async () => { geolocation.watchPosition.mockImplementation(watchPositionMockImplementation([0])); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); // published first location expect(mockClient.sendEvent).toHaveBeenCalledTimes(1); advanceDateAndTime(31000); // wait for store to settle await flushPromisesWithFakeTimers(); // republished latest location expect(mockClient.sendEvent).toHaveBeenCalledTimes(2); }); it("does not try to publish anything if there is no known position after 30s of inactivity", async () => { // no position ever returned from geolocation geolocation.watchPosition.mockImplementation(watchPositionMockImplementation([])); geolocation.getCurrentPosition.mockImplementation(watchPositionMockImplementation([])); makeRoomsWithStateEvents([alicesRoom1BeaconInfo]); await makeOwnBeaconStore(); // wait for store to settle await flushPromisesWithFakeTimers(); advanceDateAndTime(31000); // no locations published expect(mockClient.sendEvent).not.toHaveBeenCalled(); }); }); describe("createLiveBeacon", () => { const newEventId = "new-beacon-event-id"; const loggerErrorSpy = jest.spyOn(logger, "error").mockImplementation(() => {}); beforeEach(() => { localStorageGetSpy.mockReturnValue(JSON.stringify([alicesRoom1BeaconInfo.getId()])); localStorageSetSpy.mockClear(); mockClient.unstable_createLiveBeacon.mockResolvedValue({ event_id: newEventId }); }); it("creates a live beacon", async () => { const store = await makeOwnBeaconStore(); const content = ContentHelpers.makeBeaconInfoContent(100); await store.createLiveBeacon(room1Id, content); expect(mockClient.unstable_createLiveBeacon).toHaveBeenCalledWith(room1Id, content); }); it("sets new beacon event id in local storage", async () => { const store = await makeOwnBeaconStore(); const content = ContentHelpers.makeBeaconInfoContent(100); await store.createLiveBeacon(room1Id, content); expect(localStorageSetSpy).toHaveBeenCalledWith( "mx_live_beacon_created_id", JSON.stringify([alicesRoom1BeaconInfo.getId(), newEventId]), ); }); it("handles saving beacon event id when local storage has bad value", async () => { localStorageGetSpy.mockReturnValue(JSON.stringify({ id: "1" })); const store = await makeOwnBeaconStore(); const content = ContentHelpers.makeBeaconInfoContent(100); await store.createLiveBeacon(room1Id, content); // stored successfully expect(localStorageSetSpy).toHaveBeenCalledWith("mx_live_beacon_created_id", JSON.stringify([newEventId])); }); it("creates a live beacon without error when no beacons exist for room", async () => { const store = await makeOwnBeaconStore(); const content = ContentHelpers.makeBeaconInfoContent(100); await store.createLiveBeacon(room1Id, content); // didn't throw, no error log expect(loggerErrorSpy).not.toHaveBeenCalled(); }); it("stops existing live beacon for room before creates new beacon", async () => { // room1 already has a live beacon for alice makeRoomsWithStateEvents([alicesRoom1BeaconInfo, alicesRoom2BeaconInfo]); const store = await makeOwnBeaconStore(); const content = ContentHelpers.makeBeaconInfoContent(100); await store.createLiveBeacon(room1Id, content); // stop alicesRoom1BeaconInfo expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalledWith( room1Id, expect.objectContaining({ live: false }), ); // only called for beacons in room1, room2 beacon is not stopped expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalledTimes(1); // new beacon created expect(mockClient.unstable_createLiveBeacon).toHaveBeenCalledWith(room1Id, content); }); }); describe("If the feature_dynamic_room_predecessors is not enabled", () => { beforeEach(() => { jest.spyOn(SettingsStore, "getValue").mockReturnValue(false); }); it("Passes through the dynamic predecessor setting", async () => { mockClient.getVisibleRooms.mockReset(); mockClient.getVisibleRooms.mockReturnValue([]); await makeOwnBeaconStore(); expect(mockClient.getVisibleRooms).toHaveBeenCalledWith(false); }); }); describe("If the feature_dynamic_room_predecessors is enabled", () => { beforeEach(() => { // Turn on feature_dynamic_room_predecessors setting jest.spyOn(SettingsStore, "getValue").mockImplementation( (settingName) => settingName === "feature_dynamic_room_predecessors", ); }); it("Passes through the dynamic predecessor setting", async () => { mockClient.getVisibleRooms.mockReset(); mockClient.getVisibleRooms.mockReturnValue([]); await makeOwnBeaconStore(); expect(mockClient.getVisibleRooms).toHaveBeenCalledWith(true); }); it("Passes through the dynamic predecessor when reinitialised", async () => { const store = await makeOwnBeaconStore(); mockClient.getVisibleRooms.mockReset(); mockClient.getVisibleRooms.mockReturnValue([]); store.reinitialiseBeaconState(); expect(mockClient.getVisibleRooms).toHaveBeenCalledWith(true); }); }); });