Arsharth/hydrogen-web
1
0
Fork 0
forked from mystiq/hydrogen-web
Code Issues Pull requests Projects Releases Packages Wiki Activity

Make test adjustments requested in PR.

Browse source
This commit is contained in:
Danila Fedorin 2021-09-20 19:37:30 -07:00
parent 50c8b995c3
commit a3a743881d
2 changed files with 36 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

37
src/matrix/room/timeline/persistence/GapWriter.js
View file

@ -298,9 +298,9 @@ export function tests() {
return { storage, txn, fragmentIdComparer, gapWriter, syncWriter, timelineMock: new TimelineMock() }; return { storage, txn, fragmentIdComparer, gapWriter, syncWriter, timelineMock: new TimelineMock() };
} }
async function syncAndWrite(mocks, previousResponse) { async function syncAndWrite(mocks, { previous, limit } = {}) {
const {txn, timelineMock, syncWriter, fragmentIdComparer} = mocks; const {txn, timelineMock, syncWriter, fragmentIdComparer} = mocks;
const syncResponse = timelineMock.sync(previousResponse?.next_batch); const syncResponse = timelineMock.sync(previous?.next_batch, limit);
const {newLiveKey} = await syncWriter.writeSync(syncResponse, false, false, txn, logger); const {newLiveKey} = await syncWriter.writeSync(syncResponse, false, false, txn, logger);
syncWriter.afterSync(newLiveKey); syncWriter.afterSync(newLiveKey);
return { return {
@ -329,14 +329,14 @@ export function tests() {
return txn.timelineFragments.get(roomId, fragmentId); return txn.timelineFragments.get(roomId, fragmentId);
} }
function assertDeepLink(assert, fragment1, fragment2) { function assertFilledLink(assert, fragment1, fragment2) {
assert.equal(fragment1.nextId, fragment2.id); assert.equal(fragment1.nextId, fragment2.id);
assert.equal(fragment2.previousId, fragment1.id); assert.equal(fragment2.previousId, fragment1.id);
assert.equal(fragment1.nextToken, null); assert.equal(fragment1.nextToken, null);
assert.equal(fragment2.previousToken, null); assert.equal(fragment2.previousToken, null);
} }
function assertShallowLink(assert, fragment1, fragment2) { function assertGapLink(assert, fragment1, fragment2) {
assert.equal(fragment1.nextId, fragment2.id); assert.equal(fragment1.nextId, fragment2.id);
assert.equal(fragment2.previousId, fragment1.id); assert.equal(fragment2.previousId, fragment1.id);
assert.notEqual(fragment2.previousToken, null); assert.notEqual(fragment2.previousToken, null);
@ -351,46 +351,49 @@ export function tests() {
await backfillAndWrite(mocks, fragmentEntry); await backfillAndWrite(mocks, fragmentEntry);
const events = await allFragmentEvents(mocks, fragmentEntry.fragmentId); const events = await allFragmentEvents(mocks, fragmentEntry.fragmentId);
assert.deepEqual(events.map(e => e.event_id), eventIds(10, 30)); assert.deepEqual(events.map(e => e.event_id), eventIds(10, 30));
await mocks.txn.complete();
}, },
"Backfilling a fragment that is expected to link up, and does": async assert => { "Backfilling a fragment that is expected to close a gap, and does": async assert => {
const mocks = await setup(); const mocks = await setup();
const { timelineMock } = mocks; const { timelineMock } = mocks;
timelineMock.append(10); timelineMock.append(10);
const {syncResponse, fragmentEntry: firstFragmentEntry} = await syncAndWrite(mocks); const {syncResponse, fragmentEntry: firstFragmentEntry} = await syncAndWrite(mocks, { limit: 10 });
timelineMock.append(15); timelineMock.append(15);
const {fragmentEntry: secondFragmentEntry} = await syncAndWrite(mocks, syncResponse); const {fragmentEntry: secondFragmentEntry} = await syncAndWrite(mocks, { previous: syncResponse, limit: 10 });
await backfillAndWrite(mocks, secondFragmentEntry); await backfillAndWrite(mocks, secondFragmentEntry);
const firstFragment = await fetchFragment(mocks, firstFragmentEntry.fragmentId); const firstFragment = await fetchFragment(mocks, firstFragmentEntry.fragmentId);
const secondFragment = await fetchFragment(mocks, secondFragmentEntry.fragmentId); const secondFragment = await fetchFragment(mocks, secondFragmentEntry.fragmentId);
assertDeepLink(assert, firstFragment, secondFragment) assertFilledLink(assert, firstFragment, secondFragment)
const firstEvents = await allFragmentEvents(mocks, firstFragmentEntry.fragmentId); const firstEvents = await allFragmentEvents(mocks, firstFragmentEntry.fragmentId);
assert.deepEqual(firstEvents.map(e => e.event_id), eventIds(0, 10)); assert.deepEqual(firstEvents.map(e => e.event_id), eventIds(0, 10));
const secondEvents = await allFragmentEvents(mocks, secondFragmentEntry.fragmentId); const secondEvents = await allFragmentEvents(mocks, secondFragmentEntry.fragmentId);
assert.deepEqual(secondEvents.map(e => e.event_id), eventIds(10, 25)); assert.deepEqual(secondEvents.map(e => e.event_id), eventIds(10, 25));
await mocks.txn.complete();
}, },
"Backfilling a fragment that is expected to link up, but doesn't yet": async assert => { "Backfilling a fragment that is expected to close a gap, but doesn't yet": async assert => {
const mocks = await setup(); const mocks = await setup();
const { timelineMock } = mocks; const { timelineMock } = mocks;
timelineMock.append(10); timelineMock.append(10);
const {syncResponse, fragmentEntry: firstFragmentEntry} = await syncAndWrite(mocks); const {syncResponse, fragmentEntry: firstFragmentEntry} = await syncAndWrite(mocks, { limit: 10 });
timelineMock.append(20); timelineMock.append(20);
const {fragmentEntry: secondFragmentEntry} = await syncAndWrite(mocks, syncResponse); const {fragmentEntry: secondFragmentEntry} = await syncAndWrite(mocks, { previous: syncResponse, limit: 10 });
await backfillAndWrite(mocks, secondFragmentEntry); await backfillAndWrite(mocks, secondFragmentEntry);
const firstFragment = await fetchFragment(mocks, firstFragmentEntry.fragmentId); const firstFragment = await fetchFragment(mocks, firstFragmentEntry.fragmentId);
const secondFragment = await fetchFragment(mocks, secondFragmentEntry.fragmentId); const secondFragment = await fetchFragment(mocks, secondFragmentEntry.fragmentId);
assertShallowLink(assert, firstFragment, secondFragment) assertGapLink(assert, firstFragment, secondFragment)
const firstEvents = await allFragmentEvents(mocks, firstFragmentEntry.fragmentId); const firstEvents = await allFragmentEvents(mocks, firstFragmentEntry.fragmentId);
assert.deepEqual(firstEvents.map(e => e.event_id), eventIds(0, 10)); assert.deepEqual(firstEvents.map(e => e.event_id), eventIds(0, 10));
const secondEvents = await allFragmentEvents(mocks, secondFragmentEntry.fragmentId); const secondEvents = await allFragmentEvents(mocks, secondFragmentEntry.fragmentId);
assert.deepEqual(secondEvents.map(e => e.event_id), eventIds(10, 30)); assert.deepEqual(secondEvents.map(e => e.event_id), eventIds(10, 30));
await mocks.txn.complete();
}, },
"Receiving a sync with the same events as the current fragment does not create infinite link": async assert => { "Receiving a sync with the same events as the current fragment does not create infinite link": async assert => {
const mocks = await setup(); const mocks = await setup();
const { txn, timelineMock } = mocks; const { txn, timelineMock } = mocks;
timelineMock.append(10); timelineMock.append(10);
const {syncResponse, fragmentEntry: fragmentEntry} = await syncAndWrite(mocks); const {syncResponse, fragmentEntry: fragmentEntry} = await syncAndWrite(mocks, { limit: 10 });
// Mess with the saved token to receive old events in backfill // Mess with the saved token to receive old events in backfill
fragmentEntry.token = syncResponse.next_batch; fragmentEntry.token = syncResponse.next_batch;
txn.timelineFragments.update(fragmentEntry.fragment); txn.timelineFragments.update(fragmentEntry.fragment);
@ -399,14 +402,15 @@ export function tests() {
const fragment = await fetchFragment(mocks, fragmentEntry.fragmentId); const fragment = await fetchFragment(mocks, fragmentEntry.fragmentId);
assert.notEqual(fragment.nextId, fragment.id); assert.notEqual(fragment.nextId, fragment.id);
assert.notEqual(fragment.previousId, fragment.id); assert.notEqual(fragment.previousId, fragment.id);
await mocks.txn.complete();
}, },
"An event received by sync does not interrupt backfilling": async assert => { "An event received by sync does not interrupt backfilling": async assert => {
const mocks = await setup(); const mocks = await setup();
const { timelineMock } = mocks; const { timelineMock } = mocks;
timelineMock.append(10); timelineMock.append(10);
const {syncResponse, fragmentEntry: firstFragmentEntry} = await syncAndWrite(mocks); const {syncResponse, fragmentEntry: firstFragmentEntry} = await syncAndWrite(mocks, { limit: 10 });
timelineMock.append(11); timelineMock.append(11);
const {fragmentEntry: secondFragmentEntry} = await syncAndWrite(mocks, syncResponse); const {fragmentEntry: secondFragmentEntry} = await syncAndWrite(mocks, { previous: syncResponse, limit: 10 });
timelineMock.insertAfter(eventId(9), 5); timelineMock.insertAfter(eventId(9), 5);
await backfillAndWrite(mocks, secondFragmentEntry); await backfillAndWrite(mocks, secondFragmentEntry);
@ -416,7 +420,8 @@ export function tests() {
assert.deepEqual(secondEvents.map(e => e.event_id), [...eventIds(21,26), ...eventIds(10, 21)]); assert.deepEqual(secondEvents.map(e => e.event_id), [...eventIds(21,26), ...eventIds(10, 21)]);
const firstFragment = await fetchFragment(mocks, firstFragmentEntry.fragmentId); const firstFragment = await fetchFragment(mocks, firstFragmentEntry.fragmentId);
const secondFragment = await fetchFragment(mocks, secondFragmentEntry.fragmentId); const secondFragment = await fetchFragment(mocks, secondFragmentEntry.fragmentId);
assertDeepLink(assert, firstFragment, secondFragment) assertFilledLink(assert, firstFragment, secondFragment)
await mocks.txn.complete();
} }
} }
} }

25
src/mocks/TimelineMock.ts
View file

@ -109,7 +109,6 @@ export class TimelineMock {
throw new Error("Fetching context for unknown event"); throw new Error("Fetching context for unknown event");
} }
const event = this._dagOrder[eventIndex]; const event = this._dagOrder[eventIndex];
limit -= 1;
let offset = 1; let offset = 1;
const eventsBefore: TimelineEvent[] = []; const eventsBefore: TimelineEvent[] = [];
const eventsAfter: TimelineEvent[] = []; const eventsAfter: TimelineEvent[] = [];
@ -179,18 +178,18 @@ export function tests() {
const context = timeline.context(eventId(15)); const context = timeline.context(eventId(15));
assert.equal(context.event.event_id, eventId(15)); assert.equal(context.event.event_id, eventId(15));
assert.deepEqual(context.events_before.map(e => e.event_id).reverse(), eventIds(10, 15)); assert.deepEqual(context.events_before.map(e => e.event_id).reverse(), eventIds(10, 15));
assert.deepEqual(context.events_after.map(e => e.event_id), eventIds(16, 20)); assert.deepEqual(context.events_after.map(e => e.event_id), eventIds(16, 21));
}, },
"The context endpoint returns the proper number of messages": assert => { "The context endpoint returns the proper number of messages": assert => {
const timeline = new TimelineMock(SENDER); const timeline = new TimelineMock(SENDER);
timeline.append(30); timeline.append(30);
for (const i of new Array(29).keys()) { for (const i of new Array(29).keys()) {
const middleFetch = timeline.context(eventId(15), i + 1); const middleFetch = timeline.context(eventId(15), i + 1);
assert.equal(middleFetch.events_before.length + middleFetch.events_after.length + 1, i + 1); assert.equal(middleFetch.events_before.length + middleFetch.events_after.length, i + 1);
const startFetch = timeline.context(eventId(1), i + 1); const startFetch = timeline.context(eventId(1), i + 1);
assert.equal(startFetch.events_before.length + startFetch.events_after.length + 1, i + 1); assert.equal(startFetch.events_before.length + startFetch.events_after.length, i + 1);
const endFetch = timeline.context(eventId(28), i + 1); const endFetch = timeline.context(eventId(28), i + 1);
assert.equal(endFetch.events_before.length + endFetch.events_after.length + 1, i + 1); assert.equal(endFetch.events_before.length + endFetch.events_after.length, i + 1);
} }
}, },
"The previous batch from a sync returns the previous events": assert => { "The previous batch from a sync returns the previous events": assert => {
@ -204,23 +203,27 @@ export function tests() {
"Two consecutive message fetches are continuous if no new events are inserted": assert => { "Two consecutive message fetches are continuous if no new events are inserted": assert => {
const timeline = new TimelineMock(SENDER); const timeline = new TimelineMock(SENDER);
timeline.append(30); timeline.append(30);
const sync = timeline.sync(undefined, 10); const sync = timeline.sync(undefined, 10);
const messages1 = timeline.messages(sync.timeline.prev_batch, undefined, "b"); const messages1 = timeline.messages(sync.timeline.prev_batch, undefined, "b");
const events1 = messages1.chunk.map(e => e.event_id).reverse(); const events1 = messages1.chunk.map(e => e.event_id).reverse();
assert.deepEqual(events1, eventIds(10, 20));
const messages2 = timeline.messages(messages1.end, undefined, "b"); const messages2 = timeline.messages(messages1.end, undefined, "b");
const events2 = messages2.chunk.map(e => e.event_id).reverse(); const events2 = messages2.chunk.map(e => e.event_id).reverse();
assert.deepEqual(events1, eventIds(10, 20));
assert.deepEqual(events2, eventIds(0, 10)); assert.deepEqual(events2, eventIds(0, 10));
}, },
"Two consecutive message fetches detect newly inserted event": assert => { "Two consecutive message fetches detect newly inserted event": assert => {
const timeline = new TimelineMock(SENDER); const timeline = new TimelineMock(SENDER);
timeline.append(30); timeline.append(30);
const messages1 = timeline.messages(eventId(20), undefined, "b", 10); const messages1 = timeline.messages(eventId(20), undefined, "b", 10);
const events1 = messages1.chunk.map(e => e.event_id).reverse(); const events1 = messages1.chunk.map(e => e.event_id).reverse();
assert.deepEqual(events1, eventIds(10, 20));
timeline.insertAfter(eventId(9), 1); timeline.insertAfter(eventId(9), 1);
const messages2 = timeline.messages(eventId(10), undefined, "b", 10); const messages2 = timeline.messages(eventId(10), undefined, "b", 10);
const events2 = messages2.chunk.map(e => e.event_id).reverse(); const events2 = messages2.chunk.map(e => e.event_id).reverse();
assert.deepEqual(events1, eventIds(10, 20));
const expectedEvents2 = eventIds(1, 10); const expectedEvents2 = eventIds(1, 10);
expectedEvents2.push(eventId(30)); expectedEvents2.push(eventId(30));
assert.deepEqual(events2, expectedEvents2); assert.deepEqual(events2, expectedEvents2);
@ -232,23 +235,25 @@ export function tests() {
const sync2 = timeline.sync(sync1.next_batch); const sync2 = timeline.sync(sync1.next_batch);
assert.equal(sync1.next_batch, sync2.next_batch); assert.equal(sync1.next_batch, sync2.next_batch);
}, },
"An event inserted in the midle still shows up in a sync": assert => { "An event inserted at the staart still shows up in a sync": assert => {
const timeline = new TimelineMock(SENDER); const timeline = new TimelineMock(SENDER);
timeline.append(30); timeline.append(30);
const sync1 = timeline.sync(undefined, 10); const sync1 = timeline.sync(undefined, 10);
const sync2 = timeline.sync(sync1.next_batch, 10) const sync2 = timeline.sync(sync1.next_batch, 10)
assert.deepEqual(sync2.timeline.events, []); assert.deepEqual(sync2.timeline.events, []);
assert.equal(sync2.timeline.limited, false); assert.equal(sync2.timeline.limited, false);
timeline.insertAfter(TIMELINE_START_TOKEN, 1); timeline.insertAfter(TIMELINE_START_TOKEN, 1);
const sync3 = timeline.sync(sync2.next_batch, 10) const sync3 = timeline.sync(sync2.next_batch, 10)
const events = sync3.timeline.events.map(e => e.event_id); const events = sync3.timeline.events.map(e => e.event_id);
assert.deepEqual(events, eventIds(30, 31)); assert.deepEqual(events, [eventId(30)]);
}, },
"An event inserted in the midle does not show up in a message fetch": assert => { "An event inserted at the start does not show up in a non-overlapping message fetch": assert => {
const timeline = new TimelineMock(SENDER); const timeline = new TimelineMock(SENDER);
timeline.append(30); timeline.append(30);
const sync1 = timeline.sync(undefined, 10); const sync1 = timeline.sync(undefined, 10);
const messages1 = timeline.messages(sync1.timeline.prev_batch, undefined, "f", 10); const messages1 = timeline.messages(sync1.timeline.prev_batch, undefined, "f", 10);
timeline.insertAfter(TIMELINE_START_TOKEN, 1); timeline.insertAfter(TIMELINE_START_TOKEN, 1);
const messages2 = timeline.messages(sync1.timeline.prev_batch, undefined, "f", 10); const messages2 = timeline.messages(sync1.timeline.prev_batch, undefined, "f", 10);
assert.deepEqual(messages1.chunk, messages2.chunk); assert.deepEqual(messages1.chunk, messages2.chunk);