Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/features/brightness/brightness.test.js

Raw
// brightness.test.js — node test for the pure brightness module. Prints ALL PASS.
var assert = require('assert');
var B = require('./brightness.js');

// clampLevel: range + null/NaN safety
assert.strictEqual(B.clampLevel(-1), 0);
assert.strictEqual(B.clampLevel(2), 1);
assert.strictEqual(B.clampLevel(0.5), 0.5);
assert.strictEqual(B.clampLevel(null), 0);
assert.strictEqual(B.clampLevel(undefined), 0);
assert.strictEqual(B.clampLevel("0.3"), 0.3);

// levelPercent: rounded integer percent
assert.strictEqual(B.levelPercent(0), 0);
assert.strictEqual(B.levelPercent(0.5), 50);
assert.strictEqual(B.levelPercent(1), 100);
assert.strictEqual(B.levelPercent(2), 100);
assert.strictEqual(B.levelPercent(0.014), 1);

// levelRole: band boundaries (<=0.15 minor, >=0.85 warning, else accent)
assert.strictEqual(B.levelRole(0.10), "ui.minor");
assert.strictEqual(B.levelRole(0.15), "ui.minor");   // inclusive low boundary
assert.strictEqual(B.levelRole(0.16), "ui.accent");
assert.strictEqual(B.levelRole(0.5), "ui.accent");
assert.strictEqual(B.levelRole(0.84), "ui.accent");
assert.strictEqual(B.levelRole(0.85), "warning");    // inclusive high boundary
assert.strictEqual(B.levelRole(1), "warning");
assert.strictEqual(B.levelRole(null), "ui.minor");   // 0 -> dim

// displayRows: no fake built-in; unresolved external outputs get issue badges
assert.deepStrictEqual(B.displayRows({ present: false, level: 0.55 }, {
    "DP-1": { model: "27E6QC" },
    "DP-2": { model: "27E6QC" }
}, {}), [
    { id: "ddc:DP-1", name: "DP-1 · 27E6QC", kind: "ddc", level: null, controllable: false, issue: "needs setup" },
    { id: "ddc:DP-2", name: "DP-2 · 27E6QC", kind: "ddc", level: null, controllable: false, issue: "needs setup" }
]);

assert.deepStrictEqual(B.displayRows({ present: true, level: 0.55 }, {}, {}), [
    { id: "backlight", name: "built-in", kind: "backlight", level: 0.55, controllable: true, issue: "" }
]);

assert.deepStrictEqual(B.displayRows({ present: true, level: 0.75 }, [
    { name: "DP-1", model: "27E6QC" }
], { "DP-1": { level: 0.25, controllable: true } }), [
    { id: "backlight", name: "built-in", kind: "backlight", level: 0.75, controllable: true, issue: "" },
    { id: "ddc:DP-1", name: "27E6QC", kind: "ddc", level: 0.25, controllable: true, issue: "" }
]);

// A unique model names its display; a model that repeats the connector, or none, leaves the connector.
assert.deepStrictEqual(B.displayRows({}, [{ name: "winit", model: "winit" }, { name: "DP-3", model: "Unknown" }, { name: "DP-4" }], {}).map(row => row.name),
    ["winit", "DP-3", "DP-4"]);

// Internal panels never become DDC candidates, even without an available backlight.
for (const connector of ['LVDS-1', 'eDP-1', 'DSI-1', 'eDP-2']) {
    const outputs = [{ name: connector, model: 'internal panel' }];
    const ddc = { [connector]: { controllable: true, level: 0.25 } };
    assert.deepStrictEqual(B.displayRows({ present: true, level: 0.5 }, outputs, ddc), [
        { id: 'backlight', name: 'built-in', kind: 'backlight', level: 0.5, controllable: true, issue: '' }
    ]);
    assert.deepStrictEqual(B.displayRows({ present: false }, outputs, ddc), []);
}

// Docked laptops retain external DDC candidates in either output representation.
const dockedOutputs = { 'LVDS-1': { model: 'internal' }, 'HDMI-A-1': { model: 'external' } };
const dockedRows = B.displayRows({ present: true, level: 0.5 }, dockedOutputs, {});
assert.deepStrictEqual(dockedRows.map(row => row.id), ['backlight', 'ddc:HDMI-A-1']);
assert.strictEqual(dockedRows[1].issue, 'needs setup');

