ab934a2a08
Signed-off-by: Kerry Archibald <kerrya@element.io>
487 lines
19 KiB
TypeScript
487 lines
19 KiB
TypeScript
/*
|
|
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 { Room, Beacon, BeaconEvent } from "matrix-js-sdk/src/matrix";
|
|
import { M_BEACON_INFO } from "matrix-js-sdk/src/@types/beacon";
|
|
|
|
import { OwnBeaconStore, OwnBeaconStoreEvent } from "../../src/stores/OwnBeaconStore";
|
|
import { resetAsyncStoreWithClient, setupAsyncStoreWithClient } from "../test-utils";
|
|
import { makeBeaconInfoEvent } from "../test-utils/beacon";
|
|
import { getMockClientWithEventEmitter } from "../test-utils/client";
|
|
|
|
jest.useFakeTimers();
|
|
|
|
describe('OwnBeaconStore', () => {
|
|
// 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),
|
|
getVisibleRooms: jest.fn().mockReturnValue([]),
|
|
unstable_setLiveBeacon: jest.fn().mockResolvedValue({ event_id: '1' }),
|
|
});
|
|
const room1Id = '$room1:server.org';
|
|
const room2Id = '$room2:server.org';
|
|
|
|
// 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 = []): [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 advanceDateAndTime = (ms: number) => {
|
|
// bc liveness check uses Date.now we have to advance this mock
|
|
jest.spyOn(global.Date, 'now').mockReturnValue(now + ms);
|
|
// then advance time for the interval by the same amount
|
|
jest.advanceTimersByTime(ms);
|
|
};
|
|
|
|
const makeOwnBeaconStore = async () => {
|
|
const store = OwnBeaconStore.instance;
|
|
|
|
await setupAsyncStoreWithClient(store, mockClient);
|
|
return store;
|
|
};
|
|
|
|
beforeEach(() => {
|
|
mockClient.getVisibleRooms.mockReturnValue([]);
|
|
mockClient.unstable_setLiveBeacon.mockClear().mockResolvedValue({ event_id: '1' });
|
|
jest.spyOn(global.Date, 'now').mockReturnValue(now);
|
|
jest.spyOn(OwnBeaconStore.instance, 'emit').mockRestore();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await resetAsyncStoreWithClient(OwnBeaconStore.instance);
|
|
});
|
|
|
|
it('works', async () => {
|
|
const store = await makeOwnBeaconStore();
|
|
expect(store.hasLiveBeacons()).toBe(false);
|
|
});
|
|
|
|
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,
|
|
alicesOldRoomIdBeaconInfo,
|
|
bobsRoom1BeaconInfo,
|
|
bobsOldRoom1BeaconInfo,
|
|
]);
|
|
const store = await makeOwnBeaconStore();
|
|
expect(store.hasLiveBeacons()).toBe(true);
|
|
expect(store.getLiveBeaconIds()).toEqual([
|
|
alicesRoom1BeaconInfo.getId(),
|
|
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]));
|
|
});
|
|
|
|
it('destroys beacons', async () => {
|
|
const [room1] = makeRoomsWithStateEvents([
|
|
alicesRoom1BeaconInfo,
|
|
]);
|
|
const store = await makeOwnBeaconStore();
|
|
const beacon = room1.currentState.beacons.get(alicesRoom1BeaconInfo.getId());
|
|
const destroySpy = jest.spyOn(beacon, 'destroy');
|
|
// @ts-ignore
|
|
store.onNotReady();
|
|
|
|
expect(destroySpy).toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('hasLiveBeacons()', () => {
|
|
beforeEach(() => {
|
|
makeRoomsWithStateEvents([
|
|
alicesRoom1BeaconInfo,
|
|
alicesRoom2BeaconInfo,
|
|
alicesOldRoomIdBeaconInfo,
|
|
bobsRoom1BeaconInfo,
|
|
bobsOldRoom1BeaconInfo,
|
|
]);
|
|
});
|
|
|
|
it('returns true when user has live beacons', async () => {
|
|
makeRoomsWithStateEvents([
|
|
alicesRoom1BeaconInfo,
|
|
alicesOldRoomIdBeaconInfo,
|
|
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,
|
|
alicesOldRoomIdBeaconInfo,
|
|
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,
|
|
alicesOldRoomIdBeaconInfo,
|
|
bobsRoom1BeaconInfo,
|
|
bobsOldRoom1BeaconInfo,
|
|
]);
|
|
const store = await makeOwnBeaconStore();
|
|
expect(store.hasLiveBeacons(room2Id)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('getLiveBeaconIds()', () => {
|
|
beforeEach(() => {
|
|
makeRoomsWithStateEvents([
|
|
alicesRoom1BeaconInfo,
|
|
alicesRoom2BeaconInfo,
|
|
alicesOldRoomIdBeaconInfo,
|
|
bobsRoom1BeaconInfo,
|
|
bobsOldRoom1BeaconInfo,
|
|
]);
|
|
});
|
|
|
|
it('returns live beacons when user has live beacons', async () => {
|
|
makeRoomsWithStateEvents([
|
|
alicesRoom1BeaconInfo,
|
|
alicesOldRoomIdBeaconInfo,
|
|
bobsRoom1BeaconInfo,
|
|
bobsOldRoom1BeaconInfo,
|
|
]);
|
|
const store = await makeOwnBeaconStore();
|
|
expect(store.getLiveBeaconIds()).toEqual([
|
|
alicesRoom1BeaconInfo.getId(),
|
|
]);
|
|
});
|
|
|
|
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,
|
|
alicesOldRoomIdBeaconInfo,
|
|
bobsRoom1BeaconInfo,
|
|
bobsOldRoom1BeaconInfo,
|
|
]);
|
|
const store = await makeOwnBeaconStore();
|
|
expect(store.getLiveBeaconIds(room1Id)).toEqual([
|
|
alicesRoom1BeaconInfo.getId(),
|
|
]);
|
|
expect(store.getLiveBeaconIds(room2Id)).toEqual([
|
|
alicesRoom2BeaconInfo.getId(),
|
|
]);
|
|
});
|
|
|
|
it('returns empty array when user does not have live beacons for roomId', async () => {
|
|
makeRoomsWithStateEvents([
|
|
alicesRoom1BeaconInfo,
|
|
alicesOldRoomIdBeaconInfo,
|
|
bobsRoom1BeaconInfo,
|
|
bobsOldRoom1BeaconInfo,
|
|
]);
|
|
const store = await makeOwnBeaconStore();
|
|
expect(store.getLiveBeaconIds(room2Id)).toEqual([]);
|
|
});
|
|
});
|
|
|
|
describe('on new beacon event', () => {
|
|
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, true);
|
|
});
|
|
|
|
it('does not emit 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).not.toHaveBeenCalled();
|
|
});
|
|
});
|
|
|
|
describe('on liveness change event', () => {
|
|
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');
|
|
const alicesBeacon = new Beacon(alicesRoom1BeaconInfo);
|
|
|
|
// time travel until beacon is expired
|
|
advanceDateAndTime(HOUR_MS * 3);
|
|
|
|
mockClient.emit(BeaconEvent.LivenessChange, false, alicesBeacon);
|
|
|
|
expect(store.hasLiveBeacons()).toBe(false);
|
|
expect(store.hasLiveBeacons(room1Id)).toBe(false);
|
|
expect(emitSpy).toHaveBeenCalledWith(OwnBeaconStoreEvent.LivenessChange, false);
|
|
});
|
|
|
|
it('stops beacon when liveness changes from true to false and beacon is expired', async () => {
|
|
makeRoomsWithStateEvents([
|
|
alicesRoom1BeaconInfo,
|
|
]);
|
|
await makeOwnBeaconStore();
|
|
const alicesBeacon = new Beacon(alicesRoom1BeaconInfo);
|
|
const prevEventContent = alicesRoom1BeaconInfo.getContent();
|
|
|
|
// time travel until beacon is expired
|
|
advanceDateAndTime(HOUR_MS * 3);
|
|
|
|
mockClient.emit(BeaconEvent.LivenessChange, false, alicesBeacon);
|
|
|
|
// matches original state of event content
|
|
// except for live property
|
|
const expectedUpdateContent = {
|
|
...prevEventContent,
|
|
[M_BEACON_INFO.name]: {
|
|
...prevEventContent[M_BEACON_INFO.name],
|
|
live: false,
|
|
},
|
|
};
|
|
expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalledWith(
|
|
room1Id,
|
|
alicesRoom1BeaconInfo.getType(),
|
|
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');
|
|
const alicesBeacon = new Beacon(alicesOldRoomIdBeaconInfo);
|
|
const liveUpdate = makeBeaconInfoEvent(
|
|
aliceId, room1Id, { isLive: true }, alicesOldRoomIdBeaconInfo.getId(),
|
|
);
|
|
|
|
// bring the beacon back to life
|
|
alicesBeacon.update(liveUpdate);
|
|
|
|
mockClient.emit(BeaconEvent.LivenessChange, true, alicesBeacon);
|
|
|
|
expect(store.hasLiveBeacons()).toBe(true);
|
|
expect(store.hasLiveBeacons(room1Id)).toBe(true);
|
|
expect(emitSpy).toHaveBeenCalledWith(OwnBeaconStoreEvent.LivenessChange, true);
|
|
});
|
|
});
|
|
|
|
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(alicesOldRoomIdBeaconInfo.getId());
|
|
expect(mockClient.unstable_setLiveBeacon).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('updates beacon to live:false when it is unexpired', async () => {
|
|
const store = await makeOwnBeaconStore();
|
|
|
|
await store.stopBeacon(alicesOldRoomIdBeaconInfo.getId());
|
|
const prevEventContent = alicesRoom1BeaconInfo.getContent();
|
|
|
|
await store.stopBeacon(alicesRoom1BeaconInfo.getId());
|
|
|
|
// matches original state of event content
|
|
// except for live property
|
|
const expectedUpdateContent = {
|
|
...prevEventContent,
|
|
[M_BEACON_INFO.name]: {
|
|
...prevEventContent[M_BEACON_INFO.name],
|
|
live: false,
|
|
},
|
|
};
|
|
expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalledWith(
|
|
room1Id,
|
|
alicesRoom1BeaconInfo.getType(),
|
|
expectedUpdateContent,
|
|
);
|
|
});
|
|
|
|
it('updates beacon to live:false when it is expired but live property is true', async () => {
|
|
const store = await makeOwnBeaconStore();
|
|
|
|
await store.stopBeacon(alicesOldRoomIdBeaconInfo.getId());
|
|
const prevEventContent = alicesRoom1BeaconInfo.getContent();
|
|
|
|
// time travel until beacon is expired
|
|
advanceDateAndTime(HOUR_MS * 3);
|
|
|
|
await store.stopBeacon(alicesRoom1BeaconInfo.getId());
|
|
|
|
// matches original state of event content
|
|
// except for live property
|
|
const expectedUpdateContent = {
|
|
...prevEventContent,
|
|
[M_BEACON_INFO.name]: {
|
|
...prevEventContent[M_BEACON_INFO.name],
|
|
live: false,
|
|
},
|
|
};
|
|
expect(mockClient.unstable_setLiveBeacon).toHaveBeenCalledWith(
|
|
room1Id,
|
|
alicesRoom1BeaconInfo.getType(),
|
|
expectedUpdateContent,
|
|
);
|
|
});
|
|
});
|
|
});
|