83 lines
5.0 KiB
TypeScript
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);
|
|
});
|