Files
Dune/tests/joint-early-richese-bids.test.ts
T
Quintine 3ede19c90a
Verify and publish checkpoint container / container (push) Successful in 11m28s
Compose early cache and phase-wide bid commitments
2026-11-16 20:01:53 +11:00

97 lines
6.5 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import assert from 'node:assert/strict';
import test from 'node:test';
import { quoteJointEarlyRicheseBids, type JointEarlyRicheseBidInput } from '../game/joint-early-richese-bids';
import type { EarlyRicheseBidPromise } from '../game/early-richese-bid';
import type { PhaseBidPromise } from '../game/turn-bid-promises';
const early = (minimum:number,answer:boolean,extra:Partial<EarlyRicheseBidPromise> = {}):EarlyRicheseBidPromise =>
({id:`early-${minimum}-${answer}`,turn:3,player:'emperor',asker:'atreides',minimum,answer,...extra});
const phase = (minimum:number,answer:boolean,extra:Partial<PhaseBidPromise> = {}):PhaseBidPromise =>
({event:`phase-${minimum}-${answer}`,turn:3,player:'emperor',asker:'atreides',minimum,answer,...extra});
const input = (extra:Partial<JointEarlyRicheseBidInput> = {}):JointEarlyRicheseBidInput => ({
player:'emperor',turn:3,early:[],phase:[],cacheMaximum:10,...extra,
});
const ordinary = (extra:Partial<NonNullable<JointEarlyRicheseBidInput['ordinary']>> = {}) => ({
opportunity:{player:'emperor',turn:3,kind:'future' as const,minimum:1,maximum:10},
cashAvailable:9,aidAvailable:0,freeSlots:2,cacheWinSlots:1,...extra,
});
void test('one physical cache declaration intersects every live Yes and No',() => {
const result=quoteJointEarlyRicheseBids(input({
early:[early(3,true),early(8,false)],phase:[phase(5,true),phase(7,false)],
}));
assert.equal(result.earlyRequired,true); assert.equal(result.phaseRequired,true);
assert.deepEqual(result.cache,{minimum:3,maximum:6});
assert.deepEqual(result.shared,{minimum:5,maximum:6});
assert.equal(result.separate,null); assert.equal(result.possible,true);
const conflict=quoteJointEarlyRicheseBids(input({early:[early(3,true)],phase:[phase(3,false)]}));
assert.equal(conflict.cache,null); assert.equal(conflict.shared,null); assert.equal(conflict.possible,false);
const onlyNo=quoteJointEarlyRicheseBids(input({early:[early(1,false)],phase:[phase(1,false)]}));
assert.equal(onlyNo.cache,null); assert.equal(onlyNo.possible,true,'Both obligations can pass');
});
void test('a distinct ordinary bid reserves cash and a hand slot for a required cache purchase',() => {
const baseline=input({early:[early(3,true),early(4,false)],phase:[phase(6,true)],ordinary:ordinary()});
const quote=quoteJointEarlyRicheseBids(baseline);
assert.deepEqual(quote.cache,{minimum:3,maximum:3}); assert.equal(quote.shared,null);
assert.deepEqual(quote.separate,{cacheBid:3,ordinary:{minimum:6,maximum:6}});
assert.equal(quote.possible,true);
const insufficient=quoteJointEarlyRicheseBids({...baseline,ordinary:ordinary({cashAvailable:8})});
assert.equal(insufficient.separate,null); assert.equal(insufficient.possible,false);
const aided=quoteJointEarlyRicheseBids({...baseline,ordinary:ordinary({cashAvailable:8,aidAvailable:1})});
assert.deepEqual(aided.separate,{cacheBid:3,ordinary:{minimum:6,maximum:6}});
assert.equal(aided.possible,true);
const noSecondSlot=quoteJointEarlyRicheseBids({...baseline,ordinary:ordinary({freeSlots:1})});
assert.equal(noSecondSlot.separate,null); assert.equal(noSecondSlot.possible,false);
// The first Harkonnen purchase can add its bonus card before the second
// declaration. Once that declaration is placed both obligations are met.
const harkonnenTwo=quoteJointEarlyRicheseBids({...baseline,ordinary:ordinary({freeSlots:2,cacheWinSlots:2})});
assert.equal(harkonnenTwo.separate,null); assert.equal(harkonnenTwo.possible,false);
const harkonnenThree=quoteJointEarlyRicheseBids({...baseline,ordinary:ordinary({freeSlots:3,cacheWinSlots:2})});
assert.deepEqual(harkonnenThree.separate,{cacheBid:3,ordinary:{minimum:6,maximum:6}});
assert.equal(harkonnenThree.possible,true);
const noCashForCache=quoteJointEarlyRicheseBids({...baseline,ordinary:ordinary({cashAvailable:2,aidAvailable:100})});
assert.equal(noCashForCache.separate,null,'Uncommitted ally aid cannot replace the cache cash witness');
});
void test('a phase Yes can use a separate ordinary bid while the early No permits a cache pass',() => {
const quote=quoteJointEarlyRicheseBids(input({early:[early(4,false)],phase:[phase(6,true)],
ordinary:ordinary({cashAvailable:6,freeSlots:1})}));
assert.equal(quote.earlyRequired,false); assert.equal(quote.shared,null);
assert.deepEqual(quote.separate,{cacheBid:null,ordinary:{minimum:6,maximum:6}});
assert.equal(quote.possible,true);
const blocked=quoteJointEarlyRicheseBids(input({early:[early(4,false)],phase:[phase(6,true),phase(6,false)],
ordinary:ordinary({cashAvailable:10})}));
assert.equal(blocked.shared,null); assert.equal(blocked.separate,null); assert.equal(blocked.possible,false);
});
void test('only the respondent’s live receipts for this turn bind the joint quote',() => {
const quote=quoteJointEarlyRicheseBids(input({
early:[early(3,true),early(1,false,{id:'other',player:'richese'}),
early(1,false,{id:'old',turn:2}),early(1,false,{id:'bound',boundEvent:'real-cache'}),
early(1,false,{id:'finished',fulfilled:true}),early(1,false,{id:'released',released:true})],
phase:[phase(4,true),phase(1,false,{event:'other',player:'richese'}),
phase(1,false,{event:'old',turn:2}),phase(1,false,{event:'finished',fulfilled:true}),
phase(1,false,{event:'released',released:true})],
}));
assert.deepEqual(quote.cache,{minimum:3,maximum:10});
assert.deepEqual(quote.shared,{minimum:4,maximum:10});
assert.equal(quote.possible,true);
});
void test('zero and maximum safe integer budgets do not invent funding',() => {
assert.equal(quoteJointEarlyRicheseBids(input({cacheMaximum:0,early:[early(1,true)]})).possible,false);
assert.equal(quoteJointEarlyRicheseBids(input({cacheMaximum:0,early:[early(1,false)]})).possible,true);
const max=Number.MAX_SAFE_INTEGER;
const single=quoteJointEarlyRicheseBids(input({cacheMaximum:max,early:[early(max,true)],phase:[phase(max,true)]}));
assert.deepEqual(single.shared,{minimum:max,maximum:max}); assert.equal(single.possible,true);
for (const cacheMaximum of [-1,0.5,Infinity,Number.NaN,Number.MAX_SAFE_INTEGER+1])
assert.throws(() => quoteJointEarlyRicheseBids(input({cacheMaximum})));
assert.throws(() => quoteJointEarlyRicheseBids(input({turn:0})));
assert.throws(() => quoteJointEarlyRicheseBids(input({player:' emperor '})));
assert.throws(() => quoteJointEarlyRicheseBids(input({phase:[phase(1,true)],
ordinary:ordinary({cashAvailable:1,aidAvailable:-1})})));
assert.throws(() => quoteJointEarlyRicheseBids(input({phase:[phase(1,true)],
ordinary:ordinary({opportunity:{player:'richese',turn:3,kind:'future',minimum:1,maximum:1}})})));
});