b60ad6d98f
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.
373 lines
17 KiB
JavaScript
373 lines
17 KiB
JavaScript
// Browser acceptance for the pipeline detail's landed Graph tab.
|
|
//
|
|
// Serves the probe build (`flutter build web -t tool/pipeline_graph_tab_probe.dart`)
|
|
// on an OS-assigned loopback port and drives the actual PipelinesScreen: open a
|
|
// pipeline, switch to Graph, select a stage node, verify the definition pane's
|
|
// pinned identity, close it with Back and confirm the Graph tab is still there.
|
|
// Captures are written for both hosts, dark at 2x; the file prefix carries the
|
|
// viewport so short-window and large-text runs cannot overwrite each other.
|
|
//
|
|
// 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/pipeline_graph_tab_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/pipeline_graph_tab_probe_web'),
|
|
);
|
|
const variant = 'material';
|
|
const scheme = process.env.PROBE_SCHEME ?? 'dark';
|
|
const scale = process.env.PROBE_SCALE ?? '2';
|
|
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 = `pipeline-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(), 'pipeline-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: false,
|
|
}, session);
|
|
const query = `?style=${variant}&dark=${scheme === 'dark' ? 1 : 0}&scale=${scale}`;
|
|
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));
|
|
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;
|
|
};
|
|
await delay(3500);
|
|
const loaded = await evaluate('({url:location.href, ready:document.readyState})');
|
|
if (!loaded?.url.includes(`127.0.0.1:${port}/${query}`)) {
|
|
throw new Error(`Fixture did not load: ${JSON.stringify(loaded)}`);
|
|
}
|
|
await evaluate("document.querySelector('flt-semantics-placeholder')?.click()");
|
|
await delay(2200);
|
|
|
|
const semantics = () => evaluate(`[...document.querySelectorAll('flt-semantics')].map(x => {
|
|
const r = x.getBoundingClientRect();
|
|
return {
|
|
label: (x.getAttribute('aria-label') || (x.innerText || '')).trim(),
|
|
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 exact = async (label) => {
|
|
const items = await semantics();
|
|
return items.filter((item) => item.label === label && item.visible)
|
|
.sort((a, b) => a.width * a.height - b.width * b.height)[0] ?? null;
|
|
};
|
|
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(1200);
|
|
};
|
|
const clickExact = async (label) => {
|
|
const item = await exact(label);
|
|
if (!item) throw new Error(`Missing control ${JSON.stringify(label)}: ${JSON.stringify(await labels())}`);
|
|
await clickItem(item);
|
|
};
|
|
// A list row's merged semantics label starts with the pipeline name and also
|
|
// carries its id/version/run text, so match that prefix and use the row box.
|
|
const clickNamed = async (name) => {
|
|
const items = await semantics();
|
|
const item = items.filter((entry) => entry.label.startsWith(name) && entry.visible)
|
|
.sort((a, b) => a.width * a.height - b.width * b.height)[0];
|
|
if (!item) throw new Error(`Missing row ${JSON.stringify(name)}: ${JSON.stringify(await labels())}`);
|
|
await clickItem(item);
|
|
};
|
|
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 });
|
|
|
|
await waitForText('Release verification', 'pipeline list');
|
|
await clickNamed('Release verification');
|
|
await waitForText('Content hash', 'pipeline detail');
|
|
check('actual pipeline detail opened from the list', true);
|
|
|
|
await clickExact('Graph');
|
|
await waitForText('select a stage for details', 'graph tab guidance');
|
|
await waitForText('inspect', 'definition stage node');
|
|
const graphSemantics = await semantics();
|
|
const note = graphSemantics.find((item) => item.label.startsWith('Scroll or pinch to zoom'));
|
|
if (!note?.visible) throw new Error(`Graph note is not visible: ${JSON.stringify(note)}`);
|
|
const tab = graphSemantics.find((item) => item.label === 'Graph');
|
|
const node = graphSemantics.find((item) => item.label === 'inspect');
|
|
if (!node?.visible || node.width <= 0 || node.height <= 0) {
|
|
throw new Error(`Measured stage node is not visible: ${JSON.stringify(node)}`);
|
|
}
|
|
// The graph is bounded: the tabs and note stay on screen above the canvas
|
|
// instead of the canvas growing with the routed layout.
|
|
if (!tab?.visible) throw new Error(`Graph tab scrolled away: ${JSON.stringify(tab)}`);
|
|
if (note.y + note.height > node.y) {
|
|
throw new Error(`Canvas overlaps the note: ${JSON.stringify({ note, node })}`);
|
|
}
|
|
if (note.height < 16) throw new Error(`Guidance note collapsed: ${JSON.stringify(note)}`);
|
|
evidence.nodeRect = node;
|
|
evidence.noteRect = note;
|
|
// A capped note must be a real scroll region with its remainder present, not
|
|
// a label clipped at the viewport edge. Flutter's semantics expose that region
|
|
// as an overflow-scrolling group with a scroll-overflow marker, so the page
|
|
// proves the hidden guidance exists and is reachable.
|
|
const noteScroll = await evaluate(`(() => {
|
|
const matches = [...document.querySelectorAll('flt-semantics')]
|
|
.filter(x => ((x.getAttribute('aria-label') || x.innerText || '').trim()
|
|
.startsWith('Scroll or pinch to zoom')));
|
|
matches.sort((a, b) =>
|
|
a.getBoundingClientRect().height - b.getBoundingClientRect().height);
|
|
let element = matches[0];
|
|
while (element && element.tagName === 'FLT-SEMANTICS') {
|
|
if (getComputedStyle(element).overflowY === 'scroll') {
|
|
const marker = element.querySelector('flt-semantics-scroll-overflow');
|
|
return {
|
|
scrollable: true,
|
|
viewport: element.getBoundingClientRect().height,
|
|
overflowHeight: marker ? marker.getBoundingClientRect().height : 0,
|
|
};
|
|
}
|
|
element = element.parentElement;
|
|
}
|
|
return { scrollable: false, viewport: 0, overflowHeight: 0 };
|
|
})()`);
|
|
evidence.noteScroll = noteScroll;
|
|
if (noteScroll.scrollable) {
|
|
if (!(noteScroll.overflowHeight > 0)) {
|
|
throw new Error(`Capped note has no scrollable remainder: ${JSON.stringify(noteScroll)}`);
|
|
}
|
|
check(
|
|
'capped guidance note is an explicit scroll region, not a clipped label',
|
|
`${Math.round(noteScroll.viewport)}px viewport`,
|
|
);
|
|
} else {
|
|
check('the guidance note fits its slot without scrolling', true);
|
|
}
|
|
check('graph tab draws a measured native stage node inside a bounded viewport', true);
|
|
check('guidance note keeps a readable slot above the canvas', `${note.width}x${note.height}`);
|
|
evidence.captures.push(await capture('graph'));
|
|
|
|
await clickExact('inspect');
|
|
await waitForText('inspect definition', 'stage definition pane');
|
|
await waitForText('Release verification · v3', 'pinned identity');
|
|
await waitForText('Inspect the candidate release.', 'stage definition field');
|
|
const paneLabels = await labels();
|
|
if (paneLabels.includes('Release verification') && !paneLabels.includes('Graph')) {
|
|
throw new Error(`Definition pane did not replace the detail: ${JSON.stringify(paneLabels)}`);
|
|
}
|
|
evidence.checks.push({
|
|
check: 'selecting a stage opens the definition pane for the exact pinned identity',
|
|
value: 'Release verification · v3',
|
|
});
|
|
evidence.captures.push(await capture('stage-definition'));
|
|
|
|
await clickExact('Back');
|
|
await waitForText('Scroll or pinch to zoom, drag to pan', 'graph tab after Back');
|
|
const afterClose = await bodyText();
|
|
if (afterClose.includes('inspect definition')) {
|
|
throw new Error(`Definition pane stayed open after Back: ${afterClose}`);
|
|
}
|
|
check('Back closes the definition pane and returns to the same graph tab', true);
|
|
evidence.captures.push(await capture('closed'));
|
|
|
|
// A capped note is a real scroll region; prove its hidden tail moves under a
|
|
// wheel rather than being unreachable clipped text.
|
|
if (noteScroll.scrollable) {
|
|
const noteScrollTop = () => evaluate(`(() => {
|
|
const matches = [...document.querySelectorAll('flt-semantics')]
|
|
.filter(x => ((x.getAttribute('aria-label') || x.innerText || '').trim()
|
|
.startsWith('Scroll or pinch to zoom')));
|
|
matches.sort((a, b) =>
|
|
a.getBoundingClientRect().height - b.getBoundingClientRect().height);
|
|
let element = matches[0];
|
|
while (element && element.tagName === 'FLT-SEMANTICS') {
|
|
if (getComputedStyle(element).overflowY === 'scroll') return element.scrollTop;
|
|
element = element.parentElement;
|
|
}
|
|
return -1;
|
|
})()`);
|
|
await send('Input.dispatchMouseEvent', {
|
|
type: 'mouseWheel',
|
|
x: Math.round(note.x + note.width / 2),
|
|
y: Math.round(note.y + note.height / 2),
|
|
deltaX: 0,
|
|
deltaY: 120,
|
|
button: 'none',
|
|
}, session);
|
|
await delay(600);
|
|
const scrolled = await noteScrollTop();
|
|
if (!(scrolled > 0)) {
|
|
throw new Error(`Wheel did not scroll the capped note: ${JSON.stringify({ scrolled, note })}`);
|
|
}
|
|
evidence.noteScrolledPixels = scrolled;
|
|
check('wheel reaches the guidance note tail inside its scroll region', `${scrolled}px`);
|
|
evidence.captures.push(await capture('note-scrolled'));
|
|
}
|
|
|
|
// The two definition states the widget tests cover also render in the real
|
|
// page. They need the list on screen, so they run where list and detail sit
|
|
// side by side instead of behind one another.
|
|
if (width >= 1200 && height >= 900) {
|
|
// At a larger text scale the last rows start below the window; wheel the
|
|
// list itself until the row is fully on screen, then click its own box.
|
|
const clickListRow = async (name) => {
|
|
for (let attempt = 0; attempt < 8; attempt++) {
|
|
const item = (await semantics())
|
|
.filter((entry) => entry.label.startsWith(name) && entry.visible)
|
|
.sort((a, b) => a.width * a.height - b.width * b.height)[0];
|
|
if (item && item.y >= 0 && item.y + item.height <= height) {
|
|
await clickItem(item);
|
|
return;
|
|
}
|
|
await send('Input.dispatchMouseEvent', {
|
|
type: 'mouseWheel',
|
|
x: Math.round(width * 0.15),
|
|
y: Math.round(height * 0.5),
|
|
deltaX: 0,
|
|
deltaY: 240,
|
|
button: 'none',
|
|
}, session);
|
|
await delay(600);
|
|
}
|
|
throw new Error(`Missing list row ${JSON.stringify(name)}: ${JSON.stringify(await labels())}`);
|
|
};
|
|
const openGraph = async (name) => {
|
|
await clickListRow(name);
|
|
await clickExact('Graph');
|
|
};
|
|
const hasStageNode = async () =>
|
|
(await semantics()).some((item) => item.label === 'inspect' && item.visible);
|
|
|
|
await openGraph('Unparsed definition');
|
|
await waitForText('did not include the pipeline definition graph', 'missing graph state');
|
|
if (await hasStageNode()) {
|
|
throw new Error('A reply without a graph still drew a stage node');
|
|
}
|
|
check('a reply without a definition graph states it and draws nothing', true);
|
|
evidence.captures.push(await capture('missing-graph'));
|
|
|
|
await openGraph('Empty definition');
|
|
await waitForText('This pipeline has no stages.', 'empty definition state');
|
|
if (await hasStageNode()) {
|
|
throw new Error('An empty definition still drew a stage node');
|
|
}
|
|
check('an empty definition keeps its native empty message', true);
|
|
evidence.captures.push(await capture('empty-definition'));
|
|
}
|
|
|
|
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 });
|
|
}
|