Files
pipelines/app/tool/run_detail_graph_probe.mjs
alan b60ad6d98f Remove alternate hosts from tooling probes
Keep the probe suite on the Material composition so browser fixtures and capture drivers no longer render or select Cupertino hosts. Record the final residual legacy arguments and implementation checks for the delivery gate.
2026-11-11 21:38:30 +00:00

299 lines
13 KiB
JavaScript

// Real-browser acceptance for the run detail's Graph tab.
//
// Serves the probe build (`flutter build web -t tool/run_detail_graph_probe.dart`)
// on an OS-assigned loopback port and drives the actual RunDetailView over a
// server-shaped fixture. It checks the Graph tab's recorded evidence and legend,
// that an unvisited node does nothing, that a visited stage click selects the
// recorded visit in Timeline, and the exact missing-graph wording. Captures are
// written for the Material host.
//
// PROBE_SCHEME=dark|light PROBE_SCALE=1|2 \
// PROBE_WIDTH=1280 PROBE_HEIGHT=900 PROBE_WEB_ROOT=<probe build> \
// OPENCODE_ARTIFACT_DIR=<dir> node tool/run_detail_graph_probe.mjs
import { createServer } from 'node:http';
import { spawn } from 'node:child_process';
import { once } from 'node:events';
import { setTimeout as delay } from 'node:timers/promises';
import { join, extname, resolve, sep } from 'node:path';
import { tmpdir } from 'node:os';
import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
const root = resolve(
process.env.PROBE_WEB_ROOT ??
join(process.cwd(), 'build/probe-run-detail-graph'),
);
const variant = 'material';
const scheme = process.env.PROBE_SCHEME ?? 'dark';
const scale = process.env.PROBE_SCALE ?? '1';
const width = Number(process.env.PROBE_WIDTH ?? 1280);
const height = Number(process.env.PROBE_HEIGHT ?? 900);
const chromePath = process.env.CHROME_PATH ??
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
const artifactDir = process.env.OPENCODE_ARTIFACT_DIR;
if (!artifactDir) throw new Error('Set OPENCODE_ARTIFACT_DIR for the probe captures');
await mkdir(artifactDir, { recursive: true });
const prefix = `run-detail-graph-${variant}-${scheme}-${scale}x-${width}x${height}`;
const mime = {
'.html': 'text/html',
'.js': 'text/javascript',
'.json': 'application/json',
'.wasm': 'application/wasm',
'.png': 'image/png',
'.ico': 'image/x-icon',
'.otf': 'font/otf',
'.ttf': 'font/ttf',
};
const server = createServer(async (req, res) => {
try {
const path = resolve(root, '.' + decodeURIComponent(new URL(req.url, 'http://localhost').pathname));
if (path !== root && !path.startsWith(root + sep)) return res.writeHead(403).end();
const filePath = path === root || path.endsWith('/') ? join(path, 'index.html') : path;
const file = await readFile(filePath);
res.writeHead(200, { 'content-type': mime[extname(filePath)] ?? 'application/octet-stream' }).end(file);
} catch {
res.writeHead(404).end('not found');
}
});
server.listen(0, '127.0.0.1');
await once(server, 'listening');
const port = server.address().port;
const profile = await mkdtemp(join(tmpdir(), 'run-detail-graph-chrome-'));
const chrome = spawn(chromePath, [
'--headless=new', '--no-first-run', '--no-default-browser-check', '--disable-gpu',
'--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank',
], { stdio: ['ignore', 'ignore', 'pipe'] });
let stderr = '';
chrome.stderr.on('data', (data) => { stderr += data; });
const waitFor = async (fn) => {
for (let i = 0; i < 140; i++) {
const value = await fn();
if (value) return value;
await delay(100);
}
throw new Error('Timed out waiting for Chrome DevTools');
};
let ws;
try {
const endpoint = await waitFor(() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1]);
ws = new WebSocket(endpoint);
await once(ws, 'open');
let id = 0;
const pending = new Map();
ws.addEventListener('message', (event) => {
const message = JSON.parse(event.data);
if (message.method === 'Runtime.exceptionThrown') {
console.error('PAGE EXCEPTION', JSON.stringify(message.params?.exceptionDetails?.exception?.description));
}
if (message.id && pending.has(message.id)) {
pending.get(message.id)(message);
pending.delete(message.id);
}
});
const send = (method, params = {}, sessionId) => new Promise((resolveCall) => {
const callId = ++id;
pending.set(callId, resolveCall);
ws.send(JSON.stringify({ id: callId, method, params, ...(sessionId ? { sessionId } : {}) }));
});
const created = await send('Target.createTarget', { url: 'about:blank' });
const target = created.result.targetId;
const session = (await send('Target.attachToTarget', { targetId: target, flatten: true })).result.sessionId;
await send('Page.enable', {}, session);
await send('Runtime.enable', {}, session);
await send('Emulation.setEmulatedMedia', {
features: [{ name: 'prefers-color-scheme', value: scheme }],
}, session);
await send('Emulation.setDeviceMetricsOverride', {
width, height, deviceScaleFactor: 1, mobile: width < 600,
}, session);
const evaluate = async (expression) => {
const response = await send('Runtime.evaluate', {
expression, returnByValue: true, awaitPromise: true,
}, session);
if (response.error) throw new Error(`Runtime.evaluate failed: ${JSON.stringify(response)}`);
return response.result?.result?.value;
};
const semantics = () => evaluate(`[...document.querySelectorAll('flt-semantics')].map(x => {
const r = x.getBoundingClientRect();
return {
label: (x.getAttribute('aria-label') || (x.innerText || '')).trim(),
selected: x.getAttribute('aria-selected') || x.getAttribute('aria-current'),
tappable: x.hasAttribute('flt-tappable'),
x: r.x, y: r.y, width: r.width, height: r.height,
visible: r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < innerHeight,
};
})`);
const labels = async () => (await semantics()).map((item) => item.label).filter(Boolean);
const bodyText = async () => [await evaluate('document.body.innerText'), ...(await labels())].join('\n');
const waitForText = async (needle, context) => {
for (let attempt = 0; attempt < 60; attempt++) {
if ((await bodyText()).includes(needle)) return;
await delay(250);
}
throw new Error(`${context}: missing ${JSON.stringify(needle)}\n${await bodyText()}`);
};
const clickItem = async (item) => {
const x = item.x + item.width / 2;
const y = item.y + item.height / 2;
await send('Input.dispatchMouseEvent', {
type: 'mousePressed', x, y, button: 'left', clickCount: 1,
}, session);
await send('Input.dispatchMouseEvent', {
type: 'mouseReleased', x, y, button: 'left', clickCount: 1,
}, session);
await delay(1000);
};
const findVisible = async (predicate) => {
const items = (await semantics()).filter((item) => item.visible && predicate(item));
items.sort((a, b) => a.width * a.height - b.width * b.height);
return items[0] ?? null;
};
// A native control's semantics node is the one the engine listens to; a
// synthetic DOM click avoids coordinate ambiguity in a horizontally scrolled
// tab strip and in a panned graph canvas.
const clickSemantics = async (wanted, prefix = false) => {
const clicked = await evaluate(`(() => {
const wanted = ${JSON.stringify(wanted)};
const prefix = ${prefix ? 'true' : 'false'};
const text = (x) => (x.getAttribute('aria-label') || x.innerText || '').trim();
const matches = [...document.querySelectorAll('flt-semantics')]
.filter((x) => x.hasAttribute('flt-tappable'))
.filter((x) => prefix ? text(x).startsWith(wanted) : text(x) === wanted);
if (!matches.length) return false;
matches.sort((a, b) => {
const ra = a.getBoundingClientRect();
const rb = b.getBoundingClientRect();
return ra.width * ra.height - rb.width * rb.height;
});
matches[0].click();
return true;
})()`);
if (!clicked) throw new Error(`Missing tappable ${JSON.stringify(wanted)}: ${JSON.stringify(await labels())}`);
await delay(1000);
};
const clickLabel = (label) => clickSemantics(label);
const clickPrefix = (prefix) => clickSemantics(prefix, true);
const capture = async (name) => {
const data = (await send('Page.captureScreenshot', {
format: 'png', captureBeyondViewport: false,
}, session)).result.data;
const file = `${prefix}-${name}.png`;
await writeFile(join(artifactDir, file), Buffer.from(data, 'base64'));
return file;
};
const evidence = { variant, scheme, scale, width, height, checks: [], captures: [] };
const check = (text, value) => evidence.checks.push({ check: text, value });
const activate = async () => {
await delay(3200);
await evaluate("document.querySelector('flt-semantics-placeholder')?.click()");
await delay(900);
};
const navigate = async (query, needle) => {
const navigation = await send('Page.navigate', { url: `http://127.0.0.1:${port}/${query}` }, session);
if (navigation.error || navigation.result?.errorText) throw new Error(JSON.stringify(navigation));
await activate();
await waitForText(needle, 'fixture load');
};
await navigate(
`?theme=${scheme === 'dark' ? 1 : 0}&scale=${scale}&case=default`,
'Release verification',
);
check('the real run detail opened over the recorded fixture', true);
await clickLabel('Graph');
await waitForText('Executed', 'graph legend');
await waitForText('Not executed', 'graph legend');
const graphLabels = await labels();
const plan = await findVisible((entry) => entry.label.startsWith('plan') && entry.tappable);
const build = await findVisible((entry) => entry.label.startsWith('build') && entry.tappable);
const audit = await findVisible((entry) => entry.label === 'audit');
if (!plan) throw new Error(`Visited stage node is missing: ${JSON.stringify(graphLabels)}`);
if (audit?.tappable) throw new Error('An unvisited node is a tap target');
if (plan.y + plan.height > height) {
throw new Error(`Graph node falls outside the bounded viewport: ${JSON.stringify({ plan, height })}`);
}
check(
'Graph draws the recorded stages inside the viewport',
`${Math.round(plan.width)}x${Math.round(plan.height)} plan${build ? ', build visible' : ''}`,
);
check('Graph legend shows Executed and Not executed', true);
evidence.captures.push(await capture('graph'));
// An unvisited node is not a control: clicking its label leaves the Graph tab
// exactly as it was and creates no visit. At 320/2x the canvas is panned, so
// the later node may sit outside the visible viewport; the widget test covers
// that case there.
if (audit) {
await clickItem(audit);
await waitForText('Executed', 'graph after unvisited click');
if ((await bodyText()).includes('plan · visit 1')) {
throw new Error('An unvisited node invented a timeline visit');
}
check('an unvisited node does nothing and invents no visit', true);
} else {
check('unvisited node is outside this bounded viewport; widget test covers it', 'skipped');
}
await clickPrefix('plan');
await waitForText('plan · visit 1', 'timeline visit pane after stage click');
await waitForText('Status: completed', 'recorded visit facts');
await waitForText('Timeline', 'timeline tab');
const timeline = await semantics();
const titleCandidates = timeline
.filter((entry) => entry.visible && entry.label.startsWith('plan · visit 1'))
.sort((a, b) => a.width * a.height - b.width * b.height);
if (!titleCandidates.length) {
throw new Error(`Opened visit pane missing: ${JSON.stringify(timeline.map((entry) => entry.label))}`);
}
const paneLabels = timeline.map((entry) => entry.label);
for (const section of ['Input', 'Output', 'Artifacts', 'Session', 'Definition']) {
if (!paneLabels.includes(section)) {
throw new Error(`Visit section ${section} is missing: ${JSON.stringify(paneLabels)}`);
}
}
if ((await bodyText()).includes('audit · visit')) {
throw new Error('A visit was invented for the unvisited stage');
}
check('a stage click opens the recorded visit pane', true);
check('the visit pane offers its recorded sections', true);
// The programmatic switch must reveal its own tab, not leave an offscreen
// selection behind a strip still showing Summary/Graph.
const timelineTab = await findVisible((entry) => entry.label === 'Timeline' && entry.tappable);
if (!timelineTab) throw new Error(`Timeline tab is not visible: ${JSON.stringify(await labels())}`);
if (timelineTab.x < 0 || timelineTab.x + timelineTab.width > width) {
throw new Error(`Selected Timeline tab is clipped: ${JSON.stringify({ timelineTab, width })}`);
}
check('the selected Timeline tab is revealed in the strip', `${Math.round(timelineTab.x)}..${Math.round(timelineTab.x + timelineTab.width)}`);
evidence.openedPane = titleCandidates[0];
evidence.captures.push(await capture('selected-visit'));
await navigate(
`?theme=${scheme === 'dark' ? 1 : 0}&scale=${scale}&case=missing`,
'Release verification',
);
await clickLabel('Graph');
await waitForText('This server did not include the run graph.', 'missing graph');
if ((await semantics()).some((entry) => entry.label === 'audit')) {
throw new Error('A run without a graph still drew stage nodes');
}
check('a run without a graph states the exact missing wording', true);
evidence.captures.push(await capture('missing-graph'));
console.log(JSON.stringify(evidence, null, 2));
} finally {
if (ws?.readyState === WebSocket.OPEN) {
ws.send(JSON.stringify({ id: 2147483647, method: 'Browser.close' }));
}
await Promise.race([once(chrome, 'exit'), delay(3000)]);
ws?.close();
if (chrome.exitCode === null) chrome.kill('SIGTERM');
chrome.stderr.destroy();
chrome.unref();
await new Promise((resolveClose) => {
server.close(resolveClose);
server.closeAllConnections();
});
await rm(profile, { recursive: true, force: true });
}