Files
Dune/tests/public-deals-multiple-immediate.test.ts
T
Quintine b03efd2371
Verify and publish checkpoint container / container (push) Successful in 10m59s
Settle multiple immediate deal payments
2026-11-16 14:44:06 +11:00

129 lines
7.5 KiB
TypeScript

import assert from 'node:assert/strict';
import test from 'node:test';
import { viewGame, type Action, type Game } from '../game/engine';
import {
actMentatBribe as act, createMentatBribeFixture as fixture,
mentatBribeInventory as inventory, mentatBribePlayer as player,
} from './fixture-mentat-bribes';
import {
actTruthTravel, createTruthTravelFixture, settleTruthTravel,
truthTravelInventory, truthTravelPlayer,
} from './fixture-truth-travel';
const immediate = (payer: string, recipient: string, amount: number) =>
({kind:'immediateBribe', payer, recipient, amount} as const);
function reject(game: Game, actor: string, action: Action) {
const before = structuredClone(game);
assert.throws(() => act(game,actor,action));
assert.deepEqual(game,before,'Rejected consent or action leaves the original table untouched.');
}
/** Real public Basic H/A/E setup, auction and first Mentat. The inherited
* fixture orders unopened cards and Spice, without fabricating purses or
* commitments. Every offer and vote uses the normal public actions. */
void test('two immediate terms settle once at final consent in their stated order', () => {
const f = fixture(), original = f.game, originalCards = inventory(original);
const first = immediate(f.target,f.asker,2), second = immediate(f.target,f.asker,3);
const offered = act(original,f.asker,{type:'dealOffer',target:f.target,terms:'Two separate payments.',
payment:first,additionalImmediatePayments:[second]});
const id = offered.deals?.at(-1)?.id; assert.ok(id);
assert.equal(player(offered,f.target).spice,10);
assert.equal(player(offered,f.asker).bribes,0);
const logStart = offered.log.length;
let game = act(offered,f.target,{type:'dealRespond',deal:id,accept:true});
assert.equal(game.deals?.find(row => row.id === id)?.status,'active');
assert.equal(player(game,f.target).spice,5);
assert.equal(player(game,f.asker).bribes,5);
const payments = game.log.slice(logStart).map(row => row.text).filter(text => /paid a \d+-spice bribe/i.test(text));
assert.equal(payments.length,2);
assert.match(payments[0],/paid a 2-spice bribe/i);
assert.match(payments[1],/paid a 3-spice bribe/i);
reject(game,f.target,{type:'dealRespond',deal:id,accept:true});
game = act(game,f.asker,{type:'dealRelease',deal:id,agree:true});
game = act(game,f.target,{type:'dealRelease',deal:id,agree:true});
assert.equal(game.deals?.find(row => row.id === id)?.status,'released');
assert.equal(player(game,f.target).spice,5);
assert.equal(player(game,f.asker).bribes,5);
assert.deepEqual(inventory(game),originalCards);
});
void test('two additional immediate payments work without a legacy payment term', () => {
const f = fixture(), payments = [immediate(f.target,f.asker,2),immediate(f.target,f.asker,2)];
const offered = act(f.game,f.asker,{type:'dealOffer',target:f.target,terms:'Two matching payments.',
additionalImmediatePayments:payments});
const id = offered.deals?.at(-1)?.id; assert.ok(id);
const done = act(offered,f.target,{type:'dealRespond',deal:id,accept:true});
assert.equal(done.deals?.find(row => row.id === id)?.status,'active');
assert.equal(player(done,f.target).spice,6);
assert.equal(player(done,f.asker).bribes,4);
reject(done,f.target,{type:'dealRespond',deal:id,accept:true});
assert.deepEqual(inventory(done),f.originalCards);
});
void test('final consent atomically rejects two immediate terms that exceed the same purse', () => {
const f = fixture();
const offered = act(f.game,f.asker,{type:'dealOffer',target:f.target,terms:'An unfunded pair of payments.',
payment:immediate(f.target,f.asker,6),additionalImmediatePayments:[immediate(f.target,f.asker,5)]});
const id = offered.deals?.at(-1)?.id; assert.ok(id);
reject(offered,f.target,{type:'dealRespond',deal:id,accept:true});
assert.equal(offered.deals?.find(row => row.id === id)?.status,'offered');
assert.equal(player(offered,f.target).spice,10);
assert.equal(player(offered,f.asker).bribes,0);
assert.deepEqual(inventory(offered),f.originalCards);
});
void test('a group settles immediate terms from different payers only after all consent', () => {
const f = fixture(), start = f.game;
const targetBefore = player(start,f.target).spice, otherBefore = player(start,f.opponent).spice;
assert.ok(targetBefore >= 2 && otherBefore >= 1);
let game = act(start,f.asker,{type:'dealOffer',targets:[f.target,f.opponent],terms:'Two separate group payments.',
payment:immediate(f.target,f.asker,2),additionalImmediatePayments:[immediate(f.opponent,f.asker,1)]});
const id = game.deals?.at(-1)?.id; assert.ok(id);
game = act(game,f.target,{type:'dealRespond',deal:id,accept:true});
assert.equal(game.deals?.find(row => row.id === id)?.status,'offered');
assert.equal(player(game,f.target).spice,targetBefore);
assert.equal(player(game,f.opponent).spice,otherBefore);
assert.equal(player(game,f.asker).bribes,0);
game = act(game,f.opponent,{type:'dealRespond',deal:id,accept:true});
assert.equal(game.deals?.find(row => row.id === id)?.status,'active');
assert.equal(player(game,f.target).spice,targetBefore-2);
assert.equal(player(game,f.opponent).spice,otherBefore-1);
assert.equal(player(game,f.asker).bribes,3);
reject(game,f.opponent,{type:'dealRespond',deal:id,accept:true});
assert.deepEqual(inventory(game),f.originalCards);
});
void test('immediate payments, deferred payment and travel share actual resources', () => {
const f = createTruthTravelFixture(), initial = f.game, originalCards = truthTravelInventory(initial);
const cash = truthTravelPlayer(initial,f.target).spice, incoming = truthTravelPlayer(initial,f.asker).bribes;
assert.ok(cash >= f.shipmentCost+4);
let game = actTruthTravel(initial,f.asker,{type:'dealOffer',target:f.target,terms:'Pay and make the shipment.',
payment:immediate(f.target,f.asker,1),additionalImmediatePayments:[immediate(f.target,f.asker,2)],
additionalPayments:[{kind:'deferredBribe',payer:f.target,recipient:f.asker,amount:1,dueTurn:initial.turn}],
travel:{kind:'ship',territory:f.shipmentTerritory,minimum:1,answer:true}});
const id = game.deals?.at(-1)?.id; assert.ok(id);
game = actTruthTravel(game,f.target,{type:'dealRespond',deal:id,accept:true});
assert.equal(truthTravelPlayer(game,f.target).spice,cash-3);
assert.equal(truthTravelPlayer(game,f.asker).bribes,incoming+3);
assert.equal(viewGame(game,f.target).dealTravelStatus[id],'pending');
assert.equal(game.deals?.find(row => row.id === id)?.additionalPayments?.[0].paymentStatus,'pending');
game = settleTruthTravel(actTruthTravel(game,f.target,f.shipmentAction));
game = actTruthTravel(game,f.target,{type:'dealPay',deal:id,paymentIndex:0});
assert.equal(truthTravelPlayer(game,f.target).spice,cash-4-f.shipmentCost);
assert.equal(truthTravelPlayer(game,f.asker).bribes,incoming+4);
assert.equal(game.deals?.find(row => row.id === id)?.additionalPayments?.[0].paymentStatus,'paid');
assert.equal(viewGame(game,f.target).dealTravelStatus[id],'fulfilled');
assert.deepEqual(truthTravelInventory(game),originalCards);
});
void test('invalid additional immediate terms reject without creating a deal', () => {
const f = fixture(), good = immediate(f.target,f.asker,1);
const packet = {type:'dealOffer',target:f.target,terms:'Invalid payment.'};
for (const additionalImmediatePayments of [
[{...good,amount:0}], [{...good,payer:f.asker,recipient:f.asker}],
[{...good,payer:f.opponent}], [{...good,kind:'deferredBribe',dueTurn:f.game.turn}],
[{...good,extra:true}],
]) reject(f.game,f.asker,{...packet,additionalImmediatePayments});
});