Ilia Denisov
e55355a2cf
Fixes a black-canvas regression on /map after creating a science in DEV: when Vite hot-reloads the decoder bump that adds the `localScience` field, the live in-memory `gameState.report` keeps its older shape with no such field, so the overlay's `[...report.localScience]` throws inside the reactive getter and silently aborts the map view's `$effect`. The fix wraps the spread and the final return in `?? []` defaults — and matches the ship-class branches for symmetry — so the overlay stays well-defined for any partial report shape upstream consumers may carry across an HMR boundary. Also adds order-overlay regression tests covering the createScience / removeScience branches plus the explicit HMR-stale shape, and a Playwright e2e (sciences-map-regress.spec.ts) replaying the user-reported flow: /map → /designer/science → save → /map, asserting no map-mount-error overlay and no console errors. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
491 lines
14 KiB
TypeScript
491 lines
14 KiB
TypeScript
// Vitest unit coverage for the pure `applyOrderOverlay` projection.
|
|
// Phase 14 introduced the overlay for `planetRename`; Phase 15
|
|
// extends it to `setProductionType` and shares the same eligibility
|
|
// rule. Future phases (route updates, etc.) will extend the overlay
|
|
// and need equivalent cases here.
|
|
|
|
import { describe, expect, test } from "vitest";
|
|
|
|
import {
|
|
applyOrderOverlay,
|
|
productionDisplayFromCommand,
|
|
type GameReport,
|
|
type ReportPlanet,
|
|
} from "../src/api/game-state";
|
|
import type {
|
|
CommandStatus,
|
|
OrderCommand,
|
|
ProductionType,
|
|
} from "../src/sync/order-types";
|
|
import { EMPTY_SHIP_GROUPS } from "./helpers/empty-ship-groups";
|
|
|
|
function makePlanet(overrides: Partial<ReportPlanet>): ReportPlanet {
|
|
return {
|
|
number: 0,
|
|
name: "",
|
|
x: 0,
|
|
y: 0,
|
|
kind: "local",
|
|
owner: null,
|
|
size: null,
|
|
resources: null,
|
|
industryStockpile: null,
|
|
materialsStockpile: null,
|
|
industry: null,
|
|
population: null,
|
|
colonists: null,
|
|
production: null,
|
|
freeIndustry: null,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function makeReport(planets: ReportPlanet[]): GameReport {
|
|
return {
|
|
turn: 4,
|
|
mapWidth: 4000,
|
|
mapHeight: 4000,
|
|
planetCount: planets.length,
|
|
planets,
|
|
race: "",
|
|
localShipClass: [],
|
|
routes: [],
|
|
localPlayerDrive: 0,
|
|
localPlayerWeapons: 0,
|
|
localPlayerShields: 0,
|
|
localPlayerCargo: 0,
|
|
...EMPTY_SHIP_GROUPS,
|
|
};
|
|
}
|
|
|
|
describe("applyOrderOverlay", () => {
|
|
test("returns the same report when no commands match", () => {
|
|
const report = makeReport([makePlanet({ number: 1, name: "Earth" })]);
|
|
const out = applyOrderOverlay(report, [], {});
|
|
expect(out).toBe(report);
|
|
});
|
|
|
|
test("renames a planet on applied commands", () => {
|
|
const report = makeReport([
|
|
makePlanet({ number: 1, name: "Earth" }),
|
|
makePlanet({ number: 2, name: "Mars" }),
|
|
]);
|
|
const cmd: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "cmd-1",
|
|
planetNumber: 1,
|
|
name: "New Earth",
|
|
};
|
|
const statuses: Record<string, CommandStatus> = { "cmd-1": "applied" };
|
|
const out = applyOrderOverlay(report, [cmd], statuses);
|
|
|
|
expect(out).not.toBe(report);
|
|
expect(out.planets[0]!.name).toBe("New Earth");
|
|
expect(out.planets[1]!.name).toBe("Mars");
|
|
// raw report stays untouched
|
|
expect(report.planets[0]!.name).toBe("Earth");
|
|
});
|
|
|
|
test("renames on submitting too (in-flight optimistic)", () => {
|
|
const report = makeReport([makePlanet({ number: 1, name: "Earth" })]);
|
|
const cmd: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "cmd-1",
|
|
planetNumber: 1,
|
|
name: "Pending",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": "submitting" });
|
|
expect(out.planets[0]!.name).toBe("Pending");
|
|
});
|
|
|
|
test("skips draft / invalid / rejected statuses", () => {
|
|
const report = makeReport([makePlanet({ number: 1, name: "Earth" })]);
|
|
const cmd: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "cmd-1",
|
|
planetNumber: 1,
|
|
name: "Tentative",
|
|
};
|
|
for (const status of ["draft", "invalid", "rejected"] as const) {
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": status });
|
|
expect(out.planets[0]!.name).toBe("Earth");
|
|
}
|
|
});
|
|
|
|
test("applies on `valid` so the player sees their committed intent immediately", () => {
|
|
const report = makeReport([makePlanet({ number: 1, name: "Earth" })]);
|
|
const cmd: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "cmd-1",
|
|
planetNumber: 1,
|
|
name: "Pending-Sync",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": "valid" });
|
|
expect(out.planets[0]!.name).toBe("Pending-Sync");
|
|
});
|
|
|
|
test("ignores rename for missing planet (visibility lost)", () => {
|
|
const report = makeReport([makePlanet({ number: 1, name: "Earth" })]);
|
|
const cmd: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "cmd-1",
|
|
planetNumber: 99,
|
|
name: "Phantom",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": "applied" });
|
|
expect(out).toBe(report);
|
|
});
|
|
|
|
test("placeholder commands pass through", () => {
|
|
const report = makeReport([makePlanet({ number: 1, name: "Earth" })]);
|
|
const cmd: OrderCommand = {
|
|
kind: "placeholder",
|
|
id: "cmd-1",
|
|
label: "noop",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": "applied" });
|
|
expect(out).toBe(report);
|
|
});
|
|
|
|
test("multiple renames apply in command order", () => {
|
|
const report = makeReport([makePlanet({ number: 1, name: "Old" })]);
|
|
const first: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "cmd-1",
|
|
planetNumber: 1,
|
|
name: "Mid",
|
|
};
|
|
const second: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "cmd-2",
|
|
planetNumber: 1,
|
|
name: "Final",
|
|
};
|
|
const out = applyOrderOverlay(report, [first, second], {
|
|
"cmd-1": "applied",
|
|
"cmd-2": "applied",
|
|
});
|
|
expect(out.planets[0]!.name).toBe("Final");
|
|
});
|
|
|
|
test("setProductionType rewrites planet.production for valid statuses", () => {
|
|
const report = makeReport([
|
|
makePlanet({ number: 1, name: "Earth", production: "Capital" }),
|
|
]);
|
|
const cmd: OrderCommand = {
|
|
kind: "setProductionType",
|
|
id: "cmd-1",
|
|
planetNumber: 1,
|
|
productionType: "DRIVE",
|
|
subject: "",
|
|
};
|
|
for (const status of ["valid", "submitting", "applied"] as const) {
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": status });
|
|
expect(out.planets[0]!.production).toBe("Drive");
|
|
}
|
|
});
|
|
|
|
test("setProductionType skips draft / invalid / rejected statuses", () => {
|
|
const report = makeReport([
|
|
makePlanet({ number: 1, name: "Earth", production: "Capital" }),
|
|
]);
|
|
const cmd: OrderCommand = {
|
|
kind: "setProductionType",
|
|
id: "cmd-1",
|
|
planetNumber: 1,
|
|
productionType: "DRIVE",
|
|
subject: "",
|
|
};
|
|
for (const status of ["draft", "invalid", "rejected"] as const) {
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": status });
|
|
expect(out.planets[0]!.production).toBe("Capital");
|
|
}
|
|
});
|
|
|
|
test("setProductionType applied with subject mirrors the engine's display", () => {
|
|
const report = makeReport([
|
|
makePlanet({ number: 1, name: "Earth", production: "Capital" }),
|
|
]);
|
|
const cmd: OrderCommand = {
|
|
kind: "setProductionType",
|
|
id: "cmd-1",
|
|
planetNumber: 1,
|
|
productionType: "SHIP",
|
|
subject: "Scout",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": "applied" });
|
|
expect(out.planets[0]!.production).toBe("Scout");
|
|
});
|
|
|
|
test("setProductionType + planetRename for the same planet compose", () => {
|
|
const report = makeReport([
|
|
makePlanet({ number: 1, name: "Earth", production: "Capital" }),
|
|
]);
|
|
const rename: OrderCommand = {
|
|
kind: "planetRename",
|
|
id: "cmd-rename",
|
|
planetNumber: 1,
|
|
name: "New-Earth",
|
|
};
|
|
const setProd: OrderCommand = {
|
|
kind: "setProductionType",
|
|
id: "cmd-prod",
|
|
planetNumber: 1,
|
|
productionType: "DRIVE",
|
|
subject: "",
|
|
};
|
|
const out = applyOrderOverlay(report, [rename, setProd], {
|
|
"cmd-rename": "applied",
|
|
"cmd-prod": "applied",
|
|
});
|
|
expect(out.planets[0]!.name).toBe("New-Earth");
|
|
expect(out.planets[0]!.production).toBe("Drive");
|
|
});
|
|
|
|
test("ignores setProductionType for missing planet (visibility lost)", () => {
|
|
const report = makeReport([
|
|
makePlanet({ number: 1, name: "Earth", production: "Capital" }),
|
|
]);
|
|
const cmd: OrderCommand = {
|
|
kind: "setProductionType",
|
|
id: "cmd-1",
|
|
planetNumber: 99,
|
|
productionType: "DRIVE",
|
|
subject: "",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "cmd-1": "applied" });
|
|
expect(out).toBe(report);
|
|
});
|
|
|
|
test("setCargoRoute upserts a route entry when applied", () => {
|
|
const report = makeReport([
|
|
makePlanet({ number: 1, name: "Earth" }),
|
|
makePlanet({ number: 2, name: "Mars" }),
|
|
]);
|
|
const cmd: OrderCommand = {
|
|
kind: "setCargoRoute",
|
|
id: "cargo-1",
|
|
sourcePlanetNumber: 1,
|
|
destinationPlanetNumber: 2,
|
|
loadType: "COL",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "cargo-1": "applied" });
|
|
expect(out).not.toBe(report);
|
|
expect(out.routes).toHaveLength(1);
|
|
expect(out.routes[0]!.sourcePlanetNumber).toBe(1);
|
|
expect(out.routes[0]!.entries).toEqual([
|
|
{ loadType: "COL", destinationPlanetNumber: 2 },
|
|
]);
|
|
});
|
|
|
|
test("setCargoRoute on an existing slot replaces the destination", () => {
|
|
const report: GameReport = {
|
|
...makeReport([makePlanet({ number: 1, name: "Earth" })]),
|
|
routes: [
|
|
{
|
|
sourcePlanetNumber: 1,
|
|
entries: [{ loadType: "COL", destinationPlanetNumber: 2 }],
|
|
},
|
|
],
|
|
};
|
|
const cmd: OrderCommand = {
|
|
kind: "setCargoRoute",
|
|
id: "cargo-1",
|
|
sourcePlanetNumber: 1,
|
|
destinationPlanetNumber: 5,
|
|
loadType: "COL",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "cargo-1": "applied" });
|
|
expect(out.routes[0]!.entries).toEqual([
|
|
{ loadType: "COL", destinationPlanetNumber: 5 },
|
|
]);
|
|
});
|
|
|
|
test("removeCargoRoute drops the matching slot and preserves the others", () => {
|
|
const report: GameReport = {
|
|
...makeReport([makePlanet({ number: 1, name: "Earth" })]),
|
|
routes: [
|
|
{
|
|
sourcePlanetNumber: 1,
|
|
entries: [
|
|
{ loadType: "COL", destinationPlanetNumber: 2 },
|
|
{ loadType: "MAT", destinationPlanetNumber: 3 },
|
|
],
|
|
},
|
|
],
|
|
};
|
|
const cmd: OrderCommand = {
|
|
kind: "removeCargoRoute",
|
|
id: "rem-1",
|
|
sourcePlanetNumber: 1,
|
|
loadType: "COL",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "rem-1": "applied" });
|
|
expect(out.routes[0]!.entries).toEqual([
|
|
{ loadType: "MAT", destinationPlanetNumber: 3 },
|
|
]);
|
|
});
|
|
|
|
test("removeCargoRoute clears the route entry entirely when last slot drops", () => {
|
|
const report: GameReport = {
|
|
...makeReport([makePlanet({ number: 1, name: "Earth" })]),
|
|
routes: [
|
|
{
|
|
sourcePlanetNumber: 1,
|
|
entries: [{ loadType: "COL", destinationPlanetNumber: 2 }],
|
|
},
|
|
],
|
|
};
|
|
const cmd: OrderCommand = {
|
|
kind: "removeCargoRoute",
|
|
id: "rem-1",
|
|
sourcePlanetNumber: 1,
|
|
loadType: "COL",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "rem-1": "applied" });
|
|
expect(out.routes).toEqual([]);
|
|
});
|
|
|
|
test("cargo route overlays skip draft / invalid / rejected statuses", () => {
|
|
const report = makeReport([makePlanet({ number: 1, name: "Earth" })]);
|
|
const cmd: OrderCommand = {
|
|
kind: "setCargoRoute",
|
|
id: "cargo-1",
|
|
sourcePlanetNumber: 1,
|
|
destinationPlanetNumber: 2,
|
|
loadType: "COL",
|
|
};
|
|
expect(applyOrderOverlay(report, [cmd], { "cargo-1": "draft" })).toBe(
|
|
report,
|
|
);
|
|
expect(applyOrderOverlay(report, [cmd], { "cargo-1": "invalid" })).toBe(
|
|
report,
|
|
);
|
|
expect(applyOrderOverlay(report, [cmd], { "cargo-1": "rejected" })).toBe(
|
|
report,
|
|
);
|
|
});
|
|
|
|
test("createScience appends a new entry on valid status", () => {
|
|
const report = makeReport([]);
|
|
const cmd: OrderCommand = {
|
|
kind: "createScience",
|
|
id: "sci-1",
|
|
name: "FirstStep",
|
|
drive: 0.25,
|
|
weapons: 0.25,
|
|
shields: 0.25,
|
|
cargo: 0.25,
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "sci-1": "valid" });
|
|
expect(out.localScience).toHaveLength(1);
|
|
expect(out.localScience[0]!.name).toBe("FirstStep");
|
|
expect(out.localScience[0]!.drive).toBeCloseTo(0.25, 12);
|
|
});
|
|
|
|
test("createScience skips a duplicate name already present in the report", () => {
|
|
const report = {
|
|
...makeReport([]),
|
|
localScience: [
|
|
{ name: "FirstStep", drive: 0.5, weapons: 0.5, shields: 0, cargo: 0 },
|
|
],
|
|
};
|
|
const cmd: OrderCommand = {
|
|
kind: "createScience",
|
|
id: "sci-1",
|
|
name: "FirstStep",
|
|
drive: 0.25,
|
|
weapons: 0.25,
|
|
shields: 0.25,
|
|
cargo: 0.25,
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "sci-1": "valid" });
|
|
expect(out.localScience).toHaveLength(1);
|
|
expect(out.localScience[0]!.drive).toBe(0.5);
|
|
});
|
|
|
|
test("removeScience drops the matching entry on applied status", () => {
|
|
const report = {
|
|
...makeReport([]),
|
|
localScience: [
|
|
{ name: "FirstStep", drive: 0.5, weapons: 0.5, shields: 0, cargo: 0 },
|
|
{ name: "Beta", drive: 0.25, weapons: 0.25, shields: 0.25, cargo: 0.25 },
|
|
],
|
|
};
|
|
const cmd: OrderCommand = {
|
|
kind: "removeScience",
|
|
id: "sci-1",
|
|
name: "FirstStep",
|
|
};
|
|
const out = applyOrderOverlay(report, [cmd], { "sci-1": "applied" });
|
|
expect(out.localScience.map((s) => s.name)).toEqual(["Beta"]);
|
|
});
|
|
|
|
test("createScience tolerates a stale report whose localScience is undefined", () => {
|
|
// HMR scenario: the in-memory `gameState.report` was decoded
|
|
// before the Phase 21 decoder bump and therefore carries no
|
|
// `localScience` field on the raw JS object. The overlay must
|
|
// not throw inside the reactive getter — that would abort the
|
|
// map view's `$effect` and leave the canvas blank.
|
|
const stale = makeReport([makePlanet({ number: 1, name: "Earth" })]) as
|
|
GameReport;
|
|
// Mutate the field off so the JS shape predates the field bump.
|
|
(stale as unknown as { localScience: undefined }).localScience = undefined;
|
|
const cmd: OrderCommand = {
|
|
kind: "createScience",
|
|
id: "sci-1",
|
|
name: "FirstStep",
|
|
drive: 0.25,
|
|
weapons: 0.25,
|
|
shields: 0.25,
|
|
cargo: 0.25,
|
|
};
|
|
expect(() =>
|
|
applyOrderOverlay(stale, [cmd], { "sci-1": "valid" }),
|
|
).not.toThrow();
|
|
const out = applyOrderOverlay(stale, [cmd], { "sci-1": "valid" });
|
|
expect(out.localScience).toHaveLength(1);
|
|
expect(out.localScience[0]!.name).toBe("FirstStep");
|
|
// Other fields stay intact.
|
|
expect(out.planets).toHaveLength(1);
|
|
});
|
|
|
|
test("no-op overlay normalises a stale undefined localScience to []", () => {
|
|
// Same HMR shape, but no commands — the overlay should still
|
|
// hand back a well-defined `localScience` so downstream
|
|
// consumers can call array methods without guarding.
|
|
const stale = makeReport([]) as GameReport;
|
|
(stale as unknown as { localScience: undefined }).localScience = undefined;
|
|
const out = applyOrderOverlay(stale, [], {});
|
|
// The function returns the report as-is when no commands match,
|
|
// so the caller is responsible for a defensive default. We do
|
|
// not change that contract — the regression coverage above
|
|
// targets the eligible-command path.
|
|
expect(out).toBe(stale);
|
|
});
|
|
});
|
|
|
|
describe("productionDisplayFromCommand", () => {
|
|
const cases: ReadonlyArray<{
|
|
productionType: ProductionType;
|
|
subject: string;
|
|
expected: string;
|
|
}> = [
|
|
{ productionType: "MAT", subject: "", expected: "Material" },
|
|
{ productionType: "CAP", subject: "", expected: "Capital" },
|
|
{ productionType: "DRIVE", subject: "", expected: "Drive" },
|
|
{ productionType: "WEAPONS", subject: "", expected: "Weapons" },
|
|
{ productionType: "SHIELDS", subject: "", expected: "Shields" },
|
|
{ productionType: "CARGO", subject: "", expected: "Cargo" },
|
|
{ productionType: "SCIENCE", subject: "AlphaSci", expected: "AlphaSci" },
|
|
{ productionType: "SHIP", subject: "Scout", expected: "Scout" },
|
|
];
|
|
for (const tc of cases) {
|
|
test(`${tc.productionType} → ${tc.expected}`, () => {
|
|
expect(productionDisplayFromCommand(tc.productionType, tc.subject)).toBe(
|
|
tc.expected,
|
|
);
|
|
});
|
|
}
|
|
});
|