Add tests for the provider's bounded client fan-in

Reproduces Soul's probe directly: 20,000 client-sent latest-only frames
on one key, none ever drained by receive(), leave exactly 1 pending
frame in the provider's receive queue, and that frame carries the
newest sequence sent. A second test sends 20 frames across 50 distinct
keys and checks the queue holds exactly 50 (bounded by key count, not
frame count). A third proves reliable-ordered client frames are never
coalesced and stay in order at the provider.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-09-23 19:51:51 +02:00
commit 2e7f10993f

View file

@ -255,6 +255,122 @@ test("a stalled peer's outbox holds at most one pending frame per key across man
}
});
test(
"20,000 client latest-only frames on one key leave at most 1 pending in the provider's receive queue",
{ timeout: 120_000 },
async (t) => {
if (!nativeBridgeAvailable()) return void t.skip("no native bridge available");
const provider = await startProvider();
try {
const consumer = await dialProvider(provider);
try {
await waitUntil(() => provider.connectionCount === 1);
// The exact scenario Soul's probe reproduced against the unbounded
// `readyFrames` array this replaced: a publish-only StreamPixels-style
// consumer of `receive()` never drains the provider's fan-in queue,
// so a client hammering one key must not be able to grow it past one
// entry no matter how many frames it sends.
const total = 20_000;
const sends: Promise<void>[] = [];
for (let sequence = 1; sequence <= total; sequence += 1) {
sends.push(consumer.sendFrame(testFrame({ delivery: "latest-only", sequence: BigInt(sequence) })));
}
await Promise.all(sends);
await waitUntil(() => provider.receiveQueueSize > 0, 30_000);
// Let any trailing send_complete events land before asserting the
// queue has settled, so this isn't racing the last few deliveries.
await new Promise((resolve) => setTimeout(resolve, 200));
assert.equal(
provider.receiveQueueSize,
1,
`one client key must coalesce to at most one pending frame, got ${provider.receiveQueueSize}`,
);
const frame = await provider.receive();
assert.equal(frame.sequence, BigInt(total), "the one pending frame must be the newest generation sent");
assert.equal(provider.receiveQueueSize, 0);
} finally {
consumer.dispose();
}
} finally {
provider.dispose();
}
},
);
test(
"many distinct client latest-only keys stay bounded by the key count, not the frame count",
async (t) => {
if (!nativeBridgeAvailable()) return void t.skip("no native bridge available");
const provider = await startProvider();
try {
const consumer = await dialProvider(provider);
try {
await waitUntil(() => provider.connectionCount === 1);
const keyCount = 50;
const sendsPerKey = 20;
const sends: Promise<void>[] = [];
for (let key = 0; key < keyCount; key += 1) {
for (let sequence = 1; sequence <= sendsPerKey; sequence += 1) {
sends.push(
consumer.sendFrame(
testFrame({
delivery: "latest-only",
bodyId: `body:${key}`,
sequence: BigInt(sequence),
}),
),
);
}
}
await Promise.all(sends);
await waitUntil(() => provider.receiveQueueSize > 0, 10_000);
await new Promise((resolve) => setTimeout(resolve, 200));
assert.equal(
provider.receiveQueueSize,
keyCount,
`the queue must hold exactly one pending frame per distinct key, got ${provider.receiveQueueSize}`,
);
} finally {
consumer.dispose();
}
} finally {
provider.dispose();
}
},
);
test("reliable-ordered client frames are delivered in order at the provider, never coalesced", async (t) => {
if (!nativeBridgeAvailable()) return void t.skip("no native bridge available");
const provider = await startProvider();
try {
const consumer = await dialProvider(provider);
try {
await waitUntil(() => provider.connectionCount === 1);
const total = 500;
for (let sequence = 1; sequence <= total; sequence += 1) {
await consumer.sendFrame(testFrame({ delivery: "reliable-ordered", sequence: BigInt(sequence) }));
}
await waitUntil(() => provider.receiveQueueSize === total, 10_000);
const received: bigint[] = [];
for (let i = 0; i < total; i += 1) {
received.push((await provider.receive()).sequence);
}
const expected = Array.from({ length: total }, (_, i) => BigInt(i + 1));
assert.deepEqual(received, expected, "reliable-ordered frames must never be coalesced or reordered");
} finally {
consumer.dispose();
}
} finally {
provider.dispose();
}
});
test("unreliable broadcast fails closed", async (t) => {
if (!nativeBridgeAvailable()) return void t.skip("no native bridge available");
const provider = await startProvider();