mjolnir/test/integration/timelinePaginationTest.ts

98 lines
5.9 KiB
TypeScript
Raw Permalink Normal View History

import { strict as assert } from "assert";
import { newTestUser } from "./clientHelper";
import { getMessagesByUserIn } from "../../src/utils";
/**
* Ensure that Mjolnir paginates only the necessary segment of the room timeline when backfilling.
*/
describe("Test: timeline pagination", function () {
it('does not paginate across the entire room history while backfilling.', async function() {
this.timeout(60000);
// Create a few users and a room.
let badUser = await newTestUser(this.config.homeserverUrl, { name: { contains: "spammer" }});
let badUserId = await badUser.getUserId();
let moderator = await newTestUser(this.config.homeserverUrl, { name: { contains: "moderator" }});
let targetRoom = await moderator.createRoom({ invite: [await badUser.getUserId()]});
await badUser.joinRoom(targetRoom);
// send some irrelevant messages
await Promise.all([...Array(200).keys()].map((i) => moderator.sendMessage(targetRoom, {msgtype: 'm.text.', body: `Irrelevant Message #${i}`})));
// bad guy sends 5 messages
for (let i = 0; i < 5; i++) {
await badUser.sendMessage(targetRoom, {msgtype: 'm.text', body: "Very Bad Stuff"});
}
// send some irrelevant messages
await Promise.all([...Array(50).keys()].map((i) => moderator.sendMessage(targetRoom, {msgtype: 'm.text.', body: `Irrelevant Message #${i}`})));
// bad guy sends 1 extra message at the most recent edge of the timeline.
await badUser.sendMessage(targetRoom, {msgtype: 'm.text', body: "Very Bad Stuff"});
// then call this paignator and ensure that we don't go across the entire room history.
let cbCount = 0;
let eventCount = 0;
await getMessagesByUserIn(moderator, badUserId, targetRoom, 1000, function(events) {
cbCount += 1;
eventCount += events.length;
events.map(e => assert.equal(e.sender, badUserId, "All the events should be from the same sender"));
});
assert.equal(cbCount, 1, "The callback only needs to be called once with all the messages because the events should be filtered.");
assert.equal(eventCount, 7, "There shouldn't be any more events (1 member event and 6 messages), and they should all be from the same account.");
})
it('does not call the callback with an empty array when there are no relevant events', async function() {
this.timeout(60000);
let badUser = await newTestUser(this.config.homeserverUrl, { name: { contains: "spammer" }});
let badUserId = await badUser.getUserId();
let moderator = await newTestUser(this.config.homeserverUrl, { name: { contains: "moderator" }});
let targetRoom = await moderator.createRoom();
// send some irrelevant messages
await Promise.all([...Array(200).keys()].map((i) => moderator.sendMessage(targetRoom, {msgtype: 'm.text.', body: `Irrelevant Message #${i}`})));
// The callback should not be called.
let cbCount = 0;
await getMessagesByUserIn(moderator, badUserId, targetRoom, 1000, (events) => {
cbCount += 1;
});
assert.equal(cbCount, 0, "The callback should never get called");
})
it("The limit provided is respected", async function() {
this.timeout(60000);
let badUser = await newTestUser(this.config.homeserverUrl, { name: { contains: "spammer" }});
let badUserId = await badUser.getUserId();
let moderator = await newTestUser(this.config.homeserverUrl, { name: { contains: "moderator" }});
let targetRoom = await moderator.createRoom({ invite: [await badUser.getUserId()]});
await badUser.joinRoom(targetRoom);
// send some bad person messages
// bad guy sends 5 messages at the start of the timeline
for (let i = 0; i < 5; i++) {
await badUser.sendMessage(targetRoom, {msgtype: 'm.text', body: "Very Bad Stuff"});
}
// send some irrelevant messages
await Promise.all([...Array(200).keys()].map((i) => moderator.sendMessage(targetRoom, {msgtype: 'm.text.', body: `Irrelevant Message #${i}`})));
let cbCount = 0;
await getMessagesByUserIn(moderator, "*spammer*", targetRoom, 200, (events) => {
cbCount += 1;
});
// Remember that the limit is the number of events that getMessagesByUserIn has checked against the glob,
// not the number of events to provide to the callback.
// E.g. we don't want to paginate to the beginning of history just because less than 200 events match the glob,
// which is very likely if a user has only just started sending messages.
assert.equal(cbCount, 0, "The callback should never be called as the limit should be reached beforehand.");
await getMessagesByUserIn(moderator, "*spammer*", targetRoom, 205, (events) => {
cbCount += 1;
events.map(e => assert.equal(e.sender, badUserId, "All the events should be from the same sender"));
});
assert.equal(cbCount, 1, "The callback should be called once with events matching the glob.");
});
it("Gives the events to the callback ordered by youngest first (even more important when the limit is reached halfway through a chunk).", async function() {
this.timeout(60000);
let moderator = await newTestUser(this.config.homeserverUrl, { name: { contains: "moderator" }});
let moderatorId = await moderator.getUserId();
let targetRoom = await moderator.createRoom();
for (let i = 0; i < 20; i++) {
await moderator.sendMessage(targetRoom, {msgtype: 'm.text.', body: `${i}`})
}
await getMessagesByUserIn(moderator, moderatorId, targetRoom, 5, (events) => {
let messageNumbers = events.map(event => parseInt(event.content.body, 10));
messageNumbers.map(n => assert.equal(n >= 15, true, "The youngest events should be given to the callback first."))
});
})
});