Files
Dune/tests/discovery-storm-sapho-quote.test.ts
T
Quintine 05f7fc8f20
Verify and publish checkpoint container / container (push) Successful in 11m20s
Allow recovered Sapho at Testing Station
2026-11-16 19:50:58 +11:00

128 lines
6.9 KiB
TypeScript

import assert from 'node:assert/strict';
import test from 'node:test';
import {
chooseDiscoveryStorm,
discoveryStormSaphoModes,
discoveryStormSignature,
finishDiscoveryStorm,
reorderDiscoveryStorm,
validateDiscoveryStorm,
} from '../game/discovery-storm';
import {createTestingStationContestFixture} from './fixture-testing-station-contest';
// Real revealed station, original storm source and both occupants. The helper
// tests ordering only; physical Sapho ownership and disposal belong to engine.
const source = () => createTestingStationContestFixture().game;
void test('legacy station signature stays unchanged and offers only meaningful two-seat moves', () => {
const game = source(), frame = game.ecologicalStorm!;
const [first, second] = frame.queue!.order;
assert.equal(frame.signature, JSON.stringify([frame.event, frame.turn, frame.owner,
frame.token, frame.from, frame.base, frame.delta, frame.stage,
frame.queue!.order, frame.queue!.choices]));
assert.deepEqual(discoveryStormSaphoModes(game, frame, first), ['last']);
assert.deepEqual(discoveryStormSaphoModes(game, frame, second), ['first']);
assert.deepEqual(discoveryStormSaphoModes(game, frame, 'nonoccupant'), []);
});
for (const mode of ['first', 'last'] as const) void test(
`Sapho ${mode} binds a fresh station event and preserves both cumulative choices`, () => {
const game = source(), original = structuredClone(game.ecologicalStorm!);
const holder = original.queue!.order[mode === 'first' ? 1 : 0];
const frame = reorderDiscoveryStorm(game, original,
{holder, event: original.event, mode, nextEvent: 'sapho-fresh-event'});
assert.deepEqual(original, game.ecologicalStorm);
assert.deepEqual(frame.queue!.order, [...original.queue!.order].reverse());
assert.equal(frame.owner, frame.queue!.order[0]);
assert.deepEqual(frame.sapho, {event: original.event, nextEvent: 'sapho-fresh-event',
originalOrder: original.queue!.order, holder, mode});
// The helper quotes the current order; the engine separately requires
// that a later player physically reacquire the spent Sapho card.
assert.deepEqual(discoveryStormSaphoModes(game, frame, holder), [mode === 'first' ? 'last' : 'first']);
assert.throws(() => chooseDiscoveryStorm(game, frame, frame.owner, original.event, 0));
let next = chooseDiscoveryStorm(game, frame, frame.owner, frame.event, 0);
assert.equal(next.event, 'sapho-fresh-event:1');
validateDiscoveryStorm(game, next);
next = chooseDiscoveryStorm(game, next, next.owner, next.event, 0);
assert.equal(next.stage, 'traversal');
validateDiscoveryStorm(game, next);
next = finishDiscoveryStorm(next);
validateDiscoveryStorm(game, next);
assert.deepEqual(next.sapho, frame.sapho);
assert.deepEqual(next.queue!.choices.map(choice => choice.owner), frame.queue!.order);
},
);
void test('stale, ineffective, replayed and tampered station reorder requests fail closed', () => {
const game = source(), frame = game.ecologicalStorm!;
const [first, second] = frame.queue!.order, before = structuredClone(frame);
for (const input of [
{holder: first, event: 'stale', mode: 'last' as const, nextEvent: 'fresh'},
{holder: first, event: frame.event, mode: 'first' as const, nextEvent: 'fresh'},
{holder: second, event: frame.event, mode: 'first' as const, nextEvent: frame.event},
{holder: 'other', event: frame.event, mode: 'last' as const, nextEvent: 'fresh'},
]) assert.throws(() => reorderDiscoveryStorm(game, frame, input));
assert.deepEqual(frame, before);
const reordered = reorderDiscoveryStorm(game, frame,
{holder: first, event: frame.event, mode: 'last', nextEvent: 'fresh'});
assert.throws(() => reorderDiscoveryStorm(game, reordered,
{holder: second, event: 'fresh', mode: 'first', nextEvent: 'again'}));
const changed = structuredClone(reordered);
changed.sapho!.originalOrder.reverse();
changed.signature = discoveryStormSignature(changed);
assert.throws(() => validateDiscoveryStorm(game, changed));
const afterFirst = chooseDiscoveryStorm(game, frame, first, frame.event, 0);
assert.deepEqual(discoveryStormSaphoModes(game, afterFirst, second), []);
});
void test('recovered Sapho reorders keep a linked event and order history without replaying choices', () => {
const game = source(), original = structuredClone(game.ecologicalStorm!);
const [first, second] = original.queue!.order;
const one = reorderDiscoveryStorm(game, original,
{holder:first, event:original.event, mode:'last', nextEvent:'first-reorder'});
const oneBefore = structuredClone(one);
const two = reorderDiscoveryStorm(game, one,
{holder:second, event:one.event, mode:'last', nextEvent:'second-reorder'});
assert.deepEqual(one, oneBefore);
assert.deepEqual(two.queue!.order, original.queue!.order);
assert.deepEqual(two.saphoHistory, [one.sapho]);
assert.deepEqual(two.sapho, {event:'first-reorder', nextEvent:'second-reorder',
originalOrder:one.queue!.order, holder:second, mode:'last'});
assert.equal(two.owner, first);
assert.equal(two.queue!.choices.length, 0);
validateDiscoveryStorm(game, two);
const three = reorderDiscoveryStorm(game, two,
{holder:first, event:two.event, mode:'last', nextEvent:'third-reorder'});
assert.deepEqual(three.saphoHistory, [one.sapho, two.sapho]);
assert.deepEqual(three.queue!.order, [...original.queue!.order].reverse());
validateDiscoveryStorm(game, three);
for (const input of [
{holder:second, event:one.event, mode:'last' as const, nextEvent:'unused'},
{holder:first, event:two.event, mode:'last' as const, nextEvent:original.event},
{holder:first, event:two.event, mode:'last' as const, nextEvent:one.event},
]) assert.throws(() => reorderDiscoveryStorm(game, two, input));
for (const mutate of [
(changed:typeof three) => { changed.saphoHistory![0].nextEvent = 'broken-chain'; },
(changed:typeof three) => { changed.saphoHistory![1].originalOrder.reverse(); },
(changed:typeof three) => { changed.sapho!.event = one.sapho!.event; },
(changed:typeof three) => { changed.sapho!.nextEvent = one.sapho!.event; },
]) {
const changed = structuredClone(three);
mutate(changed);
changed.signature = discoveryStormSignature(changed);
assert.throws(() => validateDiscoveryStorm(game, changed));
}
const afterFirst = chooseDiscoveryStorm(game, three, three.owner, three.event, 0);
assert.deepEqual(discoveryStormSaphoModes(game, afterFirst, afterFirst.owner), []);
assert.throws(() => reorderDiscoveryStorm(game, afterFirst,
{holder:afterFirst.owner, event:afterFirst.event, mode:'first', nextEvent:'too-late'}));
const afterSecond = chooseDiscoveryStorm(game, afterFirst, afterFirst.owner, afterFirst.event, 0);
assert.deepEqual(afterSecond.queue!.choices.map(choice => choice.owner), three.queue!.order);
assert.deepEqual(afterSecond.saphoHistory, three.saphoHistory);
validateDiscoveryStorm(game, afterSecond);
});