Luigit
repositories / Unfugwart

Unfugwart

Discord caretaker for Abteilung Unfug

owned by admin

test/game-profiles.test.js

Raw
import test from 'node:test';
import assert from 'node:assert/strict';
import { Telemetry, PollController, GAME_TYPES } from '../telemetry.js';
import { Lifecycle } from '../lifecycle.js';
import { validateConfig } from '../config.js';
import { controlsBlocked, emojiPalette, renderStatus } from '../ui.js';
import { DiscordUi } from '../discord-ui.js';

const logs = Buffer.from('Game server connected\nWorld save (2/5) done\nConnections 2 ZDOS: 55\n');

test('generic is the default and ignores Valheim log patterns; adapter state is per server', () => {
  const generic = new Telemetry();
  const valheim = new Telemetry({ game: 'valheim' });
  generic.reset({ status: 'running' });
  valheim.reset({ status: 'running' });
  generic.feed(logs, 10);
  valheim.feed(logs, 10);
  assert.equal(generic.snapshot().phase, 'process-running');
  assert.equal(generic.snapshot().readiness, false);
  assert.equal(generic.snapshot().players, null);
  assert.equal(valheim.snapshot().phase, 'saving');
  assert.equal(valheim.snapshot().readiness, true);
  assert.equal(valheim.snapshot().players, 2);
  valheim.reset();
  assert.equal(generic.snapshot().status, 'running');
  assert.deepEqual(GAME_TYPES, ['generic', 'valheim']);
});

test('generic polling and startup never require console access or claim game readiness', async () => {
  const api = { status: async () => true, console: async () => assert.fail('generic must not read logs') };
  const poller = new PollController({ serverId: 'other', api });
  await poller.prepareStartup();
  poller.beginStartup();
  await poller.poll();
  assert.equal(poller.state().status, 'running');
  assert.equal(poller.state().phase, 'process-running');
  assert.equal(poller.state().game, 'generic');
  assert.equal(poller.state().readsConsole, false);
  assert.equal(poller.state().readiness, false);
  poller.close();
});

test('generic running controls remain usable while duplicate startup protection covers pre-execution gaps', async () => {
  let running = false;
  let starts = 0;
  let stops = 0;
  const api = { status: async () => running, console: async () => assert.fail('generic must not read logs'), start: async () => { starts++; running = true; return {}; }, stop: async () => { stops++; running = false; return {}; } };
  const poller = new PollController({ serverId: 'other', api, now: () => 10 });
  const control = new Lifecycle({ serverId: 'other', api, now: () => 10, setTimer: () => 1, clearTimer() {}, onBeforeStart: () => poller.prepareStartup(), onStart: () => poller.beginStartup(), onStop: () => poller.beginStop() });
  try {
    assert.equal((await control.manualStart()).status, 'success');
    await poller.poll();
    assert.equal(controlsBlocked(control.state(), poller.state(), 10), false);
    running = false;
    await poller.poll();
    assert.equal(poller.state().status, 'starting');
    await control.reconcile({ known: true, humans: 1 });
    assert.equal(starts, 1);
    running = true;
    await poller.poll();
    assert.equal((await control.keepAwake()).status, 'success');
    assert.equal(starts, 1);
    assert.equal((await control.confirmedStop()).status, 'success');
    await poller.poll();
    control.observeTelemetry(poller.state());
    assert.equal(poller.state().status, 'offline');
    assert.equal(control.state().stopping, false);
    assert.equal(stops, 1);
  } finally { control.close(); poller.close(); }
});

test('configuration selects adapters explicitly without inferring from ID or display name', () => {
  const config = { discordToken: 'test', panelUrl: 'https://panel.example', mappings: [{ guildId: '1', voiceChannelId: '2', serverId: 'valheim1', displayName: 'Valheim', oauthClientId: 'test', oauthClientSecret: 'test' }] };
  assert.equal(validateConfig(config).mappings[0].game, 'generic');
  assert.equal(validateConfig({ ...config, mappings: [{ ...config.mappings[0], game: 'valheim' }] }).mappings[0].game, 'valheim');
  assert.throws(() => validateConfig({ ...config, mappings: [{ ...config.mappings[0], game: '../plugin' }] }), /generic or valheim/);
  assert.throws(() => validateConfig({ ...config, mappings: [{ ...config.mappings[0], gameEmojiName: 'invalid name' }] }), /emoji name/);
});

test('generic presentation has no Valheim wording or automatic Valheim icon', () => {
  const pack = emojiPalette([{ id: '11', name: 'valheim' }, { id: '12', name: 'adventurer' }]);
  assert.equal(pack.adventurer.id, '12');
  const mapping = { serverId: 'minecraft1', displayName: 'Minecraft', panelUrl: 'https://panel.example' };
  for (const phase of ['running', 'ready', 'loading-world']) {
    const payload = renderStatus(mapping, { known: true, humans: 1 }, { status: 'running', phase, game: 'generic' }, 1, pack);
    assert.doesNotMatch(JSON.stringify(payload), /Valheim|valheim/);
  }
});

test('each mapping can choose its own app icon, with generic fallback when missing', () => {
  const ui = new DiscordUi({ client: {}, config: {}, entries: new Map() });
  ui.appEmojis = [{ id: '11', name: 'valheim' }, { id: '12', name: 'minecraft' }, { id: '13', name: 'adventurer' }];
  ui.emojis = emojiPalette(ui.appEmojis);
  assert.equal(ui.emojisFor({ mapping: { gameEmojiName: 'minecraft' } }).adventurer.id, '12');
  assert.equal(ui.emojisFor({ mapping: { gameEmojiName: 'valheim' } }).adventurer.id, '11');
  assert.equal(ui.emojisFor({ mapping: { gameEmojiName: 'missing' } }).adventurer.id, '13');
  assert.equal(ui.emojisFor({ mapping: {} }).adventurer.id, '13');
  ui.close();
});