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 }); }