Ilia Denisov
915b4372dd
Adds the second end-to-end command (`setProductionType`) with a collapse-by-`planetNumber` rule on the order draft, the segmented production-controls component on the planet inspector, the FBS encoder/decoder pair for `CommandPlanetProduce`, and the `localShipClass` projection on `GameReport`. Forecast number is deferred and tracked in the new `ui/docs/calc-bridge.md`.
273 lines
9.1 KiB
TypeScript
273 lines
9.1 KiB
TypeScript
// Vitest unit coverage for `sync/submit.ts`. Drives the submit
|
|
// pipeline against a stub `GalaxyClient` whose `executeCommand`
|
|
// hand-builds FBS responses, so the parser is exercised against
|
|
// payloads identical to what the real gateway returns.
|
|
|
|
import { Builder } from "flatbuffers";
|
|
import { describe, expect, test, vi } from "vitest";
|
|
|
|
import type { GalaxyClient } from "../src/api/galaxy-client";
|
|
import { uuidToHiLo } from "../src/api/game-state";
|
|
import { UUID } from "../src/proto/galaxy/fbs/common";
|
|
import {
|
|
CommandItem,
|
|
CommandPlanetProduce,
|
|
CommandPlanetRename,
|
|
CommandPayload,
|
|
PlanetProduction,
|
|
UserGamesOrder,
|
|
UserGamesOrderResponse,
|
|
} from "../src/proto/galaxy/fbs/order";
|
|
import { submitOrder } from "../src/sync/submit";
|
|
import type {
|
|
OrderCommand,
|
|
ProductionType,
|
|
} from "../src/sync/order-types";
|
|
|
|
const GAME_ID = "11111111-2222-3333-4444-555555555555";
|
|
|
|
function mockClient(
|
|
executeCommand: (
|
|
messageType: string,
|
|
payload: Uint8Array,
|
|
) => Promise<{ resultCode: string; payloadBytes: Uint8Array }>,
|
|
): GalaxyClient {
|
|
return { executeCommand } as unknown as GalaxyClient;
|
|
}
|
|
|
|
function buildResponse(
|
|
commands: { id: string; applied: boolean | null; errorCode: number | null }[],
|
|
updatedAt: number,
|
|
): Uint8Array {
|
|
const builder = new Builder(256);
|
|
const itemOffsets = commands.map((c) => {
|
|
const cmdIdOffset = builder.createString(c.id);
|
|
const nameOffset = builder.createString("ignored");
|
|
const payloadOffset = CommandPlanetRename.createCommandPlanetRename(
|
|
builder,
|
|
BigInt(0),
|
|
nameOffset,
|
|
);
|
|
CommandItem.startCommandItem(builder);
|
|
CommandItem.addCmdId(builder, cmdIdOffset);
|
|
if (c.applied !== null) CommandItem.addCmdApplied(builder, c.applied);
|
|
if (c.errorCode !== null) {
|
|
CommandItem.addCmdErrorCode(builder, BigInt(c.errorCode));
|
|
}
|
|
CommandItem.addPayloadType(builder, CommandPayload.CommandPlanetRename);
|
|
CommandItem.addPayload(builder, payloadOffset);
|
|
return CommandItem.endCommandItem(builder);
|
|
});
|
|
const commandsVec = UserGamesOrderResponse.createCommandsVector(builder, itemOffsets);
|
|
const [hi, lo] = uuidToHiLo(GAME_ID);
|
|
const gameIdOffset = UUID.createUUID(builder, hi, lo);
|
|
UserGamesOrderResponse.startUserGamesOrderResponse(builder);
|
|
UserGamesOrderResponse.addGameId(builder, gameIdOffset);
|
|
UserGamesOrderResponse.addUpdatedAt(builder, BigInt(updatedAt));
|
|
UserGamesOrderResponse.addCommands(builder, commandsVec);
|
|
const offset = UserGamesOrderResponse.endUserGamesOrderResponse(builder);
|
|
builder.finish(offset);
|
|
return builder.asUint8Array();
|
|
}
|
|
|
|
const sampleRename: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "00000000-0000-0000-0000-00000000aaaa",
|
|
planetNumber: 7,
|
|
name: "Earth",
|
|
};
|
|
|
|
describe("submitOrder", () => {
|
|
test("decodes per-command results from a populated response", async () => {
|
|
const responsePayload = buildResponse(
|
|
[{ id: sampleRename.id, applied: true, errorCode: null }],
|
|
99,
|
|
);
|
|
const exec = vi.fn(async () => ({
|
|
resultCode: "ok",
|
|
payloadBytes: responsePayload,
|
|
}));
|
|
const result = await submitOrder(mockClient(exec), GAME_ID, [sampleRename]);
|
|
|
|
expect(exec).toHaveBeenCalledOnce();
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
expect(result.results.get(sampleRename.id)).toBe("applied");
|
|
expect(result.errorCodes.get(sampleRename.id)).toBeNull();
|
|
expect(result.updatedAt).toBe(99);
|
|
});
|
|
|
|
test("falls back to batch-level applied when commands array is empty", async () => {
|
|
// Hand-craft an envelope without `commands` to mimic the legacy
|
|
// gateway behaviour (or a 204 wrapped via the fallback path).
|
|
const builder = new Builder(64);
|
|
UserGamesOrderResponse.startUserGamesOrderResponse(builder);
|
|
const offset = UserGamesOrderResponse.endUserGamesOrderResponse(builder);
|
|
builder.finish(offset);
|
|
const exec = vi.fn(async () => ({
|
|
resultCode: "ok",
|
|
payloadBytes: builder.asUint8Array(),
|
|
}));
|
|
|
|
const result = await submitOrder(mockClient(exec), GAME_ID, [sampleRename]);
|
|
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
expect(result.results.get(sampleRename.id)).toBe("applied");
|
|
expect(result.errorCodes.get(sampleRename.id)).toBeNull();
|
|
});
|
|
|
|
test("surfaces mixed applied / rejected entries by cmd id", async () => {
|
|
const second: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "00000000-0000-0000-0000-00000000bbbb",
|
|
planetNumber: 8,
|
|
name: "Mars",
|
|
};
|
|
const responsePayload = buildResponse(
|
|
[
|
|
{ id: sampleRename.id, applied: true, errorCode: null },
|
|
{ id: second.id, applied: false, errorCode: 42 },
|
|
],
|
|
120,
|
|
);
|
|
const exec = vi.fn(async () => ({
|
|
resultCode: "ok",
|
|
payloadBytes: responsePayload,
|
|
}));
|
|
|
|
const result = await submitOrder(mockClient(exec), GAME_ID, [sampleRename, second]);
|
|
expect(result.ok).toBe(true);
|
|
if (!result.ok) return;
|
|
expect(result.results.get(sampleRename.id)).toBe("applied");
|
|
expect(result.errorCodes.get(sampleRename.id)).toBeNull();
|
|
expect(result.results.get(second.id)).toBe("rejected");
|
|
expect(result.errorCodes.get(second.id)).toBe(42);
|
|
});
|
|
|
|
test("returns SubmitFailure on non-ok resultCode without throwing", async () => {
|
|
const exec = vi.fn(async () => ({
|
|
resultCode: "invalid_request",
|
|
payloadBytes: new TextEncoder().encode(
|
|
JSON.stringify({ code: "validation_failed", message: "bad name" }),
|
|
),
|
|
}));
|
|
|
|
const result = await submitOrder(mockClient(exec), GAME_ID, [sampleRename]);
|
|
|
|
expect(result.ok).toBe(false);
|
|
if (result.ok) return;
|
|
expect(result.resultCode).toBe("invalid_request");
|
|
expect(result.code).toBe("validation_failed");
|
|
expect(result.message).toBe("bad name");
|
|
});
|
|
|
|
test("posts a well-formed UserGamesOrder payload", async () => {
|
|
let captured: Uint8Array | null = null;
|
|
const exec = vi.fn(async (_messageType, payload: Uint8Array) => {
|
|
captured = payload;
|
|
return { resultCode: "ok", payloadBytes: new Uint8Array() };
|
|
});
|
|
await submitOrder(mockClient(exec), GAME_ID, [sampleRename]);
|
|
expect(captured).not.toBeNull();
|
|
const decoded = UserGamesOrder.getRootAsUserGamesOrder(
|
|
new (await import("flatbuffers")).ByteBuffer(captured!),
|
|
);
|
|
expect(decoded.commandsLength()).toBe(1);
|
|
const item = decoded.commands(0);
|
|
expect(item).not.toBeNull();
|
|
expect(item!.cmdId()).toBe(sampleRename.id);
|
|
expect(item!.payloadType()).toBe(CommandPayload.CommandPlanetRename);
|
|
const inner = new CommandPlanetRename();
|
|
item!.payload(inner);
|
|
expect(Number(inner.number())).toBe(7);
|
|
expect(inner.name()).toBe("Earth");
|
|
});
|
|
|
|
test("encodes setProductionType as CommandPlanetProduce on the wire", async () => {
|
|
let captured: Uint8Array | null = null;
|
|
const exec = vi.fn(async (_messageType, payload: Uint8Array) => {
|
|
captured = payload;
|
|
return { resultCode: "ok", payloadBytes: new Uint8Array() };
|
|
});
|
|
const cmd: OrderCommand = {
|
|
kind: "setProductionType",
|
|
id: "00000000-0000-0000-0000-00000000cccc",
|
|
planetNumber: 17,
|
|
productionType: "SHIP",
|
|
subject: "Scout",
|
|
};
|
|
await submitOrder(mockClient(exec), GAME_ID, [cmd]);
|
|
expect(captured).not.toBeNull();
|
|
const decoded = UserGamesOrder.getRootAsUserGamesOrder(
|
|
new (await import("flatbuffers")).ByteBuffer(captured!),
|
|
);
|
|
expect(decoded.commandsLength()).toBe(1);
|
|
const item = decoded.commands(0);
|
|
expect(item).not.toBeNull();
|
|
expect(item!.cmdId()).toBe(cmd.id);
|
|
expect(item!.payloadType()).toBe(CommandPayload.CommandPlanetProduce);
|
|
const inner = new CommandPlanetProduce();
|
|
item!.payload(inner);
|
|
expect(Number(inner.number())).toBe(17);
|
|
expect(inner.production()).toBe(PlanetProduction.SHIP);
|
|
expect(inner.subject()).toBe("Scout");
|
|
});
|
|
|
|
test("maps every productionType literal to its FBS enum value", async () => {
|
|
const cases: Array<{
|
|
productionType: ProductionType;
|
|
fbs: PlanetProduction;
|
|
subject: string;
|
|
}> = [
|
|
{ productionType: "MAT", fbs: PlanetProduction.MAT, subject: "" },
|
|
{ productionType: "CAP", fbs: PlanetProduction.CAP, subject: "" },
|
|
{ productionType: "DRIVE", fbs: PlanetProduction.DRIVE, subject: "" },
|
|
{
|
|
productionType: "WEAPONS",
|
|
fbs: PlanetProduction.WEAPONS,
|
|
subject: "",
|
|
},
|
|
{
|
|
productionType: "SHIELDS",
|
|
fbs: PlanetProduction.SHIELDS,
|
|
subject: "",
|
|
},
|
|
{ productionType: "CARGO", fbs: PlanetProduction.CARGO, subject: "" },
|
|
{
|
|
productionType: "SCIENCE",
|
|
fbs: PlanetProduction.SCIENCE,
|
|
subject: "AlphaSci",
|
|
},
|
|
{
|
|
productionType: "SHIP",
|
|
fbs: PlanetProduction.SHIP,
|
|
subject: "Scout",
|
|
},
|
|
];
|
|
for (const tc of cases) {
|
|
let captured: Uint8Array | null = null;
|
|
const exec = vi.fn(async (_messageType, payload: Uint8Array) => {
|
|
captured = payload;
|
|
return { resultCode: "ok", payloadBytes: new Uint8Array() };
|
|
});
|
|
const cmd: OrderCommand = {
|
|
kind: "setProductionType",
|
|
id: `id-${tc.productionType}`,
|
|
planetNumber: 5,
|
|
productionType: tc.productionType,
|
|
subject: tc.subject,
|
|
};
|
|
await submitOrder(mockClient(exec), GAME_ID, [cmd]);
|
|
expect(captured).not.toBeNull();
|
|
const decoded = UserGamesOrder.getRootAsUserGamesOrder(
|
|
new (await import("flatbuffers")).ByteBuffer(captured!),
|
|
);
|
|
const inner = new CommandPlanetProduce();
|
|
decoded.commands(0)!.payload(inner);
|
|
expect(inner.production()).toBe(tc.fbs);
|
|
expect(inner.subject()).toBe(tc.subject);
|
|
}
|
|
});
|
|
});
|