Skip to content

Timeline needs to refresh when we see a MSC2716 marker event #2299

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 56 commits into from
Jun 1, 2022
Merged

Timeline needs to refresh when we see a MSC2716 marker event #2299

Show file tree
Hide file tree
Changes from 13 commits
Commits
Show all changes
56 commits
Select commit Hold shift + click to select a range
d37fa81
Timeline needs to refresh when we see a MSC2716 marker event
MadLittleMods Apr 14, 2022
dbc7d66
Fix tests failing from function signature changes
MadLittleMods Apr 14, 2022
ee39d6c
Fix argument mismatch
MadLittleMods Apr 14, 2022
2468690
Add missing docstrings
MadLittleMods Apr 14, 2022
f44489d
Raw refreshLiveTimeline function that seems to work
MadLittleMods Apr 16, 2022
1ab5460
Clean up raw commit
MadLittleMods Apr 18, 2022
52ce184
Remove event remitters
MadLittleMods Apr 19, 2022
d7c6802
Merge branch 'develop' into madlittlemods/refresh-timeline-when-we-se…
MadLittleMods Apr 19, 2022
26d4ecd
Fix up lints
MadLittleMods Apr 19, 2022
f1979d2
Fix lints
MadLittleMods Apr 19, 2022
c863ad1
Use UnstableValue
MadLittleMods Apr 19, 2022
b58e198
Clarify toStartOfTimeline order
MadLittleMods Apr 19, 2022
81785ce
Add backwards compatible overloads
MadLittleMods Apr 19, 2022
a98df62
Fix lints
MadLittleMods Apr 19, 2022
a8e4d07
Fix lints
MadLittleMods Apr 19, 2022
d43a994
Match case of other events
MadLittleMods Apr 20, 2022
4acc712
Add some missing type hints
MadLittleMods Apr 20, 2022
15d0e8a
Use built-in matches function
MadLittleMods Apr 20, 2022
64a6e38
Add more missing types
MadLittleMods Apr 20, 2022
46f2933
Merge branch 'develop' into madlittlemods/refresh-timeline-when-we-se…
MadLittleMods May 19, 2022
d267136
Add method to call MSC2716 /batch_send endpoint
MadLittleMods May 20, 2022
148434d
Move batchSend to e2e test in matrix-react-sdk
MadLittleMods May 24, 2022
3973e34
Extra TimelineRefresh to make the timeline blank and have something t…
MadLittleMods May 24, 2022
a086489
getLatestTimeline for when no events exist in the timeline already
MadLittleMods May 25, 2022
d241f13
Some cleanup
MadLittleMods May 25, 2022
0e3a5db
Fix lints
MadLittleMods May 25, 2022
a19b075
Merge branch 'develop' into madlittlemods/refresh-timeline-when-we-se…
MadLittleMods May 25, 2022
3dff724
Better comment
MadLittleMods May 26, 2022
d37f788
Re-register state listeners after `fixUpLegacyTimelineFields` changes…
MadLittleMods May 26, 2022
6b8aa6c
Remove lastMarkerEventProcessed logic
MadLittleMods May 26, 2022
4bb1d14
Add some missing test coverage
MadLittleMods May 26, 2022
34a943b
Add tests for sync state listeners and RoomEvent.CurrentStateUpdated
MadLittleMods May 27, 2022
e412aa1
Fix lint
MadLittleMods May 27, 2022
7a90629
Merge branch 'develop' into madlittlemods/refresh-timeline-when-we-se…
MadLittleMods May 27, 2022
9d1c7c7
Fix test when we only emit on reference change
MadLittleMods May 27, 2022
c36e1b9
Fix test passing with and without timelineSupport
MadLittleMods May 27, 2022
f663d6b
Consolidate imports
MadLittleMods May 27, 2022
313df51
Remove unnecessary overloads for private method
MadLittleMods May 27, 2022
90db6fd
Add barebones tests for overloads
MadLittleMods May 28, 2022
9f3df87
More straight-forward if-else
MadLittleMods May 28, 2022
8fc837f
Added extra explanation what marker event means
MadLittleMods May 28, 2022
78689a9
Fix lint
MadLittleMods May 28, 2022
58fa63c
Dry interfaces by extending (OOP)
MadLittleMods May 28, 2022
d0466a1
Use Pick<> to be more composable and obvious what we're extending
MadLittleMods May 28, 2022
e67b620
Use optional chaining and null coalescing for more accurate and stand…
MadLittleMods May 28, 2022
2a4a430
Add type
MadLittleMods May 28, 2022
e4bd518
Add deprecation warnings for old overloads
MadLittleMods Jun 1, 2022
310423a
Better test name
MadLittleMods Jun 1, 2022
ac07eaf
Add refresh timeline tests to matrix-js-sdk
MadLittleMods Jun 1, 2022
4915aef
WIP: almost working perfect merge test
MadLittleMods Jun 1, 2022
460e887
Working tests
MadLittleMods Jun 1, 2022
741a4fa
Fix lints
MadLittleMods Jun 1, 2022
a33de28
Merge branch 'develop' into madlittlemods/refresh-timeline-when-we-se…
t3chguy Jun 1, 2022
2bda3d3
Accurate return description
MadLittleMods Jun 1, 2022
150a498
Correct function parameters
MadLittleMods Jun 1, 2022
a5f832f
Small formatting updates
MadLittleMods Jun 1, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
308 changes: 308 additions & 0 deletions spec/integ/matrix-client-syncing.spec.js
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,5 +1,7 @@
import { MatrixEvent } from "../../src/models/event";
import { RoomEvent } from "../../src/models/room";
import { EventTimeline } from "../../src/models/event-timeline";
import { UNSTABLE_MSC2716_MARKER } from "../../src/@types/event";
import * as utils from "../test-utils/test-utils";
import { TestClient } from "../TestClient";