// globalState: none/synced/mixed from controllable displays only
assert.deepStrictEqual(B.globalState([]), { mode: "none", level: 0, levels: [] });
assert.deepStrictEqual(B.globalState([{ controllable: false, level: 0.2 }]), { mode: "none", level: 0, levels: [] });
assert.deepStrictEqual(B.globalState([{ controllable: true, level: 0.5 }, { controllable: true, level: 0.5 }]), { mode: "synced", level: 0.5, levels: [0.5, 0.5] });
assert.deepStrictEqual(B.globalState([{ controllable: true, level: 0.75 }, { controllable: true, level: 0.25 }]), { mode: "mixed", level: 0.5, levels: [0.75, 0.25] });

// AMD DisplayPort AUX can use a different bus from the connector's sysfs ddc
// link. Explicit ddcutil DRM connector pairs must win over that legacy link.
assert.deepStrictEqual(B.parseDetection([
    'Display 1', '   I2C bus:  /dev/i2c-6', '      DRM_connector: card1-DP-1',
    'Display 2', '   I2C bus:  /dev/i2c-7', '      DRM_connector: card1-DP-2'
].join('\n'), { 'DP-1': { bus: 1, accessible: true }, 'DP-2': { bus: 2, accessible: true } }), {
    'DP-1': { bus: 6, controllable: false, error: '' },
    'DP-2': { bus: 7, controllable: false, error: '' }
});
assert.deepStrictEqual(B.parseDetection('Display 1\n I2C bus: /dev/i2c-6\n DRM_connector: card1-DP-9', {
    'DP-1': { bus: 6 }
}), {}, 'an explicit unknown connector must not be reassigned by bus coincidence');

for (const bus of [undefined, null, -1, 65536, NaN, Infinity, 7.5, '7']) {
    const detected = bus === undefined ? '' : 'Display 1\n I2C bus: /dev/i2c-' + String(bus);
    assert.deepStrictEqual(B.parseDetection(detected, { 'DP-1': { bus } }), {},
        'invalid or missing fallback bus must not become a display: ' + String(bus));
}
for (const bus of [0, 65535]) {
    assert.deepStrictEqual(B.parseDetection('Display 1\n I2C bus: /dev/i2c-' + bus, { 'DP-1': { bus } }), {
        'DP-1': { bus, controllable: false, error: '' }
    }, 'valid fallback boundary bus: ' + bus);
}

// Package-native argument shaping and bounded unprivileged operations.
assert.deepStrictEqual(B.ddcCommand('write', 7, 1.5, 200).slice(-6),
    ['--bus', '7', 'setvcp', '10', '200', '--verify']);
assert.deepStrictEqual(B.ddcCommand('write', '7; touch /tmp/no', 0.5, 100), []);
assert.deepStrictEqual(B.ddcCommand('read', -1), []);
for (const kind of ['detect', 'read', 'write']) {
    const command = B.ddcCommand(kind, 8, 0.5, 100);
    assert.strictEqual(command[0], '/usr/bin/timeout');
    assert.ok(command.includes('--noconfig'));
    assert.ok(!command.includes('/usr/bin/pkexec'));
}
const installed = B.parsePreflight('package=yes\nmodule=yes\nconnector=DP-1,7,yes\nconnector=DP-2,8,no');
assert.strictEqual(installed.needsPrivilege, true);
assert.strictEqual(B.parsePreflight('package=yes\nmodule=yes\nconnector=DP-1,7,yes').needsPrivilege, false);
assert.strictEqual(B.parsePreflight('package=no\nmodule=yes').needsPrivilege, true);
assert.deepStrictEqual(B.parseDetection('Display 1\n I2C bus: /dev/i2c-7\nInvalid display\n I2C bus: /dev/i2c-8', installed.connectors), {
    'DP-1': { bus: 7, controllable: false, error: '' },
    'DP-2': { bus: 8, controllable: false, error: '' }
});
assert.deepStrictEqual(B.parseBrightness('VCP 10 C 30 200'), { level: 0.15, maximum: 200 });
for (const invalid of ['VCP 10 ERR', 'VCP 10 C 20 0', 'VCP 10 C 201 200', 'password=secret'])
    assert.strictEqual(B.parseBrightness(invalid), null);
