repositories / dotfiles
dotfiles
bugabingas dorkfiles
owned by admin
quickshell/nuguland/features/brightness/fixtures/suite.mjs
Raw// `just ui-test brightness`: the registry brightness feature in the real Bar inside
// nested niri, driven by real pointer and keyboard against the feature's Brightness
// double: manual and stacked levels, compositor focus return, adaptive buckets and
// motion, threshold editing, and the DDC setup stages. Stages and outcomes enter
// through the pure double; production processes and authorization are not exercised.
// The suite contract (snapshot shape, helpers) is documented in .system/RULES.md.
import Brightness from '../brightness.js';
const names = {
slider: 'fixture display brightness',
global: 'all displays brightness',
working: 'working monitor brightness',
second: 'second monitor brightness',
broken: 'failed monitor brightness',
builtIn: 'built-in brightness',
preset: 'all displays brightness 75%',
solePreset: 'brightness 75%',
adaptiveToggle: 'adaptive',
setup: 'set up monitor control',
cancel: 'cancel setup',
retry: 'retry setup',
ready: 'monitor control ready',
showSteps: 'show steps',
hideSteps: 'hide steps',
};
const bucketNames = ['dark', 'dim', 'bright', 'sunlight'];
const stageIds = ['preflight', 'authorization', 'installation', 'detection', 'reading', 'verification', 'ready'];
// Each expanded stage as the panel words it, beside its state.
const stageText = (id, status) => `${Brightness.stageLabel(id)} · ${status}`;
// The collapsed one-line summary of a running step.
const stepText = id => `step ${stageIds.indexOf(id) + 1} of ${stageIds.length} · ${Brightness.stageLabel(id)}`;
export default async function brightnessSuite({ assert, snapshot, open, check, click, input, key, screenshot, within, call, fixture, delay, focusedWindow }) {
const brightness = value => value.features.brightness;
const service = value => brightness(value).service;
const control = (value, name) => brightness(value).controls[name === 'setup' ? 'configure light' : names[name]] || value.features.config.controls[names[name]];
const bucket = (value, index) => brightness(value).controls[`${bucketNames[index]} ambient bucket`];
const buckets = value => bucketNames.map((name, index) => bucket(value, index));
const thresholdInput = value => Object.entries(brightness(value).controls).find(([name]) => name.endsWith(' threshold'))?.[1];
const editorVisible = value => !!thresholdInput(value);
const textHas = (value, text) => [...brightness(value).texts, ...value.features.config.texts].includes(text);
const percentShown = value => brightness(value).texts.some(text => /^\d+%$/.test(text));
const displayIds = value => service(value).displays.map(row => row.id).join(',');
const display = (value, id) => service(value).displays.find(row => row.id === id);
// Every row the service reports renders as a display card named after it.
const rowsRendered = value => service(value).displays.every(row => brightness(value).controls[String(row.name)]);
const displayFrames = value => service(value).displays.filter(row => row.controllable).map(row => brightness(value).controls[String(row.name)]?.rect);
const setState = state => call('brightness', 'setState', state);
function insidePanel(rect, value) {
const panel = value.features[value.popup.name].surface;
return rect && panel && rect.x >= panel.x && rect.y >= panel.y && rect.x + rect.width <= panel.x + panel.width && rect.y + rect.height <= panel.y + panel.height;
}
// Tab until the named control holds focus, then wait until the panel reveals it.
async function focusControl(name) {
for (let step = 0; step < 24; step++) {
if (control(snapshot(), name)?.focused) {
return await check(`keyboard reveals brightness ${name}`, value => {
const rect = control(value, name)?.rect;
const panel = value.features[value.popup.name].surface;
return rect && panel && rect.y >= panel.y && rect.y + rect.height <= panel.y + panel.height;
});
}
key('Tab');
await delay(50);
}
assert.fail(`brightness ${name} was not keyboard reachable`);
}
// A point on the output but off the popup card, for outside dismissal.
function outsideRect(state) {
const card = state.popup.card;
const candidates = [
{ x: state.width - 14, y: state.height - 14, width: 6, height: 6 },
{ x: 8, y: state.height - 14, width: 6, height: 6 },
{ x: state.width - 14, y: 40, width: 6, height: 6 },
];
const result = candidates.find(rect => rect.x + rect.width < card.x || rect.x > card.x + card.width || rect.y + rect.height < card.y || rect.y > card.y + card.height);
assert(result && within(result, state.width, state.height), 'mapped output must contain an outside-click target');
return result;
}
let state = snapshot();
assert.equal(state.chips.brightness.label, 'light', 'registry bar label');
assert.equal(state.chips.brightness.active, false, 'registry bar activity');
assert.equal(service(state).sensorMonitoring, false, 'closed brightness without adaptive mode probes no sensor');
// Manual control of the double's single display.
state = await open('brightness', value => control(value, 'slider')?.rect);
await check('one controllable display opens on its own slider without an all-displays slider', value =>
control(value, 'slider')?.focused && !control(value, 'global') && control(value, 'solePreset')?.enabled);
state = await check('open brightness probes the ambient sensor', value => service(value).sensorMonitoring);
state = await check('manual presets show their level under the icon', value =>
['25%', '50%', '75%', '100%'].every(text => textHas(value, text)));
assert(!textHas(state, 'brightness'), 'the panel does not repeat the chip name');
click({ ...control(state, 'slider').rect, width: control(state, 'slider').rect.width * 1.5 });
state = await check('brightness pointer updates the display', value => service(value).writes === 1 && service(value).level > 0.7);
key('Right');
state = await check('brightness keyboard updates the same display', value => service(value).writes === 2);
call('brightness', 'externalUpdate');
state = await check('brightness follows external updates after local actions without writeback', value => control(value, 'slider')?.value === 0.25 && service(value).writes === 2);
await screenshot('brightness-live');
const formerSlider = control(state, 'slider').rect;
call('brightness', 'setAvailable', false);
state = await check('unavailable display removes its slider and percentage, says why, and offers no futile setup', value =>
!control(value, 'slider') && !control(value, 'global') && !percentShown(value) && !control(value, 'setup') &&
textHas(value, 'this display does not accept brightness changes; check its cable and the monitor menu'));
await screenshot('brightness-unavailable');
// The row stays where the slider was, now without one: a click there writes
// nothing. Escape follows the click, so the closed popup proves it was handled.
const unavailableRow = brightness(state).controls['fixture display']?.rect;
const formerCenter = { x: formerSlider.x + formerSlider.width / 2, y: formerSlider.y + formerSlider.height / 2 };
assert(unavailableRow && formerCenter.x >= unavailableRow.x && formerCenter.x <= unavailableRow.x + unavailableRow.width &&
formerCenter.y >= unavailableRow.y && formerCenter.y <= unavailableRow.y + unavailableRow.height, 'the unavailable row lies where the slider was');
click(formerSlider);
key('Escape');
await check('a click where the slider was writes nothing', value => !value.popup.open && service(value).writes === 2);
for (const docked of [false, true]) {
const outputs = [{ name: 'LVDS-1', model: 'internal panel' }];
if (docked) outputs.push({ name: 'HDMI-A-1', model: 'external monitor' });
const displays = Brightness.displayRows({ present: true, level: 0.5 }, outputs, {});
setState({
displays,
global: Brightness.globalState(displays),
setup: { needed: displays.some(row => row.kind === 'ddc' && !row.controllable), available: true },
});
if (!docked)
await open('brightness', value => control(value, 'builtIn')?.rect);
await check(docked ? 'docked laptop offers DDC only for its external monitor' : 'internal laptop panel has backlight control without DDC setup', value =>
control(value, 'builtIn')?.enabled && !!control(value, 'setup') === docked && rowsRendered(value) && !control(value, 'global') &&
displayIds(value) === (docked ? 'backlight,ddc:HDMI-A-1' : 'backlight') &&
(!docked || (display(value, 'ddc:HDMI-A-1').name === 'external monitor' && textHas(value, 'external monitor'))));
await screenshot(docked ? 'brightness-docked' : 'brightness-laptop');
}
const differingDisplays = [
{ id: 'ddc:HDMI-A-1', name: 'working monitor', controllable: true, level: 0.4, issue: '' },
{ id: 'ddc:DP-1', name: 'second monitor', controllable: true, level: 0.8, issue: '' },
];
setState({
displays: differingDisplays,
global: Brightness.globalState(differingDisplays),
setup: { needed: false, available: true },
});
state = await check('different confirmed brightness levels form one stacked global control', value =>
control(value, 'global')?.levels.join(',') === '0.4,0.8' && !textHas(value, 'mixed'));
await screenshot('brightness-stacked');
const beforeGlobalWrite = service(state).writes;
click({ ...control(state, 'global').rect, width: control(state, 'global').rect.width * 1.5 });
state = await check('shared drag sets the same absolute brightness on all controllable displays', value =>
service(value).writes === beforeGlobalWrite + 1 && service(value).global.mode === 'synced' &&
service(value).displays.every(row => row.level > 0.7 && row.level === service(value).displays[0].level) &&
control(value, 'global').levels.length === 0);
await screenshot('brightness-synced');
// Focus returns to the application that was active before the popup opened.
key('Escape');
await check('close manual brightness before establishing application focus', value => !value.popup.open);
await check('closed brightness stops probing the ambient sensor', value => !service(value).sensorMonitoring);
fixture('focus-target');
let focusTargetId;
await check('nested compositor focuses the previous application before opening brightness', value => {
const focused = focusedWindow();
if (focused?.title !== 'focus target' || !value.focusTargetActive) return false;
focusTargetId = focused.id;
return true;
});
state = await open('brightness', value => control(value, 'global')?.rect);
const adaptiveDisplays = [
{ id: 'ddc:HDMI-A-1', name: 'working monitor', controllable: true, level: 0.4, issue: '' },
{ id: 'ddc:DP-1', name: 'second monitor', controllable: true, level: 0.8, issue: '' },
];
const adaptiveState = {
displays: adaptiveDisplays,
global: Brightness.globalState(adaptiveDisplays),
setup: { needed: false, available: true, ready: true, expanded: false, running: false },
adaptive: {
enabled: true,
available: true,
active: true,
currentBucket: 1,
raw: 50,
thresholds: [25, 100, 300],
buckets: bucketNames.map((label, index) => ({
id: label,
label,
target: [0.25, 0.5, 0.75, 1][index],
targets: {
'ddc:HDMI-A-1': [0.25, 0.5, 0.75, 1][index],
'ddc:DP-1': [0.25, 0.5, 0.75, 1][index],
},
})),
error: '',
persistenceError: '',
},
};
setState(adaptiveState);
state = await check('adaptive brightness defaults checked with four ambient buckets', value =>
control(value, 'adaptiveToggle')?.enabled && control(value, 'adaptiveToggle').checked &&
service(value).adaptive?.enabled && service(value).adaptive.currentBucket === 1 &&
buckets(value).every(button => button?.rect) &&
buckets(value).filter(button => button.checked).length === 1 &&
bucket(value, 1).checked && bucket(value, 1).enabled);
assert.equal(bucket(state, 1).rect.height, bucket(state, 0).rect.height);
state = await check('adaptive-ready shows both display controls inside the viewport without scrolling', value =>
displayFrames(value).length === 2 && displayFrames(value).every(rect => insidePanel(rect, value)) &&
insidePanel(control(value, 'adaptiveToggle').rect, value));
await screenshot('brightness-adaptive-ready');
// Real Qt animation + real nested input, not service-level target checks.
const working = value => control(value, 'working')?.value;
const global = value => control(value, 'global')?.value;
const motionState = level => {
const displays = adaptiveDisplays.map(row => ({ ...row, level }));
return { ...adaptiveState, displays, global: Brightness.globalState(displays) };
};
fixture('motion-on');
setState(motionState(0.25));
await check('motion-enabled brightness settles at its initial displayed level', value =>
Math.abs(working(value) - 0.25) < 0.001 && Math.abs(global(value) - 0.25) < 0.001);
for (let frame = 0; frame < 8; frame++) {
if (frame === 0 || frame === 4)
setState(motionState(frame === 0 ? 0.75 : 0.25));
if (frame === 0)
await check('adaptive UI shows intermediate levels before convergence', value =>
working(value) > 0.25 && working(value) < 0.75 && global(value) > 0.25 && global(value) < 0.75);
await screenshot(`brightness-motion-${String(frame).padStart(2, '0')}`, 0);
await delay(40);
}
await check('adaptive UI converges after the eased transition', value => Math.abs(working(value) - 0.25) < 0.001);
state = await focusControl('working');
const beforeKeyboardMotion = service(state).writes;
setState(motionState(0.75));
await check('keyboard interruption starts during an active tween', value => working(value) > 0.25 && working(value) < 0.75);
key('Right');
await check('keyboard input interrupts easing and confirms immediately without extra writes', value => {
const confirmed = display(value, 'ddc:HDMI-A-1')?.level;
return service(value).writes === beforeKeyboardMotion + 1 && Math.abs(working(value) - confirmed) < 0.001;
});
setState(motionState(0.25));
await check('pointer interruption has a settled starting level', value => Math.abs(working(value) - 0.25) < 0.001);
const beforePointerMotion = service(snapshot()).writes;
setState(motionState(0.75));
state = await check('pointer interruption starts during an active tween', value => working(value) > 0.25 && working(value) < 0.75);
click({ ...control(state, 'working').rect, width: control(state, 'working').rect.width * 1.5 });
await check('pointer input interrupts easing and confirms immediately without extra writes', value => {
const confirmed = display(value, 'ddc:HDMI-A-1')?.level;
return service(value).writes === beforePointerMotion + 1 && Math.abs(working(value) - confirmed) < 0.001;
});
fixture('motion-off');
setState(motionState(0.3));
await check('low-power motion-off updates displayed values without a tween', value => working(value) === 0.3 && global(value) === 0.3);
setState(adaptiveState);
state = await check('motion-only updates never dispatch native intents or replace learned targets', value =>
service(value).writes === beforePointerMotion + 1 && service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] === 0.5);
// Learning: manual writes teach only the current ambient bucket.
const adaptiveWrites = service(state).writes;
click({ ...control(state, 'global').rect, width: control(state, 'global').rect.width * 1.5 });
state = await check('shared adaptive pointer write learns only the current ambient bucket', value =>
service(value).writes === adaptiveWrites + 1 && service(value).displays.every(row => row.level > 0.7) &&
service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] > 0.7 &&
service(value).adaptive.buckets[1].targets['ddc:DP-1'] > 0.7 &&
service(value).adaptive.buckets[0].targets['ddc:HDMI-A-1'] === 0.25);
const sharedTargets = service(state).adaptive.buckets[1].targets;
state = await focusControl('working');
key('Right');
state = await check('per-display adaptive keyboard write learns only that display in the current bucket', value =>
service(value).writes === adaptiveWrites + 2 &&
service(value).adaptive.currentBucket === 1 &&
service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] > sharedTargets['ddc:HDMI-A-1'] &&
service(value).adaptive.buckets[1].targets['ddc:DP-1'] === sharedTargets['ddc:DP-1']);
const learnedTargets = service(state).adaptive.buckets[1].targets;
call('brightness', 'setAmbient', 2);
await check('external ambient change applies confirmed targets without teaching the new bucket', value =>
service(value).adaptive.currentBucket === 2 && service(value).adaptive.raw === 200 &&
service(value).adaptive.buckets[2].targets['ddc:HDMI-A-1'] === 0.75 &&
service(value).displays.every(row => row.level === 0.75));
call('brightness', 'setAmbient', 1);
state = await check('external ambient return restores confirmed learned display values', value =>
service(value).adaptive.currentBucket === 1 && service(value).adaptive.raw === 50 &&
service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] === learnedTargets['ddc:HDMI-A-1'] &&
service(value).adaptive.buckets[1].targets['ddc:DP-1'] === learnedTargets['ddc:DP-1'] &&
display(value, 'ddc:HDMI-A-1').level === learnedTargets['ddc:HDMI-A-1'] &&
display(value, 'ddc:DP-1').level === learnedTargets['ddc:DP-1']);
await screenshot('brightness-adaptive-mixed-learned');
// Threshold editing on an inactive bucket.
const inactiveTargets = service(state).adaptive.buckets[3].targets;
click(bucket(state, 3).rect);
state = await check('inactive ambient bucket opens a threshold editor without changing selection', value =>
editorVisible(value) && thresholdInput(value).rect && bucket(value, 3).focused &&
buckets(value).filter(button => button.checked).length === 1 && bucket(value, 1).checked && !bucket(value, 3).checked);
key('Tab');
state = await check('Tab enters the inactive bucket threshold field', value => thresholdInput(value)?.focused);
key('ctrl+a');
input('type', '350');
// Leaving loses nothing: the open editor and its draft survive close and reopen.
click(snapshot().chips.brightness.rect);
await check('chip closes brightness with an unconfirmed threshold draft', value => !value.popup.open);
state = await open('brightness', value => thresholdInput(value)?.rect);
state = await check('reopened brightness restores the threshold editor and its draft', value =>
brightness(value).retained.expandedBucket === 3 && brightness(value).retained.lowerDraft === '350' &&
thresholdInput(value)?.filled && service(value).adaptive.thresholds.join(',') === '25,100,300');
await screenshot('brightness-threshold-retained');
for (let step = 0; step < 24 && !thresholdInput(snapshot())?.focused; step++) {
key('Tab');
await delay(50);
}
state = await check('Tab returns to the retained threshold field', value => thresholdInput(value)?.focused);
key('Return');
state = await check('threshold Enter confirms an inactive bucket boundary without teaching its target', value =>
service(value).adaptive.thresholds.join(',') === '25,100,350' &&
service(value).adaptive.buckets[3].targets['ddc:HDMI-A-1'] === inactiveTargets['ddc:HDMI-A-1'] &&
thresholdInput(value)?.focused);
key('ctrl+a');
input('type', '25');
key('Return');
await check('out-of-order threshold input preserves the confirmed boundary', value =>
service(value).adaptive.thresholds.join(',') === '25,100,350' && textHas(value, 'thresholds must stay ordered'));
// The field takes digits only, so typed text never outgrows it.
key('ctrl+a');
input('type', 'invalid7');
await check('threshold field rejects letters and keeps typed digits', value => brightness(value).retained.lowerDraft === '7');
key('ctrl+a');
key('BackSpace');
key('Return');
state = await check('invalid threshold draft preserves confirmed thresholds and reveals readable feedback', value =>
service(value).adaptive.thresholds.join(',') === '25,100,350' && textHas(value, 'enter a whole number') &&
['sunlight:', 'light from', '· now 50'].every(text => textHas(value, text)) &&
insidePanel(brightness(value).items.thresholdWarning?.rect, value) && insidePanel(thresholdInput(value)?.rect, value));
await screenshot('brightness-threshold-editor');
key('Tab');
await check('expanded brightness content remains keyboard reachable inside the viewport', value =>
value.popup.open && editorVisible(value) && control(value, 'working')?.focused && insidePanel(control(value, 'working').rect, value));
key('Tab');
await check('expanded brightness reaches the last display without clipping its control', value =>
value.popup.open && editorVisible(value) && control(value, 'second')?.focused && insidePanel(control(value, 'second').rect, value));
await screenshot('brightness-threshold-expanded-reachable');
key('shift+Tab');
await check('reverse Tab returns from the last display to the first', value => control(value, 'working')?.focused);
key('shift+Tab');
await check('reverse Tab returns to the threshold field before local Escape', value => thresholdInput(value)?.focused);
key('Escape');
state = await check('Escape from threshold input closes the editor and returns focus to its bucket', value =>
value.popup.open && value.popup.name === 'brightness' && !editorVisible(value) && bucket(value, 3).focused);
key('Escape');
await check('next Escape dismisses adaptive brightness', value => !value.popup.open && value.popup.lastCloseReason === 'escape-key');
await check('enabled adaptive mode keeps probing the sensor while brightness is closed', value => service(value).sensorMonitoring);
await check('nested compositor returns keyboard focus to the previously active application', value => {
const focused = focusedWindow();
return value.focusTargetActive && focused?.id === focusTargetId && focused.title === 'focus target';
});
// Manual and adaptive modes, sensor and DDC availability.
state = await open('brightness', value => control(value, 'adaptiveToggle')?.rect);
// Reopening preserves scroll; reveal the header before pointer activation.
state = await focusControl('adaptiveToggle');
click(control(state, 'adaptiveToggle').rect);
state = await check('manual mode restores percentage presets', value =>
!service(value).adaptive.enabled && control(value, 'preset')?.rect && control(value, 'preset').enabled);
click(control(state, 'preset').rect);
state = await check('manual percentage preset sets every controllable display', value =>
service(value).displays.every(row => row.level === 0.75));
click(control(state, 'adaptiveToggle').rect);
state = await check('adaptive toggle restores confirmed learned targets', value =>
service(value).adaptive.enabled && service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] === learnedTargets['ddc:HDMI-A-1']);
call('brightness', 'setSensorAvailable', false);
state = await check('sensor unplug disables adaptive without discarding confirmed values', value =>
!control(value, 'adaptiveToggle').enabled && service(value).adaptive.enabled &&
service(value).adaptive.thresholds.join(',') === '25,100,350' &&
service(value).adaptive.buckets[1].targets['ddc:HDMI-A-1'] === learnedTargets['ddc:HDMI-A-1']);
await screenshot('brightness-adaptive-unavailable');
call('brightness', 'setSensorAvailable', true);
await check('sensor replug restores the selected adaptive mode', value =>
control(value, 'adaptiveToggle').enabled && service(value).adaptive.enabled && service(value).adaptive.active);
call('brightness', 'setDdcReady', false);
state = await check('DDC not ready removes adaptive and fake brightness values', value =>
!control(value, 'adaptiveToggle') && !brightness(value).items.adaptiveStatus && !control(value, 'global') && !control(value, 'preset') && !percentShown(value));
await screenshot('brightness-adaptive-ddc-unavailable');
// DDC setup: stages and outcomes from the pure double.
const setupState = {
displays: [
{ id: 'ddc:HDMI-A-1', name: 'working monitor', controllable: false, issue: 'needs setup' },
{ id: 'ddc:DP-1', name: 'failed monitor', controllable: false, issue: 'needs setup' },
],
global: { mode: 'none', level: 0, levels: [] },
setup: {
needed: true, available: true, expanded: false, running: false,
stages: stageIds.map(id => ({ id, status: 'waiting', error: '' })),
},
};
setState(setupState);
state = await check('detected external displays expose setup without global controls or invented values', value =>
brightness(value).controls['configure light']?.enabled && !control(value, 'global') && !control(value, 'preset') &&
!control(value, 'working') && !control(value, 'broken') && rowsRendered(value) &&
displayIds(value) === 'ddc:HDMI-A-1,ddc:DP-1' &&
!brightness(value).texts.some(text => /^(?:\d+%|n\/a)$/.test(text)));
assert.equal(service(state).setups, 0, 'discovery cannot start setup');
await screenshot('brightness-setup-needed');
click(brightness(state).controls['configure light'].rect);
state = await check('Light routes its declaration to Config without sensor demand', value =>
value.popup.name === 'config' && value.popup.windowActive &&
value.features.config.service.selectedSection === 'light' && control(value, 'setup')?.enabled && !service(value).sensorMonitoring);
click(control(state, 'setup').rect);
state = await check('explicit setup starts observable preflight in one summary line and disables duplicate submission', value =>
service(value).setups === 1 && !control(value, 'setup').enabled && control(value, 'cancel')?.enabled &&
insidePanel(control(value, 'cancel').rect, value) && control(value, 'showSteps')?.enabled &&
textHas(value, stepText('preflight')) && !stageIds.some(id => textHas(value, stageText(id, 'waiting'))));
click(control(state, 'setup').rect);
assert.equal(service(snapshot()).setups, 1);
// Past the tooltip delay, the pointer still on the disabled action shows no tooltip over the summary.
await delay(800);
assert(!control(snapshot(), 'setup').tooltip, 'the disabled setup action shows no tooltip over the summary');
await screenshot('brightness-preflight');
click(control(state, 'showSteps').rect);
state = await check('show steps expands every stage as running or waiting', value =>
control(value, 'hideSteps') && textHas(value, stageText('preflight', 'running')) &&
stageIds.slice(1).every(id => textHas(value, stageText(id, 'waiting'))));
await screenshot('brightness-preflight-steps');
for (const stage of ['authorization', 'installation', 'detection']) {
call('brightness', 'advanceSetup', stage);
state = await check(`mock ${stage} stage is visibly running after completed predecessors`, value =>
textHas(value, stageText(stage, 'running')) && stageIds.slice(0, stageIds.indexOf(stage)).every(id => textHas(value, stageText(id, 'done'))));
await screenshot(`brightness-${stage}`);
}
click(control(state, 'cancel').rect);
state = await check('cancel intent renders a neutral cancellation and retains completed installation', value =>
service(value).cancellations === 1 && control(value, 'retry')?.enabled && !control(value, 'cancel') &&
textHas(value, stageText('installation', 'done')) && textHas(value, stageText('detection', 'cancelled')) &&
textHas(value, 'find monitors cancelled') && !value.features.config.texts.some(text => /· failed|failed ·/.test(text)));
await screenshot('brightness-cancelled-steps');
state = await focusControl('hideSteps');
key('Return');
state = await check('keyboard hide steps collapses setup to its cancelled summary', value =>
control(value, 'showSteps')?.focused && textHas(value, 'find monitors cancelled') &&
!textHas(value, stageText('installation', 'done')) && value.features.config.texts.filter(text => text.includes('cancelled')).length === 1);
await screenshot('brightness-cancelled');
state = await focusControl('retry');
click(control(state, 'retry').rect);
state = await check('retry routes once and summarises refreshed preflight', value =>
service(value).retries === 1 && service(value).setups === 2 && textHas(value, stepText('preflight')) && !control(value, 'retry'));
for (const stage of ['authorization', 'installation', 'detection', 'reading', 'verification']) {
call('brightness', 'advanceSetup', stage);
await check(`retry summarises ${stage} status`, value => textHas(value, stepText(stage)) && !textHas(value, stageText(stage, 'running')));
}
const partial = JSON.parse(JSON.stringify(setupState));
partial.displays[0] = { ...partial.displays[0], controllable: true, level: 0.4, issue: '' };
partial.displays[1].issue = 'read failed';
partial.global = { mode: 'synced', level: 0.4, levels: [0.4] };
partial.setup = {
...partial.setup, expanded: true, running: false, error: 'some displays unavailable',
stages: stageIds.map((id, index) => ({ id, status: index < 4 ? 'done' : index === 4 ? 'failed' : 'waiting', error: index === 4 ? 'read failed' : '' })),
};
setState(partial);
state = await check('failed read shows its stage details and leaves the working monitor and presets usable with stage retry', value =>
service(value).displays[0].controllable && !service(value).displays[1].controllable &&
control(value, 'retry')?.enabled && textHas(value, 'read brightness failed · read failed') && textHas(value, 'some displays unavailable') &&
!textHas(value, stageText('detection', 'done')));
await screenshot('brightness-partial-read-failure');
state = await open('brightness', value => control(value, 'working')?.rect);
assert(control(state, 'working')?.enabled && !control(state, 'broken') && !control(state, 'global') && control(state, 'solePreset')?.enabled);
const writesBefore = service(state).writes;
state = await focusControl('working');
click(control(state, 'working').rect);
key('Right');
state = await check('working display accepts pointer and keyboard while failed monitor retains no value', value =>
service(value).writes === writesBefore + 2 && service(value).lastDisplay === 'ddc:HDMI-A-1' &&
service(value).displays[0].level > 0.4 && service(value).displays[1].level === undefined &&
service(value).global.mode === 'synced' &&
service(value).global.level === service(value).displays[0].level &&
service(value).global.levels.length === 1 && service(value).global.levels[0] === service(value).displays[0].level);
await screenshot('brightness-partial-controls');
click(control(state, 'solePreset').rect);
await check('quarter-step preset routes global intent without granting failed monitor control', value =>
service(value).writes === writesBefore + 3 && service(value).displays[0].level === 0.75 && !control(value, 'broken') &&
service(value).global.mode === 'synced' && service(value).global.level === 0.75 &&
service(value).global.levels.join(',') === '0.75');
click(brightness(snapshot()).controls['configure light'].rect);
await check('partial setup deep link retains Config selection', value => value.popup.name === 'config' && value.popup.windowActive && control(value, 'retry')?.enabled);
state = await focusControl('retry');
click(control(state, 'retry').rect);
await check('partial failure retry routes from visible action', value => service(value).retries === 2 && textHas(value, stepText('preflight')));
call('brightness', 'advanceSetup', 'ready');
state = await check('successful fixture setup collapses to a neutral reopenable ready state', value =>
control(value, 'ready')?.enabled && !control(value, 'cancel') && !control(value, 'showSteps') &&
!textHas(value, stageText('preflight', 'done')) && !textHas(value, stepText('preflight')));
await screenshot('brightness-ready-compact');
click(control(state, 'ready').rect);
state = await check('ready action reopens all completed stages without another setup', value =>
stageIds.every(id => textHas(value, stageText(id, 'done'))) && service(value).setups === 3 && !control(value, 'showSteps'));
await screenshot('brightness-ready-expanded');
key('Escape');
await check('Escape dismisses expanded brightness setup', value => !value.popup.open);
state = await open('config', value => control(value, 'ready')?.rect);
click(outsideRect(state));
await check('outside pointer dismisses brightness after reopen', value => !value.popup.open);
setState(null);
// The shared slider's other callers on the same fixture: normal power must
// not turn their opt-out controls into animations.
fixture('motion-on');
const audioSlider = value => value.features.audio.controls['fixture output output volume'];
const audio = value => value.features.audio.service;
state = await open('audio', value => audioSlider(value)?.rect);
let writes = audio(state).volumeWrites;
click({ ...audioSlider(state).rect, width: audioSlider(state).rect.width * 1.4 });
state = await check('audio shared slider retains immediate pointer control', value =>
audio(value).volumeWrites > writes && audio(value).volume > 0.65 && Math.abs(audioSlider(value).value * 1.5 - audio(value).volume) < 0.006);
writes = audio(state).volumeWrites;
key('Right');
state = await check('audio shared slider retains immediate keyboard control', value =>
audio(value).volumeWrites === writes + 1 && audio(value).volume > 0.7 && Math.abs(audioSlider(value).value * 1.5 - audio(value).volume) < 0.006);
writes = audio(state).volumeWrites;
call('audio', 'externalUpdate');
await check('external audio updates redraw without user intents or tweening', value =>
audio(value).volume === 0.8 && Math.abs(audioSlider(value).value - 80 / 150) < 0.001 && audio(value).volumeWrites === writes);
await screenshot('brightness-audio-slider-regression');
fixture('motion-off');
}