fix: harden flaky RealtimeCustomClientTest::testChannelExecutions

DISCORD-15272384

The test subscribed to the project-scoped `executions` channel and then made
two bare `receive()` calls, assuming the next two frames were exactly the
execution `create` and `update` events, each bounded by a single 10s read
timeout.

The async execution's terminal `update` only arrives after worker pickup,
runtime cold start, and the function's execution timeout (the `timeout`
fixture sleeps 60s against a 10s function timeout), which regularly exceeds
one read window and surfaces as `WebSocket\TimeoutException: Client read
timeout`. The bare receives were also brittle to any intermediate or
unrelated frames on the shared channel.

Add a reusable `receiveUntilEvent()` helper to `RealtimeBase` (mirroring the
presence tests' `receiveUntil`) that polls, skips unrelated frames, and waits
generously for a matching frame. Use it in `testChannelExecutions` to wait for
the specific `create` and `update` events.

Test-only change.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
ClaudearandClaude Opus 4.8 committed 2026-07-16 09:07:06 +00:00
1 parent 50e634ffbd
commit b4e894184a
2 files changed
+59 -3

No files matched your search

@@ -4,9 +4,52 @@ namespace Tests\E2E\Services\Realtime;
use WebSocket\Client as WebSocketClient;
use WebSocket\ConnectionException;
use WebSocket\TimeoutException;
trait RealtimeBase
{
/**
* Receive websocket frames until one matches, skipping unrelated frames.
*
* Realtime channels such as `executions` are project-scoped, so a subscriber
* may see intermediate or unrelated frames before the one under test. Some
* events (e.g. an async execution's terminal `update`) also arrive only after
* substantial latency (worker pickup + runtime cold start + execution timeout),
* well beyond a single read timeout. This polls, tolerating both, until $match
* returns true or the overall deadline elapses.
*
* @param callable(array): bool $match
*/
private function receiveUntilEvent(
WebSocketClient $client,
callable $match,
int $timeoutMs = 60000,
int $pollMs = 50
): array {
$deadline = \microtime(true) + ($timeoutMs / 1000);
$lastMessage = [];
while (\microtime(true) < $deadline) {
try {
$message = \json_decode($client->receive(), true);
} catch (TimeoutException) {
\usleep($pollMs * 1000);
continue;
}
if (!\is_array($message)) {
continue;
}
$lastMessage = $message;
if ($match($message)) {
return $message;
}
}
$this->fail('Timed out waiting for expected websocket frame. Last frame: ' . \json_encode($lastMessage));
}
private function getWebsocket(
array $channels = [],
array $headers = [],
@@ -2457,11 +2457,24 @@ final class RealtimeCustomClientTest extends Scope
$this->assertEquals(202, $execution['headers']['status-code']);
$this->assertNotEmpty($execution['body']['$id']);
$response = json_decode($client->receive(), true);
$responseUpdate = json_decode($client->receive(), true);
$executionId = $execution['body']['$id'];
// The async execution first emits a `create` event, then a terminal `update`
// once the runtime finishes. That `update` only arrives after worker pickup,
// runtime cold start, and the function's execution timeout, so it can easily
// exceed a single read timeout. Skip unrelated frames and wait generously for
// each expected event instead of assuming they are the next two frames.
$response = $this->receiveUntilEvent(
$client,
fn (array $message): bool => ($message['type'] ?? null) === 'event'
&& \in_array("functions.{$functionId}.executions.{$executionId}.create", $message['data']['events'] ?? [], true)
);
$responseUpdate = $this->receiveUntilEvent(
$client,
fn (array $message): bool => ($message['type'] ?? null) === 'event'
&& \in_array("functions.{$functionId}.executions.{$executionId}.update", $message['data']['events'] ?? [], true)
);
$this->assertArrayHasKey('type', $response);
$this->assertArrayHasKey('data', $response);
$this->assertEquals('event', $response['type']);