assert.strictEqual(B.diagnostic('password=secret TOKEN=abc /usr/bin/arbitrary --command'), '');
assert.strictEqual(B.processError(124, 'write failed'), 'timeout');
assert.strictEqual(B.processError(137, 'read failed'), 'timeout');
assert.strictEqual(B.processError(1, 'write failed'), 'write failed');
assert.strictEqual(B.displayRows({ present: true, level: 0.5, error: 'write failed' }, [], {})[0].issue, 'write failed');
const stages = B.stageState(B.initialStages(), 'reading', 'failed', 'read failed');
assert.strictEqual(stages.find(stage => stage.id === 'reading').error, 'read failed');
assert.strictEqual(stages.find(stage => stage.id === 'preflight').status, 'waiting');

// Setup summary: one line for the running step, else the stage that stopped setup.
const summary = (list, running, error) => B.setupSummary(list, running, error || '');
const at = (id, status, error) => B.stageState(B.initialStages(), id, status, error);
assert.deepStrictEqual(summary(at('preflight', 'running'), true),
    { status: 'running', text: 'step 1 of 7 · check system', detail: '' });
const detecting = B.stageState(B.stageState(at('preflight', 'done'), 'authorization', 'done'), 'detection', 'running');
assert.strictEqual(summary(detecting, true).text, 'step 4 of 7 · find monitors');
assert.deepStrictEqual(summary(stages, false, 'read failed'),
    { status: 'failed', text: 'read brightness failed · read failed', detail: 'read failed' });
const cancelled = at('detection', 'failed', 'cancelled');
assert.deepStrictEqual(summary(cancelled, false, 'cancelled'),
    { status: 'cancelled', text: 'find monitors cancelled', detail: 'cancelled' });
// A retry runs again while the earlier failure is still on record.
assert.strictEqual(summary(B.stageState(stages, 'preflight', 'running'), true).text, 'step 1 of 7 · check system');
// An installation deadline fails its stage while the package process still exits.
assert.strictEqual(summary(at('installation', 'failed', 'timeout'), true, 'timeout').text, 'install ddcutil failed · timeout');
// Cancellation between stages fails no stage; setup still says it stopped.
assert.strictEqual(summary(at('preflight', 'done'), false, 'cancelled').text, 'setup cancelled');
assert.strictEqual(summary(at('preflight', 'done'), false, 'timeout').text, 'setup failed · timeout');
assert.strictEqual(summary(B.initialStages().map(stage => ({ ...stage, status: 'done' })), false).text, 'monitor control ready');
assert.strictEqual(B.stageLine(at('reading', 'failed', 'read failed').find(stage => stage.id === 'reading')), 'read brightness · failed · read failed');
assert.strictEqual(B.stageLine(cancelled.find(stage => stage.id === 'detection')), 'find monitors · cancelled');
assert.strictEqual(B.stageLine({ id: 'ready', status: 'waiting', error: '' }), 'monitor control · waiting');

