mirror of
https://github.com/Ark0N/Codeman.git
synced 2026-11-20 04:59:34 +01:00
Merge #832: a replayed Discord reply is typed once, and a store failure never costs a reply
Each allowed Discord reply is claimed by its message id in a small private store (discord-reply-dedupe.json, 0600) before the rate-limit and exited-agent checks; when the store fails the bridge falls back to memory and still types the reply.
This commit is contained in:
commit
a9ed3f55c3
7 files changed
+313
-6
No files matched your search
@@ -448,6 +448,72 @@ describe('DiscordBridge', () => {
|
||||
return b;
|
||||
}
|
||||
|
||||
it('deduplicates replayed real gateway IDs across restart while new replies still work', async () => {
|
||||
const b = await ready();
|
||||
const m = reply({ id: '555555555555555555' });
|
||||
await b.onGatewayMessage(m);
|
||||
b.stop();
|
||||
t += 10_000;
|
||||
const next = await ready();
|
||||
await next.onGatewayMessage(m);
|
||||
expect(sendInput).toHaveBeenCalledTimes(1);
|
||||
await next.onGatewayMessage(reply({ id: '555555555555555556', content: 'continue' }));
|
||||
expect(sendInput).toHaveBeenCalledTimes(2);
|
||||
next.stop();
|
||||
});
|
||||
|
||||
it('claims rate-limited snowflake replies so replays remain refused across restart', async () => {
|
||||
const b = await ready();
|
||||
await b.onGatewayMessage(reply({ id: '555555555555555555' }));
|
||||
t += 200;
|
||||
const refused = reply({ id: '555555555555555556', content: 'too soon' });
|
||||
await b.onGatewayMessage(refused);
|
||||
expect(sendInput).toHaveBeenCalledTimes(1);
|
||||
expect(posts.some((p) => p.path.includes(encodeURIComponent('⏳')))).toBe(true);
|
||||
t += 5_000;
|
||||
const count = posts.length;
|
||||
await b.onGatewayMessage(refused);
|
||||
expect(sendInput).toHaveBeenCalledTimes(1);
|
||||
expect(posts).toHaveLength(count);
|
||||
b.stop();
|
||||
const next = await ready();
|
||||
await next.onGatewayMessage(refused);
|
||||
expect(sendInput).toHaveBeenCalledTimes(1);
|
||||
await next.onGatewayMessage(reply({ id: '555555555555555557', content: 'new attempt' }));
|
||||
expect(sendInput).toHaveBeenCalledTimes(2);
|
||||
next.stop();
|
||||
});
|
||||
|
||||
it('ignores an immediate replay without adding an hourglass to a successful reply', async () => {
|
||||
const b = await ready();
|
||||
const m = reply({ id: '555555555555555555' });
|
||||
await b.onGatewayMessage(m);
|
||||
t += 200;
|
||||
await b.onGatewayMessage(m);
|
||||
expect(sendInput).toHaveBeenCalledTimes(1);
|
||||
expect(posts.filter((p) => p.method === 'PUT')).toHaveLength(1);
|
||||
expect(posts.some((p) => p.path.includes(encodeURIComponent('⏳')))).toBe(false);
|
||||
b.stop();
|
||||
});
|
||||
|
||||
it('delivers replies and alerts when metadata is corrupt and recovers without restarting', async () => {
|
||||
const b = await ready();
|
||||
writeFileSync(join(dir, 'discord-reply-dedupe.json'), '{');
|
||||
const log = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
|
||||
try {
|
||||
await b.onGatewayMessage(reply({ id: '555555555555555555' }));
|
||||
expect(sendInput).toHaveBeenCalledTimes(1);
|
||||
t += 10_000;
|
||||
expect((await b.notify(MSG))?.ok).toBe(true);
|
||||
rmSync(join(dir, 'discord-reply-dedupe.json'));
|
||||
await b.onGatewayMessage(reply({ id: '555555555555555556' }));
|
||||
expect(sendInput).toHaveBeenCalledTimes(2);
|
||||
expect(log).toHaveBeenCalledTimes(1);
|
||||
} finally {
|
||||
log.mockRestore();
|
||||
b.stop();
|
||||
}
|
||||
});
|
||||
it('types an allowed reply into the mapped session and ticks it', async () => {
|
||||
const b = await ready();
|
||||
await b.onGatewayMessage(reply());
|
||||
@@ -1143,7 +1209,7 @@ describe('DiscordBridge files and startup hint', () => {
|
||||
it('types a reply that waits on a download before a later text reply', async () => {
|
||||
const b = await make();
|
||||
const slow = b.onGatewayMessage(reply({ content: 'first' }));
|
||||
await new Promise((r) => setTimeout(r, 0)); // the first reply is under way (gate passed) before the clock moves
|
||||
await vi.waitFor(() => expect(downloads).toHaveLength(1)); // wait for the claim and rate-limit gate
|
||||
t += 5_000;
|
||||
const fast = b.onGatewayMessage(reply({ id: '555555555555555556', content: 'second', attachments: [] }));
|
||||
await Promise.all([slow, fast]);
|
||||
@@ -1157,11 +1223,11 @@ describe('DiscordBridge files and startup hint', () => {
|
||||
await b.onGatewayMessage(reply({ content: '2', attachments: [] }));
|
||||
expect(sent.at(-1)?.[1]).toBe('2');
|
||||
t += 5_000;
|
||||
await b.onGatewayMessage(reply({ content: 'yes', attachments: [] }));
|
||||
await b.onGatewayMessage(reply({ id: '555555555555555556', content: 'yes', attachments: [] }));
|
||||
expect(sent.at(-1)?.[1]).toBe('yes\r');
|
||||
t += 5_000;
|
||||
waiting = false;
|
||||
await b.onGatewayMessage(reply({ content: '2', attachments: [] }));
|
||||
await b.onGatewayMessage(reply({ id: '555555555555555557', content: '2', attachments: [] }));
|
||||
expect(sent.at(-1)?.[1]).toBe('2\r');
|
||||
b.stop();
|
||||
});
|
||||
|
||||
@@ -0,0 +1,133 @@
|
||||
import { mkdtemp, readFile, rm, writeFile, stat } from 'node:fs/promises';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { join } from 'node:path';
|
||||
import { afterEach, beforeEach, expect, it, vi } from 'vitest';
|
||||
import { DiscordReplyDedupe } from '../src/discord-reply-dedupe.js';
|
||||
import fs from 'node:fs/promises';
|
||||
let dir: string;
|
||||
const guild = '111111111111111111',
|
||||
channel = '222222222222222222',
|
||||
message = '333333333333333333';
|
||||
beforeEach(async () => {
|
||||
dir = await mkdtemp(join(tmpdir(), 'discord-replies-'));
|
||||
});
|
||||
afterEach(async () => {
|
||||
await rm(dir, { recursive: true, force: true });
|
||||
});
|
||||
it('claims once across concurrent events and restarts, without storing message content', async () => {
|
||||
const store = new DiscordReplyDedupe(dir);
|
||||
expect(await Promise.all([store.claim(guild, channel, message), store.claim(guild, channel, message)])).toEqual([
|
||||
true,
|
||||
false,
|
||||
]);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(false);
|
||||
expect((await stat(join(dir, 'discord-reply-dedupe.json'))).mode & 0o777).toBe(0o600);
|
||||
expect(JSON.parse(await readFile(join(dir, 'discord-reply-dedupe.json'), 'utf8'))).toEqual([
|
||||
[`${guild}:${channel}:${message}`, expect.any(Number)],
|
||||
]);
|
||||
});
|
||||
it('falls back on corrupt metadata, logs once, retries after recovery, and retains memory claims', async () => {
|
||||
const path = join(dir, 'discord-reply-dedupe.json');
|
||||
await writeFile(path, '{');
|
||||
const warn = vi.fn(),
|
||||
store = new DiscordReplyDedupe(dir, Date.now, warn);
|
||||
expect(await store.claim(guild, channel, message)).toBe(true);
|
||||
expect(await store.claim(guild, channel, message)).toBe(false);
|
||||
expect(warn).toHaveBeenCalledTimes(1);
|
||||
await rm(path);
|
||||
expect(await store.claim(guild, channel, '444444444444444444')).toBe(true);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(false);
|
||||
});
|
||||
it('does not poison metadata with incomplete restored configuration', async () => {
|
||||
const store = new DiscordReplyDedupe(dir);
|
||||
expect(await store.claim('', channel, message)).toBe(true);
|
||||
expect(await store.claim(guild, channel, message)).toBe(true);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(false);
|
||||
});
|
||||
it('keeps accepting new replies during ENOSPC and persists memory claims when writes recover', async () => {
|
||||
const warn = vi.fn();
|
||||
const store = new DiscordReplyDedupe(dir, Date.now, warn);
|
||||
const rename = vi.spyOn(fs, 'rename').mockRejectedValueOnce(Object.assign(new Error('full'), { code: 'ENOSPC' }));
|
||||
try {
|
||||
expect(await store.claim(guild, channel, message)).toBe(true);
|
||||
expect(await store.claim(guild, channel, message)).toBe(false);
|
||||
expect(await store.claim(guild, channel, '444444444444444444')).toBe(true);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(false);
|
||||
expect(warn).toHaveBeenCalledTimes(1);
|
||||
} finally {
|
||||
rename.mockRestore();
|
||||
}
|
||||
});
|
||||
it('evicts old records rather than refusing replies at capacity', async () => {
|
||||
await writeFile(
|
||||
join(dir, 'discord-reply-dedupe.json'),
|
||||
JSON.stringify(
|
||||
Array.from({ length: 2048 }, (_, i) => [
|
||||
`${guild}:${channel}:${String(100000000000000000n + BigInt(i))}`,
|
||||
Date.now(),
|
||||
])
|
||||
)
|
||||
);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(true);
|
||||
expect(JSON.parse(await readFile(join(dir, 'discord-reply-dedupe.json'), 'utf8'))).toHaveLength(2048);
|
||||
});
|
||||
|
||||
it.each(['{', '{}', '[null]'])(
|
||||
'heals readable invalid metadata %s and keeps the claim across restart',
|
||||
async (invalid) => {
|
||||
const path = join(dir, 'discord-reply-dedupe.json');
|
||||
await writeFile(path, invalid);
|
||||
const warn = vi.fn(),
|
||||
store = new DiscordReplyDedupe(dir, Date.now, warn);
|
||||
expect(await store.claim(guild, channel, message)).toBe(true);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(false);
|
||||
expect(warn).toHaveBeenCalledTimes(1);
|
||||
}
|
||||
);
|
||||
|
||||
it('retains newer outage claims when disk recovery reaches capacity, without overwriting an unread file', async () => {
|
||||
const path = join(dir, 'discord-reply-dedupe.json');
|
||||
const rows = Array.from({ length: 2048 }, (_, i) => [
|
||||
`${guild}:${channel}:${100000000000000000n + BigInt(i)}`,
|
||||
Date.now(),
|
||||
]);
|
||||
const original = JSON.stringify(rows);
|
||||
await writeFile(path, original);
|
||||
const warn = vi.fn(),
|
||||
store = new DiscordReplyDedupe(dir, Date.now, warn);
|
||||
const read = vi
|
||||
.spyOn(fs, 'readFile')
|
||||
.mockRejectedValueOnce(Object.assign(new Error('descriptor limit'), { code: 'EMFILE' }));
|
||||
expect(await store.claim(guild, channel, message)).toBe(true);
|
||||
read.mockRestore();
|
||||
expect(await readFile(path, 'utf8')).toBe(original);
|
||||
expect(await store.claim(guild, channel, '444444444444444444')).toBe(true);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(false);
|
||||
const saved = JSON.parse(await readFile(path, 'utf8'));
|
||||
expect(saved).toHaveLength(2048);
|
||||
expect(saved.some((row: [string, number]) => row[0] === rows[0][0])).toBe(false);
|
||||
});
|
||||
|
||||
it('heals an over-cap readable store rather than remaining memory-only until manual deletion', async () => {
|
||||
const path = join(dir, 'discord-reply-dedupe.json');
|
||||
await writeFile(
|
||||
path,
|
||||
JSON.stringify(
|
||||
Array.from({ length: 2049 }, (_, i) => [`${guild}:${channel}:${100000000000000000n + BigInt(i)}`, Date.now()])
|
||||
)
|
||||
);
|
||||
const warn = vi.fn();
|
||||
expect(await new DiscordReplyDedupe(dir, Date.now, warn).claim(guild, channel, message)).toBe(true);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(false);
|
||||
expect(warn).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
|
||||
it('heals oversized regular metadata and persists replay protection across restart', async () => {
|
||||
const path = join(dir, 'discord-reply-dedupe.json');
|
||||
await writeFile(path, ' '.repeat(512 * 1024 + 1));
|
||||
const warn = vi.fn();
|
||||
expect(await new DiscordReplyDedupe(dir, Date.now, warn).claim(guild, channel, message)).toBe(true);
|
||||
expect(await new DiscordReplyDedupe(dir).claim(guild, channel, message)).toBe(false);
|
||||
expect((await stat(path)).size).toBeLessThan(512 * 1024);
|
||||
expect(warn).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
Reference in new issue
Block a user