Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/features/brightness/adaptive-brightness-transport.test.mjs

Raw
import assert from "node:assert/strict";
import { copyFileSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { assertOffscreenPass, runOffscreen } from "../../test-fixtures/offscreen.mjs";

// Both production services and their real subprocess/signal boundary. Only
// helper executable responses, DDC command construction and time intervals differ.
// No USB access, hardware writes, parent compositor, or production state files.
const directory = mkdtempSync(join(tmpdir(), "nuguland-adaptive-transport-"));
try {
    // The feature keeps its directory; root types (Niri, Privilege) and the OSD are stubs.
    const feature = join(directory, "features", "brightness");
    mkdirSync(feature, { recursive: true });
    for (const name of ["brightness.js", "adaptive-brightness.js"])
        copyFileSync(new URL(name, import.meta.url), join(feature, name));
    for (const name of ["Brightness", "AmbientLight"]) {
        let source = readFileSync(new URL(name + ".qml", import.meta.url), "utf8");
        const edits = name === "Brightness" ? [
            ["    property Osd osdService", "    property var fixtureCommand\n    property Osd osdService"],
            ["writeProcess.command = command;", "writeProcess.command = fixtureCommand();"],
            ["interval: 2000", "interval: 50"],
            ["id: adaptiveTransitionTimer\n        interval: 100", "id: adaptiveTransitionTimer\n        interval: 5"]
        ] : [["interval: 5000", "interval: 80"], ['"10s"', '"2s"']];
        for (const [from, to] of edits) {
            assert.equal(source.split(from).length, 2, "fixture seam: " + from);
            source = source.replace(from, to);
        }
        writeFileSync(join(feature, name + ".qml"), source);
    }
    mkdirSync(join(directory, "features", "osd"), { recursive: true });
    writeFileSync(join(directory, "features", "osd", "Osd.qml"), 'import QtQuick\nItem { function trigger(event, value) { return {}; } }');
    writeFileSync(join(directory, "Niri.qml"), 'import QtQuick\nItem { function outputList() { return [{name:"DP-1"},{name:"DP-2"}]; } }');
    writeFileSync(join(directory, "Privilege.qml"), 'import QtQuick\nItem { property var polkitAgent: null }');
    mkdirSync(join(directory, "ambient-light-native"));
    writeFileSync(join(directory, "mode"), "malformed");
    writeFileSync(join(directory, "calls"), "");
    const original = { channel: "white", frequencyPercent: 0, integrationTime: 65535 };
    const effective = { ...original, frequencyPercent: 20 };
    const good = { status: "ready", error: "", raw: 53, unit: "counts", ...effective,
        original, effective, restored: original, restoration: "verified", operationError: "", restoreError: "", verificationError: "", cleanupError: "" };
    writeFileSync(join(directory, "ambient-light-native/read"), `#!/usr/bin/node
const fs=require("node:fs");
const mode=fs.readFileSync(${JSON.stringify(join(directory, "mode"))},"utf8");
const probe=process.argv[2]==="--probe";
fs.appendFileSync(${JSON.stringify(join(directory, "calls"))},(probe?"probe ":"read ")+mode+"\\n");
const good=${JSON.stringify(good)};
if(probe)console.log(JSON.stringify({found:mode!=="missing",error:""}));
else if(mode==="malformed")console.log("not-json");
else if(mode==="timeout")setTimeout(()=>{},5000);
else if(mode==="missing"){console.log(JSON.stringify({...good,status:"unavailable",error:"no-device",raw:null,original:null,effective:null,restored:null,restoration:"not-needed",operationError:"no-device"}));process.exitCode=1;}
else console.log(JSON.stringify(good));
`, { mode: 0o700 });
    writeFileSync(join(directory, "shell.qml"), `import QtQuick
import Quickshell
import Quickshell.Io
import "features/brightness"
ShellRoot {
    id: test
    property int phase: 0
    property real since: 0
    property int callsBefore: 0
    property string retained: ""
    property bool failed: false
    function check(ok, message) { if (!ok) { failed=true; console.error("ERROR transport phase "+phase+": "+message); Qt.quit(); } }
    function calls() { audit.reload(); return (audit.text().match(/^read /gm)||[]).length; }
    function levels() { return JSON.stringify(brightness.stateObject().displays.map(row=>row.level)); }
    FileView { id: mode; path: ${JSON.stringify(join(directory, "mode"))}; printErrors: false }
    FileView { id: audit; path: ${JSON.stringify(join(directory, "calls"))}; blockLoading: true; blockAllReads: true; printErrors: false }
    Niri { id: niri }
    AmbientLight { id: sensor; monitoring: true }
    Brightness {
        id: brightness
        niriService: niri
        ambientLightService: sensor
        setupReady: true
        ddcDisplays: ({"DP-1": {bus: 7,maximum:100,level:0.9,controllable:true},"DP-2":{bus:8,maximum:100,level:0.9,controllable:true}})
        fixtureCommand: function() { return ["/usr/bin/true"]; }
    }
    Timer {
        interval: 10; running: true; repeat: true
        onTriggered: {
            if (test.failed) return;
            if (test.phase===0 && brightness.adaptiveUnsafe) {
                test.check(sensor.errorCode==="invalid-response" && sensor.restorationStatus==="unverified", "malformed response did not reach production parser");
                test.check(!sensor.busy && !brightness.adaptiveActive && test.calls()===1,"unknown restoration did not stop after one read");
                test.since=Date.now();test.phase=1;
            } else if(test.phase===1 && Date.now()-test.since>250) {
                test.check(test.calls()===1,"unknown restoration retried automatically");
                mode.setText("valid");brightness.setAdaptiveEnabled(true);test.phase=2;
            } else if(test.phase===2 && brightness.adaptiveActive && sensor.status==="ready" && !sensor.busy && brightness.currentBucket===1
                    && !brightness.adaptiveTransitioning && !brightness.writePending && brightness.writeQueue.length===0 && test.levels()==="[0.5,0.5]") {
                // Wait for the sample and its writes to settle; the deadline reports a retry that never yields one.
                test.check(sensor.rawCount===53 && sensor.restorationStatus==="verified", "explicit retry did not yield native/QML sample");
                test.retained=test.levels();mode.setText("missing");test.phase=3;
            } else if(test.phase===3 && !sensor.found && !sensor.busy) {
                test.check(!brightness.adaptiveAvailable && !brightness.adaptiveActive && brightness.currentBucket===-1,"disappearance left adaptation active");
                test.callsBefore=test.calls();test.since=Date.now();test.phase=4;
            } else if(test.phase===4 && Date.now()-test.since>250) {
                test.check(test.calls()===test.callsBefore && test.levels()===test.retained,"missing sensor triggered read or changed brightness");
                mode.setText("valid");test.phase=5;
            } else if(test.phase===5 && sensor.found && brightness.adaptiveActive && !sensor.busy) {
                test.check(!brightness.adaptiveUnsafe && test.calls()>test.callsBefore && sensor.rawCount===53,"rediscovery did not resume fresh sampling");
                mode.setText("timeout");test.phase=6;
            } else if(test.phase===6 && brightness.adaptiveUnsafe) {
                test.check(sensor.errorCode==="timeout" && sensor.restorationStatus==="unverified" && !sensor.busy,"timeout did not reach unknown-restoration latch");
                test.callsBefore=test.calls();test.since=Date.now();test.phase=7;
            } else if(test.phase===7 && Date.now()-test.since>250) {
                test.check(test.calls()===test.callsBefore && !brightness.adaptiveActive,"timeout retried automatically");
                if(test.failed)return;
                console.log("adaptive transport: PASS");Qt.quit();
            }
        }
    }
    Timer { interval: 12000; running:true; onTriggered:{console.error("ERROR transport deadline phase "+test.phase);Qt.quit();} }
}`);
    const result = runOffscreen(join(directory, "shell.qml"), { directory, cwd: directory, timeout: 15000 });
    const output = result.output;
    const trace = readFileSync(join(directory, "calls"), "utf8");
    if (process.env.NUGULAND_AMBIENT_EVIDENCE_DIR) {
        const evidence = process.env.NUGULAND_AMBIENT_EVIDENCE_DIR;
        mkdirSync(evidence, { recursive: true });
        writeFileSync(join(evidence, "transport.stdout"), result.stdout || "");
        writeFileSync(join(evidence, "transport.stderr"), result.stderr || "");
        writeFileSync(join(evidence, "transport.calls"), trace);
    }
    assertOffscreenPass(result, /adaptive transport: PASS/, trace);
    assert.equal((trace.match(/^read malformed$/gm) || []).length, 1);
    assert.equal((trace.match(/^read timeout$/gm) || []).length, 1);
    assert.match(trace, /^probe missing$/m);
    console.log(output.trim());
    console.log("adaptive-brightness-transport.test.mjs: PASS (production services; substituted hardware commands)");
} finally {
    rmSync(directory, { recursive: true, force: true });
}