// Execute the production service's JavaScript against inert Process/FileView
// boundaries. No child command is executed, no host package or hardware access.
// These are lifecycle tests, not QML load, compositor or polkit proof.
const fs = require('fs');
const vm = require('vm');
const serviceSource = fs.readFileSync(__dirname + '/Brightness.qml', 'utf8');
const methods = [...serviceSource.matchAll(/^    function [\s\S]*?^    }/gm)].map(match => match[0]).join('\n');
function service(outputs = [{ name: 'DP-1' }]) {
    const deferred = [];
    const sent = [];
    const ctx = {
        Brightness: B, Qt: { callLater: fn => deferred.push(fn) },
        adaptiveEnabled: true, adaptiveAvailable: false, adaptiveActive: false,
        adaptiveThresholds: [25, 100, 300], adaptiveBuckets: [], currentBucket: -1,
        adaptiveRaw: null, adaptiveSmoothed: null, adaptiveError: '', persistenceError: '',
        adaptiveGeneration: 0, adaptiveTransitions: {}, adaptiveTransitioning: false, writeOutput: '',
        osdService: { trigger: (event, value) => ({ event, value }) },
        niriService: { outputList: () => outputs },
        privilegeService: { polkitAgent: { isRegistered: true, isActive: false } },
        devicePath: '/not-a-device', brightnessFile: { text: () => '' }, maxFile: { text: () => '' },
        ddcDisplays: {}, lastAction: {}, lastOsd: {}, liveLevel: -1, nativeError: '',
        setupStages: B.initialStages(), setupRunning: false, setupExpanded: false, setupReady: false,
        cancelRequested: false, stopReason: '', setupEpoch: 0, setupStage: '', setupError: '', preflight: {},
        readQueue: [], readingName: '', operation: '', operationPending: false,
        operationOutput: '', privilegedEntered: false,
        writeQueue: [], activeWrite: {}, writePending: false,
        setupProcess: { running: false, command: [], write: text => sent.push(text) },
        writeProcess: { running: false, command: [] },
        authorizationDeadline: { restart() {}, stop() {} },
        installationDeadline: { restart() {}, stop() {} }
    };
    Object.defineProperty(ctx, 'adaptiveRows', { get: () => B.displayRows({
        present: ctx.backlightPresent(), level: ctx.levelFraction()
    }, outputs, ctx.ddcDisplays) });
    // The panel-state bindings, evaluated live from the production source like Qt bindings.
    const bound = [...serviceSource.matchAll(/^    readonly property \w+ (displays|globalState|globalMode|globalLevel|globalLevels|setupNeeded|setupAvailable): ([\s\S]*?)\n(?=    [a-z/])/gm)];
    assert.strictEqual(bound.length, 7, 'every panel-state binding found');
    for (const [, name, expression] of bound)
        Object.defineProperty(ctx, name, { get: () => vm.runInContext(`(${expression})`, ctx) });
    vm.createContext(ctx);
    vm.runInContext(methods, ctx);
    ctx.flush = () => { while (deferred.length) deferred.shift()(); };
    ctx.complete = (text, code = 0) => {
        text.split('\n').forEach(line => ctx.consumeOutput(line));
        ctx.finishOperation(code);
        ctx.flush();
    };
    ctx.sent = sent;
    return ctx;
}

// Explicit setup only, duplicate submission guarded; cancellation wins even if
// authorization succeeds after cancellation (two-phase root-side consent).
let s = service();
assert.strictEqual(s.operationPending, false);
s.setupDdc();
assert.strictEqual(s.operation, 'preflight');
s.complete('package=no\nmodule=no');
assert.strictEqual(s.setupStage, 'authorization');
const pendingCommand = s.setupProcess.command;
s.setupDdc();
assert.strictEqual(s.setupProcess.command, pendingCommand);
s.cancelSetup();
s.consumeOutput('nugu:authorized');
assert.ok(!s.sent.includes('continue\n'));
assert.strictEqual(s.setupStages.find(stage => stage.id === 'installation').status, 'waiting');
s.finishOperation(126);
assert.strictEqual(s.setupError, 'cancelled');
assert.strictEqual(s.setupRunning, false);

// Cancellation in the deferred handoff is terminal; a new retry cannot revive
// an old attempt's callback or overwrite the new preflight operation.
s = service();
s.setupDdc();
s.consumeOutput('package=no');
s.finishOperation(0); // deliberately do not flush the authorization continuation
s.cancelSetup();
s.flush();
assert.strictEqual(s.setupError, 'cancelled');
assert.strictEqual(s.setupRunning, false);
assert.strictEqual(s.operation, 'preflight');
assert.strictEqual(s.setupStages.find(stage => stage.id === 'preflight').status, 'done');

s = service();
s.setupDdc();
s.consumeOutput('package=no');
s.finishOperation(0);
s.cancelSetup();
s.retrySetup();
const retryCommand = s.setupProcess.command;
s.flush();
assert.strictEqual(s.operation, 'retry-preflight');
assert.strictEqual(s.setupProcess.command, retryCommand);
assert.strictEqual(s.operationPending, true);

// Authorization expiry retains timeout diagnosis, including a late auth marker.
s = service();
s.setupDdc();
s.complete('package=no\nmodule=no');
s.authorizationExpired();
s.consumeOutput('nugu:authorized');
s.finishOperation(126);
assert.strictEqual(s.setupError, 'timeout');
assert.ok(!s.sent.includes('continue\n'));

// Missing or busy native authorization stays visible, with no privilege launch.
for (const [agent, expected] of [
    [{ isRegistered: false, isActive: false }, 'authorization unavailable'],
    [{ isRegistered: true, isActive: true }, 'authorization busy']
]) {
    s = service();
    s.privilegeService.polkitAgent = agent;
    s.setupDdc();
    s.complete('package=no');
    assert.strictEqual(s.setupError, expected);
    assert.strictEqual(s.operation, 'preflight');
}

