mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-07-01 12:02:05 +00:00
c393a8e55f
Concurrent sock.sendMessage() calls on a single Baileys socket can cause the WhatsApp protocol-level routing to misdeliver messages — responses intended for one chat appear in another. Add a promise-based send queue that serialises all sendMessage() calls across concurrent HTTP /send, /edit, and /send-media handlers so only one send is in-flight at a time. Includes unit tests for queue ordering, error isolation, timeout propagation, and single-consumer concurrency semantics, plus an integration check that the queue is wired into sendWithTimeout.
112 lines
3.4 KiB
JavaScript
112 lines
3.4 KiB
JavaScript
/**
|
|
* Regression tests for the WhatsApp bridge send queue (#33360).
|
|
*
|
|
* The bridge must serialise all sock.sendMessage() calls through a
|
|
* promise-based queue so that concurrent HTTP /send requests never
|
|
* produce overlapping Baileys socket writes. Overlapping writes are
|
|
* the confirmed root cause of cross-chat contamination.
|
|
*
|
|
* These tests exercise the queue itself — they do NOT require a live
|
|
* WhatsApp socket.
|
|
*/
|
|
|
|
import { strict as assert } from 'node:assert';
|
|
|
|
// ------------------------------------------------------------------
|
|
// 1. Unit test for the queue primitives
|
|
// ------------------------------------------------------------------
|
|
|
|
/**
|
|
* Replicate the queue logic from bridge.js so we can test it in
|
|
* isolation without importing the full module (which would trigger
|
|
* Baileys / express side effects).
|
|
*/
|
|
function createSendQueue() {
|
|
let _sendQueue = Promise.resolve();
|
|
|
|
function enqueueSend(fn) {
|
|
const task = _sendQueue.then(() => fn(), () => fn());
|
|
_sendQueue = task.catch(() => {});
|
|
return task;
|
|
}
|
|
|
|
return { enqueueSend };
|
|
}
|
|
|
|
// -- serial ordering -------------------------------------------------
|
|
{
|
|
const { enqueueSend } = createSendQueue();
|
|
const order = [];
|
|
|
|
const a = enqueueSend(async () => {
|
|
await new Promise(r => setTimeout(r, 30));
|
|
order.push('a');
|
|
return 'A';
|
|
});
|
|
const b = enqueueSend(async () => {
|
|
order.push('b');
|
|
return 'B';
|
|
});
|
|
const c = enqueueSend(async () => {
|
|
await new Promise(r => setTimeout(r, 10));
|
|
order.push('c');
|
|
return 'C';
|
|
});
|
|
|
|
const results = await Promise.all([a, b, c]);
|
|
assert.deepStrictEqual(results, ['A', 'B', 'C'], 'all tasks resolve');
|
|
assert.deepStrictEqual(order, ['a', 'b', 'c'], 'tasks execute in FIFO order');
|
|
console.log(' ✓ serial ordering');
|
|
}
|
|
|
|
// -- error isolation (one rejection does not stall the queue) --------
|
|
{
|
|
const { enqueueSend } = createSendQueue();
|
|
const order = [];
|
|
|
|
const bad = enqueueSend(async () => {
|
|
order.push('bad');
|
|
throw new Error('boom');
|
|
});
|
|
const good = enqueueSend(async () => {
|
|
order.push('good');
|
|
return 'ok';
|
|
});
|
|
|
|
await assert.rejects(() => bad, /boom/, 'bad task rejects');
|
|
const g = await good;
|
|
assert.strictEqual(g, 'ok', 'good task still resolves');
|
|
assert.deepStrictEqual(order, ['bad', 'good'], 'good runs after bad');
|
|
console.log(' ✓ error isolation');
|
|
}
|
|
|
|
// -- timeout still fires (wrapped inside enqueueSend) ----------------
|
|
{
|
|
const { enqueueSend } = createSendQueue();
|
|
const timedOut = enqueueSend(async () => {
|
|
await new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 20));
|
|
});
|
|
await assert.rejects(() => timedOut, /timeout/, 'inner timeout propagates');
|
|
console.log(' ✓ timeout propagation');
|
|
}
|
|
|
|
// -- concurrent enqueues maintain single-consumer semantics ----------
|
|
{
|
|
const { enqueueSend } = createSendQueue();
|
|
let concurrent = 0;
|
|
let maxConcurrent = 0;
|
|
|
|
async function tracked() {
|
|
concurrent += 1;
|
|
if (concurrent > maxConcurrent) maxConcurrent = concurrent;
|
|
await new Promise(r => setTimeout(r, 5));
|
|
concurrent -= 1;
|
|
}
|
|
|
|
await Promise.all(Array.from({ length: 20 }, () => enqueueSend(tracked)));
|
|
assert.strictEqual(maxConcurrent, 1, 'never more than one in-flight');
|
|
assert.strictEqual(concurrent, 0, 'all finished');
|
|
console.log(' ✓ single-consumer concurrency');
|
|
}
|
|
|
|
console.log('\n✅ All send-queue tests passed.');
|