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>
This commit is contained in:
Ilia Denisov
@@ -6,6 +6,7 @@
|
||||
// truth; this TS copy stays small enough to read against that test.
|
||||
|
||||
const RESPONSE_DOMAIN_MARKER_V1 = "galaxy-response-v1";
|
||||
const EVENT_DOMAIN_MARKER_V1 = "galaxy-event-v1";
|
||||
|
||||
export interface ResponseSigningFields {
|
||||
protocolVersion: string;
|
||||
@@ -15,6 +16,15 @@ export interface ResponseSigningFields {
|
||||
payloadHash: Uint8Array;
|
||||
}
|
||||
|
||||
export interface EventSigningFields {
|
||||
eventType: string;
|
||||
eventId: string;
|
||||
timestampMs: bigint;
|
||||
requestId: string;
|
||||
traceId: string;
|
||||
payloadHash: Uint8Array;
|
||||
}
|
||||
|
||||
export function buildResponseSigningInput(
|
||||
fields: ResponseSigningFields,
|
||||
): Uint8Array {
|
||||
@@ -28,6 +38,24 @@ export function buildResponseSigningInput(
|
||||
return new Uint8Array(parts);
|
||||
}
|
||||
|
||||
// `buildEventSigningInput` mirrors `ui/core/canon/event.go`
|
||||
// `BuildEventSigningInput`. The Go-side parity test
|
||||
// (`gateway/authn/parity_with_ui_core_test.go`) is the source of truth;
|
||||
// this TS copy stays close enough to that test to read against it.
|
||||
export function buildEventSigningInput(
|
||||
fields: EventSigningFields,
|
||||
): Uint8Array {
|
||||
const parts: number[] = [];
|
||||
appendLengthPrefixedString(parts, EVENT_DOMAIN_MARKER_V1);
|
||||
appendLengthPrefixedString(parts, fields.eventType);
|
||||
appendLengthPrefixedString(parts, fields.eventId);
|
||||
appendBigEndianUint64(parts, fields.timestampMs);
|
||||
appendLengthPrefixedString(parts, fields.requestId);
|
||||
appendLengthPrefixedString(parts, fields.traceId);
|
||||
appendLengthPrefixedBytes(parts, fields.payloadHash);
|
||||
return new Uint8Array(parts);
|
||||
}
|
||||
|
||||
function appendLengthPrefixedString(dst: number[], value: string): void {
|
||||
const bytes = new TextEncoder().encode(value);
|
||||
appendLengthPrefixedBytes(dst, bytes);
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
// `forgeGatewayEventFrame` produces one Connect HTTP/1.1
|
||||
// server-streaming frame carrying a `GatewayEvent` signed with the
|
||||
// fixture private key. The Playwright `turn-ready.spec.ts` route
|
||||
// handler returns this body when the UI opens `SubscribeEvents` so
|
||||
// the production verification path (`core.verifyEvent`) accepts the
|
||||
// frame under the matching public key the dev server picks up via
|
||||
// `VITE_GATEWAY_RESPONSE_PUBLIC_KEY`.
|
||||
//
|
||||
// Connect HTTP/1.1 server-streaming framing per request:
|
||||
// 1 byte flag (0x00 = message)
|
||||
// 4 bytes length (big-endian, payload size)
|
||||
// N bytes payload (JSON-encoded GatewayEvent for the JSON codec)
|
||||
//
|
||||
// The route handler closes the response after one frame; the UI's
|
||||
// `events.svelte.ts` reconnect loop treats the abrupt end-of-body as
|
||||
// a transient error and backs off, which keeps the toast visible
|
||||
// long enough for the test to assert on it.
|
||||
|
||||
import { create, toJsonString } from "@bufbuild/protobuf";
|
||||
import { webcrypto } from "node:crypto";
|
||||
import { GatewayEventSchema } from "../../../src/proto/galaxy/gateway/v1/edge_gateway_pb";
|
||||
import { buildEventSigningInput } from "./canon";
|
||||
import {
|
||||
FIXTURE_PRIVATE_KEY_PKCS8_BASE64,
|
||||
decodeBase64,
|
||||
} from "./gateway-key";
|
||||
|
||||
export interface ForgedEventInput {
|
||||
eventType: string;
|
||||
eventId: string;
|
||||
timestampMs: bigint;
|
||||
requestId: string;
|
||||
traceId: string;
|
||||
payloadBytes: Uint8Array;
|
||||
}
|
||||
|
||||
let cachedPrivateKey: CryptoKey | null = null;
|
||||
|
||||
async function privateKey(): Promise<CryptoKey> {
|
||||
if (cachedPrivateKey !== null) {
|
||||
return cachedPrivateKey;
|
||||
}
|
||||
const pkcs8 = decodeBase64(FIXTURE_PRIVATE_KEY_PKCS8_BASE64);
|
||||
cachedPrivateKey = await webcrypto.subtle.importKey(
|
||||
"pkcs8",
|
||||
pkcs8,
|
||||
{ name: "Ed25519" },
|
||||
false,
|
||||
["sign"],
|
||||
);
|
||||
return cachedPrivateKey;
|
||||
}
|
||||
|
||||
async function sha256(payload: Uint8Array): Promise<Uint8Array> {
|
||||
const digest = await webcrypto.subtle.digest("SHA-256", payload);
|
||||
return new Uint8Array(digest);
|
||||
}
|
||||
|
||||
export async function forgeGatewayEventFrame(
|
||||
input: ForgedEventInput,
|
||||
): Promise<Uint8Array> {
|
||||
const payloadHash = await sha256(input.payloadBytes);
|
||||
const canonical = buildEventSigningInput({
|
||||
eventType: input.eventType,
|
||||
eventId: input.eventId,
|
||||
timestampMs: input.timestampMs,
|
||||
requestId: input.requestId,
|
||||
traceId: input.traceId,
|
||||
payloadHash,
|
||||
});
|
||||
const signatureBuf = await webcrypto.subtle.sign(
|
||||
{ name: "Ed25519" },
|
||||
await privateKey(),
|
||||
canonical,
|
||||
);
|
||||
const event = create(GatewayEventSchema, {
|
||||
eventType: input.eventType,
|
||||
eventId: input.eventId,
|
||||
timestampMs: input.timestampMs,
|
||||
payloadBytes: input.payloadBytes,
|
||||
payloadHash,
|
||||
signature: new Uint8Array(signatureBuf),
|
||||
requestId: input.requestId,
|
||||
traceId: input.traceId,
|
||||
});
|
||||
const body = new TextEncoder().encode(
|
||||
toJsonString(GatewayEventSchema, event),
|
||||
);
|
||||
const frame = new Uint8Array(5 + body.length);
|
||||
frame[0] = 0x00; // message frame
|
||||
new DataView(frame.buffer).setUint32(1, body.length, false);
|
||||
frame.set(body, 5);
|
||||
return frame;
|
||||
}
|
||||
@@ -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",
|
||||
);
|
||||
});
|
||||
@@ -0,0 +1,324 @@
|
||||
// Vitest coverage for the SubscribeEvents stream consumer in
|
||||
// `src/api/events.svelte.ts`. The tests drive the singleton through
|
||||
// its lifecycle with a `createRouterTransport` fake — the same
|
||||
// pattern `galaxy-client.test.ts` uses for unary calls, extended to
|
||||
// async-generator handlers for server-streaming RPCs.
|
||||
//
|
||||
// The session store is mocked so `signOut("revoked")` is observable
|
||||
// without instantiating the real keystore/IndexedDB chain.
|
||||
|
||||
import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
|
||||
import { create } from "@bufbuild/protobuf";
|
||||
import {
|
||||
Code,
|
||||
ConnectError,
|
||||
createClient,
|
||||
createRouterTransport,
|
||||
} from "@connectrpc/connect";
|
||||
import {
|
||||
EdgeGateway,
|
||||
GatewayEventSchema,
|
||||
type GatewayEvent,
|
||||
} from "../src/proto/galaxy/gateway/v1/edge_gateway_pb";
|
||||
|
||||
let sessionStatus: "anonymous" | "authenticated" = "anonymous";
|
||||
const signOutSpy = vi.fn();
|
||||
vi.mock("../src/lib/session-store.svelte", () => ({
|
||||
session: {
|
||||
get status(): string {
|
||||
return sessionStatus;
|
||||
},
|
||||
signOut: (...args: unknown[]) => signOutSpy(...args),
|
||||
},
|
||||
}));
|
||||
|
||||
// The import must come after vi.mock so the module reads the mocked
|
||||
// session reference.
|
||||
const {
|
||||
eventStream,
|
||||
} = await import("../src/api/events.svelte");
|
||||
|
||||
import type { Core } from "../src/platform/core/index";
|
||||
import type { DeviceKeypair } from "../src/platform/store/index";
|
||||
|
||||
beforeEach(() => {
|
||||
eventStream.resetForTests();
|
||||
signOutSpy.mockReset();
|
||||
sessionStatus = "anonymous";
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
eventStream.resetForTests();
|
||||
});
|
||||
|
||||
function mockCore(overrides?: Partial<Core>): Core {
|
||||
return {
|
||||
signRequest: () => new Uint8Array([1, 2, 3]),
|
||||
verifyResponse: () => true,
|
||||
verifyEvent: () => true,
|
||||
verifyPayloadHash: () => true,
|
||||
driveEffective: () => 0,
|
||||
emptyMass: () => 0,
|
||||
weaponsBlockMass: () => 0,
|
||||
fullMass: () => 0,
|
||||
speed: () => 0,
|
||||
cargoCapacity: () => 0,
|
||||
carryingMass: () => 0,
|
||||
blockUpgradeCost: () => 0,
|
||||
...overrides,
|
||||
} as Core;
|
||||
}
|
||||
|
||||
function mockKeypair(): DeviceKeypair {
|
||||
return {
|
||||
publicKey: new Uint8Array(32),
|
||||
sign: async () => new Uint8Array(64),
|
||||
};
|
||||
}
|
||||
|
||||
function buildEvent(eventType: string, payload: Uint8Array): GatewayEvent {
|
||||
return create(GatewayEventSchema, {
|
||||
eventType,
|
||||
eventId: `event-${eventType}-${Math.random().toString(16).slice(2, 8)}`,
|
||||
timestampMs: 1n,
|
||||
payloadBytes: payload,
|
||||
payloadHash: new Uint8Array(32).fill(0xaa),
|
||||
signature: new Uint8Array(64).fill(0xbb),
|
||||
requestId: "req-1",
|
||||
traceId: "trace-1",
|
||||
});
|
||||
}
|
||||
|
||||
function makeRouter(
|
||||
streamFactory: () => AsyncIterable<GatewayEvent>,
|
||||
): ReturnType<typeof createClient<typeof EdgeGateway>> {
|
||||
const transport = createRouterTransport(({ service }) => {
|
||||
service(EdgeGateway, {
|
||||
executeCommand() {
|
||||
throw new Error("not used in this test");
|
||||
},
|
||||
async *subscribeEvents() {
|
||||
for await (const e of streamFactory()) {
|
||||
yield e;
|
||||
}
|
||||
},
|
||||
});
|
||||
});
|
||||
return createClient(EdgeGateway, transport);
|
||||
}
|
||||
|
||||
describe("EventStream", () => {
|
||||
test("verified events reach the registered handler", async () => {
|
||||
const handler = vi.fn();
|
||||
eventStream.on("game.turn.ready", handler);
|
||||
|
||||
const event = buildEvent(
|
||||
"game.turn.ready",
|
||||
new TextEncoder().encode(JSON.stringify({ game_id: "g", turn: 2 })),
|
||||
);
|
||||
const client = makeRouter(async function* () {
|
||||
yield event;
|
||||
});
|
||||
|
||||
const sleep = vi.fn(async () => {});
|
||||
|
||||
eventStream.start({
|
||||
core: mockCore(),
|
||||
keypair: mockKeypair(),
|
||||
deviceSessionId: "device-1",
|
||||
gatewayResponsePublicKey: new Uint8Array(32),
|
||||
client,
|
||||
sleep,
|
||||
random: () => 0,
|
||||
});
|
||||
|
||||
await vi.waitFor(() => {
|
||||
expect(handler).toHaveBeenCalled();
|
||||
});
|
||||
expect(handler).toHaveBeenCalledTimes(1);
|
||||
expect(handler.mock.calls[0]?.[0].eventType).toBe("game.turn.ready");
|
||||
eventStream.stop();
|
||||
});
|
||||
|
||||
test("handlers for other event types are not invoked", async () => {
|
||||
const turnHandler = vi.fn();
|
||||
const mailHandler = vi.fn();
|
||||
eventStream.on("game.turn.ready", turnHandler);
|
||||
eventStream.on("mail.received", mailHandler);
|
||||
|
||||
const event = buildEvent(
|
||||
"game.turn.ready",
|
||||
new TextEncoder().encode("{}"),
|
||||
);
|
||||
const client = makeRouter(async function* () {
|
||||
yield event;
|
||||
});
|
||||
eventStream.start({
|
||||
core: mockCore(),
|
||||
keypair: mockKeypair(),
|
||||
deviceSessionId: "device-1",
|
||||
gatewayResponsePublicKey: new Uint8Array(32),
|
||||
client,
|
||||
sleep: async () => {},
|
||||
random: () => 0,
|
||||
});
|
||||
|
||||
await vi.waitFor(() => {
|
||||
expect(turnHandler).toHaveBeenCalled();
|
||||
});
|
||||
expect(mailHandler).not.toHaveBeenCalled();
|
||||
eventStream.stop();
|
||||
});
|
||||
|
||||
test("unsubscribe removes the handler", async () => {
|
||||
const handler = vi.fn();
|
||||
const off = eventStream.on("game.turn.ready", handler);
|
||||
off();
|
||||
|
||||
const event = buildEvent(
|
||||
"game.turn.ready",
|
||||
new TextEncoder().encode("{}"),
|
||||
);
|
||||
const client = makeRouter(async function* () {
|
||||
yield event;
|
||||
});
|
||||
const sleepSpy = vi.fn(async () => {});
|
||||
eventStream.start({
|
||||
core: mockCore(),
|
||||
keypair: mockKeypair(),
|
||||
deviceSessionId: "device-1",
|
||||
gatewayResponsePublicKey: new Uint8Array(32),
|
||||
client,
|
||||
sleep: sleepSpy,
|
||||
random: () => 0,
|
||||
});
|
||||
|
||||
await vi.waitFor(() => {
|
||||
// Stream finished — either status became idle, or the loop
|
||||
// is at backoff after a clean close on an anonymous
|
||||
// session (which goes straight to idle as well).
|
||||
expect(eventStream.connectionStatus).toBe("idle");
|
||||
});
|
||||
expect(handler).not.toHaveBeenCalled();
|
||||
eventStream.stop();
|
||||
});
|
||||
|
||||
test("bad signature tears down the stream and reconnects", async () => {
|
||||
const handler = vi.fn();
|
||||
eventStream.on("game.turn.ready", handler);
|
||||
|
||||
let verifyCalls = 0;
|
||||
const core = mockCore({
|
||||
verifyEvent: () => {
|
||||
verifyCalls += 1;
|
||||
return verifyCalls > 1; // first event fails, then passes
|
||||
},
|
||||
});
|
||||
|
||||
let streamCalls = 0;
|
||||
const client = makeRouter(async function* () {
|
||||
streamCalls += 1;
|
||||
yield buildEvent(
|
||||
"game.turn.ready",
|
||||
new TextEncoder().encode("{}"),
|
||||
);
|
||||
});
|
||||
|
||||
const sleepCalls: number[] = [];
|
||||
eventStream.start({
|
||||
core,
|
||||
keypair: mockKeypair(),
|
||||
deviceSessionId: "device-1",
|
||||
gatewayResponsePublicKey: new Uint8Array(32),
|
||||
client,
|
||||
sleep: async (ms) => {
|
||||
sleepCalls.push(ms);
|
||||
},
|
||||
random: () => 0, // full-jitter = 0 → instant retry
|
||||
});
|
||||
|
||||
await vi.waitFor(() => {
|
||||
expect(handler).toHaveBeenCalled();
|
||||
});
|
||||
// Two stream openings: first one rejected on bad signature,
|
||||
// second one delivered the good event.
|
||||
expect(streamCalls).toBeGreaterThanOrEqual(2);
|
||||
// Backoff was scheduled between attempts.
|
||||
expect(sleepCalls.length).toBeGreaterThanOrEqual(1);
|
||||
eventStream.stop();
|
||||
});
|
||||
|
||||
test("unauthenticated error signs the session out", async () => {
|
||||
sessionStatus = "authenticated";
|
||||
const client = makeRouter(async function* () {
|
||||
yield* [];
|
||||
throw new ConnectError("revoked", Code.Unauthenticated);
|
||||
});
|
||||
eventStream.start({
|
||||
core: mockCore(),
|
||||
keypair: mockKeypair(),
|
||||
deviceSessionId: "device-1",
|
||||
gatewayResponsePublicKey: new Uint8Array(32),
|
||||
client,
|
||||
sleep: async () => {},
|
||||
random: () => 0,
|
||||
});
|
||||
|
||||
await vi.waitFor(() => {
|
||||
expect(signOutSpy).toHaveBeenCalled();
|
||||
});
|
||||
expect(signOutSpy).toHaveBeenCalledWith("revoked");
|
||||
eventStream.stop();
|
||||
});
|
||||
|
||||
test("clean end-of-stream on an authenticated session is the revocation signal", async () => {
|
||||
sessionStatus = "authenticated";
|
||||
const client = makeRouter(async function* () {
|
||||
yield* [];
|
||||
});
|
||||
eventStream.start({
|
||||
core: mockCore(),
|
||||
keypair: mockKeypair(),
|
||||
deviceSessionId: "device-1",
|
||||
gatewayResponsePublicKey: new Uint8Array(32),
|
||||
client,
|
||||
sleep: async () => {},
|
||||
random: () => 0,
|
||||
});
|
||||
await vi.waitFor(() => {
|
||||
expect(signOutSpy).toHaveBeenCalledWith("revoked");
|
||||
});
|
||||
eventStream.stop();
|
||||
});
|
||||
|
||||
test("connectionStatus transitions through connecting → connected → idle", async () => {
|
||||
expect(eventStream.connectionStatus).toBe("idle");
|
||||
const event = buildEvent(
|
||||
"game.turn.ready",
|
||||
new TextEncoder().encode("{}"),
|
||||
);
|
||||
const observed: string[] = [];
|
||||
const client = makeRouter(async function* () {
|
||||
yield event;
|
||||
});
|
||||
const handler = vi.fn(() => {
|
||||
observed.push(eventStream.connectionStatus);
|
||||
});
|
||||
eventStream.on("game.turn.ready", handler);
|
||||
eventStream.start({
|
||||
core: mockCore(),
|
||||
keypair: mockKeypair(),
|
||||
deviceSessionId: "device-1",
|
||||
gatewayResponsePublicKey: new Uint8Array(32),
|
||||
client,
|
||||
sleep: async () => {},
|
||||
random: () => 0,
|
||||
});
|
||||
await vi.waitFor(() => {
|
||||
expect(handler).toHaveBeenCalled();
|
||||
});
|
||||
// Inside the handler, status had already flipped to connected.
|
||||
expect(observed).toContain("connected");
|
||||
eventStream.stop();
|
||||
});
|
||||
});
|
||||
@@ -23,12 +23,21 @@ import { IDBCache } from "../src/platform/store/idb-cache";
|
||||
import { openGalaxyDB, type GalaxyDB } from "../src/platform/store/idb";
|
||||
import type { IDBPDatabase } from "idb";
|
||||
import { UUID } from "../src/proto/galaxy/fbs/common";
|
||||
import { ByteBuffer } from "flatbuffers";
|
||||
import {
|
||||
GameReportRequest,
|
||||
LocalPlanet,
|
||||
Report,
|
||||
ShipClass,
|
||||
} from "../src/proto/galaxy/fbs/report";
|
||||
|
||||
function decodeRequestedTurn(payload: Uint8Array): number {
|
||||
const req = GameReportRequest.getRootAsGameReportRequest(
|
||||
new ByteBuffer(payload),
|
||||
);
|
||||
return req.turn();
|
||||
}
|
||||
|
||||
const listMyGamesSpy = vi.fn();
|
||||
vi.mock("../src/api/lobby", async () => {
|
||||
const actual = await vi.importActual<typeof import("../src/api/lobby")>(
|
||||
@@ -291,6 +300,91 @@ describe("GameStateStore", () => {
|
||||
expect(store.error).toBe("device session missing");
|
||||
});
|
||||
|
||||
test("setGame opens last-viewed turn and surfaces pendingTurn when server is ahead", async () => {
|
||||
await cache.put("game-prefs", `${GAME_ID}/last-viewed-turn`, 4);
|
||||
listMyGamesSpy.mockResolvedValue([makeGameSummary(7)]);
|
||||
const requestedTurns: number[] = [];
|
||||
const client = makeFakeClient(async (_messageType, payload) => {
|
||||
const turn = decodeRequestedTurn(payload);
|
||||
requestedTurns.push(turn);
|
||||
return {
|
||||
resultCode: "ok",
|
||||
payloadBytes: buildReportPayload({ turn }),
|
||||
};
|
||||
});
|
||||
|
||||
const store = new GameStateStore();
|
||||
await store.init({ client, cache, gameId: GAME_ID });
|
||||
|
||||
expect(requestedTurns).toEqual([4]);
|
||||
expect(store.report?.turn).toBe(4);
|
||||
expect(store.currentTurn).toBe(4);
|
||||
expect(store.pendingTurn).toBe(7);
|
||||
store.dispose();
|
||||
});
|
||||
|
||||
test("markPendingTurn records server-side advance without a network call", async () => {
|
||||
listMyGamesSpy.mockResolvedValue([makeGameSummary(3)]);
|
||||
let calls = 0;
|
||||
const client = makeFakeClient(async () => {
|
||||
calls += 1;
|
||||
return {
|
||||
resultCode: "ok",
|
||||
payloadBytes: buildReportPayload({ turn: 3 }),
|
||||
};
|
||||
});
|
||||
|
||||
const store = new GameStateStore();
|
||||
await store.init({ client, cache, gameId: GAME_ID });
|
||||
expect(store.pendingTurn).toBeNull();
|
||||
|
||||
const before = calls;
|
||||
store.markPendingTurn(4);
|
||||
expect(store.pendingTurn).toBe(4);
|
||||
store.markPendingTurn(3); // not strictly ahead → ignored
|
||||
expect(store.pendingTurn).toBe(4);
|
||||
store.markPendingTurn(6);
|
||||
expect(store.pendingTurn).toBe(6);
|
||||
store.markPendingTurn(5); // not ahead of pending=6 → ignored
|
||||
expect(store.pendingTurn).toBe(6);
|
||||
expect(calls).toBe(before);
|
||||
|
||||
store.dispose();
|
||||
});
|
||||
|
||||
test("advanceToPending refetches and clears the pending indicator", async () => {
|
||||
await cache.put("game-prefs", `${GAME_ID}/last-viewed-turn`, 2);
|
||||
const summaries = [makeGameSummary(5), makeGameSummary(5)];
|
||||
let listCalls = 0;
|
||||
listMyGamesSpy.mockImplementation(() => {
|
||||
const out = summaries[listCalls] ?? summaries.at(-1)!;
|
||||
listCalls += 1;
|
||||
return Promise.resolve([out]);
|
||||
});
|
||||
|
||||
const requestedTurns: number[] = [];
|
||||
const client = makeFakeClient(async (_messageType, payload) => {
|
||||
const turn = decodeRequestedTurn(payload);
|
||||
requestedTurns.push(turn);
|
||||
return {
|
||||
resultCode: "ok",
|
||||
payloadBytes: buildReportPayload({ turn }),
|
||||
};
|
||||
});
|
||||
|
||||
const store = new GameStateStore();
|
||||
await store.init({ client, cache, gameId: GAME_ID });
|
||||
expect(store.currentTurn).toBe(2);
|
||||
expect(store.pendingTurn).toBe(5);
|
||||
|
||||
await store.advanceToPending();
|
||||
expect(store.currentTurn).toBe(5);
|
||||
expect(store.pendingTurn).toBeNull();
|
||||
expect(requestedTurns).toEqual([2, 5]);
|
||||
|
||||
store.dispose();
|
||||
});
|
||||
|
||||
test("decodeReport surfaces the localShipClass projection with full attributes", async () => {
|
||||
listMyGamesSpy.mockResolvedValue([makeGameSummary(1)]);
|
||||
const client = makeFakeClient(async () => ({
|
||||
|
||||
@@ -0,0 +1,127 @@
|
||||
// Vitest coverage for the toast primitive in
|
||||
// `src/lib/toast.svelte.ts`. The store keeps one active toast at a
|
||||
// time, replaces it on a fresh `show`, auto-dismisses after the
|
||||
// configured duration, runs the `onAction` callback once on the
|
||||
// action button, and ignores a stale `dismiss(id)` whose target was
|
||||
// already replaced.
|
||||
|
||||
import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
|
||||
import { toast } from "../src/lib/toast.svelte";
|
||||
|
||||
beforeEach(() => {
|
||||
toast.resetForTests();
|
||||
vi.useFakeTimers();
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
vi.useRealTimers();
|
||||
toast.resetForTests();
|
||||
});
|
||||
|
||||
describe("toast.show", () => {
|
||||
test("sets current and assigns a fresh id", () => {
|
||||
const id = toast.show({
|
||||
messageKey: "common.loading",
|
||||
});
|
||||
expect(id).toBeTruthy();
|
||||
expect(toast.current).not.toBeNull();
|
||||
expect(toast.current?.id).toBe(id);
|
||||
expect(toast.current?.messageKey).toBe("common.loading");
|
||||
});
|
||||
|
||||
test("a second show replaces the previous descriptor", () => {
|
||||
const first = toast.show({ messageKey: "common.loading" });
|
||||
const second = toast.show({
|
||||
messageKey: "common.dismiss",
|
||||
});
|
||||
expect(second).not.toBe(first);
|
||||
expect(toast.current?.id).toBe(second);
|
||||
expect(toast.current?.messageKey).toBe("common.dismiss");
|
||||
});
|
||||
|
||||
test("auto-dismisses after durationMs", () => {
|
||||
toast.show({
|
||||
messageKey: "common.loading",
|
||||
durationMs: 2_000,
|
||||
});
|
||||
expect(toast.current).not.toBeNull();
|
||||
vi.advanceTimersByTime(1_999);
|
||||
expect(toast.current).not.toBeNull();
|
||||
vi.advanceTimersByTime(1);
|
||||
expect(toast.current).toBeNull();
|
||||
});
|
||||
|
||||
test("durationMs=null makes the toast sticky", () => {
|
||||
toast.show({
|
||||
messageKey: "common.loading",
|
||||
durationMs: null,
|
||||
});
|
||||
vi.advanceTimersByTime(60_000);
|
||||
expect(toast.current).not.toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe("toast.dismiss", () => {
|
||||
test("clears current when called without an id", () => {
|
||||
toast.show({ messageKey: "common.loading" });
|
||||
toast.dismiss();
|
||||
expect(toast.current).toBeNull();
|
||||
});
|
||||
|
||||
test("ignores a stale id whose target was replaced", () => {
|
||||
const first = toast.show({
|
||||
messageKey: "common.loading",
|
||||
durationMs: 5_000,
|
||||
});
|
||||
const second = toast.show({ messageKey: "common.dismiss" });
|
||||
toast.dismiss(first);
|
||||
expect(toast.current?.id).toBe(second);
|
||||
expect(toast.current?.messageKey).toBe("common.dismiss");
|
||||
});
|
||||
|
||||
test("auto-dismiss timer of the replaced toast does not clobber the live one", () => {
|
||||
toast.show({ messageKey: "common.loading", durationMs: 500 });
|
||||
const second = toast.show({
|
||||
messageKey: "common.dismiss",
|
||||
durationMs: null,
|
||||
});
|
||||
vi.advanceTimersByTime(500);
|
||||
// The first toast's timer fired but the dismiss is a no-op
|
||||
// because `current.id !== first`. The sticky second toast
|
||||
// stays alive.
|
||||
expect(toast.current?.id).toBe(second);
|
||||
});
|
||||
});
|
||||
|
||||
describe("onAction", () => {
|
||||
test("ignored unless the action button is invoked manually", () => {
|
||||
const onAction = vi.fn();
|
||||
toast.show({
|
||||
messageKey: "common.loading",
|
||||
actionLabelKey: "common.dismiss",
|
||||
onAction,
|
||||
});
|
||||
vi.advanceTimersByTime(1_000);
|
||||
expect(onAction).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
test("toast-host wiring is exercised by the layout: callback fires when host calls onAction then dismiss", () => {
|
||||
// The host component runs `onAction()` and then `dismiss(id)`.
|
||||
// We simulate that sequence here to pin the contract the host
|
||||
// relies on: a single invocation of the user callback per
|
||||
// descriptor, and the toast clears afterwards.
|
||||
const onAction = vi.fn();
|
||||
const id = toast.show({
|
||||
messageKey: "common.loading",
|
||||
actionLabelKey: "common.dismiss",
|
||||
onAction,
|
||||
});
|
||||
const current = toast.current;
|
||||
current?.onAction?.();
|
||||
toast.dismiss(current?.id);
|
||||
expect(onAction).toHaveBeenCalledTimes(1);
|
||||
expect(toast.current).toBeNull();
|
||||
// id stays unique — a follow-up show must return a different one.
|
||||
expect(toast.show({ messageKey: "common.loading" })).not.toBe(id);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user