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.
714 lines
22 KiB
JavaScript
714 lines
22 KiB
JavaScript
// Real-browser acceptance for the registered Templates destination.
|
|
//
|
|
// From app/:
|
|
// flutter build web -o build/templates_wiring_web
|
|
// OPENCODE_ARTIFACT_DIR=<shared public dir> \
|
|
// node tool/templates_wiring_probe.mjs build/templates_wiring_web
|
|
//
|
|
// The fixture server is an isolated loopback implementation of the Pipelines
|
|
// websocket protocol used by
|
|
// this flow; no production server, database or operator data is involved.
|
|
import { createServer } from 'node:http';
|
|
import { readFile, mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
|
|
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 { createHash } from 'node:crypto';
|
|
|
|
const root = resolve(process.argv[2] ?? 'build/templates_wiring_web');
|
|
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 host = 'material';
|
|
const width = Number(process.env.PROBE_WIDTH ?? 390);
|
|
const height = Number(process.env.PROBE_HEIGHT ?? 844);
|
|
const deviceScaleFactor = Number(process.env.PROBE_DPR ?? 1);
|
|
const capturePrefix = process.env.PROBE_CAPTURE_PREFIX ?? `t1-wire-${host}`;
|
|
|
|
const MIME = {
|
|
'.html': 'text/html; charset=utf-8',
|
|
'.js': 'text/javascript; charset=utf-8',
|
|
'.mjs': 'text/javascript; charset=utf-8',
|
|
'.json': 'application/json; charset=utf-8',
|
|
'.wasm': 'application/wasm',
|
|
'.png': 'image/png',
|
|
'.svg': 'image/svg+xml',
|
|
'.ico': 'image/x-icon',
|
|
'.ttf': 'font/ttf',
|
|
'.otf': 'font/otf',
|
|
'.woff': 'font/woff',
|
|
'.woff2': 'font/woff2',
|
|
};
|
|
|
|
const PIPELINES = [
|
|
{
|
|
id: 1, name: 'Alpha review', version: 2, stages: 2,
|
|
created_at: '2026-10-21T09:00:00', updated_at: '2026-10-21T10:00:00',
|
|
scheduled: true, schedule_count: 1, enabled_schedule_count: 1,
|
|
},
|
|
{
|
|
id: 2, name: 'Beta deploy', version: 1, stages: 1,
|
|
created_at: '2026-10-20T09:00:00', updated_at: '2026-10-20T10:00:00',
|
|
scheduled: false, schedule_count: 0, enabled_schedule_count: 0,
|
|
},
|
|
];
|
|
const RUNS = [
|
|
{
|
|
id: 42, pipeline_id: 1, status: 'succeeded',
|
|
created_at: '2026-10-21T09:30:00', finished_at: '2026-10-21T09:35:00',
|
|
executing: false,
|
|
},
|
|
];
|
|
const TEMPLATE = {
|
|
key: 'release',
|
|
name: 'Release workflow',
|
|
description: 'Ship a version',
|
|
source: 'name: "release"\nstages:\n build:\n type: model\n',
|
|
scheduled: true,
|
|
};
|
|
|
|
function accept(key) {
|
|
return createHash('sha1')
|
|
.update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)
|
|
.digest('base64');
|
|
}
|
|
|
|
function frame(opcode, payload) {
|
|
const length = payload.length;
|
|
let header;
|
|
if (length < 126) {
|
|
header = Buffer.from([0x80 | opcode, length]);
|
|
} else if (length < 65536) {
|
|
header = Buffer.alloc(4);
|
|
header[0] = 0x80 | opcode;
|
|
header[1] = 126;
|
|
header.writeUInt16BE(length, 2);
|
|
} else {
|
|
header = Buffer.alloc(10);
|
|
header[0] = 0x80 | opcode;
|
|
header[1] = 127;
|
|
header.writeBigUInt64BE(BigInt(length), 2);
|
|
}
|
|
return Buffer.concat([header, payload]);
|
|
}
|
|
|
|
class Connection {
|
|
constructor(socket, owner) {
|
|
this.socket = socket;
|
|
this.owner = owner;
|
|
this.buffer = Buffer.alloc(0);
|
|
this.fragments = [];
|
|
this.fragmentOpcode = 0;
|
|
}
|
|
|
|
push(chunk) {
|
|
if (chunk?.length) this.buffer = Buffer.concat([this.buffer, chunk]);
|
|
this.parse();
|
|
}
|
|
|
|
parse() {
|
|
while (this.buffer.length >= 2) {
|
|
const first = this.buffer[0];
|
|
const second = this.buffer[1];
|
|
const fin = (first & 0x80) !== 0;
|
|
const opcode = first & 0x0f;
|
|
const masked = (second & 0x80) !== 0;
|
|
let length = second & 0x7f;
|
|
let offset = 2;
|
|
if (length === 126) {
|
|
if (this.buffer.length < 4) return;
|
|
length = this.buffer.readUInt16BE(2);
|
|
offset = 4;
|
|
} else if (length === 127) {
|
|
if (this.buffer.length < 10) return;
|
|
const big = this.buffer.readBigUInt64BE(2);
|
|
if (big > BigInt(Number.MAX_SAFE_INTEGER)) return this.close();
|
|
length = Number(big);
|
|
offset = 10;
|
|
}
|
|
const maskOffset = offset;
|
|
if (masked) {
|
|
if (this.buffer.length < offset + 4) return;
|
|
offset += 4;
|
|
}
|
|
if (this.buffer.length < offset + length) return;
|
|
let payload = Buffer.from(this.buffer.subarray(offset, offset + length));
|
|
if (masked) {
|
|
const mask = this.buffer.subarray(maskOffset, maskOffset + 4);
|
|
for (let index = 0; index < payload.length; index++) {
|
|
payload[index] ^= mask[index % 4];
|
|
}
|
|
}
|
|
this.buffer = this.buffer.subarray(offset + length);
|
|
this.handleFrame(fin, opcode, payload);
|
|
}
|
|
}
|
|
|
|
handleFrame(fin, opcode, payload) {
|
|
if (opcode === 0x8) return this.close();
|
|
if (opcode === 0x9) return void this.socket.write(frame(0x0a, payload));
|
|
if (opcode === 0x0a) return;
|
|
if (opcode === 0x0) {
|
|
this.fragments.push(payload);
|
|
if (fin) {
|
|
const data = Buffer.concat(this.fragments);
|
|
this.fragments = [];
|
|
this.message(this.fragmentOpcode, data);
|
|
}
|
|
return;
|
|
}
|
|
if (opcode !== 0x1) return;
|
|
if (!fin) {
|
|
this.fragmentOpcode = opcode;
|
|
this.fragments = [payload];
|
|
return;
|
|
}
|
|
this.message(opcode, payload);
|
|
}
|
|
|
|
message(_opcode, payload) {
|
|
let request;
|
|
try {
|
|
request = JSON.parse(payload.toString('utf8'));
|
|
} catch {
|
|
return;
|
|
}
|
|
this.owner.onMessage(this, request);
|
|
}
|
|
|
|
send(value) {
|
|
if (this.socket.destroyed) return;
|
|
this.socket.write(frame(0x1, Buffer.from(JSON.stringify(value))));
|
|
}
|
|
|
|
close() {
|
|
if (!this.socket.destroyed) this.socket.end();
|
|
}
|
|
}
|
|
|
|
async function staticFile(base, pathname, req, res) {
|
|
let file = resolve(base, `.${pathname}`);
|
|
if (file !== base && !file.startsWith(base + sep)) {
|
|
res.writeHead(403).end();
|
|
return;
|
|
}
|
|
try {
|
|
if ((await stat(file)).isDirectory()) file = join(file, 'index.html');
|
|
} catch {
|
|
if (extname(pathname)) {
|
|
res.writeHead(404).end('not found');
|
|
return;
|
|
}
|
|
file = join(base, 'index.html');
|
|
}
|
|
try {
|
|
const body = await readFile(file);
|
|
res
|
|
.writeHead(200, {
|
|
'content-type': MIME[extname(file)] ?? 'application/octet-stream',
|
|
'cache-control': 'no-store',
|
|
})
|
|
.end(req.method === 'HEAD' ? undefined : body);
|
|
} catch {
|
|
res.writeHead(404).end('not found');
|
|
}
|
|
}
|
|
|
|
async function startFixture(base) {
|
|
const connections = new Set();
|
|
const sockets = new Set();
|
|
const state = {
|
|
connections: 0,
|
|
subscribed: 0,
|
|
ping: 0,
|
|
listPipelines: 0,
|
|
listRuns: 0,
|
|
listTemplates: 0,
|
|
validates: 0,
|
|
submits: 0,
|
|
submitsBody: [],
|
|
};
|
|
const created = [];
|
|
const pipelines = () => [
|
|
...PIPELINES,
|
|
...created.map((item) => ({
|
|
id: item.id,
|
|
name: item.name,
|
|
version: 1,
|
|
stages: 1,
|
|
created_at: '2026-10-22T00:00:00',
|
|
updated_at: '2026-10-22T00:00:00',
|
|
scheduled: false,
|
|
schedule_count: 0,
|
|
enabled_schedule_count: 0,
|
|
})),
|
|
];
|
|
|
|
const server = createServer(async (req, res) => {
|
|
const pathname = new URL(req.url, 'http://fixture').pathname;
|
|
if (pathname === '/fixture/state') {
|
|
res
|
|
.writeHead(200, { 'content-type': 'application/json' })
|
|
.end(JSON.stringify({ ...state, pipelines: pipelines().length }));
|
|
return;
|
|
}
|
|
if (req.method !== 'GET' && req.method !== 'HEAD') {
|
|
res.writeHead(405).end();
|
|
return;
|
|
}
|
|
await staticFile(base, pathname, req, res);
|
|
});
|
|
|
|
server.on('upgrade', (req, socket, head) => {
|
|
const url = new URL(req.url, 'http://fixture');
|
|
if (
|
|
url.pathname !== '/connect' ||
|
|
req.headers.upgrade?.toLowerCase() !== 'websocket' ||
|
|
!req.headers['sec-websocket-key']
|
|
) {
|
|
socket.end('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
|
|
return;
|
|
}
|
|
socket.write(
|
|
'HTTP/1.1 101 Switching Protocols\r\n' +
|
|
'Upgrade: websocket\r\n' +
|
|
'Connection: Upgrade\r\n' +
|
|
`Sec-WebSocket-Accept: ${accept(req.headers['sec-websocket-key'])}\r\n\r\n`,
|
|
);
|
|
const connection = new Connection(socket, {
|
|
onMessage: (client, request) => {
|
|
if (request.type === 'subscribe') {
|
|
// Like the real server in this app's probes, the watch stays silent.
|
|
state.subscribed++;
|
|
return;
|
|
}
|
|
if (request.type === 'unsubscribe') return;
|
|
if (request.type === 'ping') {
|
|
state.ping++;
|
|
client.send({
|
|
id: request.id,
|
|
type: 'pong',
|
|
build: { version: 'fixture templates build' },
|
|
time: '2026-10-22T00:00:00Z',
|
|
});
|
|
return;
|
|
}
|
|
if (request.type === 'list_pipelines') {
|
|
state.listPipelines++;
|
|
client.send({ id: request.id, type: 'pipelines', pipelines: pipelines() });
|
|
return;
|
|
}
|
|
if (request.type === 'list_runs') {
|
|
state.listRuns++;
|
|
client.send({ id: request.id, type: 'runs', runs: RUNS });
|
|
return;
|
|
}
|
|
if (request.type === 'list_templates') {
|
|
state.listTemplates++;
|
|
client.send({ id: request.id, type: 'templates', templates: [TEMPLATE] });
|
|
return;
|
|
}
|
|
if (request.type === 'validate') {
|
|
state.validates++;
|
|
client.send({ id: request.id, type: 'graph', graph: { stages: [] } });
|
|
return;
|
|
}
|
|
if (request.type === 'submit') {
|
|
state.submits++;
|
|
state.submitsBody.push({
|
|
name: request.name,
|
|
source: request.source,
|
|
create_only: request.create_only,
|
|
});
|
|
const id = 41 + created.length;
|
|
const name = String(request.name ?? '').trim() || 'Unnamed';
|
|
created.push({ id, name, source: request.source });
|
|
client.send({
|
|
id: request.id,
|
|
type: 'pipeline',
|
|
detail: { id, name },
|
|
});
|
|
return;
|
|
}
|
|
client.send({
|
|
id: request.id,
|
|
type: 'error',
|
|
error: `Fixture does not implement ${request.type}`,
|
|
});
|
|
},
|
|
});
|
|
connections.add(connection);
|
|
state.connections = connections.size;
|
|
socket.on('data', (chunk) => connection.push(chunk));
|
|
socket.on('close', () => {
|
|
connections.delete(connection);
|
|
state.connections = connections.size;
|
|
});
|
|
socket.on('error', () => connections.delete(connection));
|
|
connection.push(head);
|
|
});
|
|
|
|
server.listen(0, '127.0.0.1');
|
|
await once(server, 'listening');
|
|
server.on('connection', (socket) => {
|
|
sockets.add(socket);
|
|
socket.on('close', () => sockets.delete(socket));
|
|
});
|
|
const port = server.address().port;
|
|
return {
|
|
server,
|
|
origin: `http://127.0.0.1:${port}`,
|
|
created,
|
|
close: () =>
|
|
new Promise((resolveClose) => {
|
|
for (const connection of connections) connection.close();
|
|
server.close(() => resolveClose());
|
|
for (const socket of sockets) socket.destroy();
|
|
}),
|
|
};
|
|
}
|
|
|
|
const fixture = await startFixture(await realpathOrSelf(root));
|
|
const profile = await mkdtemp(join(tmpdir(), 'templates-wiring-chrome-'));
|
|
const chrome = spawn(
|
|
'/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
|
|
[
|
|
'--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;
|
|
});
|
|
|
|
function realpathOrSelf(path) {
|
|
return resolve(path);
|
|
}
|
|
|
|
async function waitFor(check, label, attempts = 180) {
|
|
for (let attempt = 0; attempt < attempts; attempt++) {
|
|
const value = await check();
|
|
if (value) return value;
|
|
await delay(100);
|
|
}
|
|
throw new Error(`Timed out waiting for ${label}\n${stderr.slice(-1200)}`);
|
|
}
|
|
|
|
let ws;
|
|
try {
|
|
const endpoint = await waitFor(
|
|
() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1],
|
|
'Chrome DevTools',
|
|
);
|
|
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 target = (await send('Target.createTarget', { url: 'about:blank' })).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.setDeviceMetricsOverride',
|
|
{ width, height, deviceScaleFactor, mobile: true },
|
|
session,
|
|
);
|
|
await send(
|
|
'Emulation.setEmulatedMedia',
|
|
{ features: [{ name: 'prefers-color-scheme', value: 'dark' }] },
|
|
session,
|
|
);
|
|
|
|
const evaluate = async (expression) => {
|
|
const response = await send(
|
|
'Runtime.evaluate',
|
|
{ expression, returnByValue: true, awaitPromise: true },
|
|
session,
|
|
);
|
|
if (response.error) throw new Error(JSON.stringify(response));
|
|
if (response.result?.exceptionDetails) {
|
|
throw new Error(JSON.stringify(response.result.exceptionDetails));
|
|
}
|
|
return response.result?.result?.value;
|
|
};
|
|
|
|
const semanticText = () =>
|
|
evaluate(`(() => {
|
|
const chunks = [];
|
|
for (const el of document.querySelectorAll('flt-semantics')) {
|
|
const label = el.getAttribute('aria-label');
|
|
if (label) chunks.push(label);
|
|
if (!el.children.length && el.innerText) chunks.push(el.innerText);
|
|
}
|
|
for (const el of document.querySelectorAll('input, textarea')) {
|
|
if (el.getAttribute('aria-label')) chunks.push(el.getAttribute('aria-label'));
|
|
if (el.value) chunks.push(String(el.value));
|
|
}
|
|
if (document.body?.innerText) chunks.push(document.body.innerText);
|
|
return [...new Set(chunks)].join('\\n');
|
|
})()`);
|
|
|
|
const labels = () =>
|
|
evaluate(
|
|
"[...document.querySelectorAll('flt-semantics')].map((el) => (el.getAttribute('aria-label') || el.innerText || '').trim()).filter(Boolean)",
|
|
);
|
|
|
|
const assertBody = async (text) => {
|
|
try {
|
|
await waitFor(
|
|
async () => (await semanticText()).includes(text),
|
|
`body to contain ${JSON.stringify(text)}`,
|
|
);
|
|
} catch (error) {
|
|
throw new Error(
|
|
`${error.message}\nBody now:\n${(await semanticText()).slice(0, 3000)}`,
|
|
);
|
|
}
|
|
};
|
|
|
|
const pathname = () => evaluate('location.pathname');
|
|
const assertPath = async (path) => {
|
|
await waitFor(async () => (await pathname()) === path, `path ${path}`);
|
|
};
|
|
|
|
const labelPoint = (label, contains) =>
|
|
evaluate(`(() => {
|
|
const needle = ${JSON.stringify(label)};
|
|
const candidates = [...document.querySelectorAll('flt-semantics')].filter((el) => {
|
|
const text = (el.getAttribute('aria-label') || el.innerText || '').trim();
|
|
return ${contains ? 'text.includes(needle)' : 'text === needle'};
|
|
});
|
|
const target = candidates.find((el) =>
|
|
['button', 'tab', 'link', 'checkbox', 'menuitem'].includes(el.getAttribute('role')),
|
|
) ?? candidates[0];
|
|
if (!target) return null;
|
|
const r = target.getBoundingClientRect();
|
|
if (r.width === 0 || r.height === 0) return null;
|
|
return { x: r.x + r.width / 2, y: r.y + r.height / 2 };
|
|
})()`);
|
|
|
|
const wheel = async (deltaY) => {
|
|
await send(
|
|
'Input.dispatchMouseEvent',
|
|
{
|
|
type: 'mouseWheel',
|
|
x: width / 2,
|
|
y: height / 2,
|
|
deltaX: 0,
|
|
deltaY,
|
|
},
|
|
session,
|
|
);
|
|
await delay(250);
|
|
};
|
|
|
|
const clickLabel = async (label, { contains = false } = {}) => {
|
|
for (let attempt = 0; attempt < 12; attempt++) {
|
|
const point = await labelPoint(label, contains);
|
|
if (point && point.y > 4 && point.y < height - 4) {
|
|
await send(
|
|
'Input.dispatchMouseEvent',
|
|
{ type: 'mousePressed', x: point.x, y: point.y, button: 'left', clickCount: 1 },
|
|
session,
|
|
);
|
|
await send(
|
|
'Input.dispatchMouseEvent',
|
|
{ type: 'mouseReleased', x: point.x, y: point.y, button: 'left', clickCount: 1 },
|
|
session,
|
|
);
|
|
await delay(500);
|
|
return;
|
|
}
|
|
// The Settings page scrolls; bring an off-screen row into the viewport.
|
|
await wheel(point && point.y < 0 ? -350 : 350);
|
|
}
|
|
throw new Error(
|
|
`Could not click ${JSON.stringify(label)}. Labels: ${JSON.stringify(await labels())}`,
|
|
);
|
|
};
|
|
|
|
const typeIntoFocused = async (value) => {
|
|
const focused = await evaluate(`(() => {
|
|
const inputs = [...document.querySelectorAll('input, textarea')].filter((el) => {
|
|
const r = el.getBoundingClientRect();
|
|
return r.width > 0 && r.height > 0;
|
|
});
|
|
const input = inputs[inputs.length - 1];
|
|
if (!input) return false;
|
|
input.focus();
|
|
input.select?.();
|
|
input.setSelectionRange?.(0, (input.value || '').length);
|
|
return true;
|
|
})()`);
|
|
if (!focused) throw new Error('No semantics input was available to type into');
|
|
await delay(300);
|
|
await send('Input.insertText', { text: value }, session);
|
|
await delay(400);
|
|
};
|
|
|
|
const state = () =>
|
|
evaluate(`fetch('${fixture.origin}/fixture/state').then((r) => r.json())`);
|
|
const capture = async (name) => {
|
|
const data = (
|
|
await send('Page.captureScreenshot', { format: 'png' }, session)
|
|
).result.data;
|
|
const path = join(artifactDir, `${name}.png`);
|
|
await writeFile(path, Buffer.from(data, 'base64'));
|
|
return path;
|
|
};
|
|
|
|
const checks = [];
|
|
const captures = [];
|
|
|
|
await send('Page.navigate', { url: `${fixture.origin}/` }, session);
|
|
await waitFor(
|
|
() => evaluate("Boolean(document.querySelector('flt-semantics-placeholder'))"),
|
|
'semantics placeholder',
|
|
);
|
|
await evaluate("document.querySelector('flt-semantics-placeholder')?.click()");
|
|
await delay(900);
|
|
|
|
await assertBody('Alpha review');
|
|
captures.push(await capture(`${capturePrefix}-pipelines`));
|
|
|
|
await clickLabel('Settings');
|
|
await assertPath('/settings');
|
|
await assertBody('Server URL');
|
|
await assertBody('Browse templates');
|
|
const settingsState = await state();
|
|
captures.push(await capture(`${capturePrefix}-settings`));
|
|
|
|
await clickLabel('Browse templates', { contains: true });
|
|
await assertPath('/templates');
|
|
await assertBody('Release workflow');
|
|
const opened = await state();
|
|
if (opened.listTemplates !== 1) {
|
|
throw new Error(`Templates did not read the catalogue once: ${JSON.stringify(opened)}`);
|
|
}
|
|
captures.push(await capture(`${capturePrefix}-gallery`));
|
|
|
|
await clickLabel('Release workflow', { contains: true });
|
|
await assertBody('Definition source');
|
|
await assertBody('Create pipeline from this template');
|
|
const detail = await state();
|
|
if (detail.validates !== 0 || detail.submits !== 0) {
|
|
throw new Error(`Opening a template sent a write: ${JSON.stringify(detail)}`);
|
|
}
|
|
captures.push(await capture(`${capturePrefix}-detail`));
|
|
|
|
await clickLabel('Create pipeline from this template');
|
|
await assertBody('Create from Release workflow');
|
|
await typeIntoFocused('Probe release');
|
|
await clickLabel('Create');
|
|
await assertBody('Created "Probe release". It is in the Pipelines list.');
|
|
const createdState = await state();
|
|
if (
|
|
createdState.validates !== 1 ||
|
|
createdState.submits !== 1 ||
|
|
createdState.submitsBody?.[0]?.create_only !== true ||
|
|
createdState.submitsBody?.[0]?.source !== TEMPLATE.source
|
|
) {
|
|
throw new Error(`The accepted create drifted: ${JSON.stringify(createdState)}`);
|
|
}
|
|
if (createdState.listPipelines !== 2) {
|
|
throw new Error(
|
|
`The accepted detail did not request exactly one fresh list: ${JSON.stringify(createdState)}`,
|
|
);
|
|
}
|
|
captures.push(await capture(`${capturePrefix}-created`));
|
|
checks.push({ check: 'created detail triggered one fresh list read', state: createdState });
|
|
|
|
await clickLabel('Close');
|
|
await assertBody('Definition source');
|
|
|
|
// Detail Back returns to the gallery; the page Back restores Settings.
|
|
await clickLabel(host === 'material' ? 'Back Templates' : 'Back');
|
|
await assertBody('Release workflow');
|
|
await clickLabel('Back to Settings');
|
|
await assertPath('/settings');
|
|
await assertBody('Server URL');
|
|
await assertBody('Browse templates');
|
|
captures.push(await capture(`${capturePrefix}-back-settings`));
|
|
const restored = await state();
|
|
if (restored.listTemplates !== 1 || restored.submits !== 1) {
|
|
throw new Error(`Returning to Settings re-read or re-submitted: ${JSON.stringify(restored)}`);
|
|
}
|
|
if (restored.ping !== settingsState.ping) {
|
|
throw new Error(`Settings was remounted instead of preserved: ${JSON.stringify(restored)}`);
|
|
}
|
|
checks.push({ check: 'Back restored the same Settings screen', state: restored });
|
|
|
|
await clickLabel('Pipelines');
|
|
await assertPath('/pipelines');
|
|
await assertBody('Probe release');
|
|
const refreshed = await state();
|
|
if (refreshed.listPipelines !== 2 || refreshed.listRuns !== 2) {
|
|
throw new Error(`Showing Pipelines added a read: ${JSON.stringify(refreshed)}`);
|
|
}
|
|
if (refreshed.connections !== 1) {
|
|
throw new Error(`Templates opened a second socket: ${JSON.stringify(refreshed)}`);
|
|
}
|
|
captures.push(await capture(`${capturePrefix}-refreshed-pipelines`));
|
|
checks.push({ check: 'Pipelines showed the server row over one socket', state: refreshed });
|
|
|
|
console.log(
|
|
JSON.stringify(
|
|
{
|
|
ok: true,
|
|
origin: fixture.origin,
|
|
host,
|
|
viewport: { width, height, deviceScaleFactor },
|
|
checks,
|
|
captures,
|
|
},
|
|
null,
|
|
2,
|
|
),
|
|
);
|
|
} finally {
|
|
ws?.close();
|
|
chrome.kill('SIGTERM');
|
|
await Promise.race([once(chrome, 'exit'), delay(3000)]);
|
|
await fixture.close();
|
|
await rm(profile, { recursive: true, force: true });
|
|
}
|