forked from mystiq/hydrogen-web
606 lines
27 KiB
JavaScript
606 lines
27 KiB
JavaScript
/*
|
|
Copyright 2020 Bruno Windels <bruno@windels.cloud>
|
|
Copyright 2021 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 {SortedArray, AsyncMappedList, ConcatList, ObservableArray} from "../../../observable/index.js";
|
|
import {Disposables} from "../../../utils/Disposables.js";
|
|
import {Direction} from "./Direction.js";
|
|
import {TimelineReader} from "./persistence/TimelineReader.js";
|
|
import {PendingEventEntry} from "./entries/PendingEventEntry.js";
|
|
import {RoomMember} from "../members/RoomMember.js";
|
|
import {PowerLevels} from "./PowerLevels.js";
|
|
import {getRelation, ANNOTATION_RELATION_TYPE} from "./relations.js";
|
|
import {REDACTION_TYPE} from "../common.js";
|
|
|
|
export class Timeline {
|
|
constructor({roomId, storage, closeCallback, fragmentIdComparer, pendingEvents, clock}) {
|
|
this._roomId = roomId;
|
|
this._storage = storage;
|
|
this._closeCallback = closeCallback;
|
|
this._fragmentIdComparer = fragmentIdComparer;
|
|
this._disposables = new Disposables();
|
|
this._pendingEvents = pendingEvents;
|
|
this._clock = clock;
|
|
// constructing this early avoid some problem while sync and openTimeline race
|
|
this._remoteEntries = new SortedArray((a, b) => a.compare(b));
|
|
this._ownMember = null;
|
|
this._timelineReader = new TimelineReader({
|
|
roomId: this._roomId,
|
|
storage: this._storage,
|
|
fragmentIdComparer: this._fragmentIdComparer
|
|
});
|
|
this._readerRequest = null;
|
|
this._allEntries = null;
|
|
this._powerLevels = null;
|
|
}
|
|
|
|
/** @package */
|
|
async load(user, membership, log) {
|
|
const txn = await this._storage.readTxn(this._timelineReader.readTxnStores.concat(
|
|
this._storage.storeNames.roomMembers,
|
|
this._storage.storeNames.roomState
|
|
));
|
|
const memberData = await txn.roomMembers.get(this._roomId, user.id);
|
|
if (memberData) {
|
|
this._ownMember = new RoomMember(memberData);
|
|
} else {
|
|
// this should never happen, as our own join into the room would have
|
|
// made us receive our own member event, but just to be on the safe side and not crash,
|
|
// fall back to bare user id
|
|
this._ownMember = RoomMember.fromUserId(this._roomId, user.id, membership);
|
|
}
|
|
// it should be fine to not update the local entries,
|
|
// as they should only populate once the view subscribes to it
|
|
// if they are populated already, the sender profile would be empty
|
|
|
|
this._powerLevels = await this._loadPowerLevels(membership, txn);
|
|
// 30 seems to be a good amount to fill the entire screen
|
|
const readerRequest = this._disposables.track(this._timelineReader.readFromEnd(30, txn, log));
|
|
try {
|
|
const entries = await readerRequest.complete();
|
|
this._setupEntries(entries);
|
|
} finally {
|
|
this._disposables.disposeTracked(readerRequest);
|
|
}
|
|
// txn should be assumed to have finished here, as decryption will close it.
|
|
}
|
|
|
|
async _loadPowerLevels(membership, txn) {
|
|
// TODO: update power levels as state is updated
|
|
const powerLevelsState = await txn.roomState.get(this._roomId, "m.room.power_levels", "");
|
|
if (powerLevelsState) {
|
|
return new PowerLevels({
|
|
powerLevelEvent: powerLevelsState.event,
|
|
ownUserId: this._ownMember.userId,
|
|
membership
|
|
});
|
|
}
|
|
const createState = await txn.roomState.get(this._roomId, "m.room.create", "");
|
|
if (createState) {
|
|
return new PowerLevels({
|
|
createEvent: createState.event,
|
|
ownUserId: this._ownMember.userId,
|
|
membership
|
|
});
|
|
} else {
|
|
return new PowerLevels({ownUserId: this._ownMember.userId, membership});
|
|
}
|
|
}
|
|
|
|
_setupEntries(timelineEntries) {
|
|
this._remoteEntries.setManySorted(timelineEntries);
|
|
if (this._pendingEvents) {
|
|
this._localEntries = new AsyncMappedList(this._pendingEvents,
|
|
pe => this._mapPendingEventToEntry(pe),
|
|
(pee, params) => {
|
|
// is sending but redacted, who do we detect that here to remove the relation?
|
|
pee.notifyUpdate(params);
|
|
},
|
|
pee => this._applyAndEmitLocalRelationChange(pee, target => target.removeLocalRelation(pee))
|
|
);
|
|
} else {
|
|
this._localEntries = new ObservableArray();
|
|
}
|
|
this._allEntries = new ConcatList(this._remoteEntries, this._localEntries);
|
|
}
|
|
|
|
async _mapPendingEventToEntry(pe) {
|
|
// we load the redaction target for pending events,
|
|
// so if we are redacting a relation, we can pass the redaction
|
|
// to the relation target and the removal of the relation can
|
|
// be taken into account for local echo.
|
|
let redactingEntry;
|
|
if (pe.eventType === REDACTION_TYPE) {
|
|
redactingEntry = await this._getOrLoadEntry(pe.relatedTxnId, pe.relatedEventId);
|
|
}
|
|
const pee = new PendingEventEntry({
|
|
pendingEvent: pe, member: this._ownMember,
|
|
clock: this._clock, redactingEntry
|
|
});
|
|
this._applyAndEmitLocalRelationChange(pee, target => target.addLocalRelation(pee));
|
|
return pee;
|
|
}
|
|
|
|
_applyAndEmitLocalRelationChange(pee, updater) {
|
|
// this is the contract of findAndUpdate, used in _findAndUpdateRelatedEntry
|
|
const updateOrFalse = e => {
|
|
const params = updater(e);
|
|
return params ? params : false;
|
|
};
|
|
this._findAndUpdateRelatedEntry(pee.pendingEvent.relatedTxnId, pee.relatedEventId, updateOrFalse);
|
|
// also look for a relation target to update with this redaction
|
|
if (pee.redactingEntry) {
|
|
// redactingEntry might be a PendingEventEntry or an EventEntry, so don't assume pendingEvent
|
|
const relatedTxnId = pee.redactingEntry.pendingEvent?.relatedTxnId;
|
|
this._findAndUpdateRelatedEntry(relatedTxnId, pee.redactingEntry.relatedEventId, updateOrFalse);
|
|
}
|
|
}
|
|
|
|
_findAndUpdateRelatedEntry(relatedTxnId, relatedEventId, updateOrFalse) {
|
|
let found = false;
|
|
// first, look in local entries based on txn id
|
|
if (relatedTxnId) {
|
|
found = this._localEntries.findAndUpdate(
|
|
e => e.id === relatedTxnId,
|
|
updateOrFalse,
|
|
);
|
|
}
|
|
// if not found here, look in remote entries based on event id
|
|
if (!found && relatedEventId) {
|
|
this._remoteEntries.findAndUpdate(
|
|
e => e.id === relatedEventId,
|
|
updateOrFalse
|
|
);
|
|
}
|
|
}
|
|
|
|
async getOwnAnnotationEntry(targetId, key) {
|
|
const txn = await this._storage.readWriteTxn([
|
|
this._storage.storeNames.timelineEvents,
|
|
this._storage.storeNames.timelineRelations,
|
|
]);
|
|
const relations = await txn.timelineRelations.getForTargetAndType(this._roomId, targetId, ANNOTATION_RELATION_TYPE);
|
|
for (const relation of relations) {
|
|
const annotation = await txn.timelineEvents.getByEventId(this._roomId, relation.sourceEventId);
|
|
if (annotation && annotation.event.sender === this._ownMember.userId && getRelation(annotation.event).key === key) {
|
|
const eventEntry = new EventEntry(annotation, this._fragmentIdComparer);
|
|
this._addLocalRelationsToNewRemoteEntries([eventEntry]);
|
|
return eventEntry;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** @package */
|
|
updateOwnMember(member) {
|
|
this._ownMember = member;
|
|
}
|
|
|
|
_addLocalRelationsToNewRemoteEntries(entries) {
|
|
// because it is not safe to iterate a derived observable collection
|
|
// before it has any subscriptions, we bail out if this isn't
|
|
// the case yet. This can happen when sync adds or replaces entries
|
|
// before load has finished and the view has subscribed to the timeline.
|
|
//
|
|
// Once the subscription is setup, MappedList will set up the local
|
|
// relations as needed with _applyAndEmitLocalRelationChange,
|
|
// so we're not missing anything by bailing out.
|
|
//
|
|
// _localEntries can also not yet exist
|
|
if (!this._localEntries?.hasSubscriptions) {
|
|
return;
|
|
}
|
|
// find any local relations to this new remote event
|
|
for (const pee of this._localEntries) {
|
|
// this will work because we set relatedEventId when removing remote echos
|
|
if (pee.relatedEventId) {
|
|
const relationTarget = entries.find(e => e.id === pee.relatedEventId);
|
|
// no need to emit here as this entry is about to be added
|
|
relationTarget?.addLocalRelation(pee);
|
|
}
|
|
if (pee.redactingEntry) {
|
|
const eventId = pee.redactingEntry.relatedEventId;
|
|
const relationTarget = entries.find(e => e.id === eventId);
|
|
relationTarget?.addLocalRelation(pee);
|
|
}
|
|
}
|
|
}
|
|
|
|
// used in replaceEntries
|
|
static _entryUpdater(existingEntry, entry) {
|
|
entry.updateFrom(existingEntry);
|
|
return entry;
|
|
}
|
|
|
|
/** @package */
|
|
replaceEntries(entries) {
|
|
this._addLocalRelationsToNewRemoteEntries(entries);
|
|
for (const entry of entries) {
|
|
this._remoteEntries.getAndUpdate(entry, Timeline._entryUpdater);
|
|
}
|
|
}
|
|
|
|
/** @package */
|
|
addEntries(newEntries) {
|
|
this._addLocalRelationsToNewRemoteEntries(newEntries);
|
|
this._remoteEntries.setManySorted(newEntries);
|
|
}
|
|
|
|
// tries to prepend `amount` entries to the `entries` list.
|
|
/**
|
|
* [loadAtTop description]
|
|
* @param {[type]} amount [description]
|
|
* @return {boolean} true if the top of the timeline has been reached
|
|
*
|
|
*/
|
|
async loadAtTop(amount) {
|
|
if (this._disposables.isDisposed) {
|
|
return true;
|
|
}
|
|
const firstEventEntry = this._remoteEntries.array.find(e => !!e.eventType);
|
|
if (!firstEventEntry) {
|
|
return true;
|
|
}
|
|
const readerRequest = this._disposables.track(this._timelineReader.readFrom(
|
|
firstEventEntry.asEventKey(),
|
|
Direction.Backward,
|
|
amount
|
|
));
|
|
try {
|
|
const entries = await readerRequest.complete();
|
|
this.addEntries(entries);
|
|
return entries.length < amount;
|
|
} finally {
|
|
this._disposables.disposeTracked(readerRequest);
|
|
}
|
|
}
|
|
|
|
async _getOrLoadEntry(txnId, eventId) {
|
|
if (txnId) {
|
|
// also look for redacting relation in pending events, in case the target is already being sent
|
|
for (const p of this._localEntries) {
|
|
if (p.id === txnId) {
|
|
return p;
|
|
}
|
|
}
|
|
}
|
|
if (eventId) {
|
|
const loadedEntry = this.getByEventId(eventId);
|
|
if (loadedEntry) {
|
|
return loadedEntry;
|
|
} else {
|
|
const txn = await this._storage.readWriteTxn([
|
|
this._storage.storeNames.timelineEvents,
|
|
]);
|
|
const redactionTargetEntry = await txn.timelineEvents.getByEventId(this._roomId, eventId);
|
|
if (redactionTargetEntry) {
|
|
return new EventEntry(redactionTargetEntry, this._fragmentIdComparer);
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
getByEventId(eventId) {
|
|
for (let i = 0; i < this._remoteEntries.length; i += 1) {
|
|
const entry = this._remoteEntries.get(i);
|
|
if (entry.id === eventId) {
|
|
return entry;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** @public */
|
|
get entries() {
|
|
return this._allEntries;
|
|
}
|
|
|
|
/**
|
|
* @internal
|
|
* @return {Array<EventEntry>} remote event entries, should not be modified
|
|
*/
|
|
get remoteEntries() {
|
|
return this._remoteEntries.array;
|
|
}
|
|
|
|
/** @public */
|
|
dispose() {
|
|
if (this._closeCallback) {
|
|
this._disposables.dispose();
|
|
this._closeCallback();
|
|
this._closeCallback = null;
|
|
}
|
|
}
|
|
|
|
/** @internal */
|
|
enableEncryption(decryptEntries) {
|
|
this._timelineReader.enableEncryption(decryptEntries);
|
|
}
|
|
|
|
get powerLevels() {
|
|
return this._powerLevels;
|
|
}
|
|
|
|
get me() {
|
|
return this._ownMember;
|
|
}
|
|
}
|
|
|
|
import {FragmentIdComparer} from "./FragmentIdComparer.js";
|
|
import {poll} from "../../../mocks/poll.js";
|
|
import {Clock as MockClock} from "../../../mocks/Clock.js";
|
|
import {createMockStorage} from "../../../mocks/Storage.js";
|
|
import {ListObserver} from "../../../mocks/ListObserver.js";
|
|
import {createEvent, withTextBody, withContent, withSender} from "../../../mocks/event.js";
|
|
import {NullLogItem} from "../../../logging/NullLogger.js";
|
|
import {EventEntry} from "./entries/EventEntry.js";
|
|
import {User} from "../../User.js";
|
|
import {PendingEvent} from "../sending/PendingEvent.js";
|
|
import {createAnnotation} from "./relations.js";
|
|
|
|
export function tests() {
|
|
const fragmentIdComparer = new FragmentIdComparer([]);
|
|
const roomId = "$abc";
|
|
const alice = "@alice:hs.tld";
|
|
const bob = "@bob:hs.tld";
|
|
|
|
function getIndexFromIterable(it, n) {
|
|
let i = 0;
|
|
for (const item of it) {
|
|
if (i === n) {
|
|
return item;
|
|
}
|
|
i += 1;
|
|
}
|
|
throw new Error("not enough items in iterable");
|
|
}
|
|
|
|
return {
|
|
"adding or replacing entries before subscribing to entries does not lose local relations": async assert => {
|
|
const pendingEvents = new ObservableArray();
|
|
const timeline = new Timeline({roomId, storage: await createMockStorage(),
|
|
closeCallback: () => {}, fragmentIdComparer, pendingEvents, clock: new MockClock()});
|
|
// 1. load timeline
|
|
await timeline.load(new User(alice), "join", new NullLogItem());
|
|
// 2. test replaceEntries and addEntries don't fail
|
|
const event1 = withTextBody("hi!", withSender(bob, createEvent("m.room.message", "!abc")));
|
|
const entry1 = new EventEntry({event: event1, fragmentId: 1, eventIndex: 1}, fragmentIdComparer);
|
|
timeline.replaceEntries([entry1]);
|
|
const event2 = withTextBody("hi bob!", withSender(alice, createEvent("m.room.message", "!def")));
|
|
const entry2 = new EventEntry({event: event2, fragmentId: 1, eventIndex: 2}, fragmentIdComparer);
|
|
timeline.addEntries([entry2]);
|
|
// 3. add local relation (redaction)
|
|
pendingEvents.append(new PendingEvent({data: {
|
|
roomId,
|
|
queueIndex: 1,
|
|
eventType: "m.room.redaction",
|
|
txnId: "t123",
|
|
content: {},
|
|
relatedEventId: event2.event_id
|
|
}}));
|
|
// 4. subscribe (it's now safe to iterate timeline.entries)
|
|
timeline.entries.subscribe(new ListObserver());
|
|
// 5. check the local relation got correctly aggregated
|
|
const locallyRedacted = await poll(() => Array.from(timeline.entries)[0].isRedacting);
|
|
assert.equal(locallyRedacted, true);
|
|
},
|
|
"add and remove local reaction, and cancel again": async assert => {
|
|
// 1. setup timeline with message
|
|
const pendingEvents = new ObservableArray();
|
|
const timeline = new Timeline({roomId, storage: await createMockStorage(),
|
|
closeCallback: () => {}, fragmentIdComparer, pendingEvents, clock: new MockClock()});
|
|
await timeline.load(new User(bob), "join", new NullLogItem());
|
|
timeline.entries.subscribe(new ListObserver());
|
|
const event = withTextBody("hi bob!", withSender(alice, createEvent("m.room.message", "!abc")));
|
|
timeline.addEntries([new EventEntry({event, fragmentId: 1, eventIndex: 2}, fragmentIdComparer)]);
|
|
let entry = getIndexFromIterable(timeline.entries, 0);
|
|
// 2. add local reaction
|
|
pendingEvents.append(new PendingEvent({data: {
|
|
roomId,
|
|
queueIndex: 1,
|
|
eventType: "m.reaction",
|
|
txnId: "t123",
|
|
content: entry.annotate("👋"),
|
|
relatedEventId: entry.id
|
|
}}));
|
|
await poll(() => timeline.entries.length === 2);
|
|
assert.equal(entry.pendingAnnotations.get("👋").count, 1);
|
|
const reactionEntry = getIndexFromIterable(timeline.entries, 1);
|
|
// 3. add redaction to timeline
|
|
pendingEvents.append(new PendingEvent({data: {
|
|
roomId,
|
|
queueIndex: 2,
|
|
eventType: "m.room.redaction",
|
|
txnId: "t456",
|
|
content: {},
|
|
relatedTxnId: reactionEntry.id
|
|
}}));
|
|
// TODO: await nextUpdate here with ListObserver, to ensure entry emits an update when pendingAnnotations changes
|
|
await poll(() => timeline.entries.length === 3);
|
|
assert.equal(entry.pendingAnnotations.get("👋").count, 0);
|
|
// 4. cancel redaction
|
|
pendingEvents.remove(1);
|
|
await poll(() => timeline.entries.length === 2);
|
|
assert.equal(entry.pendingAnnotations.get("👋").count, 1);
|
|
// 5. cancel reaction
|
|
pendingEvents.remove(0);
|
|
await poll(() => timeline.entries.length === 1);
|
|
assert(!entry.pendingAnnotations);
|
|
},
|
|
"getOwnAnnotationEntry": async assert => {
|
|
const messageId = "!abc";
|
|
const reactionId = "!def";
|
|
// 1. put event and reaction into storage
|
|
const storage = await createMockStorage();
|
|
const txn = await storage.readWriteTxn([storage.storeNames.timelineEvents, storage.storeNames.timelineRelations]);
|
|
txn.timelineEvents.insert({
|
|
event: withContent(createAnnotation(messageId, "👋"), createEvent("m.reaction", reactionId, bob)),
|
|
fragmentId: 1, eventIndex: 1, roomId
|
|
});
|
|
txn.timelineRelations.add(roomId, messageId, ANNOTATION_RELATION_TYPE, reactionId);
|
|
await txn.complete();
|
|
// 2. setup the timeline
|
|
const timeline = new Timeline({roomId, storage, closeCallback: () => {},
|
|
fragmentIdComparer, pendingEvents: new ObservableArray(), clock: new MockClock()});
|
|
await timeline.load(new User(bob), "join", new NullLogItem());
|
|
// 3. get the own annotation out
|
|
const reactionEntry = await timeline.getOwnAnnotationEntry(messageId, "👋");
|
|
assert.equal(reactionEntry.id, reactionId);
|
|
assert.equal(reactionEntry.relation.key, "👋");
|
|
},
|
|
"remote reaction": async assert => {
|
|
const messageEntry = new EventEntry({
|
|
event: withTextBody("hi bob!", createEvent("m.room.message", "!abc", alice)),
|
|
fragmentId: 1, eventIndex: 2, roomId,
|
|
annotations: { // aggregated like RelationWriter would
|
|
"👋": {count: 1, me: true, firstTimestamp: 0}
|
|
},
|
|
}, fragmentIdComparer);
|
|
// 2. setup timeline
|
|
const pendingEvents = new ObservableArray();
|
|
const timeline = new Timeline({roomId, storage: await createMockStorage(),
|
|
closeCallback: () => {}, fragmentIdComparer, pendingEvents, clock: new MockClock()});
|
|
await timeline.load(new User(bob), "join", new NullLogItem());
|
|
timeline.entries.subscribe(new ListObserver());
|
|
// 3. add message to timeline
|
|
timeline.addEntries([messageEntry]);
|
|
const entry = getIndexFromIterable(timeline.entries, 0);
|
|
assert.equal(entry, messageEntry);
|
|
assert.equal(entry.annotations["👋"].count, 1);
|
|
},
|
|
"remove remote reaction": async assert => {
|
|
// 1. setup timeline
|
|
const pendingEvents = new ObservableArray();
|
|
const timeline = new Timeline({roomId, storage: await createMockStorage(),
|
|
closeCallback: () => {}, fragmentIdComparer, pendingEvents, clock: new MockClock()});
|
|
await timeline.load(new User(bob), "join", new NullLogItem());
|
|
timeline.entries.subscribe(new ListObserver());
|
|
// 2. add message and reaction to timeline
|
|
const messageEntry = new EventEntry({
|
|
event: withTextBody("hi bob!", createEvent("m.room.message", "!abc", alice)),
|
|
fragmentId: 1, eventIndex: 2, roomId,
|
|
}, fragmentIdComparer);
|
|
const reactionEntry = new EventEntry({
|
|
event: withContent(createAnnotation(messageEntry.id, "👋"), createEvent("m.reaction", "!def", bob)),
|
|
fragmentId: 1, eventIndex: 3, roomId
|
|
}, fragmentIdComparer);
|
|
timeline.addEntries([messageEntry, reactionEntry]);
|
|
// 3. redact reaction
|
|
pendingEvents.append(new PendingEvent({data: {
|
|
roomId,
|
|
queueIndex: 1,
|
|
eventType: "m.room.redaction",
|
|
txnId: "t123",
|
|
content: {},
|
|
relatedEventId: reactionEntry.id
|
|
}}));
|
|
await poll(() => timeline.entries.length >= 3);
|
|
assert.equal(messageEntry.pendingAnnotations.get("👋").count, -1);
|
|
},
|
|
"local reaction gets applied after remote echo is added to timeline": async assert => {
|
|
const messageEntry = new EventEntry({event: withTextBody("hi bob!", withSender(alice, createEvent("m.room.message", "!abc"))),
|
|
fragmentId: 1, eventIndex: 2}, fragmentIdComparer);
|
|
// 1. setup timeline
|
|
const pendingEvents = new ObservableArray();
|
|
const timeline = new Timeline({roomId, storage: await createMockStorage(),
|
|
closeCallback: () => {}, fragmentIdComparer, pendingEvents, clock: new MockClock()});
|
|
await timeline.load(new User(bob), "join", new NullLogItem());
|
|
timeline.entries.subscribe(new ListObserver());
|
|
// 2. add local reaction
|
|
pendingEvents.append(new PendingEvent({data: {
|
|
roomId,
|
|
queueIndex: 1,
|
|
eventType: "m.reaction",
|
|
txnId: "t123",
|
|
content: messageEntry.annotate("👋"),
|
|
relatedEventId: messageEntry.id
|
|
}}));
|
|
await poll(() => timeline.entries.length === 1);
|
|
// 3. add remote reaction target
|
|
timeline.addEntries([messageEntry]);
|
|
await poll(() => timeline.entries.length === 2);
|
|
const entry = getIndexFromIterable(timeline.entries, 0);
|
|
assert.equal(entry, messageEntry);
|
|
assert.equal(entry.pendingAnnotations.get("👋").count, 1);
|
|
},
|
|
"local reaction removal gets applied after remote echo is added to timeline with reaction not loaded": async assert => {
|
|
const messageId = "!abc";
|
|
const reactionId = "!def";
|
|
// 1. put reaction in storage
|
|
const storage = await createMockStorage();
|
|
const txn = await storage.readWriteTxn([storage.storeNames.timelineEvents, storage.storeNames.timelineRelations]);
|
|
txn.timelineEvents.insert({
|
|
event: withContent(createAnnotation(messageId, "👋"), createEvent("m.reaction", reactionId, bob)),
|
|
fragmentId: 1, eventIndex: 3, roomId
|
|
});
|
|
await txn.complete();
|
|
// 2. setup timeline
|
|
const pendingEvents = new ObservableArray();
|
|
const timeline = new Timeline({roomId, storage, closeCallback: () => {},
|
|
fragmentIdComparer, pendingEvents, clock: new MockClock()});
|
|
await timeline.load(new User(bob), "join", new NullLogItem());
|
|
timeline.entries.subscribe(new ListObserver());
|
|
// 3. add local redaction for reaction
|
|
pendingEvents.append(new PendingEvent({data: {
|
|
roomId,
|
|
queueIndex: 1,
|
|
eventType: "m.room.redaction",
|
|
txnId: "t123",
|
|
content: {},
|
|
relatedEventId: reactionId
|
|
}}));
|
|
await poll(() => timeline.entries.length === 1);
|
|
// 4. add reaction target
|
|
timeline.addEntries([new EventEntry({
|
|
event: withTextBody("hi bob!", createEvent("m.room.message", messageId, alice)),
|
|
fragmentId: 1, eventIndex: 2}, fragmentIdComparer)
|
|
]);
|
|
await poll(() => timeline.entries.length === 2);
|
|
// 5. check that redaction was linked to reaction target
|
|
const entry = getIndexFromIterable(timeline.entries, 0);
|
|
assert.equal(entry.pendingAnnotations.get("👋").count, -1);
|
|
},
|
|
"decrypted entry preserves content when receiving other update without decryption": async assert => {
|
|
// 1. create encrypted and decrypted entry
|
|
const encryptedEntry = new EventEntry({
|
|
event: withContent({ciphertext: "abc"}, createEvent("m.room.encrypted", "!abc", alice)),
|
|
fragmentId: 1, eventIndex: 1, roomId
|
|
}, fragmentIdComparer);
|
|
const decryptedEntry = encryptedEntry.clone();
|
|
decryptedEntry.setDecryptionResult({
|
|
event: withTextBody("hi bob!", createEvent("m.room.message", encryptedEntry.id, encryptedEntry.sender))
|
|
});
|
|
// 2. setup the timeline
|
|
const timeline = new Timeline({roomId, storage: await createMockStorage(), closeCallback: () => {},
|
|
fragmentIdComparer, pendingEvents: new ObservableArray(), clock: new MockClock()});
|
|
await timeline.load(new User(alice), "join", new NullLogItem());
|
|
timeline.addEntries([decryptedEntry]);
|
|
const observer = new ListObserver();
|
|
timeline.entries.subscribe(observer);
|
|
// 3. replace the entry with one that is not decrypted
|
|
// (as would happen when receiving a reaction,
|
|
// as it does not rerun the decryption)
|
|
// and check that the decrypted content is preserved
|
|
timeline.replaceEntries([encryptedEntry]);
|
|
const {value, type} = await observer.next();
|
|
assert.equal(type, "update");
|
|
assert.equal(value.eventType, "m.room.message");
|
|
assert.equal(value.content.body, "hi bob!");
|
|
}
|
|
};
|
|
}
|