Expand Down Expand Up @@ -461,6 +463,312 @@ describe("MatrixClient syncing", function() {
xit("should update the room topic", function() {

});

describe("onMarkerStateEvent", () => {
const normalMessageEvent = utils.mkMessage({
room: roomOne, user: otherUserId, msg: "hello",
});

it('new marker event *NOT* from the room creator in a subsequent syncs ' +
'should *NOT* mark the timeline as needing a refresh', async () => {
const roomCreateEvent = utils.mkEvent({
type: "m.room.create", room: roomOne, user: otherUserId,
content: {
creator: otherUserId,
room_version: '9',
},
});
const normalFirstSync = {
next_batch: "batch_token",
rooms: {
join: {},
},
};
normalFirstSync.rooms.join[roomOne] = {
timeline: {
events: [normalMessageEvent],
prev_batch: "pagTok",
},
state: {
events: [roomCreateEvent],
},
};

const nextSyncData = {
next_batch: "batch_token",
rooms: {
join: {},
},
};
nextSyncData.rooms.join[roomOne] = {
timeline: {
events: [
// In subsequent syncs, a marker event in timeline
// range should normally trigger
// `timelineNeedsRefresh=true` but this marker isn't
// being sent by the room creator so it has no
// special meaning in existing room versions.
utils.mkEvent({
type: UNSTABLE_MSC2716_MARKER.name,
room: roomOne,
// The important part we're testing is here!
// `userC` is not the room creator.
user: userC,
skey: "",
content: {
"m.insertion_id": "$abc",
},
}),
],
prev_batch: "pagTok",
},
};

// Ensure the marker is being sent by someone who is not the room creator
// because this is the main thing we're testing in this spec.
const markerEvent = nextSyncData.rooms.join[roomOne].timeline.events[0];
expect(markerEvent.sender).toBeDefined();
expect(markerEvent.sender).not.toEqual(roomCreateEvent.sender);

httpBackend.when("GET", "/sync").respond(200, normalFirstSync);
httpBackend.when("GET", "/sync").respond(200, nextSyncData);

client.startClient();
await Promise.all([
httpBackend.flushAllExpected(),
awaitSyncEvent(2),
]);

const room = client.getRoom(roomOne);
expect(room.getTimelineNeedsRefresh()).toEqual(false);
});

[{
label: 'In existing room versions (when the room creator sends the MSC2716 events)',
roomVersion: '9',
}, {
label: 'In a MSC2716 supported room version',
roomVersion: 'org.matrix.msc2716v3',
}].forEach((testMeta) => {
describe(testMeta.label, () => {
const roomCreateEvent = utils.mkEvent({
type: "m.room.create", room: roomOne, user: otherUserId,
content: {
creator: otherUserId,
room_version: testMeta.roomVersion,
},
});

const markerEventFromRoomCreator = utils.mkEvent({
type: UNSTABLE_MSC2716_MARKER.name, room: roomOne, user: otherUserId,
skey: "",
content: {
"m.insertion_id": "$abc",
},
});

const normalFirstSync = {
next_batch: "batch_token",
rooms: {
join: {},
},
};
normalFirstSync.rooms.join[roomOne] = {
timeline: {
events: [normalMessageEvent],
prev_batch: "pagTok",
},
state: {
events: [roomCreateEvent],
},
};

it('no marker event in sync response '+
'should *NOT* mark the timeline as needing a refresh (check for a sane default)', async () => {
const syncData = {
next_batch: "batch_token",
rooms: {
join: {},
},
};
syncData.rooms.join[roomOne] = {
timeline: {
events: [normalMessageEvent],
prev_batch: "pagTok",
},
state: {
events: [roomCreateEvent],
},
};

httpBackend.when("GET", "/sync").respond(200, syncData);

client.startClient();
await Promise.all([
httpBackend.flushAllExpected(),
awaitSyncEvent(),
]);

const room = client.getRoom(roomOne);
expect(room.getTimelineNeedsRefresh()).toEqual(false);
});

it('marker event already sent within timeline range when you join ' +
'should *NOT* mark the timeline as needing a refresh (timelineWasEmpty)', async () => {
const syncData = {
next_batch: "batch_token",
rooms: {
join: {},
},
};
syncData.rooms.join[roomOne] = {
timeline: {
events: [markerEventFromRoomCreator],
prev_batch: "pagTok",
},
state: {
events: [roomCreateEvent],
},
};

httpBackend.when("GET", "/sync").respond(200, syncData);

client.startClient();
await Promise.all([
httpBackend.flushAllExpected(),
awaitSyncEvent(),
]);

const room = client.getRoom(roomOne);
expect(room.getTimelineNeedsRefresh()).toEqual(false);
});

it('marker event already sent before joining (in state) ' +
'should *NOT* mark the timeline as needing a refresh (timelineWasEmpty)', async () => {
const syncData = {
next_batch: "batch_token",
rooms: {
join: {},
},
};
syncData.rooms.join[roomOne] = {
timeline: {
events: [normalMessageEvent],
prev_batch: "pagTok",
},
state: {
events: [
roomCreateEvent,
markerEventFromRoomCreator,
],
},
};

httpBackend.when("GET", "/sync").respond(200, syncData);

client.startClient();
await Promise.all([
httpBackend.flushAllExpected(),
awaitSyncEvent(),
]);

const room = client.getRoom(roomOne);
expect(room.getTimelineNeedsRefresh()).toEqual(false);
});

it('new marker event in a subsequent syncs timeline range ' +
'should mark the timeline as needing a refresh', async () => {
const nextSyncData = {
next_batch: "batch_token",
rooms: {
join: {},
},
};
nextSyncData.rooms.join[roomOne] = {
timeline: {
events: [
// In subsequent syncs, a marker event in timeline
// range should trigger `timelineNeedsRefresh=true`
markerEventFromRoomCreator,
],
prev_batch: "pagTok",
},
};

const markerEventId = nextSyncData.rooms.join[roomOne].timeline.events[0].event_id;

// Only do the first sync
httpBackend.when("GET", "/sync").respond(200, normalFirstSync);
client.startClient();
await Promise.all([
httpBackend.flushAllExpected(),
awaitSyncEvent(),
]);

// Get the room after the first sync so the room is created
const room = client.getRoom(roomOne);

let emitCount = 0;
room.on(RoomEvent.historyImportedWithinTimeline, function(markerEvent, room) {
expect(markerEvent.getId()).toEqual(markerEventId);
expect(room.roomId).toEqual(roomOne);
emitCount += 1;
});

// Now do a subsequent sync with the marker event
httpBackend.when("GET", "/sync").respond(200, nextSyncData);
await Promise.all([
httpBackend.flushAllExpected(),
awaitSyncEvent(),
]);

expect(room.getTimelineNeedsRefresh()).toEqual(true);
// Make sure `RoomEvent.historyImportedWithinTimeline` was emitted
expect(emitCount).toEqual(1);
expect(room.getLastMarkerEventIdProcessed()).toEqual(markerEventId);
});

// Mimic a marker event being sent far back in the scroll back but since our last sync
it('new marker event in sync state should mark the timeline as needing a refresh', async () => {
const nextSyncData = {
next_batch: "batch_token",
rooms: {
join: {},
},
};
nextSyncData.rooms.join[roomOne] = {
timeline: {
events: [
utils.mkMessage({
room: roomOne, user: otherUserId, msg: "hello again",
}),
],
prev_batch: "pagTok",
},
state: {
events: [
// In subsequent syncs, a marker event in state
// should trigger `timelineNeedsRefresh=true`
markerEventFromRoomCreator,
],
},
};

httpBackend.when("GET", "/sync").respond(200, normalFirstSync);
httpBackend.when("GET", "/sync").respond(200, nextSyncData);

client.startClient();
await Promise.all([
httpBackend.flushAllExpected(),
awaitSyncEvent(2),
]);

const room = client.getRoom(roomOne);
expect(room.getTimelineNeedsRefresh()).toEqual(true);
});
});
});
});
});

describe("timeline", function() {
Expand Down
Loading