Files
cinny/src/app/utils/presenceWrite.test.ts
T

128 lines
4.1 KiB
TypeScript
Raw Normal View History

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { IPresenceOpts, MatrixError } from 'matrix-js-sdk';
import {
PresenceDeduper,
describePresenceError,
isPresenceWritePending,
queuePresenceWrite,
setPresenceWithRetry,
} from './presenceWrite';
const limited = (retryMs = 3000) =>
new MatrixError(
{ errcode: 'M_LIMIT_EXCEEDED', error: 'Too Many Requests', retry_after_ms: retryMs },
429,
);
test('429 is retried after Retry-After, then succeeds', async () => {
let n = 0;
const waits: number[] = [];
const mx = {
setPresence: async () => {
n += 1;
if (n < 3) throw limited(3000);
return {};
},
};
await setPresenceWithRetry(
mx,
{ presence: 'online', status_msg: 'hi' },
{
sleepFn: async (ms) => {
waits.push(ms);
},
},
);
assert.equal(n, 3);
assert.deepEqual(waits, [3000, 3000]);
});
test('gives up once the total wait would exceed the cap; other errors are not retried', async () => {
const mx = {
setPresence: async () => {
throw limited(20_000);
},
};
await assert.rejects(
() =>
setPresenceWithRetry(
mx,
{ presence: 'online' },
{ maxWaitMs: 25_000, sleepFn: async () => undefined },
),
/Too Many/,
);
let calls = 0;
const forbidden = {
setPresence: async () => {
calls += 1;
throw new MatrixError({ errcode: 'M_FORBIDDEN', error: 'nope' }, 403);
},
};
await assert.rejects(() => setPresenceWithRetry(forbidden, { presence: 'online' }));
assert.equal(calls, 1);
});
test('deduper skips identical writes and notices changes', () => {
const d = new PresenceDeduper();
assert.equal(d.shouldSend({ presence: 'online', status_msg: 'a' }), true);
d.sent({ presence: 'online', status_msg: 'a' });
assert.equal(d.shouldSend({ presence: 'online', status_msg: 'a' }), false);
assert.equal(d.shouldSend({ presence: 'unavailable', status_msg: 'a' }), true);
assert.equal(d.shouldSend({ presence: 'online', status_msg: 'b' }), true);
d.reset();
assert.equal(d.shouldSend({ presence: 'online', status_msg: 'a' }), true);
});
test('error wording', () => {
assert.match(describePresenceError(limited()), /once every 10 seconds/);
assert.equal(
describePresenceError(
new MatrixError({ errcode: 'M_FORBIDDEN', error: 'Presence is disabled' }, 403),
),
'Failed to save status: Presence is disabled',
);
assert.match(describePresenceError(new TypeError('Failed to fetch')), /couldn't reach/);
});
test('[status save] queuePresenceWrite: newest wins, waits out 429 once, all callers settle', async () => {
const sent: string[] = [];
let calls = 0;
const sleeps: number[] = [];
const mx = {
setPresence: async (w: IPresenceOpts) => {
calls += 1;
if (calls === 1) {
sent.push(`429:${w.status_msg}`);
throw new MatrixError({ errcode: 'M_LIMIT_EXCEEDED', retry_after_ms: 7000 }, 429);
}
sent.push(`ok:${w.status_msg}`);
},
};
const sleepFn = async (ms: number) => {
sleeps.push(ms);
};
// 'a' goes out at once; 'b' and 'c' arrive while it waits out the limit.
const first = queuePresenceWrite(mx, { presence: 'online', status_msg: 'a' }, { sleepFn });
const second = queuePresenceWrite(mx, { presence: 'online', status_msg: 'b' }, { sleepFn });
const third = queuePresenceWrite(mx, { presence: 'online', status_msg: 'c' }, { sleepFn });
assert.equal(isPresenceWritePending(mx), true);
await Promise.all([first, second, third]);
// 'a' was 429'd; after the wait only the newest ('c') goes out — 'a' isn't
// retried and 'b' is never sent.
assert.deepEqual(sent, ['429:a', 'ok:c']);
assert.deepEqual(sleeps, [7000]);
assert.equal(isPresenceWritePending(mx), false);
});
test('[status save] queuePresenceWrite: a failure rejects the callers of that write', async () => {
const mx = {
setPresence: async () => {
throw new MatrixError({ errcode: 'M_FORBIDDEN' }, 403);
},
};
await assert.rejects(queuePresenceWrite(mx, { presence: 'online', status_msg: 'x' }));
assert.equal(isPresenceWritePending(mx), false);
});