Files
Dune/tests/public-deals-additional-travel-model.test.ts
T
Quintine d7d0f89625
Verify and publish checkpoint container / container (push) Canceled after 0s
Support multiple travel terms in public deals
2026-11-16 15:19:10 +11:00

83 lines
5.0 KiB
TypeScript

import assert from 'node:assert/strict';
import test from 'node:test';
import {
createMultipartyPublicDeal, createPublicDeal, publicDealTravelTerms, PublicDealError,
releasePublicDeal, respondPublicDeal, setPublicDealAdditionalTravel, setPublicDealTravel,
validatePublicDeals, withdrawPublicDeal, type PublicDeal, type PublicDealSeat,
} from '../game/public-deals';
const seats: PublicDealSeat[] = ['a','b','c','d'].map(id => ({id}));
const original = {kind:'ship', territory:'polar_sink', minimum:1, answer:true} as const;
const extra = {kind:'move', territory:'imperial_basin', minimum:1, answer:true, actor:'a'} as const;
const pair = () => setPublicDealTravel(createPublicDeal(seats, 'a', 'b', 'Travel together', 3, 'pair'), original, seats);
const group = () => setPublicDealTravel(createMultipartyPublicDeal(seats, 'a', ['b','c','d'], 'Travel together', 3, 'group'),
{...original, actor:'b'}, seats);
void test('legacy, explicit and repeated additional travel terms retain stable indexes through the deal lifecycle', () => {
const source = pair();
assert.deepEqual(publicDealTravelTerms(source), [{travel:original}]);
const values = [extra, {...extra}, {...original, actor:'b', dueTurn:5}];
const offered = setPublicDealAdditionalTravel(source, values, seats);
assert.equal(source.additionalTravel, undefined);
assert.deepEqual(publicDealTravelTerms(offered), [
{travel:original}, {travel:extra,index:0}, {travel:extra,index:1},
{travel:{...original,actor:'b',dueTurn:5},index:2},
]);
assert.notEqual(offered.additionalTravel![0], values[0]);
const active = respondPublicDeal(offered, seats, 'b', true);
const released = releasePublicDeal(releasePublicDeal(active, seats, 'a', true), seats, 'b', true);
for (const saved of [offered,active,released]) {
const restored = JSON.parse(JSON.stringify(saved)) as PublicDeal;
validatePublicDeals([restored], seats);
assert.deepEqual(publicDealTravelTerms(restored), publicDealTravelTerms(offered));
}
});
void test('additional terms require a fresh original travel term, explicit participants and valid deadlines', () => {
const source = pair();
const withoutTravel = createPublicDeal(seats, 'a', 'b', 'Travel', 3, 'without');
assert.throws(() => setPublicDealAdditionalTravel(withoutTravel, [extra], seats), PublicDealError);
for (const bad of [null, undefined, [], Array(13).fill(extra), [original],
[{...extra,actor:'c'}], [{...extra,actor:''}], [{...extra,dueTurn:2}],
[{...extra,dueTurn:undefined}], [{...extra,sector:9}]])
assert.throws(() => setPublicDealAdditionalTravel(source, bad, seats), PublicDealError);
const twelve = setPublicDealAdditionalTravel(source, Array(12).fill(extra), seats);
assert.equal(publicDealTravelTerms(twelve).length, 13);
assert.throws(() => setPublicDealAdditionalTravel(twelve, [extra], seats), PublicDealError);
assert.throws(() => setPublicDealAdditionalTravel(respondPublicDeal(source,seats,'b',true), [extra], seats), PublicDealError);
for (const malformed of [
{...source, additionalTravel:[]}, {...source, additionalTravel:[original]},
{...withoutTravel, additionalTravel:[extra]}, {...source, additionalTravel:undefined},
]) assert.throws(() => validatePublicDeals([malformed], seats), PublicDealError);
});
void test('group non-travelers accept before any invited traveler, then travelers accept in either order', () => {
const offered = setPublicDealAdditionalTravel(group(), [{...extra,actor:'c'}], seats);
for (const actor of ['b','c'])
assert.throws(() => respondPublicDeal(offered,seats,actor,true), PublicDealError);
const beforeTravelers = respondPublicDeal(offered,seats,'d',true);
for (const [first,last] of [['b','c'],['c','b']]) {
const partial = respondPublicDeal(beforeTravelers,seats,first,true);
assert.equal(partial.status,'offered');
validatePublicDeals([JSON.parse(JSON.stringify(partial))],seats);
const active = respondPublicDeal(partial,seats,last,true);
assert.equal(active.status,'active');
assert.deepEqual(active.acceptVotes,['a','b','c','d']);
validatePublicDeals([active],seats);
}
assert.throws(() => validatePublicDeals([{...offered,acceptVotes:['a','b']}],seats), PublicDealError);
assert.equal(respondPublicDeal(offered,seats,'b',false).status,'declined');
assert.equal(withdrawPublicDeal(offered,seats,'a').status,'withdrawn');
});
void test('proposer consent is implicit and repeated traveler identities need only one vote', () => {
const self = setPublicDealTravel(createMultipartyPublicDeal(seats,'a',['b','c','d'],'I travel',3,'self'),
{...original,actor:'a'},seats);
const offered = setPublicDealAdditionalTravel(self, [extra,{...extra,actor:'b'},{...extra,actor:'b'}], seats);
assert.throws(() => respondPublicDeal(offered,seats,'b',true), PublicDealError);
const otherVotes = respondPublicDeal(respondPublicDeal(offered,seats,'c',true),seats,'d',true);
const active = respondPublicDeal(otherVotes,seats,'b',true);
assert.equal(active.status,'active');
assert.equal(publicDealTravelTerms(active).length,4);
});