357 lines
25 KiB
JavaScript
357 lines
25 KiB
JavaScript
// Run actual production functions in a VM; mocks cover I/O and DOM only.
|
|
// vMix29: SuspendCountdown pauses only; StopCountdown resets; PauseCountdown toggles.
|
|
// https://www.vmix.com/help29/ShortcutFunctionReference.html
|
|
const fs = require('node:fs');
|
|
const vm = require('node:vm');
|
|
const path = require('node:path');
|
|
const assert = require('node:assert/strict');
|
|
const source = fs.readFileSync(path.join(__dirname, '../ui_builder/static/app.js'), 'utf8');
|
|
function extract(name) {
|
|
const start = source.search(new RegExp('^ (?:async )?function ' + name + '\\(', 'm'));
|
|
assert.ok(start >= 0, `missing production function ${name}`);
|
|
const end = source.indexOf('\n }', start);
|
|
assert.ok(end > start, `missing function end ${name}`);
|
|
return source.slice(start, end + 4);
|
|
}
|
|
// Load new transport dependencies from production; existing I/O/DOM edges stay local.
|
|
function productionClosure(context, roots) {
|
|
const functions = new Map(), pattern = /^( {0,2})(?:async )?function (\w+)\(/gm;
|
|
let match;
|
|
while ((match = pattern.exec(source))) {
|
|
const start = match.index, lineEnd = source.indexOf('\n', start);
|
|
const singleLine = /\}\s*;?\s*$/.test(source.slice(start, lineEnd));
|
|
const end = singleLine ? lineEnd : source.indexOf('\n' + match[1] + '}', start) + match[1].length + 2;
|
|
assert.ok(end > start, 'Unclosed production helper ' + match[2]);
|
|
functions.set(match[2], source.slice(start, end));
|
|
}
|
|
const needed = new Set(roots);
|
|
function visit(name) {
|
|
assert.ok(functions.has(name), 'Missing actual production helper ' + name);
|
|
for (const candidate of functions.keys()) {
|
|
if (needed.has(candidate) || typeof context[candidate] === 'function') continue;
|
|
if (new RegExp('\\b' + candidate + '\\s*\\(').test(functions.get(name))) {
|
|
needed.add(candidate); visit(candidate);
|
|
}
|
|
}
|
|
}
|
|
roots.forEach(visit);
|
|
return [...needed].map(name => functions.get(name)).join('\n');
|
|
}
|
|
function runtime(extra = []) {
|
|
const noop = () => {};
|
|
const game = { action_id:'hockey_game_timer', type:'timer', props:{mode:'count_down',startTime:'20:00'} };
|
|
const boardComponent = { action_id:'penalties', type:'hockey_penalty_dashboard', props:{} };
|
|
const main = { currentMs:1200000, running:false, paused:true, startedOnce:false, finished:false,
|
|
reached:{}, lastTimestamp:1000 };
|
|
const board = { penalties:[], selectedEventId:null };
|
|
const target = {id:'home-slot',input:'Penalty Home',selected_name:'Penalty.Text',overlay:'2'};
|
|
const step = {id:'clock-step',enabled:true,type:'hockey_vmix_timers_start',sync_vmix_game:true,
|
|
game_timer_action_id:game.action_id,game_vmix_input:'Score',game_vmix_selected_name:'Clock.Text',
|
|
game_vmix_mode:'countdown',sync_vmix_penalties:false,start_web_game:true,start_web_penalties:false,
|
|
hockey_timer_command:'toggle',home_penalty_targets:[target],away_penalty_targets:[]};
|
|
const sequence = {id:'clock-sequence',enabled:true,steps:[step]};
|
|
const sent = [], events = [], order = [];
|
|
const state = {config:{components:[game,boardComponent],shortcut_sequences:[sequence]},
|
|
activeHockeyVmixTimerSteps:new Set(),vmixGameCountdownSeededTargets:new Set(),
|
|
vmixPenaltyTargetAssignments:new Map(),vmixPenaltyMirrors:new Map(),vmixTimerMirrors:new Map(),
|
|
hockeyPenaltyAdvantageCycle:{hadAdvantage:false,lastAdvantageSide:''},vmixOverlayRuntime:new Map(),
|
|
runningShortcutSequences:new Set(),pendingShortcutSequenceRuns:new Map(),data:{}};
|
|
let allowed = true;
|
|
const compact = raw => Object.fromEntries(Object.entries(raw).map(([key,value])=>[key,typeof value==='function'?value():value]));
|
|
const context = {console,Date,AbortController,URLSearchParams,performance:{now:()=>1000},state,boot:{mode:'runtime'},setTimeout,clearTimeout,
|
|
window:{setTimeout,clearTimeout,HockeyMatchAccess:{storage:{getItem:()=> 'account-a'}}},
|
|
refreshQuickPanelOnAirClasses:noop,hockeyRuntimeVmixInputTitle:async input=>String(input),
|
|
async fetch(url,options={}) {
|
|
assert.equal(options.method,'POST');
|
|
if(url.startsWith('/api/hockey/agents/devices/OUTPUT-A/apply-mapping?')) return {ok:true,status:200,json:async()=>({ok:true,complete:true,mapping_ack_waited:true,confirmation:'ack',applied:1,
|
|
text_fields_total:1,text_fields_confirmed:1,missing:[],rule_missing:[],errors:[],warnings:[]})};
|
|
assert.equal(url,'/api/hockey/vmix/sequence');
|
|
const body=JSON.parse(options.body);order.push('transport');sent.push(body.commands.map(compact));
|
|
return {ok:true,status:200,json:async()=>({ok:true,confirmation:'ack',applied:body.commands.length,
|
|
results:body.commands.map(command=>({ok:true,function:command.Function,ack_waited:true}))})};
|
|
},
|
|
padTimer:value=>String(value).padStart(2,'0'),clamp:(n,l,h)=>Math.max(l,Math.min(h,n)),
|
|
hockeyCanControl:()=>allowed,componentByActionId:id=>id===game.action_id?game:id===boardComponent.action_id?boardComponent:null,
|
|
isTimerComponent:c=>c===game,ensureTimerState:()=>main,
|
|
ensureHockeyBoardState:()=>board,hockeyEventReady:event=>Boolean(event.ready!==false && event.durationMs>0),
|
|
currentHockeyPenaltyEntries:()=>board.penalties.filter(event=>!event.finished && context.hockeyEventReady(event)).map(event=>({component:boardComponent,event,side:event.side})),
|
|
sequencePenaltyTargets:(s,side)=>s[side+'_penalty_targets'],
|
|
penaltyDisplayEntriesByTargetSide:()=>({home:context.currentHockeyPenaltyEntries(),away:[]}),
|
|
rememberPenaltyAdvantagePlan:noop,vmixInputByRef:()=>null,
|
|
emitInteraction:(component,event,detail)=>{events.push({component,event,detail});order.push('event:'+event);},
|
|
updateTimerNodes:noop,formatTimerValue:()=>String(main.currentMs),persistTimer:noop,
|
|
timerInitialMilliseconds:c=>context.parseTimerMilliseconds(c.props.startTime),
|
|
persistHockeyBoard:noop,refreshHockeyBoardNodes:noop,emitHockeyEventUpdated:noop,
|
|
hockeyPenaltyContext:()=>({}),fireConfiguredTimerFinishActions:noop,
|
|
timerEndMilliseconds:()=>null,timerMilestones:()=>[],
|
|
hockeyScheduleTimerSave:noop,addHockeyHistory:noop,hockeyInfractionWebLabel:()=>'',
|
|
hockeySyncPenaltySideMappingContext:async()=>true,
|
|
buildShortcutRuntimeContext:()=>({}),sequenceConditionMatches:()=>true,
|
|
currentRuntimeVmixDeviceId:()=> 'OUTPUT-A',currentRuntimeHockeySessionToken:()=> 'session-a',
|
|
hockeyMainTimerComponent:()=>game,
|
|
penaltyFullStrengthSide:()=> 'home',resetPenaltyAdvantageCycle:()=>{state.hockeyPenaltyAdvantageCycle.hadAdvantage=false;state.hockeyPenaltyAdvantageCycle.lastAdvantageSide='';},
|
|
hockeyClearSelectedPenaltyMappingContext:async()=>true,updateHockeyBoardTickerNodes:noop,
|
|
getByPath:(object,key)=>key.split('.').reduce((value,part)=>value?.[part],object),
|
|
hockeyGameClockSnapshot:()=>({formatted:'18:42',milliseconds:1122000}),
|
|
uid:()=> 'draft-id',clone:value=>JSON.parse(JSON.stringify(value)),closeHockeyInfractionDropdown:noop,
|
|
applyPresetToHockeyEvent:(_component,event,preset)=>{event.preset=preset;event.durationMs=event.remainingMs=120000;},
|
|
sendRuntimeVmixTimerSequence:commands=>{order.push('transport');sent.push(commands.map(compact));return new Promise(()=>{});},
|
|
};
|
|
const names = ['parseTimerMilliseconds','vmixCountdownValue','vmixGameCountdownControlCommands',
|
|
'vmixPenaltyCountdownControlCommands','vmixGameCountdownTargetKey','markVmixGameCountdownSeeded',
|
|
'isVmixGameCountdownSeeded','hockeyTimerSyncStepById','syncActiveVmixGameCountdown',
|
|
'configuredHockeyVmixGameCountdownTargets','syncConfiguredScoreboardCountdownsToRuntime',
|
|
'emitTimerEvent','controlTimer','runShortcutSequenceStep','updateSingleTimer',
|
|
'penaltyMirrorKey','penaltyTargetAssignmentKey','activateConfiguredPenaltyCountdowns',
|
|
'rebalanceVmixPenaltyTargets','controlHockeyPenalty','hockeyApplyTimerRules',
|
|
'hockeyTimerSelectedGameId','normalizeRuntimeVmixInputRef','runtimeOverlayInputRefs','runtimeOverlayMatchesInput','vmixOverlayLayer',
|
|
'templateSequenceValue','templateValue','formatValue',
|
|
'hockeyTeamStateSequenceStep','hockeyScoreboardPrimaryOverlayTargets','hockeyScoreboardSequenceIsLive','hockeyScoreboardIsLive',
|
|
'hockeyScoreboardDelaySeconds','hockeyScoreboardPresentationContext','hockeyObserveScoreboardPresentation','hockeyScoreboardAuxiliaryReady',
|
|
'hockeyScoreboardAuxiliaryDelay','hockeyScoreboardAuxiliaryTargetReady','hockeyMatchFlags',
|
|
'hockeyScoreboardTeamStateSettings','hockeyTeamStateSetting','hockeyGameControlLanguage','shortcutVmixStepCommands',
|
|
'hockeyAuxiliaryGateContext','hockeyScoreboardAuxiliariesEnabled','hockeyPenaltyEntryDeliveryPending', 'hockeyPenaltyDisplayTargetAllowed', 'hockeyPenaltyCaptionTargetAllowed',
|
|
'hockeyPenaltyTargetDeliveryPending', 'hockeyPenaltyTransportSampler', 'sendRuntimeVmixSequence',...extra];
|
|
vm.createContext(context);
|
|
vm.runInContext(productionClosure(context,[...new Set(names)]),context);
|
|
return {context,game,main,board,boardComponent,step,sequence,target,state,sent,events,order,
|
|
allow:value=>{allowed=value;},clear:()=>{sent.length=events.length=order.length=0;},
|
|
functions:()=>sent.flat().map(command=>command.Function)};
|
|
}
|
|
function functions(commands) {return Array.from(commands,command=>command.Function);}
|
|
function seededCommands(h,action,value=125000) {
|
|
return h.context.vmixGameCountdownControlCommands(' Score ',' Clock.Text ',()=>value,action);
|
|
}
|
|
const cases = {};
|
|
cases.first_start = async()=>{
|
|
const h=runtime();
|
|
const commands=seededCommands(h,'start',1200000);
|
|
assert.deepEqual(functions(commands),['SetCountdown','StartCountdown']);
|
|
assert.equal(commands[0].Value,'00:20:00');
|
|
assert.ok(commands.every(c=>c.Input==='Score' && c.SelectedName==='Clock.Text'));
|
|
assert.deepEqual(Array.from(h.context.vmixGameCountdownControlCommands('','Clock.Text',1000,'start')),[]);
|
|
assert.deepEqual(Array.from(h.context.vmixGameCountdownControlCommands('Score','',1000,'start')),[]);
|
|
};
|
|
cases.pause_freezes = async()=>{
|
|
const h=runtime();
|
|
for(const action of ['pause','stop']) {
|
|
let reads=0;
|
|
const commands=h.context.vmixGameCountdownControlCommands('Score','Clock.Text',()=>{reads++;return 940000;},action);
|
|
assert.deepEqual(functions(commands),['SuspendCountdown']);
|
|
assert.equal(reads,0,'pause cannot read/write browser time or reset native duration');
|
|
assert.ok(commands.every(c=>!('Value' in c)));
|
|
}
|
|
};
|
|
cases.resume_preserves_native = async()=>{
|
|
const h=runtime();let reads=0;
|
|
const commands=h.context.vmixGameCountdownControlCommands('Score','Clock.Text',()=>{reads++;return 1200000;},'resume');
|
|
assert.deepEqual(functions(commands),['StartCountdown']);assert.equal(reads,0);
|
|
const native={position:83,running:false};
|
|
for(const c of commands) if(c.Function==='StartCountdown')native.running=true;
|
|
assert.equal(native.position,83,'resume must keep the native paused position');
|
|
};
|
|
cases.explicit_edit = async()=>{
|
|
const h=runtime();
|
|
assert.equal(h.context.controlTimer(h.game.action_id,'set_time','16:01'),true);
|
|
assert.deepEqual(h.functions(),['SetCountdown','StopCountdown']);
|
|
assert.equal(h.sent[0][0].Value,'00:16:01');assert.equal(h.main.currentMs,961000);
|
|
h.clear();h.main.running=true;
|
|
h.context.controlTimer(h.game.action_id,'set_time','05:17');
|
|
assert.deepEqual(h.functions(),['SetCountdown','StopCountdown','StartCountdown']);
|
|
assert.equal(h.sent[0][0].Value,'00:05:17');assert.equal(h.main.running,true);
|
|
};
|
|
cases.first_edit_before_activation = async()=>{
|
|
const h=runtime();assert.equal(h.state.activeHockeyVmixTimerSteps.size,0);
|
|
for(const [event,value] of [['timer_set_time',300000],['timer_reset',1200000],['timer_add_time',1210000],['timer_subtract_time',1190000]]) {
|
|
h.clear();h.main.currentMs=value;
|
|
assert.equal(await h.context.syncActiveVmixGameCountdown(h.game,h.main,event),true);
|
|
assert.deepEqual(h.functions(),['SetCountdown','StopCountdown']);
|
|
assert.equal(h.sent[0][0].Value,h.context.vmixCountdownValue(value));
|
|
}
|
|
};
|
|
cases.native_events = async()=>{
|
|
const h=runtime();h.state.activeHockeyVmixTimerSteps.add(h.step.id);
|
|
await h.context.syncActiveVmixGameCountdown(h.game,h.main,'timer_start',{wasStartedOnce:false});
|
|
assert.deepEqual(h.functions(),['SetCountdown','StartCountdown']);
|
|
for(const name of ['timer_pause','timer_stop','timer_finished']) {
|
|
h.clear();await h.context.syncActiveVmixGameCountdown(h.game,h.main,name);
|
|
assert.deepEqual(h.functions(),['SuspendCountdown']);
|
|
}
|
|
for(const [name,detail] of [['timer_resume',{}],['timer_start',{wasStartedOnce:true}]]) {
|
|
h.clear();await h.context.syncActiveVmixGameCountdown(h.game,h.main,name,detail);
|
|
assert.deepEqual(h.functions(),['StartCountdown']);
|
|
}
|
|
h.clear();await h.context.syncActiveVmixGameCountdown(h.game,h.main,'timer_restart');
|
|
assert.deepEqual(h.functions(),['SetCountdown','StartCountdown']);
|
|
};
|
|
cases.no_tick_transport = async()=>{
|
|
const h=runtime();h.state.activeHockeyVmixTimerSteps.add(h.step.id);
|
|
h.main.running=true;h.main.lastTimestamp=1000;
|
|
h.main.lastWholeSecond=1200;
|
|
for(let second=1;second<=60;second++) h.context.updateSingleTimer(h.game,h.main,1000+1000*second);
|
|
assert.equal(h.main.currentMs,1140000,'web countdown still advances');
|
|
assert.equal(h.events.filter(e=>e.event==='timer_tick').length,60,'UI receives every second');
|
|
assert.deepEqual(h.functions(),[],'native vMix clock receives no per-second packets');
|
|
assert.equal(await h.context.syncActiveVmixGameCountdown(h.game,h.main,'timer_tick'),false);
|
|
};
|
|
cases.web_first = async()=>{
|
|
const h=runtime();
|
|
const promise=h.context.runShortcutSequenceStep(h.sequence,h.step);
|
|
assert.equal(h.main.running,true,'web state changes before caller awaits');
|
|
assert.ok(h.order.indexOf('event:timer_start')<h.order.indexOf('transport'));
|
|
const result=await promise;assert.equal(result.ok,true);
|
|
assert.deepEqual(h.functions(),['SetCountdown','StartCountdown']);
|
|
h.clear();await h.context.runShortcutSequenceStep(h.sequence,h.step);
|
|
assert.equal(h.main.running,false);assert.deepEqual(h.functions(),['SuspendCountdown']);
|
|
assert.ok(h.order.indexOf('event:timer_pause')<h.order.indexOf('transport'));
|
|
};
|
|
cases.shortcut_resume = async()=>{
|
|
const h=runtime();h.step.sync_vmix_penalties=true;h.step.start_web_penalties=true;
|
|
h.board.penalties.push({id:'p1',side:'home',durationMs:120000,remainingMs:120000,running:false,startedOnce:false});
|
|
await h.context.runShortcutSequenceStep(h.sequence,h.step);
|
|
assert.deepEqual(h.functions(),['SetCountdown','StartCountdown','SetCountdown','StopCountdown','StartCountdown']);
|
|
h.clear();await h.context.runShortcutSequenceStep(h.sequence,h.step);
|
|
assert.deepEqual(h.functions(),['SuspendCountdown','SuspendCountdown']);
|
|
h.clear();h.main.currentMs=1182000;h.board.penalties[0].remainingMs=102000;
|
|
await h.context.runShortcutSequenceStep(h.sequence,h.step);
|
|
assert.deepEqual(h.functions(),['StartCountdown','StartCountdown']);
|
|
assert.ok(h.sent.flat().every(c=>!('Value'in c)),'resume cannot reseed from delayed web values');
|
|
};
|
|
cases.period_base = async()=>{
|
|
const h=runtime();
|
|
for(const [minutes,expected] of [[20,'00:20:00'],[5,'00:05:00'],[20,'00:20:00']]) {
|
|
h.clear();h.main.currentMs=47000;h.main.startedOnce=true;h.main.running=true;
|
|
h.context.hockeyApplyTimerRules({timer_rules:{minutes}});
|
|
h.context.controlTimer(h.game.action_id,'reset');
|
|
assert.equal(h.main.currentMs,minutes*60000);assert.equal(h.main.startedOnce,false);
|
|
assert.deepEqual(h.functions(),['SetCountdown','StopCountdown']);
|
|
h.clear();await h.context.runShortcutSequenceStep(h.sequence,h.step);
|
|
assert.deepEqual(h.functions(),['SetCountdown','StartCountdown']);assert.equal(h.sent[0][0].Value,expected);
|
|
}
|
|
};
|
|
cases.scoreboard_seed = async()=>{
|
|
const h=runtime();let sent=false;let release;
|
|
h.context.sendRuntimeVmixTimerSequence=commands=>{sent=true;h.sent.push(commands);return new Promise(r=>{release=r;});};
|
|
const pending=h.context.syncConfiguredScoreboardCountdownsToRuntime();
|
|
assert.equal(sent,true);assert.deepEqual(h.functions(),['SetCountdown','StopCountdown']);
|
|
let finished=false;pending.then(()=>{finished=true;});await Promise.resolve();assert.equal(finished,false);
|
|
release({ok:true});await pending;assert.equal(finished,true);
|
|
h.clear();h.main.running=true;
|
|
await h.context.syncConfiguredScoreboardCountdownsToRuntime();assert.deepEqual(h.functions(),[],'showing scoreboard cannot disturb running native clock');
|
|
};
|
|
cases.prepared_penalty = async()=>{
|
|
const h=runtime();h.step.sync_vmix_penalties=true;h.state.activeHockeyVmixTimerSteps.add(h.step.id);
|
|
const penalty={id:'p1',side:'home',durationMs:120000,remainingMs:120000,running:false,startedOnce:false};h.board.penalties.push(penalty);
|
|
h.state.data.hockey={selected_game:{external_id:'game-a'},
|
|
game_control:{game_id:'game-a',flags:{scoreboard_auxiliaries_enabled:true}}};
|
|
h.state.config.shortcut_sequences.push({id:'scoreboard',enabled:true,is_scoreboard_sequence:true,
|
|
steps:[{type:'vmix_command',enabled:true,function:'OverlayInput1In',input:'Upper score',condition:'always'}]});
|
|
h.state.vmixOverlayRuntime.set('1',{input:'Upper score'}); // Actual upper-score ACK/tally before auxiliary IN.
|
|
await h.context.rebalanceVmixPenaltyTargets({scoreboardActive:true});
|
|
assert.deepEqual(h.functions(),['SetCountdown','StopCountdown','OverlayInput2In']);
|
|
assert.equal(penalty.startedOnce,false);assert.equal(penalty.running,false);
|
|
h.clear();h.context.controlHockeyPenalty(h.boardComponent,penalty.id,'start');
|
|
assert.equal(penalty.startedOnce,true);assert.deepEqual(h.functions(),['SetCountdown','StopCountdown','StartCountdown']);
|
|
};
|
|
cases.penalty_pause = async()=>{
|
|
const h=runtime();h.step.sync_vmix_penalties=true;h.state.activeHockeyVmixTimerSteps.add(h.step.id);
|
|
const penalty={id:'p1',side:'home',durationMs:120000,remainingMs:120000,running:false,startedOnce:false};h.board.penalties.push(penalty);
|
|
h.context.controlHockeyPenalty(h.boardComponent,'p1','start');h.clear();
|
|
penalty.remainingMs=89000;h.context.controlHockeyPenalty(h.boardComponent,'p1','pause');
|
|
assert.deepEqual(h.functions(),['SuspendCountdown']);
|
|
h.clear();h.context.controlHockeyPenalty(h.boardComponent,'p1','start');
|
|
assert.deepEqual(h.functions(),['StartCountdown']);
|
|
assert.ok(h.sent.flat().every(c=>!('Value'in c)));
|
|
};
|
|
cases.penalty_edit_reset = async()=>{
|
|
const h=runtime();h.step.sync_vmix_penalties=true;h.state.activeHockeyVmixTimerSteps.add(h.step.id);
|
|
const penalty={id:'p1',side:'home',durationMs:120000,remainingMs:120000,running:false,startedOnce:false};h.board.penalties.push(penalty);
|
|
h.context.controlHockeyPenalty(h.boardComponent,'p1','start');h.clear();
|
|
h.context.controlHockeyPenalty(h.boardComponent,'p1','set_time','01:11');
|
|
assert.deepEqual(h.functions(),['SetCountdown','StopCountdown','StartCountdown']);assert.equal(h.sent[0][0].Value,'00:01:11');
|
|
h.clear();h.context.controlHockeyPenalty(h.boardComponent,'p1','reset');
|
|
assert.deepEqual(h.functions(),['SetCountdown','StopCountdown']);assert.equal(penalty.remainingMs,120000);assert.equal(penalty.running,false);
|
|
};
|
|
cases.no_legacy_text_packets = async()=>{
|
|
const h=runtime();h.step.game_vmix_mode='text';h.step.penalty_vmix_mode='text';
|
|
await h.context.runShortcutSequenceStep(h.sequence,h.step);
|
|
assert.deepEqual(h.functions(),['SetCountdown','StartCountdown']);
|
|
assert.equal(h.state.vmixTimerMirrors.size,0);assert.equal(h.state.vmixPenaltyMirrors.size,0);
|
|
h.clear();h.context.emitTimerEvent(h.game,'timer_tick',h.main);assert.deepEqual(h.functions(),[]);
|
|
};
|
|
cases.target_scope = async()=>{
|
|
const h=runtime();
|
|
h.sequence.steps.push({...h.step,id:'same-target'});
|
|
h.sequence.steps.push({...h.step,id:'disabled-target',enabled:false,game_vmix_input:'Wrong'});
|
|
h.sequence.steps.push({...h.step,id:'other-timer',game_timer_action_id:'other',game_vmix_input:'Other'});
|
|
await h.context.syncActiveVmixGameCountdown(h.game,h.main,'timer_set_time');
|
|
assert.equal(h.sent.flat().length,2);assert.ok(h.sent.flat().every(c=>c.Input==='Score'&&c.SelectedName==='Clock.Text'));
|
|
h.clear();h.step.game_vmix_selected_name='';h.sequence.steps=[h.step];
|
|
assert.equal(await h.context.syncActiveVmixGameCountdown(h.game,h.main,'timer_set_time'),false);assert.deepEqual(h.functions(),[]);
|
|
};
|
|
cases.busy_timer = async()=>{
|
|
const h=runtime(['shortcutSequenceTimerControlSteps','runShortcutTimerControlsWhileBusy']);
|
|
h.main.running=true;h.main.startedOnce=true;
|
|
h.sequence.steps.push({id:'title-step',enabled:true,type:'vmix_command',function:'Cut'});
|
|
assert.equal(h.context.runShortcutTimerControlsWhileBusy(h.sequence,{queued:true}),true);
|
|
assert.equal(h.main.running,false,'busy title sequence cannot delay the next Space pause');
|
|
assert.deepEqual(h.functions(),['SuspendCountdown']);
|
|
assert.equal(h.context.shortcutSequenceTimerControlSteps(h.sequence).length,1,'non-timer steps cannot run twice');
|
|
};
|
|
cases.penalty_priority = async()=>{
|
|
const h=runtime(['hockeyPenaltyHasStarted','activeHockeyPenaltyEntries','sortedPenaltyEntries',
|
|
'penaltyLocalAdvantageSide','penaltyDisplayEntriesByTargetSide']);
|
|
h.board.penalties.push(
|
|
{id:'paused',side:'home',durationMs:120000,remainingMs:20000,running:false,startedOnce:true},
|
|
{id:'running',side:'home',durationMs:120000,remainingMs:80000,running:true,startedOnce:true},
|
|
{id:'prepared',side:'home',durationMs:120000,remainingMs:120000,running:false,startedOnce:false});
|
|
assert.deepEqual(Array.from(h.context.sortedPenaltyEntries('home'),entry=>entry.event.id),['running','paused']);
|
|
const display=h.context.penaltyDisplayEntriesByTargetSide(h.step);
|
|
assert.equal(display.transitionEntry.event.id,'running');assert.equal(display.away.length,1);assert.equal(display.home.length,0);
|
|
h.board.penalties[1].running=false;
|
|
assert.equal(h.context.sortedPenaltyEntries('home')[0].event.id,'paused');
|
|
};
|
|
cases.prepared_emission = async()=>{
|
|
const h=runtime(['createHockeyPenaltyDraft','emitHockeyEventUpdated']);h.step.sync_vmix_penalties=true;
|
|
const event=h.context.createHockeyPenaltyDraft(h.boardComponent);
|
|
assert.equal(event.startedOnce,false);assert.equal(event.running,false);assert.equal(event.durationMs,0);
|
|
assert.equal(event.readyPending,undefined);assert.deepEqual(h.functions(),[]);
|
|
event.durationMs=event.remainingMs=120000;event.side='home';event.infraction={id:'minor'};event.preset='2';
|
|
h.context.emitHockeyEventUpdated(h.boardComponent,event,'preset');
|
|
assert.equal(event.readyPending,true);assert.equal(event.assignedPending,true);
|
|
assert.equal(event.startedOnce,false);assert.equal(event.running,false);
|
|
assert.equal(h.state.activeHockeyVmixTimerSteps.has(h.step.id),true);
|
|
assert.ok(!h.events.some(e=>e.event==='penalty_ready'||e.event==='penalty_assigned'));
|
|
assert.deepEqual(h.functions(),[],'ready triggers and plate wait for saved authoritative strength');
|
|
};
|
|
cases.strength_plate_cycle = async()=>{
|
|
const h=runtime(['hockeyPenaltyHasStarted','activeHockeyPenaltyEntries','sortedPenaltyEntries',
|
|
'penaltyLocalAdvantageSide','penaltyDisplayEntriesByTargetSide','rememberPenaltyAdvantagePlan']);
|
|
const entry=(id,side,remaining=120000)=>({id,side,durationMs:120000,remainingMs:remaining,running:false,startedOnce:false});
|
|
h.board.penalties.push(entry('h1','home'));let display=h.context.penaltyDisplayEntriesByTargetSide(h.step);
|
|
assert.equal(display.advantageSide,'away');assert.equal(display.away.length,1,'ready, not started penalty already owns a plate');
|
|
h.context.rememberPenaltyAdvantagePlan(display);assert.equal(h.state.hockeyPenaltyAdvantageCycle.hadAdvantage,true);
|
|
h.board.penalties.push(entry('a1','away'));
|
|
display=h.context.penaltyDisplayEntriesByTargetSide(h.step);
|
|
assert.equal(display.holdingEqualStrength,true);assert.equal(display.away.length,1);assert.equal(display.home.length,0);
|
|
h.state.hockeyPenaltyAdvantageCycle={hadAdvantage:false,lastAdvantageSide:''};
|
|
display=h.context.penaltyDisplayEntriesByTargetSide(h.step);
|
|
assert.equal(display.holdingEqualStrength,false);assert.equal(display.home.length+display.away.length,0);
|
|
};
|
|
cases.full_strength_waits_ready = async()=>{
|
|
for(const method of ['manual','tick'])for(const ready of [true,false]){
|
|
const h=runtime(['updateHockeyPenaltyBoards']);const completed=[];
|
|
h.context.fireConfiguredTimerFinishActions=(_source,detail)=>completed.push(detail);
|
|
h.state.hockeyPenaltyAdvantageCycle={hadAdvantage:true,lastAdvantageSide:'away'};
|
|
h.board.penalties.push({id:'ending',side:'home',durationMs:120000,remainingMs:100,running:true,startedOnce:true,lastTimestamp:1000},
|
|
{id:'waiting',side:'home',durationMs:ready?120000:0,remainingMs:ready?120000:0,running:false,startedOnce:false,ready});
|
|
if(method==='manual')assert.equal(h.context.controlHockeyPenalty(h.boardComponent,'ending','finish'),true);
|
|
else h.context.updateHockeyPenaltyBoards(1200);
|
|
for(let turn=0;turn<5;turn++)await Promise.resolve();
|
|
assert.equal(completed.length,1,method);
|
|
assert.equal(completed[0].remaining_total,ready?1:0,`${method}: complete prepared penalty counts; incomplete draft does not`);
|
|
assert.equal(h.state.hockeyPenaltyAdvantageCycle.hadAdvantage,ready,method);
|
|
}
|
|
};
|
|
(async()=>{const scenario=process.argv[2];assert.ok(cases[scenario],`unknown timer scenario ${scenario}`);await cases[scenario]();console.log(`PASS: ${scenario}`);})().catch(error=>{console.error(error);process.exitCode=1;});
|