import test from 'node:test'; import assert from 'node:assert/strict'; import { Lifecycle } from '../lifecycle.js'; function fixture() { const calls = []; const timers = new Map(); let nextTimer = 1; const api = { async status() { calls.push('status'); return false; }, async start() { calls.push('start'); }, async stop() { calls.push('stop'); }, }; const control = new Lifecycle({ serverId: 'game', api, delayMs: 10, setTimer: fn => (timers.set(nextTimer, fn), nextTimer++), clearTimer: id => timers.delete(id), log: { error() {} }, }); return { calls, control, timers, fire: id => { const callback = timers.get(id); timers.delete(id); callback?.(); } }; } function deferred() { let resolve; const promise = new Promise(done => { resolve = done; }); return { promise, resolve }; } test('first human join starts stopped server', async () => { const { calls, control } = fixture(); await control.reconcile({ known: true, humans: 1 }); assert.deepEqual(calls, ['status', 'start']); }); test('empty channel delays then gracefully stops running server', async () => { const { calls, control, fire } = fixture(); control.api.status = async () => (calls.push('status'), true); await control.reconcile({ known: true, humans: 0 }); assert.deepEqual(calls, []); fire(1); await control.chain; assert.deepEqual(calls, ['status', 'stop']); }); test('repeated empty reconciliation preserves its grace timer', async () => { const { control, timers } = fixture(); control.reconcile({ known: true, humans: 0 }); control.reconcile({ known: true, humans: 0 }); assert.deepEqual([...timers.keys()], [1]); }); test('reconnect invalidates then resume begins a fresh grace period', () => { const { control, timers } = fixture(); control.reconcile({ known: true, humans: 0 }); control.reconcile({ known: false, humans: 0 }); control.reconcile({ known: true, humans: 0 }); assert.deepEqual([...timers.keys()], [2]); }); test('join during deferred stop status prevents stop', async () => { const { calls, control, fire } = fixture(); const status = deferred(); control.api.status = async () => (calls.push('status'), status.promise); control.reconcile({ known: true, humans: 0 }); fire(1); await Promise.resolve(); control.reconcile({ known: true, humans: 1 }); status.resolve(true); await control.chain; assert.deepEqual(calls, ['status', 'status']); }); test('close during deferred stop status prevents stop', async () => { const { calls, control, fire } = fixture(); const status = deferred(); control.api.status = async () => (calls.push('status'), status.promise); control.reconcile({ known: true, humans: 0 }); fire(1); await Promise.resolve(); control.close(); status.resolve(true); await control.chain; assert.deepEqual(calls, ['status']); }); test('join then leave during pending status invalidates old action and starts full new delay', async () => { const { calls, control, timers } = fixture(); const status = deferred(); control.api.status = async () => (calls.push('status'), status.promise); control.reconcile({ known: true, humans: 1 }); await Promise.resolve(); control.reconcile({ known: true, humans: 0 }); status.resolve(false); await control.chain; assert.deepEqual(calls, ['status']); assert.deepEqual([...timers.keys()], [1]); }); test('rapid join and leave cancels old timer before queued work drains', async () => { const { calls, control, timers, fire } = fixture(); control.api.status = async () => (calls.push('status'), true); control.reconcile({ known: true, humans: 0 }); control.reconcile({ known: true, humans: 1 }); control.reconcile({ known: true, humans: 0 }); fire(1); fire(2); await control.chain; assert.deepEqual([...timers.keys()], []); assert.deepEqual(calls, ['status', 'stop']); }); test('manual start and confirmed stop share serial API actions', async () => { const { calls, control } = fixture(); control.api.status = async () => (calls.push('status'), calls.filter(call => call === 'status').length === 1 ? false : true); await control.manualStart(); await control.confirmedStop(); assert.deepEqual(calls, ['status', 'start', 'status', 'stop']); }); test('keep-awake caps hold, blocks empty auto-stop, then resumes empty grace', async () => { const { calls, control, timers } = fixture(); control.api.status = async () => (calls.push('status'), false); await control.keepAwake(99_999_999); assert.ok(control.holdUntil - Date.now() <= 3_600_000); control.reconcile({ known: true, humans: 0 }); assert.equal(timers.size, 1); assert.deepEqual(calls, ['status', 'start']); }); test('voice reconciliation does not invalidate an active hold lease', async () => { const { control, timers, fire } = fixture(); await control.keepAwake(10); control.reconcile({ known: true, humans: 1 }); control.reconcile({ known: true, humans: 0 }); assert.ok(timers.has(1)); fire(1); assert.equal(control.holdUntil, null); }); test('mappings have independent serial lifecycles', async () => { const a = fixture(); const b = fixture(); b.control.api.status = async () => (b.calls.push('status'), true); await Promise.all([a.control.reconcile({ known: true, humans: 1 }), b.control.reconcile({ known: true, humans: 0 })]); b.fire(1); await b.control.chain; assert.deepEqual(a.calls, ['status', 'start']); assert.deepEqual(b.calls, ['status', 'stop']); }); test('manual start while empty arms a finite empty grace', async () => { const { control, timers } = fixture(); control.reconcile({ known: true, humans: 0 }); await control.manualStart(); assert.equal(timers.size, 1); assert.notEqual(control.state().deadlineAt, null); }); test('explicit stop cancels hold and blocks occupied voice restart until empty transition', async () => { const { calls, control, timers } = fixture(); control.api.status = async () => (calls.push('status'), true); await control.keepAwake(100); await control.confirmedStop(); assert.equal(control.holdUntil, null); control.reconcile({ known: true, humans: 1 }); await control.chain; assert.deepEqual(calls, ['status', 'status', 'stop']); control.reconcile({ known: true, humans: 0 }); control.reconcile({ known: true, humans: 1 }); await control.chain; assert.deepEqual(calls, ['status', 'status', 'stop', 'status']); assert.equal(timers.size, 0); }); test('telemetry completion clears startup only on ready and verified offline completes stop', async () => { const { control } = fixture(); await control.manualStart(); assert.notEqual(control.startupUntil, null); control.observeTelemetry({ status: 'running', phase: 'process-running' }); assert.notEqual(control.startupUntil, null); control.observeTelemetry({ status: 'running', phase: 'ready' }); assert.equal(control.startupUntil, null); control.api.status = async () => true; await control.confirmedStop(); control.observeTelemetry({ status: 'starting', phase: 'not-ready' }); assert.equal(control.stopping, true); control.observeTelemetry({ status: 'offline', phase: 'offline' }); assert.equal(control.stopping, false); }); test('cancelled start returns a result and callback failures return failure without poisoning retry', async () => { let fail = true; const { control } = fixture(); control.onBeforeStart = async () => { if (fail) throw new Error('baseline'); }; assert.deepEqual(await control.manualStart(), { status: 'failure' }); fail = false; assert.deepEqual(await control.manualStart(), { status: 'success' }); control.onStart = async () => { throw new Error('post-dispatch'); }; assert.deepEqual(await control.manualStart(), { status: 'failure' }); control.onStart = () => {}; assert.deepEqual(await control.manualStart(), { status: 'success' }); const stopped = fixture().control; stopped.close(); assert.deepEqual(await stopped.manualStart(), { status: 'cancelled' }); });