test adding locations

Signed-off-by: Kerry Archibald <[email protected]>

Author: Kerry Archibald

spec/unit/models/beacon.spec.ts

@@ -14,15 +14,15 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-import { EventType } from "../../../src";
+import { EventType } from "../../../src/@types/event";
 import { M_BEACON_INFO } from "../../../src/@types/beacon";
 import {
     isTimestampInDuration,
     isBeaconInfoEventType,
     Beacon,
     BeaconEvent,
 } from "../../../src/models/beacon";
-import { makeBeaconInfoEvent } from "../../test-utils/beacon";
+import { makeBeaconEvent, makeBeaconInfoEvent } from "../../test-utils/beacon";
 
 jest.useFakeTimers();
 
@@ -277,5 +277,93 @@ describe('Beacon', () => {
                 expect(emitSpy).toHaveBeenCalledTimes(1);
             });
         });
+
+        describe('addLocations', () => {
+            it('ignores locations when beacon is not live', () => {
+                const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: false }));
+                const emitSpy = jest.spyOn(beacon, 'emit');
+
+                beacon.addLocations([
+                    makeBeaconEvent(userId, { beaconInfoId: beacon.beaconInfoId, timestamp: now + 1 }),
+                ]);
+
+                expect(beacon.latestLocationState).toBeFalsy();
+                expect(emitSpy).not.toHaveBeenCalled();
+            });
+
+            it('ignores locations outside the beacon live duration', () => {
+                const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
+                const emitSpy = jest.spyOn(beacon, 'emit');
+
+                beacon.addLocations([
+                    // beacon has now + 60000 live period
+                    makeBeaconEvent(userId, { beaconInfoId: beacon.beaconInfoId, timestamp: now + 100000 }),
+                ]);
+
+                expect(beacon.latestLocationState).toBeFalsy();
+                expect(emitSpy).not.toHaveBeenCalled();
+            });
+
+            it('sets latest location state to most recent location', () => {
+                const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
+                const emitSpy = jest.spyOn(beacon, 'emit');
+
+                const locations = [
+                    // older
+                    makeBeaconEvent(
+                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:foo', timestamp: now + 1 },
+                    ),
+                    // newer
+                    makeBeaconEvent(
+                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:bar', timestamp: now + 10000 },
+                    ),
+                    // not valid
+                    makeBeaconEvent(
+                        userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:baz', timestamp: now - 5 },
+                    ),
+                ];
+
+                beacon.addLocations(locations);
+
+                const expectedLatestLocation = {
+                    description: undefined,
+                    timestamp: now + 10000,
+                    uri: 'geo:bar',
+                };
+
+                // the newest valid location
+                expect(beacon.latestLocationState).toEqual(expectedLatestLocation);
+                expect(emitSpy).toHaveBeenCalledWith(BeaconEvent.LocationUpdate, expectedLatestLocation);
+            });
+
+            it('ignores locations that are less recent that the current latest location', () => {
+                const beacon = new Beacon(makeBeaconInfoEvent(userId, roomId, { isLive: true, timeout: 60000 }));
+
+                const olderLocation = makeBeaconEvent(
+                    userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:foo', timestamp: now + 1 },
+                );
+                const newerLocation = makeBeaconEvent(
+                    userId, { beaconInfoId: beacon.beaconInfoId, uri: 'geo:bar', timestamp: now + 10000 },
+                );
+
+                beacon.addLocations([newerLocation]);
+                // latest location set to newerLocation
+                expect(beacon.latestLocationState).toEqual(expect.objectContaining({
+                    uri: 'geo:bar',
+                }));
+
+                const emitSpy = jest.spyOn(beacon, 'emit').mockClear();
+
+                // add older location
+                beacon.addLocations([olderLocation]);
+
+                // no change
+                expect(beacon.latestLocationState).toEqual(expect.objectContaining({
+                    uri: 'geo:bar',
+                }));
+                // no emit
+                expect(emitSpy).not.toHaveBeenCalled();
+            });
+        });
     });
 });

spec/unit/room-state.spec.js

@@ -1,5 +1,5 @@
 import * as utils from "../test-utils/test-utils";
-import { makeBeaconInfoEvent } from "../test-utils/beacon";
+import { makeBeaconEvent, makeBeaconInfoEvent } from "../test-utils/beacon";
 import { filterEmitCallsByEventType } from "../test-utils/emitter";
 import { RoomState, RoomStateEvent } from "../../src/models/room-state";
 import { BeaconEvent } from "../../src/models/beacon";
@@ -712,4 +712,56 @@ describe("RoomState", function() {
             expect(state.maySendEvent('m.room.other_thing', userB)).toEqual(false);
         });
     });
