Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++
8.5 KB
Raw Blame
import test from 'node:test';
import assert from 'node:assert/strict';
import { readFile } from 'node:fs/promises';
import { build } from 'esbuild';
import { KNOWN_KEYS, checkAndParseRunConfig, checkRunConfig, describeIssues, nearestKey } from '../server/run-config-check.mjs';
import { NATIVE_FIELDS } from '../server/native-settings.mjs';
import { openTextFile, textEditorCommand } from '../server/open-text-file.mjs';

const good = `{
  "exe": "/opt/strata/strata",
  "args": ["--native", "/m/a.gguf", "--max-context", "65536"],
  "env": {"STRATA_PCIE_FRAC_DEFAULT": "old"},
  "sampling": {"temperature": 0.7, "repeat_penalty": 1.1},
  "parallel": 2,
  "aliases": "chat, coding",
  "gpu": [0, 1],
  "layer_split": "16,32",
  "port": 8080
}`;

test('a normal run config has no issues', () => {
  assert.deepEqual(checkRunConfig(good), { ok: true, issues: [] });
  assert.deepEqual(checkRunConfig('\uFEFF{}'), { ok: true, issues: [] }, 'Notepad’s byte-order mark is fine');
});

test('the checked configuration is parsed from the same captured text', () => {
  const text = '\uFEFF{"parallel":2,"args":["--ple-io","mmap"]}';
  const checked = checkAndParseRunConfig(text);
  assert.deepEqual(checked, {
    ok: true,
    issues: [],
    config: { parallel: 2, args: ['--ple-io', 'mmap'] },
  });
  const refused = checkAndParseRunConfig('{"parallel":99}');
  assert.equal(refused.ok, false);
  assert.equal(refused.config, null);
  assert.equal(refused.issues[0].code, 'whole-range');
});

test('every key the app edits is a known key', () => {
  for (const field of NATIVE_FIELDS) assert.ok(KNOWN_KEYS.has(field.id), field.id);
});

test('broken JSON is reported with its line, in plain words', () => {
  const text = '{\n  "args": ["--ple-io" "mmap"],\n  "port": 8080\n}';
  const result = checkRunConfig(text);
  assert.equal(result.ok, false);
  assert.equal(result.issues[0].code, 'json');
  assert.equal(result.issues[0].level, 'error');
  assert.equal(result.issues[0].line, 2);
  assert.match(describeIssues(result.issues)[0], /^Line 2: The settings file is not valid JSON; look near line 2\. Check for a missing comma/);
  assert.equal(checkRunConfig('[1,2]').issues[0].code, 'not-object');
  assert.equal(checkRunConfig('').ok, false);
});

test('an unknown key is a warning with the nearest real name, and does not hold the start back', () => {
  const result = checkRunConfig('{\n  "paralel": 2,\n  "idle_unload_secs": 5,\n  "totally_made_up_thing": 1\n}');
  assert.equal(result.ok, true);
  assert.deepEqual(result.issues.map(i => [i.level, i.code, i.key, i.params.near, i.line]), [
    ['warning', 'unknown-key-near', 'paralel', 'parallel', 2],
    ['warning', 'unknown-key-near', 'idle_unload_secs', 'idle_unload_s', 3],
    ['warning', 'unknown-key', 'totally_made_up_thing', '', 4]]);
  assert.match(result.issues[0].message, /"paralel" is not a setting Strata reads, so it is ignored\. Did you mean "parallel"\?/);
  assert.equal(nearestKey('Lazy-Load'), 'lazy_load');
  assert.equal(nearestKey('zzzzzzzz'), null);
});

test('a bad value is an error that names the key, the line, what is allowed and what was found', () => {
  const text = '{\n  "parallel": 12,\n  "lazy_load": "yes",\n  "anthropic_thinking": "sometimes",\n  "idle_unload_s": 1.5,\n  "port": 70000,\n  "args": ["--ple-io", 4],\n  "env": {"PATH": "/x", "STRATA_Y": 2},\n  "sampling": {"temperature": -1, "top_k": 0.5, "banana": 3},\n  "gpu": "first",\n  "layer_split": "32,16",\n  "reasoning_effort": "max"\n}';
  const result = checkRunConfig(text);
  assert.equal(result.ok, false);
  const by = key => result.issues.filter(i => i.key === key);
  assert.deepEqual(by('parallel').map(i => [i.code, i.line, i.params.min, i.params.max, i.params.value]), [['whole-range', 2, 1, 8, '12']]);
  assert.equal(by('lazy_load')[0].code, 'bool');
  assert.deepEqual([by('anthropic_thinking')[0].code, by('anthropic_thinking')[0].params.choices], ['choice', 'model, on_request']);
  assert.equal(by('idle_unload_s')[0].code, 'whole-range');
  assert.equal(by('port')[0].code, 'number-range');
  assert.equal(by('args')[0].code, 'args-type');
  assert.deepEqual(by('env').map(i => i.code), ['env-value'], 'names other than STRATA_ (PATH) are kept, only a non-text value is wrong');
  assert.deepEqual(by('sampling').map(i => [i.code, i.params.key]), [['number-range', 'sampling.temperature'], ['whole-range', 'sampling.top_k'], ['unknown-key', 'sampling.banana']]);
  assert.equal(by('gpu')[0].code, 'gpu');
  assert.equal(by('layer_split')[0].code, 'layer-split');
  assert.equal(by('reasoning_effort')[0].code, 'choice');
  assert.ok(result.issues.filter(i => i.level === 'error').every(i => i.message.length > 20));
});

