84 lines
4.1 KiB
TypeScript
84 lines
4.1 KiB
TypeScript
import { test, expect } from '@playwright/test';
|
|
|
|
// ISS-129 (v0.57.0): /api/events pushes full state snapshots over SSE — the current snapshot on
|
|
// connect, then one after every sim tick (~1 s; the background tick runs even while idle since
|
|
// v0.56.0, so no scale hook is needed). Reached via the same base URL as playwright.config.ts
|
|
// (E2E_BASE_URL, defaulting to the live instance) — node-side fetch, no browser involved.
|
|
const baseUrl = process.env.E2E_BASE_URL ?? 'https://flight.dev.kkhost.pl';
|
|
|
|
interface StateBody {
|
|
simState: { clockMs: number };
|
|
packages?: Array<{ status: string }>;
|
|
}
|
|
|
|
// ISS-133 (v0.59.0): frames carry only the package statuses the client renders — terminal history
|
|
// (delivered/abandoned) is unbounded in the DB and must never leak into a pushed frame.
|
|
const ALLOWED_PACKAGE_STATUSES = new Set(['open', 'loaded', 'expired']);
|
|
|
|
test('GET /api/events streams state snapshots over SSE', async ({ request }) => {
|
|
// v1.1.0 (ISS-107): the stream is session-guarded — EventSource cannot set headers, so the client
|
|
// passes ?session= (requireAuthSse). Mint one via the test hook and use exactly that path.
|
|
const mint = await request.post('/api/test/mint-player-session');
|
|
expect(mint.status(), 'mint-player-session hook should be enabled in the CI stack (FLIGHT_TEST_HOOKS=1)').toBe(200);
|
|
const { sessionId } = (await mint.json()) as { sessionId: string };
|
|
|
|
const res = await fetch(`${baseUrl}/api/events?session=${sessionId}`, { headers: { Accept: 'text/event-stream' } });
|
|
expect(res.status).toBe(200);
|
|
expect(res.headers.get('content-type')).toContain('text/event-stream');
|
|
expect(res.body).not.toBeNull();
|
|
|
|
const reader = res.body!.getReader();
|
|
const decoder = new TextDecoder();
|
|
let buffer = '';
|
|
const clocks: number[] = []; // simState.clockMs of each parsed snapshot event
|
|
const statusesSeen = new Set<string>(); // package statuses observed in any frame (ISS-133)
|
|
let maxFrameBytes = 0;
|
|
|
|
try {
|
|
// Collect two snapshot events: the initial one, then at least one pushed by a background tick.
|
|
const deadline = Date.now() + 15_000;
|
|
while (clocks.length < 2 && Date.now() < deadline) {
|
|
let chunk: ReadableStreamReadResult<Uint8Array>;
|
|
try {
|
|
chunk = await Promise.race([
|
|
reader.read(),
|
|
new Promise<never>((_, reject) =>
|
|
setTimeout(() => reject(new Error('SSE stream stalled')), Math.max(1, deadline - Date.now())),
|
|
),
|
|
]);
|
|
} catch {
|
|
break; // stalled or past the deadline — let the length assertion report it
|
|
}
|
|
if (chunk.done) break; // stream ended early — same
|
|
buffer += decoder.decode(chunk.value, { stream: true });
|
|
let sep: number;
|
|
while ((sep = buffer.indexOf('\n\n')) >= 0) {
|
|
const frame = buffer.slice(0, sep);
|
|
buffer = buffer.slice(sep + 2);
|
|
for (const line of frame.split('\n')) {
|
|
if (!line.startsWith('data: ')) continue; // heartbeats are comment lines (" : ping")
|
|
const snap = JSON.parse(line.slice('data: '.length)) as StateBody;
|
|
clocks.push(snap.simState.clockMs);
|
|
for (const p of snap.packages ?? []) statusesSeen.add(p.status);
|
|
maxFrameBytes = Math.max(maxFrameBytes, line.length);
|
|
}
|
|
}
|
|
}
|
|
} finally {
|
|
await reader.cancel(); // close the stream → server unsubscribes
|
|
}
|
|
|
|
// The initial snapshot arrives on connect; the second comes from a background tick within ~1 s.
|
|
// A grounded fleet freezes the clock (#135), so consecutive frames may carry the SAME clockMs —
|
|
// non-decreasing is what proves real pushes, not replays (advance itself is pinned in sim.spec.ts).
|
|
expect(clocks.length).toBeGreaterThanOrEqual(2);
|
|
expect(clocks[1]).toBeGreaterThanOrEqual(clocks[0]);
|
|
|
|
// ISS-133: no terminal package history in any frame (the DB keeps it forever; frames must not),
|
|
// and a bounded frame size even on an instance with long-running history (~597 KB pre-v0.59.0).
|
|
for (const status of statusesSeen) {
|
|
expect(ALLOWED_PACKAGE_STATUSES.has(status)).toBe(true);
|
|
}
|
|
expect(maxFrameBytes).toBeLessThan(200_000);
|
|
});
|