Luigit
repositories / dotfiles

dotfiles

bugabingas dorkfiles

owned by admin

quickshell/nuguland/features/brightness/ambient-light.test.mjs

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

// Default suite: compile the helper, exercise harmless CLI paths, then load the
// real QML service with a subprocess double. Live USB sampling is opt-in only.
const directory = mkdtempSync(join(tmpdir(), "nuguland-ambient-test-"));
const live = process.env.NUGULAND_COLORHUG_LIVE === "1";
const evidence = process.env.NUGULAND_AMBIENT_EVIDENCE_DIR;
if (evidence) mkdirSync(evidence, { recursive: true });
try {
    function run(command, args) {
        const result = runIsolated(command, args, { directory, encoding: "utf8", timeout: 30000 });
        assert.ifError(result.error);
        assert.equal(result.status, 0, result.stdout + result.stderr);
        return result;
    }
    const flags = run("pkg-config", ["--cflags", "--libs", "colorhug"]).stdout.trim().split(/\s+/);
    const binary = join(directory, "native-read");
    const source = fileURLToPath(new URL("../../ambient-light-native/read.c", import.meta.url));
    if (live) {
        assert.equal(process.env.LD_PRELOAD, undefined, "live test must not inherit a native double");
        const built = fileURLToPath(new URL("../../ambient-light-native/read", import.meta.url));
        assert(statSync(built).mtimeMs >= statSync(source).mtimeMs, "run just build before live sampling");
        copyFileSync(built, binary);
    } else run("cc", ["-std=c17", "-Wall", "-Wextra", "-Werror", "-O2", source, "-o", binary, ...flags]);
    assert.match(run(binary, ["--help"]).stdout, /usage:/);
    const invalid = runIsolated(binary, ["--invalid"], { directory, encoding: "utf8", timeout: 3000 });
    assert.equal(invalid.status, 1);
    const invalidState = JSON.parse(invalid.stdout);
    assert.equal(invalidState.status, "unavailable");
    assert.equal(invalidState.error, "invalid-arguments");
    assert.equal(invalidState.raw, null);
    assert.equal(invalidState.restoration, "not-needed");

    if (!live) {
        const backend = join(directory, "fake.so");
        run("cc", ["-std=c17", "-Wall", "-Wextra", "-Werror", "-O2", "-shared", "-fPIC",
            fileURLToPath(new URL("../../ambient-light-native/fake.c", import.meta.url)), "-o", backend, ...flags]);
        for (const [scenario, found] of [["active", true], ["missing", false]]) {
            const tracePath = join(directory, "probe-" + scenario + ".trace");
            const result = runIsolated(binary, ["--probe"], { directory, encoding: "utf8", timeout: 3000,
                env: { LD_PRELOAD: backend, NUGULAND_COLORHUG_FAKE_SCENARIO: scenario, NUGULAND_COLORHUG_FAKE_LOG: tracePath } });
            assert.ifError(result.error);
            assert.equal(result.status, 0, result.stdout + result.stderr);
            assert.equal(result.stderr, "");
            assert.deepEqual(JSON.parse(result.stdout), { found, error: "" });
            assert.doesNotMatch(readFileSync(tracePath, "utf8"), /^(?:open|claim|snapshot|sample|set-scale|direct-integral|release|close)\b/m, "discovery must not open or change the sensor");
        }
        const cases = [
            ["active", "", "verified", 1], ["scale-zero", "", "verified", 1],
            ["integral-zero", "", "verified", 1], ["both-zero", "", "verified", 1],
            ["activation-ack-lost", "activation-scale-failed", "verified", 0],
            ["sample-failure", "sensor-reading-failed", "verified", 1],
            ["restore-scale-failure", "restore-scale-failed", "mismatch", 1],
            ["restore-scale-ack-lost", "restore-scale-failed", "verified", 1],
            ["restore-scale-timeout", "restore-scale-failed", "mismatch", 1],
            ["restore-integral-timeout", "restore-integral-failed", "mismatch", 1],
            ["verification-mismatch", "verification-mismatch", "mismatch", 1],
            ["verification-failure", "verification-read-failed", "unverified", 1],
            ["verification-timeout", "verification-read-failed", "unverified", 1],
            ["work-timeout", "work-timeout", "verified", 1],
            ["signal-work", "interrupted", "verified", 1],
            ["signal-restore", "interrupted", "verified", 1],
            ["release-failure", "interface-release-failed", "verified", 1],
            ["close-failure", "usb-close-failed", "verified", 1],
            ["effective-mismatch", "effective-mismatch", "verified", 0],
            ["effective-failure", "effective-read-failed", "verified", 0],
            ["original-failure", "sensor-state-read-failed", "not-needed", 0],
            ["original-invalid", "sensor-state-invalid", "not-needed", 0]
        ];
        const settings = line => {
            const [, channel, frequency, integration] = line.split(" ");
            return { channel, frequencyPercent: Number(frequency), integrationTime: Number(integration) };
        };
        for (const [scenario, error, restoration, sampleCalls] of cases) {
            const tracePath = join(directory, scenario + ".trace");
            const result = runIsolated(binary, [], {
                directory, encoding: "utf8", timeout: 12000,
                env: { LD_PRELOAD: backend,
                    NUGULAND_COLORHUG_FAKE_SCENARIO: scenario, NUGULAND_COLORHUG_FAKE_LOG: tracePath }
            });
            const trace = readFileSync(tracePath, "utf8");
            if (evidence) {
                writeFileSync(join(evidence, scenario + ".stdout"), result.stdout || "");
                writeFileSync(join(evidence, scenario + ".stderr"), result.stderr || "");
                writeFileSync(join(evidence, scenario + ".trace"), trace);
            }
            const context = scenario + "\n" + String(result.stdout) + String(result.stderr) + trace;
            assert.ifError(result.error);
            assert.equal(result.status, error ? 1 : 0, context);
            assert.equal(result.stderr, "", context);
            assert.equal(result.stdout.trim().split("\n").length, 1, context);
            assert(result.stdout.length < 2048, context);
            const value = JSON.parse(result.stdout);
            assert.equal(value.error, error, context);
            assert.equal(value.restoration, restoration, context);
            assert.equal(value.status, error ? "unavailable" : "ready", context);
            assert.equal(value.unit, "counts", context);
            assert.equal((trace.match(/^sample /gm) || []).length, sampleCalls, context);
            assert.doesNotMatch(trace, /replay |forbidden|unknown-operation/, context);
            assert.match(trace, /^release$/m, context);
            assert.match(trace, /^close blue /m, context);
            const lines = trace.trim().split("\n");
            const initial = settings(lines.find(line => line.startsWith("initial ")));
            const final = settings(lines.find(line => line.startsWith("close ")));
            if (value.original) assert.deepEqual(value.original, initial, context);
            if (value.restored) assert.deepEqual(value.restored, final, context);
            if (restoration === "verified") assert.deepEqual(final, initial, context);
            if (restoration === "mismatch") assert.notDeepEqual(final, initial, context);
            if (restoration === "unverified") assert.equal(value.restored, null, context);
            if (["active", "original-failure", "original-invalid"].includes(scenario))
                assert.doesNotMatch(trace, /^set-scale|^direct-integral/m, context);
            if (scenario === "scale-zero") assert.doesNotMatch(trace, /^direct-integral/m, context);
            if (scenario === "integral-zero") assert.doesNotMatch(trace, /^set-scale/m, context);
            if (["both-zero", "restore-scale-failure", "restore-scale-timeout"].includes(scenario))
                assert.match(trace, /^direct-integral 0$/m, context);
            if (scenario === "signal-restore") assert.match(trace, /^restore-cancelled 0$/m, context);
            if (scenario.includes("restore-")) {
                assert.equal(value.raw, 123456, context);
                if (scenario !== "signal-restore") assert.notEqual(value.restoreError, "", context);
            }
        }
        console.log("ambient native: 22 failure/rollback scenarios passed (substituted USB backend)");
    }

    mkdirSync(join(directory, "ambient-light-native"));
    writeFileSync(join(directory, "mode"), "0");
    let service = readFileSync(new URL("AmbientLight.qml", import.meta.url), "utf8");
    if (!live) {
        for (const [from, to] of [
            ["    property string status:", "    property int fixtureCase: 0\n    property string status:"],
            ['"10s"', '"2s"'],
            ['Quickshell.shellPath("ambient-light-native/read")]', 'Quickshell.shellPath(root.fixtureCase === 5 ? "missing-helper" : "ambient-light-native/read")]']
        ]) {
            assert.equal(service.split(from).length, 2, "missing or ambiguous fixture seam: " + from);
            service = service.replace(from, to);
        }
    }
    writeFileSync(join(directory, "AmbientLight.qml"), service);
    const helper = join(directory, "ambient-light-native/read");
    const original = { channel: "white", frequencyPercent: 0, integrationTime: 65535 };
    const effective = { ...original, frequencyPercent: 20 };
    const good = { status: "ready", error: "", raw: 1234, unit: "counts", ...effective, original, effective, restored: original, restoration: "verified", operationError: "", restoreError: "", verificationError: "", cleanupError: "" };
    // Live: the real helper's output, recorded on its way to QML. Fixture: a double.
    const nativeOut = JSON.stringify(join(directory, "native.stdout"));
    const nativeErr = JSON.stringify(join(directory, "native.stderr"));
    const liveWrapper = `#!/bin/sh
/usr/bin/timeout 9s ${JSON.stringify(binary)} >${nativeOut} 2>${nativeErr}
status=$?
cat ${nativeOut}
cat ${nativeErr} >&2
exit $status
`;
    const wrapper = `const mode=fs.readFileSync(${JSON.stringify(join(directory, "mode"))},"utf8");
fs.appendFileSync(${JSON.stringify(join(directory, "calls"))},mode+"\\n");
const good=${JSON.stringify(good)};
if(mode==="6")setTimeout(()=>{},5000);
else if(mode==="1"){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 if(mode==="2")console.log("not json");
else if(mode==="3")console.log(JSON.stringify({...good,raw:-1}));
else if(mode==="4"){console.log(JSON.stringify({...good,status:"unavailable",error:"password=secret /arbitrary/command"}));process.exitCode=1;}
else if(mode==="8"||mode==="9"){console.log(JSON.stringify({...good,status:"unavailable",error:"restore-scale-failed",restored:mode==="8"?good.effective:good.original,restoration:mode==="8"?"mismatch":"verified",restoreError:"restore-scale-failed",verificationError:mode==="8"?"verification-mismatch":""}));process.exitCode=1;}
else if(mode==="10")console.log(JSON.stringify({...good,restored:good.effective}));
else setTimeout(()=>console.log(JSON.stringify(good)),50);
`;
    writeFileSync(helper, live ? liveWrapper : "#!/usr/bin/node\nconst fs=require(\"node:fs\");\n" + wrapper, { mode: 0o700 });
    writeFileSync(join(directory, "shell.qml"), `import QtQuick
import Quickshell
import Quickshell.Io
ShellRoot {
    id: test
    property int phase: 0
    property bool failed: false
    function check(ok, message) {
        if (!ok) { failed = true; console.error("ERROR ambient phase " + phase + ": " + message); Qt.quit(); }
    }
    AmbientLight { id: sensor }
    FileView { id: mode; path: ${JSON.stringify(join(directory, "mode"))}; printErrors: false }
    Component.onCompleted: {
        test.check(sensor.status === "idle" && !sensor.busy, "unexpected startup read");
        sensor.requestRead();
        sensor.requestRead();
    }
    Timer {
        interval: 10
        running: true
        repeat: true
        onTriggered: {
            if (sensor.busy) return;
            const state = JSON.parse(sensor.stateJson());
            test.check(!state.busy, "terminal state is busy");
            test.check(state.unit === "counts", "raw data mislabeled as lux");
            if (${live}) {
                console.log("ambient-result: " + sensor.stateJson());
                test.check(state.status === "ready", "native sample unavailable: " + state.error);
                if (test.failed) return;
                console.log("ambient qml: PASS");
                Qt.quit();
                return;
            }
            const expected = ["", "no-device", "invalid-response", "invalid-response", "read-failed", "helper-not-built", "timeout", "", "restore-scale-failed", "restore-scale-failed", "invalid-response"][test.phase];
            test.check(state.error === expected, "unexpected error: " + JSON.stringify(state));
            if (test.phase === 0 || test.phase === 7) {
                test.check(state.status === "ready" && state.raw === 1234 && state.channel === "white" && state.frequencyPercent === 20 && state.integrationTime === 65535 && state.readAt.length > 0, "sample mismatch");
            } else test.check(state.status === "unavailable" && state.raw === null && state.readAt === "", "failure exposes stale sample");
            if (test.phase === 8 || test.phase === 9)
                test.check(state.measurement.raw === 1234 && state.restoreError === "restore-scale-failed" && state.operationError === "" && state.original.frequencyPercent === 0 && state.restoration === (test.phase === 8 ? "mismatch" : "verified"), "restoration failure lost sample or independent audit");
            test.check(sensor.stateJson().indexOf("secret") < 0, "untrusted diagnostics exposed");
            if (test.failed) return;
            if (test.phase === 10) {
                console.log("ambient qml: PASS");
                Qt.quit();
                return;
            }
            test.phase++;
            sensor.fixtureCase = test.phase;
            mode.setText(String(test.phase));
            sensor.requestRead();
        }
    }
    Timer { interval: 15000; running: true; onTriggered: { console.error("ERROR ambient deadline"); Qt.quit(); } }
}
`);
    // The live copy has no fixtureCase property; omit the unreachable fixture
    // assignment so QML's dynamic branch cannot diagnose an unknown property.
    if (live) {
        const path = join(directory, "shell.qml");
        writeFileSync(path, readFileSync(path, "utf8").replace("sensor.fixtureCase = test.phase;", ""));
    }
    const result = runOffscreen(join(directory, "shell.qml"), { directory, cwd: directory, timeout: 20000 });
    const output = result.output;
    if (evidence) {
        writeFileSync(join(evidence, "qml.stdout"), String(result.stdout || ""));
        writeFileSync(join(evidence, "qml.stderr"), String(result.stderr || ""));
        for (const name of ["native.stdout", "native.stderr"])
            if (existsSync(join(directory, name))) copyFileSync(join(directory, name), join(evidence, name));
    }
    assertOffscreenPass(result, /ambient qml: PASS/);
    if (live) {
        const native = JSON.parse(readFileSync(join(directory, "native.stdout"), "utf8"));
        const state = JSON.parse(output.match(/ambient-result: (.+)/)[1]);
        for (const field of ["status", "raw", "unit", "channel", "frequencyPercent", "integrationTime", "original", "effective", "restored", "restoration", "operationError", "restoreError", "verificationError", "cleanupError"])
            assert.deepEqual(state[field], native[field], "native/QML mismatch: " + field);
        assert.equal(native.restoration, "verified");
        assert.deepEqual(native.restored, native.original, "hardware read-back differs from original settings");
        assert.equal(native.effective.channel, native.original.channel, "channel changed without authorization");
        assert.equal(native.effective.frequencyPercent, native.original.frequencyPercent === 0 ? 20 : native.original.frequencyPercent);
        assert.equal(native.effective.integrationTime, native.original.integrationTime === 0 ? 14848 : native.original.integrationTime);
        assert.equal(readFileSync(join(directory, "native.stderr"), "utf8"), "");
    } else assert.equal(readFileSync(join(directory, "calls"), "utf8"), "0\n1\n2\n3\n4\n6\n7\n8\n9\n10\n", "duplicate request launched a helper");
    console.log(output.trim());
    console.log("ambient-light.test.mjs: PASS (" + (live ? "live USB read through QML Process" : "substituted helper; no USB reads") + ")");
} finally {
    rmSync(directory, { recursive: true, force: true });
}