galaxy-game/ui/frontend/tests/e2e/turn-ready.spec.ts

// 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/edge/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(
		"**/edge.v1.Gateway/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 root layout opens the event stream while the dispatcher is
	// still on the lobby screen (the single-URL app-shell starts the
	// singleton stream on authentication, before the player enters a
	// game). The per-game `game.turn.ready` handler only registers once
	// the game shell mounts, so the very first frame can land before the
	// handler exists. Deliver the signed frame on the first TWO
	// SubscribeEvents requests — the post-frame reconnect (events.ts
	// retries after the abrupt end-of-body) carries it again once the
	// handler is up; `markPendingTurn(5)` is idempotent. Hold every
	// later reconnect open so the toast stays visible for the test.
	await page.route(
		"**/edge.v1.Gateway/SubscribeEvents",
		async (route) => {
			state.subscribeHits += 1;
			if (state.subscribeHits <= 2) {
				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("/");
	await page.waitForFunction(() => window.__galaxyNav !== undefined);
	await page.evaluate(
		(id) => window.__galaxyNav!.enterGame(id, "map", {}),
		GAME_ID,
	);

	// 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("/");
	await page.waitForFunction(() => window.__galaxyNav !== undefined);
	await page.evaluate(
		(id) => window.__galaxyNav!.enterGame(id, "map", {}),
		GAME_ID,
	);

	// Let the game shell finish booting (so the per-game turn-ready
	// handler is registered) before expecting the pushed toast.
	await expect(page.getByTestId("active-view-map")).toHaveAttribute(
		"data-status",
		"ready",
	);
	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",
	);
});