// Deferred cancellation retains busy ownership throughout actual installation.
s = service();
s.setupDdc();
s.complete('package=no\nmodule=no');
s.consumeOutput('nugu:authorized');
assert.deepStrictEqual(s.sent, ['continue\n']);
s.cancelSetup();
assert.strictEqual(s.setupRunning, true);
assert.strictEqual(s.operationPending, true);
s.finishOperation(0);
assert.strictEqual(s.setupError, 'cancelled');
assert.strictEqual(s.operation, 'privileged');
s.retrySetup();
assert.strictEqual(s.operation, 'retry-preflight');
s.complete('package=yes\nmodule=yes\nconnector=DP-1,7,yes');
assert.strictEqual(s.operation, 'detect');
assert.ok(!s.setupProcess.command.includes('/usr/bin/pkexec'));

// Package deadline is observable, never releases busy ownership prematurely.
s = service();
s.setupDdc();
s.complete('package=no\nmodule=no');
s.consumeOutput('nugu:authorized');
s.installationExpired();
assert.strictEqual(s.setupStages.find(stage => stage.id === 'installation').status, 'failed');
assert.strictEqual(s.setupError, 'timeout');
assert.strictEqual(s.setupRunning, true);
s.finishOperation(124);
assert.strictEqual(s.setupError, 'timeout');
assert.strictEqual(s.setupRunning, false);

// Partial discovery/read failure leaves the working monitor usable. Retry
// refreshes detection, recovers the second connector, preserves the first read.
s = service([{ name: 'DP-1' }, { name: 'DP-2' }]);
s.setupDdc();
s.complete('package=yes\nmodule=yes\nconnector=DP-1,7,yes\nconnector=DP-2,8,yes');
assert.strictEqual(s.operation, 'detect');
s.complete('Display 1\n I2C bus: /dev/i2c-7');
assert.strictEqual(s.readingName, 'DP-1');
s.complete('VCP 10 C 40 100');
assert.strictEqual(s.setupError, 'some displays unavailable');
assert.strictEqual(s.ddcDisplays['DP-1'].controllable, true);
s.retrySetup();
assert.strictEqual(s.operation, 'retry-preflight');
s.complete('package=yes\nmodule=yes\nconnector=DP-1,7,yes\nconnector=DP-2,8,yes');
s.complete('Display 1\n I2C bus: /dev/i2c-7\nDisplay 2\n I2C bus: /dev/i2c-8');
assert.strictEqual(s.readingName, 'DP-2');
assert.strictEqual(s.ddcDisplays['DP-1'].level, 0.4);
s.complete('VCP 10 C 80 200');
assert.strictEqual(s.setupReady, true);
assert.strictEqual(s.setupExpanded, false);
s.toggleSetup();
assert.strictEqual(s.setupExpanded, true);

// Writes use the mapped bus, preserve the confirmed value and OSD on failure,
// retain inline error, then recover only on successful completion.
s.lastOsd = { event: 'brightness', value: '40' };
s.setDisplay('ddc:DP-2', 0.75);
assert.ok(s.writeProcess.command.includes('8'));
assert.strictEqual(s.ddcDisplays['DP-2'].level, 0.4);
s.finishWrite(124);
assert.strictEqual(s.ddcDisplays['DP-2'].level, 0.4);
assert.strictEqual(s.ddcDisplays['DP-2'].error, 'timeout');
assert.strictEqual(s.lastOsd.value, '40');
s.flush();
s.setDisplay('ddc:DP-2', 0.75);
s.finishWrite(0);
s.flush();
assert.strictEqual(s.ddcDisplays['DP-2'].level, 0.75);
assert.strictEqual(s.ddcDisplays['DP-2'].error, '');
assert.strictEqual(s.lastOsd.value, '75');

s = service([]);
s.brightnessFile.text = () => '50';
s.maxFile.text = () => '100';
s.lastOsd = { value: '50' };
s.setDisplay('backlight', 0.7);
s.finishWrite(1);
assert.strictEqual(s.stateObject().displays[0].level, 0.5);
assert.strictEqual(s.stateObject().displays[0].issue, 'write failed');
assert.strictEqual(s.lastOsd.value, '50');

