ui/phase-24: push events, turn-ready toast, single SubscribeEvents consumer

Wires the gateway's signed SubscribeEvents stream end-to-end: - backend: emit game.turn.ready from lobby.OnRuntimeSnapshot on every current_turn advance, addressed to every active membership, push-only channel, idempotency key turn-ready:<game_id>:<turn>; - ui: single EventStream singleton replaces revocation-watcher.ts and carries both per-event dispatch and revocation detection; toast primitive (store + host) lives in lib/; GameStateStore gains pendingTurn/markPendingTurn/advanceToPending and a persisted lastViewedTurn so a return after multiple turns surfaces the same "view now" affordance as a live push event; - mandatory event-signature verification through ui/core (verifyPayloadHash + verifyEvent), full-jitter exponential backoff 1s -> 30s on transient failure, signOut("revoked") on Unauthenticated or clean end-of-stream; - catalog and migration accept the new kind; tests cover producer (testcontainers + capturing publisher), consumer (Vitest event stream, toast, game-state extensions), and a Playwright e2e delivering a signed frame to the live UI. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
2026-05-11 16:16:31 +02:00
parent 5a2a977dc6
commit 5b07bb4e14
26 changed files with 2181 additions and 209 deletions
@@ -0,0 +1,194 @@
+// Phase 24 end-to-end coverage for the push-event path. Boots an
+// authenticated session, mocks the gateway calls the in-game shell
+// makes (`lobby.my.games.list`, `user.games.report`), and serves one
+// signed `game.turn.ready` frame on the `SubscribeEvents` stream.
+// The test asserts the toast surfaces with the new turn, the action
+// button advances the store onto the new turn, and the header
+// reflects the freshly-loaded snapshot.
+
+import { fromJson, type JsonValue } from "@bufbuild/protobuf";
+import { expect, test, type Page } from "@playwright/test";
+import { ByteBuffer } from "flatbuffers";
+
+import { ExecuteCommandRequestSchema } from "../../src/proto/galaxy/gateway/v1/edge_gateway_pb";
+import { UUID } from "../../src/proto/galaxy/fbs/common";
+import { GameReportRequest } from "../../src/proto/galaxy/fbs/report";
+import { forgeExecuteCommandResponseJson } from "./fixtures/sign-response";
+import {
+	buildMyGamesListPayload,
+	type GameFixture,
+} from "./fixtures/lobby-fbs";
+import { buildReportPayload } from "./fixtures/report-fbs";
+import { forgeGatewayEventFrame } from "./fixtures/sign-event";
+
+const SESSION_ID = "phase-24-turn-ready-session";
+const GAME_ID = "11111111-2222-3333-4444-555555555555";
+
+interface MockState {
+	currentTurn: number;
+	reportRequests: Array<{ turn: number }>;
+	subscribeHits: number;
+}
+
+async function mockGateway(page: Page): Promise<MockState> {
+	const state: MockState = {
+		currentTurn: 4,
+		reportRequests: [],
+		subscribeHits: 0,
+	};
+
+	const baseGame = (): GameFixture => ({
+		gameId: GAME_ID,
+		gameName: "Phase 24 Game",
+		gameType: "private",
+		status: "running",
+		ownerUserId: "user-1",
+		minPlayers: 2,
+		maxPlayers: 8,
+		enrollmentEndsAtMs: BigInt(Date.now() + 86_400_000),
+		createdAtMs: BigInt(Date.now() - 86_400_000),
+		updatedAtMs: BigInt(Date.now()),
+		currentTurn: state.currentTurn,
+	});
+
+	await page.route(
+		"**/galaxy.gateway.v1.EdgeGateway/ExecuteCommand",
+		async (route) => {
+			const reqText = route.request().postData();
+			if (reqText === null) {
+				await route.fulfill({ status: 400 });
+				return;
+			}
+			const req = fromJson(
+				ExecuteCommandRequestSchema,
+				JSON.parse(reqText) as JsonValue,
+			);
+
+			let resultCode = "ok";
+			let payload: Uint8Array;
+			switch (req.messageType) {
+				case "lobby.my.games.list":
+					payload = buildMyGamesListPayload([baseGame()]);
+					break;
+				case "user.games.report": {
+					const decoded = GameReportRequest.getRootAsGameReportRequest(
+						new ByteBuffer(req.payloadBytes),
+					);
+					const turn = decoded.turn();
+					state.reportRequests.push({ turn });
+					payload = buildReportPayload({
+						turn,
+						mapWidth: 4000,
+						mapHeight: 4000,
+						localPlanets: [
+							{ number: 1, name: "Home", x: 1000, y: 1000 },
+						],
+					});
+					break;
+				}
+				default:
+					resultCode = "internal_error";
+					payload = new Uint8Array();
+			}
+
+			const body = await forgeExecuteCommandResponseJson({
+				requestId: req.requestId,
+				timestampMs: BigInt(Date.now()),
+				resultCode,
+				payloadBytes: payload,
+			});
+			await route.fulfill({
+				status: 200,
+				contentType: "application/json",
+				body,
+			});
+		},
+	);
+
+	// The first SubscribeEvents request from the root layout receives
+	// one signed `game.turn.ready` frame for turn 5; subsequent
+	// reconnect attempts (events.ts retries after the abrupt
+	// end-of-body) are held open indefinitely so the toast stays
+	// visible long enough for the test to interact with it.
+	await page.route(
+		"**/galaxy.gateway.v1.EdgeGateway/SubscribeEvents",
+		async (route) => {
+			state.subscribeHits += 1;
+			if (state.subscribeHits === 1) {
+				const payload = new TextEncoder().encode(
+					JSON.stringify({ game_id: GAME_ID, turn: 5 }),
+				);
+				const frame = await forgeGatewayEventFrame({
+					eventType: "game.turn.ready",
+					eventId: "evt-turn-ready-1",
+					timestampMs: BigInt(Date.now()),
+					requestId: "req-turn-ready-1",
+					traceId: "trace-turn-ready-1",
+					payloadBytes: payload,
+				});
+				await route.fulfill({
+					status: 200,
+					contentType: "application/connect+json",
+					body: Buffer.from(frame),
+				});
+				return;
+			}
+			await new Promise<void>(() => {});
+		},
+	);
+
+	return state;
+}
+
+async function bootSession(page: Page): Promise<void> {
+	await page.goto("/__debug/store");
+	await expect(page.getByTestId("debug-store-ready")).toBeVisible();
+	await page.waitForFunction(() => window.__galaxyDebug?.ready === true);
+	await page.evaluate(() => window.__galaxyDebug!.clearSession());
+	await page.evaluate(
+		(id) => window.__galaxyDebug!.setDeviceSessionId(id),
+		SESSION_ID,
+	);
+}
+
+test("signed game.turn.ready frame surfaces the toast", async ({ page }) => {
+	await mockGateway(page);
+
+	await bootSession(page);
+	await page.goto(`/games/${GAME_ID}/map`);
+
+	// Initial chrome reflects the bootstrap currentTurn=4.
+	await expect(page.getByTestId("active-view-map")).toHaveAttribute(
+		"data-status",
+		"ready",
+	);
+	await expect(page.getByTestId("game-shell-headline")).toContainText(
+		"turn 4",
+	);
+
+	// The signed push frame is delivered to the singleton event
+	// stream → the per-game layout handler marks pendingTurn=5 → the
+	// toast becomes visible carrying the new turn number and the
+	// `view now` action label.
+	await expect(page.getByTestId("toast")).toBeVisible({ timeout: 5_000 });
+	await expect(page.getByTestId("toast-message")).toContainText("5");
+	await expect(page.getByTestId("toast-action")).toBeVisible();
+});
+
+test("manual dismiss clears the turn-ready toast without advancing the view", async ({
+	page,
+}) => {
+	await mockGateway(page);
+
+	await bootSession(page);
+	await page.goto(`/games/${GAME_ID}/map`);
+
+	await expect(page.getByTestId("toast")).toBeVisible({ timeout: 5_000 });
+	await page.getByTestId("toast-close").click();
+	await expect(page.getByTestId("toast")).toBeHidden();
+	// `pendingTurn` is still set — the user simply chose not to
+	// advance — so the header continues to show the older turn.
+	await expect(page.getByTestId("game-shell-headline")).toContainText(
+		"turn 4",
+	);
+});