SnowLuma/packages/common/tests/runtime.test.ts

import fs from 'node:fs';
import path from 'node:path';
import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { normalizeRuntimeConfig, resolveRuntimeEnvOverrides } from '../src/runtime';

describe('normalizeRuntimeConfig', () => {
  it('applies all defaults for an empty object', () => {
    expect(normalizeRuntimeConfig({})).toEqual({
      webuiPort: 5099,
      hookAutoLoad: false,
      webuiHost: '127.0.0.1',
      webuiTls: { enabled: false },
      trustProxy: '',
      logMaxTotalMb: 1024,
      logRetainDays: 7,
      logPerUin: false,
    });
  });

  it('passes through valid values', () => {
    expect(normalizeRuntimeConfig({
      webuiPort: 8080,
      hookAutoLoad: true,
      webuiHost: '127.0.0.1',
      webuiTls: { enabled: true },
      trustProxy: '1',
      logMaxTotalMb: 2048,
      logRetainDays: 0,
      logPerUin: true,
    })).toEqual({
      webuiPort: 8080,
      hookAutoLoad: true,
      webuiHost: '127.0.0.1',
      webuiTls: { enabled: true },
      trustProxy: '1',
      logMaxTotalMb: 2048,
      logRetainDays: 0,
      logPerUin: true,
    });
  });

  it('falls back on invalid types', () => {
    const out = normalizeRuntimeConfig({
      webuiPort: 0,            // out of range → default
      webuiHost: 123,          // non-string → default
      webuiTls: 'yes',         // non-object → default
      trustProxy: 5,           // non-string → default
    });
    expect(out.webuiPort).toBe(5099);
    expect(out.webuiHost).toBe('127.0.0.1');
    expect(out.webuiTls).toEqual({ enabled: false });
    expect(out.trustProxy).toBe('');
  });

  it('fails fast on invalid persisted log settings', () => {
    expect(() => normalizeRuntimeConfig({ logMaxTotalMb: 0 }))
      .toThrow(/logMaxTotalMb/);
    expect(() => normalizeRuntimeConfig({ logRetainDays: -1 }))
      .toThrow(/logRetainDays/);
    expect(() => normalizeRuntimeConfig({ logPerUin: 'maybe' }))
      .toThrow(/logPerUin/);
    expect(() => normalizeRuntimeConfig({ logPerUin: '' }))
      .toThrow(/logPerUin/);
    expect(() => normalizeRuntimeConfig({ logMaxTotalMb: Number.MAX_SAFE_INTEGER }))
      .toThrow(/logMaxTotalMb/);
    expect(() => normalizeRuntimeConfig({ logRetainDays: Number.MAX_SAFE_INTEGER }))
      .toThrow(/logRetainDays/);
  });

  it('coerces webuiTls.enabled loosely and trims a blank host to default', () => {
    expect(normalizeRuntimeConfig({ webuiTls: { enabled: 1 } }).webuiTls).toEqual({ enabled: true });
    expect(normalizeRuntimeConfig({ webuiHost: '   ' }).webuiHost).toBe('127.0.0.1');
  });

  it('rejects a non-object input back to full defaults', () => {
    expect(normalizeRuntimeConfig(null).webuiPort).toBe(5099);
    expect(normalizeRuntimeConfig('nope').webuiHost).toBe('127.0.0.1');
  });
});