// A shared absolute target does not preserve offsets or fabricate completed
// values. One failed write leaves a genuinely mixed global state and row error.
s = service([{ name: 'DP-1' }, { name: 'DP-2' }]);
s.ddcDisplays = {
    'DP-1': { bus: 7, maximum: 100, level: 0.4, controllable: true },
    'DP-2': { bus: 8, maximum: 100, level: 0.8, controllable: true }
};
s.setAll(0.6);
assert.deepStrictEqual(Array.from(s.stateObject().global.levels), [0.4, 0.8]);
assert.ok(s.writeProcess.command.includes('7'));
assert.strictEqual(s.writeProcess.command.at(-2), '60');
s.finishWrite(0);
s.flush();
assert.deepStrictEqual(Array.from(s.stateObject().global.levels), [0.6, 0.8]);
assert.ok(s.writeProcess.command.includes('8'));
assert.strictEqual(s.writeProcess.command.at(-2), '60');
s.finishWrite(1);
s.flush();
assert.strictEqual(s.stateObject().global.mode, 'mixed');
assert.deepStrictEqual(Array.from(s.stateObject().global.levels), [0.6, 0.8]);
assert.strictEqual(s.ddcDisplays['DP-2'].error, 'write failed');
assert.strictEqual(s.lastOsd.value, '60');
s.setDisplay('ddc:DP-2', 0.6);
s.finishWrite(0);
s.flush();
assert.strictEqual(s.stateObject().global.mode, 'synced');
assert.deepStrictEqual(Array.from(s.stateObject().global.levels), [0.6, 0.6]);

// Adaptive targets snap to device steps; a backlight never turns fully off, DDC may.
s = service([]);
s.maxFile.text = () => '7';
s.ddcDisplays = { 'DP-1': { maximum: 100 } };
assert.strictEqual(s.deviceLevel({ id: 'backlight', kind: 'backlight' }, 0), 1 / 7);
assert.strictEqual(s.deviceLevel({ id: 'backlight', kind: 'backlight' }, 0.5), 4 / 7);
assert.strictEqual(s.deviceLevel({ id: 'ddc:DP-1', kind: 'ddc' }, 0), 0);
assert.strictEqual(s.deviceLevel({ id: 'ddc:DP-1', kind: 'ddc' }, 0.333), 0.33);

// QML source contracts prove routing/safety conventions, not actual loading.
assert.ok(!/execDetached|startDetached/.test(serviceSource));
assert.ok(serviceSource.includes('root.authorizationExpired()'));
// The registry forwards its privilege host input to the service it creates.
assert.match(fs.readFileSync(__dirname + '/../../Registry.qml', 'utf8'), /BrightnessFeature\.Brightness \{[^}]*\n        privilegeService: root\.privilegeService\n/);
const privileged = B.privilegedCommand(true);
assert.strictEqual(privileged[0], '/usr/bin/pkexec');
assert.ok(privileged.includes('--disable-internal-agent'));
assert.ok(privileged[privileged.length - 1].includes('read -r consent'));
assert.ok(privileged[privileged.length - 1].indexOf('read -r consent') < privileged[privileged.length - 1].indexOf('/usr/bin/pacman -S'));
assert.ok(!B.privilegedCommand(false).join(' ').includes('/usr/bin/pacman -S'));
assert.ok(!/\/etc\/|chmod|usermod|modules-load\.d\//.test(privileged.join(' ')));

// Harmless real subprocess proof of the exact authorization/consent prefix.
// The mutation suffix is removed before execution, not stubbed via PATH.
const { runIsolated } = require('../../test-fixtures/isolation.js');
const prefix = privileged[privileged.length - 1].split('/usr/bin/timeout --signal=INT')[0];
assert.ok(!/pacman|modprobe|udevadm/.test(prefix));
for (const [input, permitted] of [['cancel\n', false], ['continue\n', true], ['', false]]) {
    const run = runIsolated('/usr/bin/sh', ['-c', prefix + "printf 'stub:installation\\n'\n"], {
        input, encoding: 'utf8', timeout: 7000
    });
    assert.ifError(run.error);
    assert.ok(run.stdout.includes('nugu:authorized'));
    assert.strictEqual(run.stdout.includes('stub:installation'), permitted);
    assert.strictEqual(run.status === 0, permitted);
}
console.log('brightness.test.js: ALL PASS');