+
+    describe('processBeaconEvents', () => {
+        const beacon1 = makeBeaconInfoEvent(userA, roomId, {}, '$beacon1', '$beacon1');
+        const beacon2 = makeBeaconInfoEvent(userA, roomId, {}, '$beacon2', '$beacon2');
+
+        it('does nothing when state has no beacons', () => {
+            const emitSpy = jest.spyOn(state, 'emit');
+            state.processBeaconEvents([makeBeaconEvent(userA, { beaconInfoId: '$beacon1' })]);
+            expect(emitSpy).not.toHaveBeenCalled();
+        });
+
+        it('does nothing when there are no events', () => {
+            state.setStateEvents([beacon1, beacon2]);
+            const emitSpy = jest.spyOn(state, 'emit').mockClear();
+            state.processBeaconEvents([]);
+            expect(emitSpy).not.toHaveBeenCalled();
+        });
+
+        it('discards events for beacons that are not in state', () => {
+            const location = makeBeaconEvent(userA, {
+                beaconInfoId: 'some-other-beacon',
+            });
+            state.setStateEvents([beacon1, beacon2]);
+            const emitSpy = jest.spyOn(state, 'emit').mockClear();
+            state.processBeaconEvents([location]);
+            expect(emitSpy).not.toHaveBeenCalled();
+        });
+
+        it('adds locations to beacons', () => {
+            const location1 = makeBeaconEvent(userA, {
+                beaconInfoId: '$beacon1', timestamp: Date.now() + 1,
+            });
+            const location2 = makeBeaconEvent(userA, {
+                beaconInfoId: '$beacon1', timestamp: Date.now() + 2,
+            });
+            const location3 = makeBeaconEvent(userA, {
+                beaconInfoId: 'some-other-beacon',
+            });
+            state.setStateEvents([beacon1, beacon2]);
+
+            expect(state.beacons.size).toEqual(2);
+
+            const beaconInstance = state.beacons.get(beacon1.getType());
+            const addLocationsSpy = jest.spyOn(beaconInstance, 'addLocations');
+
+            state.processBeaconEvents([location1, location2, location3]);
+
+            expect(addLocationsSpy).toHaveBeenCalledTimes(1);
+            // only called with locations for beacon1
+            expect(addLocationsSpy).toHaveBeenCalledWith([location1, location2]);
+        });
+    });
 });

spec/unit/utils.spec.ts

@@ -10,7 +10,7 @@ import {
     prevString,
     simpleRetryOperation,
     stringToBase,
-    sortEventsByLatestContentTimestamp
+    sortEventsByLatestContentTimestamp,
 } from "../../src/utils";
 import { logger } from "../../src/logger";
 import { mkMessage } from "../test-utils/test-utils";

src/client.ts

@@ -8928,7 +8928,6 @@ export class MatrixClient extends TypedEventEmitter<EmittedEvents, ClientEventHa
             return;
         }
         const beaconEvents = events.filter(event => M_BEACON.matches(event.getType()));
-        // console.log('hhh processBeaocnEvents', room, beaconEvents);
         room.currentState.processBeaconEvents(beaconEvents);
     }
 

src/models/beacon.ts

@@ -25,9 +25,8 @@ export enum BeaconEvent {
     New = "Beacon.new",
     Update = "Beacon.update",
     LivenessChange = "Beacon.LivenessChange",
-    Destroy = "Destroy",
-    LocationUpdate = "LocationUpdate",
-    Destroy = "Destroy"
+    Destroy = "Beacon.Destroy",
+    LocationUpdate = "Beacon.LocationUpdate",
 }
 
 export type BeaconEventHandlerMap = {
@@ -134,7 +133,6 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
     public addLocations(locationEvents: MatrixEvent[]): void {
         // discard locations for beacons that are not live
 
-        console.log('hhh addLocation', JSON.stringify(locationEvents));
         if (!this.isLive) {
             return;
         }
@@ -151,10 +149,10 @@ export class Beacon extends TypedEventEmitter<Exclude<BeaconEvent, BeaconEvent.N
         });
         const latestLocationEvent = validLocationEvents.sort(sortEventsByLatestContentTimestamp)?.[0];
 
-        this._latestLocationState = parseBeaconContent(latestLocationEvent.getContent());
-
-        console.log('hhh', 'emitting new latest location', this.identifier);
-        this.emit(BeaconEvent.LocationUpdate, this.latestLocationState);
+        if (latestLocationEvent) {
+            this._latestLocationState = parseBeaconContent(latestLocationEvent.getContent());
+            this.emit(BeaconEvent.LocationUpdate, this.latestLocationState);
+        }
     }
 
     private setBeaconInfo(event: MatrixEvent): void {

src/models/room-state.ts

@@ -405,8 +405,11 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
     }
 
     public processBeaconEvents(events: MatrixEvent[]): void {
-        // discard locations if we have no beacons
-        if (!events?.length || !this.beacons.size) {
+        if (
+            !events.length ||
+            // discard locations if we have no beacons
+            !this.beacons.size
+        ) {
             return;
         }
 
@@ -424,7 +427,6 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
         }, {});
 
         Object.entries(locationEventsByBeaconId).forEach(([beaconInfoEventId, events]) => {
-            // TODO better way to find beacon by event_id
             const beacon = [...this.beacons.values()].find(beacon => beacon.beaconInfoId === beaconInfoEventId);
 
             if (beacon) {
@@ -466,7 +468,6 @@ export class RoomState extends TypedEventEmitter<EmittedEvents, EventHandlerMap>
      * @experimental
      */
     private setBeacon(event: MatrixEvent): void {
-        console.log('hhh', event.getType(), event.isRedacted(), event.isRedaction(), event);
         if (this.beacons.has(event.getType())) {
             const beacon = this.beacons.get(event.getType());