repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
quickshell/nuguland/features/clock/time-ipc.test.js
Raw'use strict';
const assert = require('node:assert/strict');
const fs = require('node:fs');
const os = require('node:os');
const path = require('node:path');
const { runIsolated } = require('../../test-fixtures/isolation.js');
// Compare settled date values with native clocks, not raw notification counts:
// SystemClock 0.3.2 emits dateChanged even for equal values; a QML date binding
// suppresses those, but emits its initial value before Component.onCompleted.
const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'nuguland-clock-'));
try {
fs.symlinkSync(path.join(__dirname, 'Time.qml'), path.join(directory, 'Time.qml'));
fs.writeFileSync(path.join(directory, 'shell.qml'), `
import QtQuick
import Quickshell
ShellRoot {
id: test
property string phase: "initializing"
property var counts: ({ seconds: 0, minutes: 0, service: 0 })
property var events: []
property double initialMinute: 0
property double lastSecond: 0
property int advances: 0
property bool secondsReady: false
property var secondTargets: []
property var serviceSeconds: []
function minute(value) { return Math.floor(value / 60000) * 60000; }
function fail(message) {
console.error("ERROR clock: " + message + " " + JSON.stringify({
phase, wall: Date.now(), counts, advances, secondsReady, secondTargets, serviceSeconds,
seconds: seconds.date.getTime(), minutes: minutes.date.getTime(),
service: time.now.getTime(), events
}));
phase = "done";
Qt.quit();
}
function observe(name, value) {
counts[name]++;
events.push({ name, phase, wall: Date.now(), value: value.getTime() });
// Check every service change, not only the final sample of a phase.
if ((phase === "minutes" || phase === "closed") && name === "service"
&& value.getTime() !== minute(value.getTime()))
return fail("service emitted seconds while closed");
if ((phase === "seconds" || phase === "reopened") && secondsReady
&& value.getTime() > lastSecond) {
const values = name === "seconds" ? secondTargets : name === "service" ? serviceSeconds : null;
if (values && values[values.length - 1] !== value.getTime())
values.push(value.getTime());
}
Qt.callLater(test.check);
}
function secondsPhase(next) {
phase = next;
advances = 0;
secondsReady = false;
secondTargets = [];
serviceSeconds = [];
time.secondsShown = true;
Qt.callLater(test.check);
}
function begin() {
// All initial bindings are now installed. Initialization is not a tick.
initialMinute = minutes.date.getTime();
phase = "minutes";
if (time.now.getTime() !== initialMinute)
return fail("initial minute differs from upstream");
}
function check() {
const service = time.now.getTime();
const second = seconds.date.getTime();
if (phase === "minutes") {
// Either clock may notify first; wait for the same later native minute.
if (minutes.date.getTime() > initialMinute && service === minutes.date.getTime())
secondsPhase("seconds");
} else if (phase === "seconds" || phase === "reopened") {
// Exclude the synchronous precision refresh using a shared baseline.
if (!secondsReady) {
if (service === second) {
lastSecond = second;
secondsReady = true;
}
return;
}
// Each following native advance fences delivery of the preceding one.
// Either timer may notify first, but occasional later matches cannot
// hide missed seconds (e.g. a service updating only every ten seconds).
if (secondTargets.length >= 2 && !serviceSeconds.includes(secondTargets[0]))
return fail("service missed first native second");
if (secondTargets.length < 3)
return;
if (!serviceSeconds.includes(secondTargets[1]))
return fail("service missed second native second");
lastSecond = second;
if (phase === "reopened") {
phase = "done";
console.log("clock upstream cadence: PASS " + JSON.stringify({ counts, events }));
Qt.quit();
return;
}
phase = "closed";
advances = 0;
time.secondsShown = false;
if (time.now.getTime() !== minute(time.now.getTime()))
return fail("service did not return to minutes");
} else if (phase === "closed" && second > lastSecond) {
// Observe a stable minute over two native seconds. If closing straddles
// a boundary, start that observation in the new minute instead.
if (minute(second) !== minute(lastSecond)) {
advances = 0;
lastSecond = second;
} else if (service === minute(second)) {
lastSecond = second;
if (++advances === 2)
secondsPhase("reopened");
}
}
}
Component.onCompleted: Qt.callLater(test.begin)
SystemClock { id: seconds; precision: SystemClock.Seconds; onDateChanged: test.observe("seconds", date) }
SystemClock { id: minutes; precision: SystemClock.Minutes; onDateChanged: test.observe("minutes", date) }
Time { id: time; onNowChanged: test.observe("service", now) }
Timer { interval: 72000; running: true; onTriggered: test.fail("deadline") }
}
`);
const run = runIsolated('qs', ['--no-color', '-p', path.join(directory, 'shell.qml')], {
directory, encoding: 'utf8', timeout: 80000
});
const output = String(run.stdout || '') + String(run.stderr || '');
assert.ifError(run.error);
assert.equal(run.status, 0, output);
assert.doesNotMatch(output, /WARN|ERROR|Error:|TypeError|ReferenceError/, output);
assert.match(output, /clock upstream cadence: PASS/, output);
console.log('time-ipc.test.js: PASS');
} finally {
fs.rmSync(directory, { recursive: true, force: true });
}