describe('resolveRuntimeEnvOverrides', () => {
  it('returns empty when no SNOWLUMA_* vars are set', () => {
    expect(resolveRuntimeEnvOverrides({})).toEqual({});
  });

  it('parses port / host / trustProxy from env', () => {
    expect(resolveRuntimeEnvOverrides({
      SNOWLUMA_WEBUI_PORT: '6700',
      SNOWLUMA_WEBUI_HOST: '127.0.0.1',
      SNOWLUMA_WEBUI_TRUST_PROXY: '1',
    })).toEqual({ webuiPort: 6700, webuiHost: '127.0.0.1', trustProxy: '1' });
  });

  it('parses log storage overrides including retainDays=0', () => {
    expect(resolveRuntimeEnvOverrides({
      SNOWLUMA_LOG_MAX_TOTAL_MB: '4096',
      SNOWLUMA_LOG_RETAIN_DAYS: '0',
      SNOWLUMA_LOG_PER_UIN: '1',
    })).toEqual({
      logMaxTotalMb: 4096,
      logRetainDays: 0,
      logPerUin: true,
    });
  });

  it('fails fast on invalid log storage overrides', () => {
    expect(() => resolveRuntimeEnvOverrides({
      SNOWLUMA_LOG_MAX_TOTAL_MB: '0',
    })).toThrow(/SNOWLUMA_LOG_MAX_TOTAL_MB/);
    expect(() => resolveRuntimeEnvOverrides({
      SNOWLUMA_LOG_RETAIN_DAYS: '-1',
    })).toThrow(/SNOWLUMA_LOG_RETAIN_DAYS/);
    expect(() => resolveRuntimeEnvOverrides({
      SNOWLUMA_LOG_PER_UIN: 'maybe',
    })).toThrow(/SNOWLUMA_LOG_PER_UIN/);
  });

  it('fails fast when converted log storage overrides would be unsafe', () => {
    expect(() => resolveRuntimeEnvOverrides({
      SNOWLUMA_LOG_MAX_TOTAL_MB: String(Number.MAX_SAFE_INTEGER),
    })).toThrow(/SNOWLUMA_LOG_MAX_TOTAL_MB/);
    expect(() => resolveRuntimeEnvOverrides({
      SNOWLUMA_LOG_RETAIN_DAYS: String(Number.MAX_SAFE_INTEGER),
    })).toThrow(/SNOWLUMA_LOG_RETAIN_DAYS/);
  });

  it('parses SNOWLUMA_WEBUI_TLS over the saved switch', () => {
    expect(resolveRuntimeEnvOverrides({ SNOWLUMA_WEBUI_TLS: '1' })).toEqual({
      webuiTls: { enabled: true },
    });
    expect(resolveRuntimeEnvOverrides({ SNOWLUMA_WEBUI_TLS: '0' })).toEqual({
      webuiTls: { enabled: false },
    });
    expect(() => resolveRuntimeEnvOverrides({ SNOWLUMA_WEBUI_TLS: 'maybe' }))
      .toThrow(/SNOWLUMA_WEBUI_TLS/);
  });

  it('ignores an out-of-range / non-numeric port env', () => {
    expect(resolveRuntimeEnvOverrides({ SNOWLUMA_WEBUI_PORT: '0' })).toEqual({});
    expect(resolveRuntimeEnvOverrides({ SNOWLUMA_WEBUI_PORT: 'abc' })).toEqual({});
  });

  it('treats trustProxy="0"/"off" as a real override (not absent)', () => {
    expect(resolveRuntimeEnvOverrides({ SNOWLUMA_WEBUI_TRUST_PROXY: '0' })).toEqual({ trustProxy: '0' });
  });
});

describe('updateRuntimeConfig (fs)', () => {
  let prevCwd: string;
  let dir: string;
  let prevPortEnv: string | undefined;
  beforeEach(async () => {
    const fs = await import('fs'); const os = await import('os'); const path = await import('path');
    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sl-rt-'));
    prevCwd = process.cwd();
    process.chdir(dir);
    prevPortEnv = process.env.SNOWLUMA_WEBUI_PORT;
    delete process.env.SNOWLUMA_WEBUI_PORT;
  });
  afterEach(async () => {
    process.chdir(prevCwd);
    if (prevPortEnv === undefined) delete process.env.SNOWLUMA_WEBUI_PORT;
    else process.env.SNOWLUMA_WEBUI_PORT = prevPortEnv;
    fs.rmSync(dir, { recursive: true, force: true });
    vi.restoreAllMocks();
  });

  it('merges a patch over on-disk values and persists normalized', async () => {
    const { updateRuntimeConfig } = await import('../src/runtime');
    const fs = await import('fs'); const path = await import('path');
    const out = updateRuntimeConfig({ webuiHost: '127.0.0.1', webuiTls: { enabled: true } });
    expect(out.webuiHost).toBe('127.0.0.1');
    expect(out.webuiTls).toEqual({ enabled: true });
    const onDisk = JSON.parse(fs.readFileSync(path.join('config', 'runtime.json'), 'utf8'));
    expect(onDisk.webuiHost).toBe('127.0.0.1');
    expect(onDisk.webuiTls).toEqual({ enabled: true });
  });

  it('does NOT bake an env-overridden port into the persisted file', async () => {
    const { updateRuntimeConfig } = await import('../src/runtime');
    const fs = await import('fs'); const path = await import('path');
    process.env.SNOWLUMA_WEBUI_PORT = '9999';
    updateRuntimeConfig({ webuiHost: '127.0.0.1' });
    const onDisk = JSON.parse(fs.readFileSync(path.join('config', 'runtime.json'), 'utf8'));
    expect(onDisk.webuiPort).toBe(5099); // default on-disk, NOT the env 9999
  });

  it('keeps the previous runtime file intact when atomic replacement fails', async () => {
    const { updateRuntimeConfig } = await import('../src/runtime');
    updateRuntimeConfig({ logRetainDays: 7 });
    const runtimePath = path.join('config', 'runtime.json');
    const before = fs.readFileSync(runtimePath, 'utf8');
    vi.spyOn(fs, 'renameSync').mockImplementationOnce(() => {
      throw Object.assign(new Error('disk replacement failed'), { code: 'EIO' });
    });

    expect(() => updateRuntimeConfig({ logRetainDays: 0 }))
      .toThrow(/disk replacement failed/);
    expect(fs.readFileSync(runtimePath, 'utf8')).toBe(before);
    expect(fs.readdirSync('config').filter((name) => name.includes('.tmp-'))).toEqual([]);
  });
});