Files
Dune/tests/public-deals-multiple-payments.test.ts
T
Quintine cacc88906c
Verify and publish checkpoint container / container (push) Successful in 10m22s
Support multiple deferred payments in public deals
2026-11-16 14:30:36 +11:00

180 lines
11 KiB
TypeScript

import assert from 'node:assert/strict';
import test from 'node:test';
import { botActions } from '../game/bots';
import { viewGame, type Action, type Game } from '../game/engine';
import type { PublicDeal } from '../game/public-deals';
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';
type Deferred = { kind:'deferredBribe'; payer:string; recipient:string; amount:number; dueTurn:number };
type Line = { payment:Deferred; paymentStatus?:'pending'|'paid'|'void'|'released' };
type MultiDeal = PublicDeal & { additionalPayments?:Line[] };
const term = (payer:string, recipient:string, amount:number, dueTurn:number): Deferred =>
({kind:'deferredBribe',payer,recipient,amount,dueTurn});
const key = (deal:string, index:number) => `${deal}:payment:${index}`;
function deal(game: Game, id: string): MultiDeal {
const found = game.deals?.find(row => row.id === id); assert.ok(found); return found as MultiDeal;
}
function reject(game: Game, actor: string, action: Action) {
const before = structuredClone(game);
assert.throws(() => act(game,actor,action));
assert.deepEqual(game,before,'Rejected actions leave the original state unchanged');
}
function offer(game: Game, from: string, to: string, additionalPayments: Deferred[], payment?: object) {
game = act(game,from,{type:'dealOffer',target:to,terms:'Pay the agreed separate amounts.',additionalPayments,
...(payment ? {payment} : {})});
const id = game.deals?.at(-1)?.id; assert.ok(id);
return {game,id};
}
const accept = (game: Game, actor:string, id:string) => act(game,actor,{type:'dealRespond',deal:id,accept:true});
const pay = (game: Game, actor:string, id:string, paymentIndex:number) =>
act(game,actor,{type:'dealPay',deal:id,paymentIndex});
/** Public Basic H/A/E start, real auction and first Mentat. The inherited
* fixture orders only unopened original cards and Spice; no purse or deal is
* fabricated. Every term's consent and transfer uses native player actions. */
void test('identical deferred terms have separate indices and each exact payment settles once', () => {
const f = fixture(), start = f.game, original = inventory(start);
const terms = [term(f.target,f.asker,3,start.turn),term(f.target,f.asker,3,start.turn)];
const proposed = offer(start,f.asker,f.target,terms);
assert.deepEqual(deal(proposed.game,proposed.id).additionalPayments?.map(line => line.payment),terms);
assert.equal(player(proposed.game,f.target).spice,10);
let game = accept(proposed.game,f.target,proposed.id);
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['pending','pending']);
assert.equal(viewGame(game,f.target).deferredDealPaymentOptions[key(proposed.id,0)]?.blocked,null);
assert.equal(viewGame(game,f.target).deferredDealPaymentOptions[key(proposed.id,1)]?.blocked,null);
reject(game,f.asker,{type:'dealPay',deal:proposed.id,paymentIndex:0});
reject(game,f.target,{type:'dealPay',deal:proposed.id,paymentIndex:2});
reject(game,f.target,{type:'dealPay',deal:proposed.id});
game = pay(game,f.target,proposed.id,1);
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['pending','paid']);
assert.equal(player(game,f.target).spice,7); assert.equal(player(game,f.asker).bribes,3);
reject(game,f.target,{type:'dealPay',deal:proposed.id,paymentIndex:1});
game = pay(game,f.target,proposed.id,0);
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['paid','paid']);
assert.equal(player(game,f.target).spice,4); assert.equal(player(game,f.asker).bribes,6);
assert.deepEqual(inventory(game),original);
});
void test('final consent rolls back when separate due terms overcommit the same purse', () => {
const f = fixture(), terms = [term(f.target,f.asker,6,f.game.turn),term(f.target,f.asker,5,f.game.turn)];
const proposed = offer(f.game,f.asker,f.target,terms), before = structuredClone(proposed.game);
reject(proposed.game,f.target,{type:'dealRespond',deal:proposed.id,accept:true});
assert.deepEqual(proposed.game,before);
assert.equal(deal(proposed.game,proposed.id).status,'offered');
assert.deepEqual(deal(proposed.game,proposed.id).additionalPayments?.map(line => line.paymentStatus),[undefined,undefined]);
assert.equal(player(proposed.game,f.target).spice,10);
assert.deepEqual(inventory(proposed.game),f.originalCards);
});
void test('current and future terms reserve only the current due amount and keep distinct payment receipts', () => {
const f = fixture(), due = f.game.turn;
const proposed = offer(f.game,f.asker,f.target,[term(f.target,f.asker,3,due),term(f.target,f.asker,8,due+1)]);
let game = accept(proposed.game,f.target,proposed.id);
assert.equal(viewGame(game,f.target).deferredDealPaymentOptions[key(proposed.id,0)]?.blocked,null);
assert.ok(viewGame(game,f.target).deferredDealPaymentOptions[key(proposed.id,1)]?.blocked);
reject(game,f.target,{type:'dealPay',deal:proposed.id,paymentIndex:1});
game = pay(game,f.target,proposed.id,0);
assert.equal(player(game,f.target).spice,7);
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['paid','pending']);
assert.deepEqual(inventory(game),f.originalCards);
});
void test('unanimous release cancels only unpaid terms and does not refund paid spice', () => {
const f = fixture(), proposed = offer(f.game,f.asker,f.target,
[term(f.target,f.asker,2,f.game.turn),term(f.target,f.asker,3,f.game.turn)]);
let game = accept(proposed.game,f.target,proposed.id);
game = pay(game,f.target,proposed.id,0);
game = act(game,f.asker,{type:'dealRelease',deal:proposed.id,agree:true});
assert.equal(deal(game,proposed.id).status,'active');
game = act(game,f.target,{type:'dealRelease',deal:proposed.id,agree:true});
assert.equal(deal(game,proposed.id).status,'released');
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['paid','released']);
assert.equal(player(game,f.target).spice,8); assert.equal(player(game,f.asker).bribes,2);
reject(game,f.target,{type:'dealPay',deal:proposed.id,paymentIndex:1});
assert.deepEqual(inventory(game),f.originalCards);
});
void test('a group can accept distinct payer terms without settling before all consent', () => {
const f = fixture(), start = f.game;
assert.ok(player(start,f.opponent).spice >= 1);
const terms = [term(f.target,f.asker,2,start.turn),term(f.opponent,f.asker,1,start.turn)];
let game = act(start,f.asker,{type:'dealOffer',targets:[f.target,f.opponent],terms:'Both pay agreed spice.',additionalPayments:terms});
const id = game.deals?.at(-1)?.id; assert.ok(id);
game = accept(game,f.target,id);
assert.equal(deal(game,id).status,'offered');
assert.equal(player(game,f.target).spice,player(start,f.target).spice);
game = accept(game,f.opponent,id);
assert.equal(deal(game,id).status,'active');
reject(game,f.target,{type:'dealPay',deal:id,paymentIndex:1});
game = pay(game,f.opponent,id,1);
game = pay(game,f.target,id,0);
assert.equal(player(game,f.asker).bribes,3);
assert.deepEqual(deal(game,id).additionalPayments?.map(line => line.paymentStatus),['paid','paid']);
assert.deepEqual(inventory(game),f.originalCards);
});
void test('the original immediate payment and extra deferred payments use separate native transfers', () => {
const f = fixture(), start = f.game;
const immediate = {kind:'immediateBribe',payer:f.target,recipient:f.asker,amount:2};
const proposed = offer(start,f.asker,f.target,[term(f.target,f.asker,3,start.turn)],immediate);
assert.equal(player(proposed.game,f.target).spice,10);
let game = accept(proposed.game,f.target,proposed.id);
assert.equal(player(game,f.target).spice,8); assert.equal(player(game,f.asker).bribes,2);
assert.equal(deal(game,proposed.id).additionalPayments?.[0].paymentStatus,'pending');
game = pay(game,f.target,proposed.id,0);
assert.equal(player(game,f.target).spice,5); assert.equal(player(game,f.asker).bribes,5);
assert.equal(deal(game,proposed.id).additionalPayments?.[0].paymentStatus,'paid');
assert.deepEqual(inventory(game),f.originalCards);
});
void test('autopilot uses a legal indexed action for each payment that is due', () => {
const f = fixture(), proposed = offer(f.game,f.asker,f.target,
[term(f.target,f.asker,2,f.game.turn),term(f.target,f.asker,3,f.game.turn)]);
let game = accept(proposed.game,f.target,proposed.id);
game = act(game,f.target,{type:'setAutopilot',difficulty:'Easy'});
for (let count = 0; count < 2; count++) {
const action = botActions(viewGame(game,f.target))[0]; assert.ok(action);
assert.equal(action.type,'dealPay'); assert.equal(action.deal,proposed.id);
assert.ok(action.paymentIndex === 0 || action.paymentIndex === 1);
game = act(game,f.target,action);
}
assert.deepEqual(deal(game,proposed.id).additionalPayments?.map(line => line.paymentStatus),['paid','paid']);
assert.equal(player(game,f.target).spice,5); assert.equal(player(game,f.asker).bribes,5);
assert.deepEqual(inventory(game),f.originalCards);
});
void test('multiple deferred payments can accompany an actual current-turn shipment', () => {
const f = createTruthTravelFixture(), initial = f.game, original = truthTravelInventory(initial);
const terms = [term(f.target,f.asker,1,initial.turn),term(f.target,f.asker,1,initial.turn)];
let game = actTruthTravel(initial,f.asker,{type:'dealOffer',target:f.target,terms:'Two payments and a shipment.',
additionalPayments:terms,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(viewGame(game,f.target).dealTravelStatus[id],'pending');
game = actTruthTravel(game,f.target,{type:'dealPay',deal:id,paymentIndex:0});
game = settleTruthTravel(actTruthTravel(game,f.target,f.shipmentAction));
game = actTruthTravel(game,f.target,{type:'dealPay',deal:id,paymentIndex:1});
assert.equal(viewGame(game,f.target).dealTravelStatus[id],'fulfilled');
assert.deepEqual(deal(game,id).additionalPayments?.map(line => line.paymentStatus),['paid','paid']);
assert.equal(truthTravelPlayer(game,f.target).forces['polar_sink:0'],1);
assert.deepEqual(truthTravelInventory(game),original);
});
void test('malformed additional payment packets are rejected without opening a deal', () => {
const f = fixture(), due = f.game.turn, valid = term(f.target,f.asker,1,due);
const packet = {type:'dealOffer',target:f.target,terms:'Invalid payment terms.'};
for (const additionalPayments of [
[{...valid,amount:0}], [{...valid,payer:f.asker,recipient:f.asker}],
[{...valid,dueTurn:due-1}], [{...valid,kind:'immediateBribe'}],
[{...valid,extra:true}], Array.from({length:13},() => valid),
]) reject(f.game,f.asker,{...packet,additionalPayments});
});