Allow Fremen Nexus Betrayal before native worm rides

This commit is contained in:
Quintine committed 2026-10-26 07:06:15 +11:00
1 parent 78bcf22bca
commit 725672364d
19 files changed
+1251 -20

No files matched your search

@@ -0,0 +1,115 @@
import assert from 'node:assert/strict';
import test from 'node:test';
import { Children, createElement, isValidElement, type ReactNode } from 'react';
import { renderToStaticMarkup } from 'react-dom/server';
import { NexusFremenRideBetrayal } from '../components/nexus-fremen-ride-betrayal';
import { createGame, joinGame, newPlayer, viewGame, type Action, type GameView } from '../game/engine';
type Source = NonNullable<GameView['nexusFremenRideBetrayal']>['source'];
// Controlled projection fixtures isolate the actual hook-free callbacks. The
// separate native source suite earns and restores the worm/Cunning/Maker ride;
// these controls tests install no played Game custody or pending decision.
function projected(kind: Source['kind'] = 'wormRide'): GameView {
const game = createGame('NEXUSFREMENRIDECONTROLS', newPlayer('a', 'Atreides', 'atreides'), false);
joinGame(game, newPlayer('f', 'Fremen', 'fremen'));
joinGame(game, newPlayer('g', 'Guild', 'guild'));
const view = viewGame(game, 'a'); view.status = 'playing'; view.phase = 1;
const source: Source = kind === 'wormRide'
? { kind, player: 'f', territory: 'hagga_basin' }
: { kind, player: 'f', event: 'controlled-original-ride-event' };
view.nexusFremenRideBetrayal = {
event: 'controlled-before-ride-event', player: 'a', source, canUse: true, passed: [],
};
return view;
}
function markup(game: GameView, busy = false) {
return renderToStaticMarkup(createElement(NexusFremenRideBetrayal, { game, busy, act() {} }));
}
function click(node: ReactNode, choice: 'continue' | 'prevent'): boolean {
for (const child of Children.toArray(node)) {
if (!isValidElement<{
children?: ReactNode; onClick?: () => void; 'data-testid'?: string;
}>(child)) continue;
if (child.props['data-testid'] === `nexus-fremen-ride-${choice}` && child.props.onClick) {
child.props.onClick(); return true;
}
if (click(child.props.children, choice)) return true;
}
return false;
}
function choose(game: GameView, choice: 'continue' | 'prevent', busy = false): Action[] {
const actions: Action[] = [];
click(NexusFremenRideBetrayal({ game, busy, act(action) { actions.push(action); } }), choice);
return actions;
}
void test('the current responder sends exact before-ride Continue and prevention actions for all three sources', () => {
for (const kind of ['wormRide', 'nexusFremenCunningRide', 'greatMakerRide'] as const) {
const game = projected(kind), event = game.nexusFremenRideBetrayal!.event;
assert.deepEqual(choose(game, 'continue'), [{ type: 'decision', event, use: false }]);
assert.deepEqual(choose(game, 'prevent'), [{ type: 'decision', event, use: true }]);
assert.equal(Object.keys(choose(game, 'prevent')[0]).sort().join(','), 'event,type,use');
assert.doesNotMatch(markup(game), /controlled-original-ride-event/);
}
});
void test('the neutral panel names each public ride source without a secret card face', () => {
assert.match(markup(projected()), /Fremen has a worm ride from Hagga Basin waiting/);
assert.match(markup(projected('nexusFremenCunningRide')), /Fremen has a Fremen Nexus Cunning ride waiting/);
assert.match(markup(projected('greatMakerRide')), /Fremen has a Great Maker ride waiting/);
assert.match(markup(projected()), /aria-label="Fremen Nexus before-ride Betrayal"/);
});
void test('a projected no-Use responder still has the actual Continue callback', () => {
const game = projected(); game.nexusFremenRideBetrayal!.canUse = false;
const html = markup(game);
assert.match(html, /Continue · allow rides/); assert.doesNotMatch(html, /data-testid="nexus-fremen-ride-prevent"/);
assert.deepEqual(choose(game, 'continue'), [{ type: 'decision', event: 'controlled-before-ride-event', use: false }]);
assert.deepEqual(choose(game, 'prevent'), []);
assert.match(html, /without revealing anyone’s secret Nexus identity/);
});
void test('waiting and already-passed viewers retain the public guide without another response button', () => {
const waiting = projected(); waiting.me = 'g';
assert.match(markup(waiting), /Waiting for Atreides to respond before the ride/);
assert.doesNotMatch(markup(waiting), /<button\b/);
assert.deepEqual(choose(waiting, 'continue'), []); assert.deepEqual(choose(waiting, 'prevent'), []);
const passed = projected(); passed.nexusFremenRideBetrayal!.passed = ['a'];
assert.match(markup(passed), /You have continued. Waiting for the remaining ride responses/);
assert.match(markup(passed), /prevent the remaining rides this turn/);
assert.doesNotMatch(markup(passed), /<button\b/);
assert.deepEqual(choose(passed, 'continue'), []); assert.deepEqual(choose(passed, 'prevent'), []);
});
void test('busy and finished views guard both actual callbacks without removing the explanation', () => {
const game = projected();
assert.deepEqual(choose(game, 'continue', true), []); assert.deepEqual(choose(game, 'prevent', true), []);
assert.equal((markup(game, true).match(/<button\b[^>]*\sdisabled=""/g) ?? []).length, 2);
assert.match(markup(game, true), /The worm, Spice Blow and any Nexus that have already resolved stay resolved/);
game.status = 'finished';
assert.deepEqual(choose(game, 'continue'), []); assert.deepEqual(choose(game, 'prevent'), []);
});
void test('the persistent guide preserves completed effects and describes prevention without moving forces or replaying payment', () => {
const game = projected();
for (let render = 0; render < 3; render++) {
const html = markup(game);
assert.match(html, /Continue to allow the original ride choices/);
assert.match(html, /prevent the remaining rides this turn/);
assert.match(html, /The worm, Spice Blow and any Nexus that have already resolved stay resolved/);
assert.match(html, /Prevention does not move or destroy forces/);
assert.match(html, /Previous payments and effects are not repeated/);
assert.doesNotMatch(html, /countdown|automatically continue|seconds remaining|Confirm|Acknowledge/);
}
});
void test('a missing reaction renders nothing and private hands or wallets cannot determine Use', () => {
const absent = projected(); absent.nexusFremenRideBetrayal = null;
assert.equal(markup(absent), ''); assert.deepEqual(choose(absent, 'continue'), []);
const game = projected();
Object.defineProperty(game, 'nexusCards', { get() { throw Error('The response control inspected a private Nexus face'); } });
for (const player of game.players) for (const field of ['hand', 'spice', 'forces', 'elites', 'traitors'])
Object.defineProperty(player, field, { get() { throw Error(`The response control read ${field}`); } });
assert.match(markup(game), /Use Fremen Nexus · prevent remaining rides/);
assert.deepEqual(choose(game, 'prevent'), [{ type: 'decision', event: 'controlled-before-ride-event', use: true }]);
});