repositories / Unfugwart
Unfugwart
Discord caretaker for Abteilung Unfug
owned by admin
test/lifecycle.test.js
Rawimport 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' });
});