test('null and empty values mean "use the default" and are never an error', () => {
  assert.deepEqual(checkRunConfig('{"parallel": null, "lazy_load": null, "reasoning_budget_tokens": ""}'), { ok: true, issues: [] });
});

test('--host, --port and --api-key in args are a warning, not a refusal', () => {
  const r = checkRunConfig('{"args": ["--port", "9"]}');
  assert.equal(r.ok, true);
  assert.equal(r.issues[0].code, 'args-managed');
});

test('the text editor: Notepad on Windows, text mode on a Mac, the system text-file program on Linux', async () => {
  assert.deepEqual(await textEditorCommand('C:\\s\\strata-q.json', { platform: 'win32' }), ['notepad.exe', ['C:\\s\\strata-q.json']]);
  assert.deepEqual(await textEditorCommand('/s/strata-q.json', { platform: 'darwin' }), ['open', ['-t', '/s/strata-q.json']]);
  const ask = async (command, args) => command === 'xdg-mime' ? 'org.gnome.gedit.desktop\n' : args[1] === 'command -v gtk-launch' ? '/usr/bin/gtk-launch\n' : '';
  assert.deepEqual(await textEditorCommand('/s/strata-q.json', { platform: 'linux', ask }), ['/usr/bin/gtk-launch', ['org.gnome.gedit.desktop', '/s/strata-q.json']]);
  const noEditor = async () => '';
  const seen = [];
  await openTextFile('/s/strata-q.json', { platform: 'linux', ask: noEditor, recorder: seen });
  assert.deepEqual(seen, [['xdg-open', '/s/strata-q.json']], 'with no text editor known the file’s own program opens it');
});

test('every issue sentence exists in all nine languages and keeps its slots', async () => {
  const languages = ['en', 'zh', 'ja', 'de', 'es', 'ru', 'pt', 'ko', 'fr'];
  const compiled = await build({ stdin: { contents: "export * from './src/lib/run-config-issues'; export * from './src/lib/i18n';", resolveDir: process.cwd() }, bundle: true, write: false, platform: 'node', format: 'esm' });
  const { issueText, setTranslationLanguage } = await import(`data:text/javascript;base64,${Buffer.from(compiled.outputFiles[0].text).toString('base64')}`);
  const samples = [
    { code: 'json', line: 3, params: { line: 3 } }, { code: 'json', line: null, params: { line: 0 } }, { code: 'not-object', params: {} },
    { code: 'unknown-key-near', params: { key: 'paralel', near: 'parallel' } }, { code: 'unknown-key', params: { key: 'zzz' } },
    { code: 'args-type', params: {} }, { code: 'args-managed', params: {} }, { code: 'env-type', params: {} },
    { code: 'env-value', params: { name: 'STRATA_X' } }, { code: 'sampling-type', params: {} }, { code: 'bool', params: { key: 'lazy_load', value: '"yes"' } },
    { code: 'number-range', params: { key: 'port', min: 1, max: 65535, value: '0' } }, { code: 'whole-range', params: { key: 'parallel', min: 1, max: 8, value: '12' } },
    { code: 'choice', params: { key: 'gpu_order', choices: 'auto, as_given', value: '"x"' } }, { code: 'text', params: { key: 'aliases' } },
    { code: 'layer-split', params: {} }, { code: 'gpu', params: {} },
  ].map(s => ({ level: 'error', key: 'k', message: 'ENGLISH FALLBACK', line: s.line === undefined ? 5 : s.line, ...s }));
  const english = {};
  setTranslationLanguage('en');
  for (const s of samples) english[`${s.code}:${s.line}`] = issueText(s);
  for (const s of samples) assert.notEqual(english[`${s.code}:${s.line}`], 'ENGLISH FALLBACK', s.code);
  for (const language of languages.filter(l => l !== 'en')) {
    setTranslationLanguage(language);
    for (const s of samples) {
      const text = issueText(s);
      assert.notEqual(text, english[`${s.code}:${s.line}`], `${language}:${s.code} is not translated`);
      assert.ok(!/\{\d+\}/.test(text), `${language}:${s.code} left a slot`);
    }
  }
  setTranslationLanguage('en');
});

test('the notes the app itself writes into the file (ui_resource_baseline, ui_vision_device, ...) are not reported', () => {
  assert.deepEqual(checkRunConfig('{"ui_resource_baseline": {"parallel": 2}, "ui_vision_device": "cpu", "ui_resource_profile": "work"}'), { ok: true, issues: [] });
});