import assert from 'node:assert/strict'; import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, utimesSync, writeFileSync } from 'node:fs'; import { createServer } from 'node:net'; import { tmpdir } from 'node:os'; import { dirname, join } from 'node:path'; import test from 'node:test'; import { runInNewContext } from 'node:vm'; import { allSuites, assertCleanLog, assertFixtureLog, assertHumanLabels, assertNiriLog, assertPlainLabels, assertPureService, assertSafeCapture, captureUiFailure, childEnvironment, finishUiRun, lastWrite, pruneEvidence, treeBytes, qtTextInputWorkaround, replayRequest, stopChild } from './ui-test.mjs'; import { assertSubscription, nativeFeatures } from './test-fixtures/ui/niri-integration.mjs'; import { barOverlayFixtures } from './test-fixtures/ui/bar.mjs'; import { featureDoubles, featureSuites, registryEntries, rootEntry } from './test-fixtures/sources.js'; import { runIsolated, spawnIsolated } from './test-fixtures/isolation.js'; test('QTBUG-146211 workaround is removed as soon as installed Qt changes', () => { const installed = runIsolated('/usr/lib/qt6/bin/qtpaths6', ['--qt-query', 'QT_VERSION'], { encoding: 'utf8' }); assert.equal(installed.status, 0, installed.stderr); assert.equal(installed.stdout.trim(), qtTextInputWorkaround.brokenQt, 'Qt changed: remove the QTBUG-146211 workaround (git grep QTBUG-146211), then rerun just ui-test'); }); test('QTBUG-146211 workaround accepts only the reproduced child diagnostics and counts raw records', () => { const disable = ' WARN qt.qpa.wayland.textinput: virtual void QtWaylandClient::QWaylandTextInputv3::disableSurface(wl_surface*) Trying to disable 0xabc123 but 0x0 is focused'; const enable = ' WARN qt.qpa.wayland.textinput: virtual void QtWaylandClient::QWaylandTextInputv3::enableSurface(wl_surface*) Trying to enable 0xabc123 but 0xdef456 has focus'; const native = disable.replace(' WARN', 'warning'); const stale = disable.replace('0x0 is focused', '0xdef456 is focused'); const log = `INFO: loaded\n${disable}\n${native}\n${enable}\n${stale}\n`; assert.equal(assertFixtureLog(log), 4); assert(log.includes(disable), 'raw evidence must not be rewritten'); for (const warning of [disable, enable]) { assert.throws(() => assertCleanLog(warning), 'non-fixture gates remain strict'); for (const unexpected of [ warning.replace('WARN', 'ERROR'), warning.replace('textinput:', 'other:'), warning + ' extra diagnostic', `${warning}\nERROR genuine failure` ]) assert.throws(() => assertFixtureLog(unexpected)); } for (const unexpected of [ 'WARN unrelated Qt warning', disable.replace('but 0x0 is focused', 'but 0xdef is enabled'), enable.replace('has focus', 'is already enabled') ]) assert.throws(() => assertFixtureLog(unexpected)); }); test('the label guard fails a suite on any machine identifier a person can see', () => { const human = { chips: { clipboard: { label: 'clips', badge: '', title: 'clipboard', accessibleName: 'clipboard', tooltip: '' } }, barControls: { clock: { label: '12:30', tooltip: 'calendar' } }, features: { clipboard: { texts: ['image', 'text · 2m', 'report.pdf', 'pasting into wezterm'], controls: { 'image': { text: '' }, 'copy selected item': { text: '' } }, items: { searchField: { text: '' } }, // Service state is data, not a label; the guard never reads it. service: { rows: ['/tmp/pi-clipboard-23965d8a-47d6-45ce-9d1a-f83c6b805220.png'] }, focusOverlay: null, }, noko: { texts: [], controls: {}, items: {}, focusOverlay: { texts: ['listening'], controls: {}, items: {} } }, }, }; assertHumanLabels(human); const leak = '/tmp/pi-clipboard-23965d8a-47d6-45ce-9d1a-f83c6b805220.png'; for (const [where, place] of [ ['visible text', state => state.features.clipboard.texts.push(leak)], ['control name', state => { state.features.clipboard.controls[leak] = { text: '' }; }], ['control text', state => { state.features.clipboard.controls.image.text = `select ${leak}`; }], ['item text', state => { state.features.clipboard.items.searchField.text = 'org.mpris.MediaPlayer2.firefox.instance_1234'; }], ['focus overlay text', state => state.features.noko.focusOverlay.texts.push('alsa_input.pci-0000_00_1f.3.analog-stereo')], ['chip tooltip', state => { state.chips.clipboard.tooltip = 'file:///run/user/1000/x.png'; }], ['chip accessible name', state => { state.chips.clipboard.accessibleName = 'org.kde.StatusNotifierItem-1234-1'; }], ['bar control label', state => { state.barControls.clock.label = '23965d8a-47d6-45ce-9d1a-f83c6b805220'; }], ]) { const state = structuredClone(human); place(state); assert.throws(() => assertHumanLabels(state), /machine identifiers in rendered labels/, where); } }); test('the narration guard fails a suite on a line about what the interface cannot do', () => { // Lines Nuguland shows today: states, next steps, consequences, short reasons. const plain = () => ({ chips: { media: { label: 'media', badge: '', title: 'media', accessibleName: 'media', tooltip: 'media' } }, barControls: { clock: { label: '12:30', tooltip: 'calendar' } }, features: { media: { texts: ['fixture track', 'playing', 'nothing playing', 'play media in an app to control it here'], controls: { 'previous track': { text: '', tooltipText: 'no previous track' }, pause: { text: '', tooltipText: 'pause' } }, items: { transportActions: { text: '', tooltipText: '' } }, userTexts: ['fixture track'], focusOverlay: null, }, brightness: { texts: ['light sensor unavailable', 'this display does not accept brightness changes; check its cable and the monitor menu'], controls: { adaptive: { text: 'adaptive', tooltipText: 'light sensor unavailable' } }, items: {}, userTexts: [], focusOverlay: null, }, notifications: { // A body an app wrote is data, whatever it says. texts: ['clear 2 notifications?', 'this cannot be undone', 'shuffle and repeat not supported by this phone', 'reply'], controls: { reply: { text: 'reply', tooltipText: 'reply' } }, items: {}, userTexts: ['shuffle and repeat not supported by this phone'], focusOverlay: null, }, clipboard: { texts: ['this file cannot be opened', 'text · 2m', 'nothing copied yet'], controls: { 'select this file cannot be opened': { text: '', tooltipText: '' } }, items: {}, userTexts: ['this file cannot be opened'], focusOverlay: null, }, system: { texts: ['repair prompt unavailable or invalid', 'camera and microphone in use', 'crash history unavailable · journal unreadable'], controls: {}, items: { vaultField: { text: 'unsupported', tooltipText: '' } }, userTexts: [], focusOverlay: null, }, }, }); assertPlainLabels(plain()); const owner = 'shuffle, previous track, next track and repeat not supported by this player'; for (const [where, place] of [ ['the owner example as a line', state => state.features.media.texts.push(owner)], ['a player that cannot be controlled', state => state.features.media.texts.push('this player cannot be controlled')], ['one control', state => state.features.media.texts.push('previous track not supported by this player')], ['a capability list without the phrase', state => state.features.media.texts.push('shuffle and repeat unavailable')], ['a disabled tooltip', state => { state.features.media.controls['previous track'].tooltipText = 'previous track unavailable for this player'; }], ['a control name', state => { state.features.brightness.controls['adaptive (this display cannot be adjusted)'] = { text: '' }; }], ['an explained disabled state', state => { state.features.brightness.controls.adaptive.tooltipText = 'disabled because monitor control is missing'; }], ['a chip tooltip', state => { state.chips.media.tooltip = "this player doesn't support seeking"; }], ['a focus overlay', state => { state.features.media.focusOverlay = { texts: ['only supports play'], controls: {}, items: {}, userTexts: [] }; }], ['narration around written text', state => state.features.media.texts.push('fixture track cannot be controlled')], ['written text without its userText mark', state => { state.features.notifications.userTexts = []; }], ]) { const state = plain(); place(state); assert.throws(() => assertPlainLabels(state), /labels narrate the interface/, where); } }); test('fixture entries at the shell root rewrite every root-relative import', () => { assert.equal(rootEntry('import QtQuick\nimport "../.." as N\nimport "../../features/audio" as AudioFeature\nimport "../../Util.js" as Util\n', 2), 'import QtQuick\nimport "." as N\nimport "./features/audio" as AudioFeature\nimport "./Util.js" as Util\n'); assert.equal(rootEntry('import "../../.." as N\nimport "../../../features/audio" as AudioFeature\n', 3), 'import "." as N\nimport "./features/audio" as AudioFeature\n'); assert.throws(() => rootEntry('import QtQuick\n', 2), /must import the shell root/); assert.throws(() => rootEntry('import "../../.." as N\n', 2), /must import the shell root/); }); test('evidence that vanishes during a concurrent prune is skipped, not an error', () => { const missing = join(tmpdir(), `nuguland-ui-test-vanished-${process.pid}`); assert.equal(lastWrite(missing), null); assert.equal(treeBytes(missing), 0); const file = join(mkdtempSync(join(tmpdir(), 'nuguland-prune-file-')), 'run'); writeFileSync(file, ''); assert.throws(() => lastWrite(file), error => error.code === 'ENOTDIR', 'other errors still fail'); rmSync(dirname(file), { recursive: true }); }); test('evidence pruning keeps the newest runs per fixture and spares recent and foreign directories', () => { const root = mkdtempSync(join(tmpdir(), 'nuguland-prune-test-')); try { const now = Date.now(); const run = (name, fixture, minutesAgo) => { const path = join(root, name); mkdirSync(path); if (fixture) writeFileSync(join(path, 'replay.json'), JSON.stringify({ fixture })); writeFileSync(join(path, 'runner.log'), 'log'); const time = new Date(now - minutesAgo * 60_000); for (const file of readdirSync(path)) utimesSync(join(path, file), time, time); utimesSync(path, time, time); }; for (const minutes of [1, 2, 3, 4]) run(`nuguland-ui-test-recent${minutes}`, 'all', minutes); run('nuguland-ui-test-old', 'all', 60); run('nuguland-ui-test-bar', 'bar', 300); run('nuguland-ui-test-unnamed', null, 500); run('nuguland-ui-test-corrupt', null, 600); writeFileSync(join(root, 'nuguland-ui-test-corrupt', 'replay.json'), '{'); run('foreign-dir', 'all', 999); const removed = pruneEvidence(root, { keep: 3, quietMs: 15 * 60_000, now }); assert.deepEqual(removed.map(entry => entry.path), [join(root, 'nuguland-ui-test-old')]); assert(removed[0].bytes > 0); assert.deepEqual(readdirSync(root).sort(), ['foreign-dir', 'nuguland-ui-test-bar', 'nuguland-ui-test-corrupt', 'nuguland-ui-test-recent1', 'nuguland-ui-test-recent2', 'nuguland-ui-test-recent3', 'nuguland-ui-test-recent4', 'nuguland-ui-test-unnamed']); } finally { rmSync(root, { recursive: true, force: true }); } }); test('named replay defaults to all and rejects invalid selections before execution', () => { assert.deepEqual(replayRequest([]), { version: 1, fixture: 'all', command: 'just ui-test all' }); for (const fixture of ['all', 'controls', 'popups', 'privilege', 'niri', 'bar', 'qt-focus', 'qt-focus-editor', ...featureSuites()]) { assert.deepEqual(replayRequest([fixture]), { version: 1, fixture, command: `just ui-test ${fixture}` }); } for (const args of [[''], ['unknown'], ['../controls'], ['all', 'noko'], ['--help']]) { assert.throws(() => replayRequest(args), /usage: just ui-test/); } }); test('Bar geometry and service overlays remain explicit and isolated', () => { for (const size of ['1366x768', '2560x1440']) assert.deepEqual(replayRequest(['bar', size]), { version: 1, fixture: 'bar', size, command: `just ui-test bar ${size}` }); for (const args of [['bar', '0x0'], ['bar', '../host'], ['all', '1366x768'], ['bar', '1366x768', 'extra']]) assert.throws(() => replayRequest(args)); assert.equal(new Set(barOverlayFixtures.map(row => row.target)).size, barOverlayFixtures.length); for (const { source, target } of barOverlayFixtures) { assert.match(source, /^(?:test-fixtures\/ui\/fixture-services\/(?:bar|lifecycle)\/|features\/[a-z-]+\/fixtures\/services\/)\w+\.qml$/); assert.match(target, /^\w+\.qml$/); assertPureService(readFileSync(source, 'utf8')); } const source = readFileSync('test-fixtures/ui/bar.qml', 'utf8'); assert.match(source, /N\.Bar\s*\{/); // Registry controls never serialize editable text, only whether it is filled // and whether a password editor masks it. assert.match(source, /"text": editable \? "" : text,/); assert.match(source, /"masked": item\.echoMode === TextInput\.Password,/); assert.match(source, /&& !root\.editableItem\(item\)\) \{\n\s*state\.texts\.push\(item\.text\);\n(?:\s*\/\/.*\n)*\s*if \(item\.userText === true\)\n\s*state\.userTexts\.push\(item\.text\);/); }); test('subscription termination requires an exact native command and direct QML parent', () => { const command = '/usr/bin/niri\0msg\0--json\0event-stream\0'; assert.doesNotThrow(() => assertSubscription(42, 30, 'Name:\tniri\nPPid:\t30\n', command)); for (const pid of [0, 1, -1, null, '42', 42.5]) { assert.throws(() => assertSubscription(pid, 30, 'PPid:\t30\n', command)); } for (const [parent, status, args] of [ [1, 'PPid:\t1\n', command], [30, 'PPid:\t99\n', command], [30, 'Name:\tniri\n', command], [30, 'PPid:\t30\n', '/usr/bin/niri\0'], [30, 'PPid:\t30\n', '/other/niri\0msg\0--json\0event-stream\0'], [30, 'PPid:\t30\n', command.replace('event-stream', 'outputs')], [30, 'PPid:\t30\n', command + 'extra\0'] ]) assert.throws(() => assertSubscription(42, parent, status, args)); }); test('niri fixture drives the real Bar/Niri route', () => { const fixture = readFileSync('test-fixtures/ui/niri-integration.qml', 'utf8'); for (const type of ['Bar', 'Niri']) assert(fixture.includes(`N.${type} {`)); assert.match(fixture, /function fixtureOutputs\(enabled: bool\)/); const runner = readFileSync('ui-test.mjs', 'utf8'); assert.match(runner, /const integration = replay.fixture === 'niri'/); assert.match(runner, /await runNiriIntegration\(/); // Native features keep production services only in the integration fixture. assert.match(runner, /featureDoubles\('\/project', null, integration \? nativeFeatures : \[\]\)/); const registry = readFileSync('Registry.qml', 'utf8'); const binding = /\n N\.Registry \{\n([\s\S]*?)\n \}\n/.exec(fixture)[1]; for (const name of nativeFeatures) { assert.match(registry, new RegExp(`^\\s*name: "${name}"$`, 'm'), `${name} is a registry feature`); const doubles = featureDoubles(undefined, name); assert(doubles.length > 0, `${name} has a double that other fixtures use`); assert.deepEqual(featureDoubles(undefined, name, nativeFeatures), [], `${name} keeps production in integration`); // The fixture binds every registry input the production service is given. const service = new RegExp(`\\n readonly property \\w+\\.\\w+ ${name}: \\w+\\.\\w+ \\{\\n([\\s\\S]*?)\\n \\}\\n`).exec(registry)[1]; const inputs = [...registry.matchAll(/^ property [A-Z]\w* (\w+): null$/gm)].map(match => match[1]).filter(input => service.includes(`root.${input}`)); assert(inputs.length > 0, `${name} service inputs found`); for (const input of inputs) assert.match(binding, new RegExp(`^ ${input}: \\w+$`, 'm'), `niri fixture binds ${name} input ${input}`); } }); test('failure screenshots allow masked input but never revealed input or unknown auth state', () => { assert.doesNotThrow(() => assertSafeCapture({ auth: { visible: true, hasInput: true, inputMasked: true } })); assert.doesNotThrow(() => assertSafeCapture({ auth: { visible: true, hasInput: false, inputMasked: false } })); assert.throws(() => assertSafeCapture({ auth: { visible: true, hasInput: true, inputMasked: false } }), /unmasked input/); assert.throws(() => assertSafeCapture({ auth: { visible: true } }), /unmasked input/); assert.throws(() => assertSafeCapture(null), /snapshot unavailable/); }); test('failure evidence retains the original error, named phase and last safe snapshot', async () => { const calls = []; const snapshot = { auth: { visible: true, hasInput: true, inputMasked: true } }; const error = new Error('original assertion'); const record = await captureUiFailure(error, { evidence: '/evidence', fixture: 'privilege', phase: 'privilege', snapshot, screenshot: async name => { calls.push(name); return '/evidence/failure.png'; }, write: (path, text) => calls.push([path, JSON.parse(text)]) }); assert.equal(record.error, error.stack); assert.equal(record.fixture, 'privilege'); assert.equal(record.phase, 'privilege'); assert.deepEqual(record.snapshot, snapshot); assert.equal(record.screenshot, '/evidence/failure.png'); assert.deepEqual(record.captureErrors, []); assert.equal(calls[0], 'failure'); assert.deepEqual(calls[1], ['/evidence/failure.json', record]); const failedCapture = await captureUiFailure(error, { evidence: '/evidence', fixture: 'all', phase: 'controls', snapshot, screenshot: async () => { throw new Error('capture socket gone'); }, write: () => {} }); assert.equal(failedCapture.error, error.stack); assert.equal(failedCapture.screenshot, null); assert.match(failedCapture.captureErrors[0], /capture socket gone/); assert.deepEqual(failedCapture.snapshot, snapshot); }); test('runtime gate is captured before teardown; all children and complete logs are still checked', async () => { for (const original of [null, new Error('original interaction')]) { const calls = []; const diagnostic = new Error('WARN private login1'); await assert.rejects(finishUiRun(original, { children: ['weston', 'niri', 'fixture'], checkLogs: () => { calls.push('logs'); throw diagnostic; }, capture: async error => { calls.push(['capture', error]); }, stop: async child => { calls.push(['stop', child]); } }), error => error === (original || diagnostic)); assert.deepEqual(calls, ['logs', ['capture', original || diagnostic], ['stop', 'fixture'], ['stop', 'niri'], ['stop', 'weston'], 'logs']); } }); test('clean completion checks full logs on both sides of teardown without failure capture', async () => { const calls = []; const children = ['weston', 'niri']; await finishUiRun(null, { children, checkLogs: () => calls.push('logs'), capture: async () => assert.fail('unexpected failure capture'), stop: async child => calls.push(child) }); assert.deepEqual(calls, ['logs', 'niri', 'weston', 'logs']); assert.deepEqual(children, ['weston', 'niri']); }); test('capture and teardown errors cannot replace the original error or skip sibling cleanup', async () => { const original = new Error('original assertion'); const stopped = []; const secondary = []; await assert.rejects(finishUiRun(original, { children: ['weston', 'niri', 'fixture'], checkLogs: () => {}, capture: async () => { throw new Error('evidence unwritable'); }, stop: async child => { stopped.push(child); if (child === 'fixture') throw new Error('teardown error'); }, report: error => secondary.push(error.message) }), error => error === original); assert.deepEqual(stopped, ['fixture', 'niri', 'weston']); assert.deepEqual(secondary, ['evidence unwritable', 'teardown error']); }); test('diagnostics produced only during teardown still fail the run', async () => { const diagnostic = new Error('ERROR during shutdown'); let stopped = false; let captured; await assert.rejects(finishUiRun(null, { children: ['niri'], checkLogs: () => { if (stopped) throw diagnostic; }, capture: async error => { captured = error; }, stop: async () => { stopped = true; } }), error => error === diagnostic); assert.equal(captured, diagnostic); }); test('fixture snapshots serialize predicates, never editable contents', () => { const controls = readFileSync('ui-test.qml', 'utf8'); assert(!/query: root\.query|text: field\.text/.test(controls)); assert.match(controls, /queryMatchesInput: root\.query === field\.text/); const lifecycle = readFileSync('test-fixtures/ui/lifecycle.qml', 'utf8'); assert.match(lifecycle, /child\.echoMode === undefined/); assert.match(lifecycle, /hasInput: input \? input\.text\.length > 0 : false/); assert.match(lifecycle, /inputMasked: input \? input\.echoMode === TextInput\.Password : false/); }); test('snapshot predicates and visual-text selection redact hostile editable values', () => { const sentinel = 'fixture-only\"\\nhttps://private.invalid/account'; const controls = readFileSync('ui-test.qml', 'utf8'); const body = controls.match(/function snapshot\(\): string \{([\s\S]*?)\n \}/)[1]; const field = { text: sentinel, input: {} }; const state = JSON.parse(runInNewContext(`(function () { ${body} })()`, { root: { query: sentinel, rect: () => ({ x: 1, y: 2, width: 3, height: 4 }) }, field, window: {}, mute: {}, slider: { Accessible: {} }, surface: {}, actionCard: {}, nestedAction: {}, iconAction: { Accessible: {} }, disabledAction: {}, longAction: {}, iconField: { input: { text: sentinel } } })); assert.equal(state.queryMatchesInput, true); assert.equal(state.queryIsHeadphones, false); assert(!JSON.stringify(state).includes('fixture-only')); const lifecycle = readFileSync('test-fixtures/ui/lifecycle.qml', 'utf8'); const visibleText = lifecycle.match(/function visibleText\(item: var, window: var\): var \{([\s\S]*?)\n \}/)[1]; for (const echoMode of [0, 1, 2, 3]) { const rows = runInNewContext(`(function (item, window) { ${visibleText} })(null, null)`, { tree: () => [{ visible: true, font: {}, text: sentinel, echoMode }, { visible: true, font: {}, text: 'safe label' }], rect: () => ({ x: 1, y: 2, width: 3, height: 4 }) }); assert.equal(rows.length, 1); assert.equal(rows[0].text, 'safe label'); assert(!JSON.stringify(rows).includes('fixture-only')); } }); test('input targets must be real sockets inside the owned runtime', async () => { const runtime = mkdtempSync(join(tmpdir(), 'ui-boundary-')); const outside = mkdtempSync(join(tmpdir(), 'ui-parent-')); const servers = []; async function socket(path) { const server = createServer(); await new Promise((resolve, reject) => { server.once('error', reject); server.listen(path, resolve); }); servers.push(server); return path; } try { const display = await socket(join(runtime, 'wayland-1')); const ipc = await socket(join(runtime, 'niri.wayland-1.42.sock')); const parent = await socket(join(outside, 'wayland-0')); const weston = await socket(join(runtime, 'weston-headless')); const env = childEnvironment(runtime, display, ipc); assert.equal(env.WAYLAND_DISPLAY, display); assert.equal(env.NIRI_SOCKET, ipc); assert.equal(env.XDG_RUNTIME_DIR, runtime); assert.throws(() => childEnvironment(runtime, parent, ipc), /refusing non-child socket/); assert.throws(() => childEnvironment(runtime, weston, ipc), /regular expression/); const file = join(runtime, 'wayland-2'); writeFileSync(file, 'not a socket'); assert.throws(() => childEnvironment(runtime, file, ipc), /must be a socket/); assert.throws(() => childEnvironment(runtime, ipc, display), /regular expression/); } finally { for (const server of servers) await new Promise(resolve => server.close(resolve)); rmSync(runtime, { recursive: true }); rmSync(outside, { recursive: true }); } }); test('runtime diagnostics fail rather than being filtered or downgraded', () => { assert.doesNotThrow(() => assertCleanLog('INFO: Configuration Loaded\n')); for (const diagnostic of ['WARN: unresolved binding', 'WARNING: unresolved binding', 'warning: deprecated API', 'Could not bind', 'failed to load', 'ERROR: creation failed', 'ReferenceError: missing', 'TypeError: wrong value', 'binding loop detected', 'Error parsing file']) { assert.throws(() => assertCleanLog(diagnostic)); } }); const niriRecord = (level, source, message) => `2026-09-06T14:51:45.642004Z ${level} ${source}: ${message}\n`; const softwareFallback = niriRecord('DEBUG', 'niri::backend::winit', 'failed building default dmabuf feedback, falling back to v3: error getting EGL device render node\n\nCaused by:\n None of the following EGL extensions is supported by the underlying EGL implementation, at least one is required: ["EGL_EXT_device_drm"]'); const nativeWriteWarning = niriRecord('WARN', 'niri::niri', 'error saving screenshot image: Os { code: 2, kind: NotFound, message: "No such file or directory" }'); test('only the exact Niri software fallback at DEBUG is a sandbox diagnostic exception', () => { assert.deepEqual(assertNiriLog(''), { softwareFallbacks: 0 }); assert.deepEqual(assertNiriLog(softwareFallback), { softwareFallbacks: 1 }); assert.deepEqual(assertNiriLog(softwareFallback.replace('DEBUG', '\x1b[34mDEBUG\x1b[0m')), { softwareFallbacks: 1 }); for (const invalid of [ softwareFallback.replace('DEBUG', 'WARN'), softwareFallback.replace('DEBUG', 'ERROR'), softwareFallback.replace('niri::backend::winit', 'niri::renderer'), softwareFallback.replace('EGL_EXT_device_drm', 'EGL_other_extension'), softwareFallback.replace('falling back to v3', 'aborting'), softwareFallback + softwareFallback, softwareFallback + 'WARN: unrelated\n', niriRecord('DEBUG', 'niri::backend::winit', 'failed to initialize renderer'), niriRecord('WARN', 'niri::dbus::freedesktop_login1', 'service absent'), niriRecord('WARN', 'niri::dbus::freedesktop_locale1', 'service absent'), nativeWriteWarning ]) assert.throws(() => assertNiriLog(invalid)); // Production/default log checking has no exceptions. assert.throws(() => assertCleanLog(softwareFallback)); assert.throws(() => assertCleanLog(nativeWriteWarning)); }); test('native diagnostic exceptions apply only to the child compositor and fixtures precede its launch', () => { const runner = readFileSync('ui-test.mjs', 'utf8'); assert.match(runner, /log === join\(evidence, 'niri.log'\)\) diagnostics = assertNiriLog\(text\)/); assert.match(runner, /else assertCleanLog\(text\)/); assert(runner.indexOf("await waitFor('private login/locale fixtures'") < runner.indexOf("const compositor = start('niri'")); assert.match(runner, /Niri consumed private login\/locale properties/); const fixture = readFileSync('test-fixtures/ui/session-bus.c', 'utf8'); assert.match(fixture, /sd_bus_set_address\(bus, address\)/); assert.match(fixture, /strcmp\(address, getenv\("DBUS_SYSTEM_BUS_ADDRESS"\)\)/); assert(!/SD_BUS_METHOD|SD_BUS_WRITABLE_PROPERTY|sd_bus_open_system/.test(fixture), 'fixture exports no mutation or implicit system bus access'); }); test('overlay service doubles are pure QtQuick Item state/functions without privileged APIs', () => { for (const name of ['Privilege', 'Niri']) { assertPureService(readFileSync(`test-fixtures/ui/fixture-services/lifecycle/${name}.qml`, 'utf8')); } const doubles = featureDoubles(); assert(doubles.some(({ target }) => target === 'features/audio/Audio.qml'), 'audio double replaces the feature service'); for (const { source, target } of doubles) { assert.notEqual(source, target); assertPureService(readFileSync(source, 'utf8')); } for (const body of ['Process {}', 'FileView {}', 'PolkitAgent {}', 'PamContext {}', 'WorkerScript {}', 'function bad() { Qt.openUrlExternally("test"); }', 'function bad() { new XMLHttpRequest(); }', 'function bad() { fetch("test"); }', 'function bad() { eval("test"); }', 'function bad() { Quickshell.execDetached([]); }']) { assert.throws(() => assertPureService(`import QtQuick\nItem { ${body} }`)); } assert.throws(() => assertPureService('import QtQuick\nimport Quickshell.Io\nItem {}')); assert.throws(() => assertPureService('import "../../"\nItem {}')); }); test('fixture replacement reaps only its own process, including an uncooperative child', { timeout: 8000 }, async () => { const sibling = spawnIsolated(process.execPath, ['-e', 'setInterval(() => {}, 1000)']); try { for (const ignoreTerm of [false, true]) { const child = spawnIsolated(process.execPath, ['-e', `${ignoreTerm ? 'process.on("SIGTERM", () => {});' : ''} console.log("ready"); setInterval(() => {}, 1000);`]); try { await new Promise(resolve => child.stdout.once('data', resolve)); await stopChild(child); assert.equal(child.signalCode, ignoreTerm ? 'SIGKILL' : 'SIGTERM'); assert.equal(sibling.exitCode, null); assert.equal(sibling.signalCode, null); await stopChild(child); } finally { await stopChild(child); } } } finally { await stopChild(sibling); } }); test('an unsuccessful spawn has nothing to reap', async () => { const child = spawnIsolated('/nonexistent-nuguland-fixture-command'); await new Promise(resolve => child.once('error', resolve)); await stopChild(child); }); test('invalid invocation and unsandboxed internal invocation fail before launching a compositor', () => { for (const args of [['unexpected'], ['--inside'], ['controls', 'noko'], ['--inside', 'invalid']]) { const result = runIsolated(process.execPath, ['ui-test.mjs', ...args], { encoding: 'utf8', timeout: 5000 }); assert.equal(result.status, 1); assert.match(result.stderr, args.length === 1 && args[0] === '--inside' ? /internal mode requires sandbox/ : /usage: just ui-test/); assert(!result.stdout.includes('evidence:')); } }); test('named selections reach the sandbox and its original failure evidence is never overwritten', () => { const dir = mkdtempSync(join(tmpdir(), 'ui-replay-')); try { writeFileSync(join(dir, 'bwrap'), `#!${process.execPath} const fs = require('node:fs'); const args = process.argv.slice(2); const evidence = args[args.indexOf('/evidence') - 1]; fs.writeFileSync(evidence + '/failure.json', JSON.stringify({ error: 'original inner assertion', fixture: args.at(-1) })); process.exit(7); `, { mode: 0o755 }); for (const fixture of ['controls', 'popups', 'privilege', 'niri', 'bar', 'qt-focus', 'qt-focus-editor', ...featureSuites()]) { const result = runIsolated(process.execPath, ['ui-test.mjs', fixture], { env: { PATH: dir, TMPDIR: dir }, encoding: 'utf8', timeout: 5000 }); const evidence = result.stdout.match(/^evidence: (.+)$/m)?.[1]; assert(evidence, result.stderr); try { assert.equal(result.status, 1); assert.deepEqual(JSON.parse(readFileSync(join(evidence, 'failure.json'), 'utf8')), { error: 'original inner assertion', fixture }); assert.deepEqual(JSON.parse(readFileSync(join(evidence, 'replay.json'), 'utf8')), { ...replayRequest([fixture]), phase: 'startup' }); const { command } = JSON.parse(readFileSync(join(evidence, 'command.json'), 'utf8')); assert.deepEqual(command.slice(-2), ['--inside', fixture]); assert(!existsSync(command[command.indexOf('/run/user/1000') - 1])); } finally { rmSync(evidence, { recursive: true }); } } } finally { rmSync(dir, { recursive: true }); } }); function fakeSuiteSandbox(dir, body) { writeFileSync(join(dir, 'bwrap'), `#!${process.execPath} const fs = require('node:fs'); const args = process.argv.slice(2); const evidence = args[args.indexOf('/evidence') - 1]; const fixture = args.at(-1); ${body} `, { mode: 0o755 }); } function suiteLines(stdout) { return Object.fromEntries([...stdout.matchAll(/^(pass|FAIL) suite (\S+) \([\d.]+s\): (.*)(?:\n evidence: (.+))?$/gm)] .map(([, status, fixture, detail, failed]) => [fixture, { status, detail, evidence: status === 'pass' ? detail : failed }])); } function assertSuiteSandbox(fixture, evidence) { const { command } = JSON.parse(readFileSync(join(evidence, 'command.json'), 'utf8')); assert.deepEqual(command.slice(-2), ['--inside', fixture]); assert.equal(JSON.parse(readFileSync(join(evidence, 'replay.json'), 'utf8')).fixture, fixture); assert(!existsSync(command[command.indexOf('/run/user/1000') - 1]), `${fixture}: runtime leaked`); } test('every registry entry names an existing load target and a suite that all runs', () => { const registry = readFileSync('Registry.qml', 'utf8'); const names = [...registry.matchAll(/^\s*FeatureEntry \{\s*name: "([a-z][a-z0-9-]*)"/gm)].map(match => match[1]); // Registry entries and feature directories with suites match one to one; no list to edit. assert(names.length > 0); assert.deepEqual([...names].sort(), featureSuites()); assert.doesNotMatch(registry, /uiSuite:|loadTarget:/, 'proof locations follow the feature name'); // Host inputs may be null in fixtures, so production must bind every one. const inputs = [...registry.matchAll(/^ property [A-Z]\w* (\w+): null$/gm)].map(match => match[1]); const composition = /\n Registry \{\n([\s\S]*?)\n \}\n/.exec(readFileSync('shell.qml', 'utf8'))[1]; for (const input of inputs) assert.match(composition, new RegExp(`^ ${input}: \\w+$`, 'm'), `shell.qml binds registry input ${input}`); const kinds = [...registry.matchAll(/^\s*kind: "([a-z]+)"/gm)].map(match => match[1]); for (const kind of kinds) assert(['popup', 'overlay', 'toggle'].includes(kind), `kind ${kind} has a host`); for (const [kind, host] of [['popups', 'SurfaceManager.qml'], ['popup(', 'PopupHost.qml'], ['overlays', 'OverlayHost.qml'], ['focusOverlays', 'OverlayHost.qml'], ['toggle(', 'Bar.qml']]) assert(readFileSync(host, 'utf8').includes(`registry.${kind}`), `${host} reads registry ${kind}`); // Popup and overlay entries render a panel; a toggle entry is only a chip. for (const entry of registryEntries()) assert.equal(entry.panel, entry.kind !== 'toggle', `${entry.name} panel matches kind ${entry.kind}`); // Hosts read entries, never a registry feature's name; the legacy catalog is gone. for (const host of ['Bar.qml', 'PopupHost.qml', 'SurfaceManager.qml', 'OverlayHost.qml']) { const source = readFileSync(host, 'utf8'); for (const name of names) assert(!source.includes(`"${name}"`), `${host} names registry feature ${name}`); } // The bar chip renders every entry's emphasis fields; the noko suite proves them in pixels. const bar = readFileSync('Bar.qml', 'utf8'); for (const field of ['barLabel', 'barTitle', 'barIcon', 'barBadge', 'barActive', 'barStrong', 'barRole', 'barBusy']) assert(bar.includes(`feature.${field}`), `Bar reads FeatureEntry.${field}`); for (const name of names) { assert(existsSync(`features/${name}/fixtures/load.qml`), `${name} load target`); assert(existsSync(`features/${name}/fixtures/suite.mjs`), `${name} suite`); assert(allSuites.includes(name), `${name} suite runs in all`); assert.deepEqual(replayRequest([name]).fixture, name); } }); test('a feature production proof is a default-exported function beside its suite', async () => { const runner = readFileSync('ui-test.mjs', 'utf8'); assert.match(runner, /const \{ default: proof \} = await import\(`\/project\/features\/\$\{replay\.fixture\}\/fixtures\/production\.mjs`\)/); let proofs = 0; for (const name of featureSuites()) { const path = `features/${name}/fixtures/production.mjs`; if (!existsSync(path)) continue; const { default: proof } = await import(`./${path}`); assert.equal(typeof proof, 'function', `${name} production proof`); proofs++; } assert(proofs > 0, 'the system suite keeps its production proof'); }); test('all runs every suite in its own sandbox and leads failures with the suite record', () => { // qt-focus suites are upstream Qt diagnostics. assert.deepEqual([...allSuites].sort(), ['controls', 'shell', 'niri', 'popups', 'privilege', 'bar', ...featureSuites()].sort()); const dir = mkdtempSync(join(tmpdir(), 'ui-all-')); try { fakeSuiteSandbox(dir, `if (fixture === 'noko') { fs.writeFileSync(evidence + '/failure.json', JSON.stringify({ error: 'AssertionError: noko check label\\n at stack' })); process.exit(7); }`); const result = runIsolated(process.execPath, ['ui-test.mjs', 'all'], { env: { PATH: dir, TMPDIR: dir }, encoding: 'utf8', timeout: 10_000 }); assert.equal(result.status, 1, result.stderr); const suites = suiteLines(result.stdout); assert.deepEqual(Object.keys(suites).sort(), [...allSuites].sort(), result.stdout); for (const fixture of allSuites) { assert.equal(suites[fixture].status, fixture === 'noko' ? 'FAIL' : 'pass'); assertSuiteSandbox(fixture, suites[fixture].evidence); } assert.equal(suites.noko.detail, 'AssertionError: noko check label'); assert.match(result.stdout, new RegExp(`^all: ${allSuites.length - 1}/${allSuites.length} suites passed in [\\d.]+s$`, 'm')); assert.match(result.stderr, /failed suites: noko/); } finally { rmSync(dir, { recursive: true }); } }); test('all bounds compositor admission; interruption cleans active suites and never launches queued suites', { timeout: 15_000 }, async () => { const dir = mkdtempSync(join(tmpdir(), 'ui-all-interrupt-')); try { fakeSuiteSandbox(dir, `fs.writeFileSync(${JSON.stringify(dir)} + '/ready-' + fixture, ''); process.on('SIGTERM', () => process.exit(0)); setInterval(() => {}, 1000);`); const child = spawnIsolated(process.execPath, ['ui-test.mjs', 'all'], { env: { PATH: dir, TMPDIR: dir }, stdio: ['ignore', 'pipe', 'pipe'] }); let stdout = ''; let stderr = ''; child.stdout.on('data', data => { stdout += data; }); child.stderr.on('data', data => { stderr += data; }); while (readdirSync(dir).filter(name => name.startsWith('ready-')).length < 2) await new Promise(resolve => setTimeout(resolve, 20)); child.kill('SIGINT'); assert.equal(await new Promise(resolve => child.once('close', resolve)), 1); // One shared signal dispatcher, not one listener pair per sandbox. assert.doesNotMatch(stderr, /MaxListenersExceededWarning/); const suites = suiteLines(stdout); for (const fixture of allSuites) { assert.equal(suites[fixture]?.status, 'FAIL', stdout); assert.match(suites[fixture].detail, /interrupted/); if (allSuites.indexOf(fixture) < 2) assertSuiteSandbox(fixture, suites[fixture].evidence); else { assert.match(suites[fixture].detail, /queued suite not run/); assert.equal(suites[fixture].evidence, 'none'); } } assert.equal(readdirSync(dir).filter(name => name.startsWith('ready-')).length, 2, 'no admission after interruption'); } finally { rmSync(dir, { recursive: true }); } }); test('sandbox failure, spawn error, and interruption remove the owned runtime and fail', { timeout: 10_000 }, async () => { const dir = mkdtempSync(join(tmpdir(), 'ui-lifecycle-')); try { for (const mode of ['failure', 'interrupt', 'stubborn', 'missing']) { const executable = join(dir, 'bwrap'); if (mode === 'missing') rmSync(executable); else writeFileSync(executable, `#!${process.execPath}\n${mode === 'failure' ? 'process.exit(7)' : `process.on("SIGTERM", () => { ${mode === 'stubborn' ? '' : 'process.exit(0)'} }); console.log("sandbox-ready"); setInterval(() => {}, 1000)`}\n`, { mode: 0o755 }); const child = spawnIsolated(process.execPath, ['ui-test.mjs', 'controls'], { env: { PATH: dir, TMPDIR: dir }, stdio: ['ignore', 'pipe', 'pipe'] }); let stdout = ''; let stderr = ''; child.stdout.on('data', data => { stdout += data; if (['interrupt', 'stubborn'].includes(mode) && stdout.includes('sandbox-ready')) child.kill('SIGINT'); }); child.stderr.on('data', data => { stderr += data; }); const code = await new Promise((resolve, reject) => { child.once('error', reject); child.once('close', resolve); }); const evidence = stdout.match(/^evidence: (.+)$/m)?.[1]; assert(evidence, `${mode}: no evidence directory`); try { assert.equal(code, 1, `${mode}: ${stderr}`); const failure = JSON.parse(readFileSync(join(evidence, 'failure.json'), 'utf8')); assert.equal(failure.fixture, 'controls'); assert.equal(failure.phase, 'startup'); assert.equal(failure.snapshot, null); assert.equal(failure.screenshot, null); assert.match(failure.captureErrors[0], /sandbox unavailable/); assert.match(failure.error, mode === 'missing' ? /ENOENT/ : ['interrupt', 'stubborn'].includes(mode) ? /interrupted/ : /nested UI test failed/); const replay = JSON.parse(readFileSync(join(evidence, 'replay.json'), 'utf8')); assert.deepEqual(replay, { ...replayRequest(['controls']), phase: 'startup' }); const { command } = JSON.parse(readFileSync(join(evidence, 'command.json'), 'utf8')); assert.deepEqual(command.slice(-2), ['--inside', 'controls']); const runtime = command[command.indexOf('/run/user/1000') - 1]; assert(runtime.startsWith(join(dir, 'nuguland-ui-runtime-'))); assert(!existsSync(runtime), `${mode}: runtime leaked`); assert(!command.includes('WAYLAND_DISPLAY'), `${mode}: inherited display configuration`); assert(!command.includes('/run/parent-display'), `${mode}: exposed host compositor`); if (['interrupt', 'stubborn'].includes(mode)) assert.match(stderr, /interrupted/); } finally { rmSync(evidence, { recursive: true }); } } } finally { rmSync(dir, { recursive: true }); } });