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); });