Luigit
repositories / Unfugwart

Unfugwart

Discord caretaker for Abteilung Unfug

owned by admin

test/lifecycle.test.js

Raw
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' });
});