Files
moli/scripts/playwright-cdp-smoke.mjs
T
Donough Liu 76dfcbcaac fix(downloads): stream retained and authorized Blob downloads (#2968)
Retain immutable Blob backing after authorizing the initiating Document storage key and partition. Stream bounded chunks through the existing download artifact lifecycle and report unavailable local Blob URLs as canceled downloads.

Include the Playwright callback regression from #2970, large Blob transport and artifact checks, permission isolation, read-error cleanup and cancellation coverage.

Consolidates #2970.
Fixes #2932.
2026-11-15 23:11:50 +08:00

1602 lines
58 KiB
JavaScript
Executable File

#!/usr/bin/env node
import { createServer } from 'node:http';
import { checkFulfilledRedirectRouting } from './playwright-cdp-smoke-redirect-routing.mjs';
import { checkBlobDownloadDelivery } from './playwright-cdp-smoke-blob-downloads.mjs';
import { createRequire } from 'node:module';
import { mkdtempSync, readFileSync, rmSync, writeFileSync, existsSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { dirname, join, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import { spawn } from 'node:child_process';
import { createHash } from 'node:crypto';
const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
const require = createRequire(import.meta.url);
const PROXY_ENV_KEYS = [
'HTTP_PROXY',
'HTTPS_PROXY',
'ALL_PROXY',
'http_proxy',
'https_proxy',
'all_proxy',
];
function usage() {
return [
'Usage: node scripts/playwright-cdp-smoke.mjs',
'',
'Environment:',
' MOLI_BIN=/path/to/moli Override the binary under test.',
' PLAYWRIGHT_CORE_MODULE=playwright-core Override the Playwright module name/path.',
' MOLI_CDP_PORT=9222 Override the CDP port; defaults to a free local port.',
].join('\n');
}
function clearProxyEnv(env) {
const next = { ...env };
for (const key of PROXY_ENV_KEYS) {
delete next[key];
}
next.NO_PROXY = '*';
next.no_proxy = '*';
return next;
}
for (const key of PROXY_ENV_KEYS) {
delete process.env[key];
}
process.env.NO_PROXY = '*';
process.env.no_proxy = '*';
function loadPlaywright() {
const moduleName = process.env.PLAYWRIGHT_CORE_MODULE || 'playwright-core';
try {
return require(moduleName);
} catch (error) {
throw new Error(
`failed to load ${moduleName}. Install playwright-core in this checkout or set NODE_PATH/PLAYWRIGHT_CORE_MODULE.\n${usage()}\n${error.message}`,
);
}
}
function moliBinary() {
if (process.env.MOLI_BIN) {
return resolve(process.env.MOLI_BIN);
}
const candidates = [
join(repoRoot, 'target', 'debug', 'moli'),
join(repoRoot, 'target', 'release', 'moli'),
];
for (const candidate of candidates) {
if (existsSync(candidate)) {
return candidate;
}
}
throw new Error(
'missing moli binary. Build one first with `cargo build -p moli`, or set MOLI_BIN.',
);
}
async function reservePort() {
const server = createServer();
await new Promise((resolveListen, rejectListen) => {
server.once('error', rejectListen);
server.listen(0, '127.0.0.1', resolveListen);
});
const { port } = server.address();
await new Promise((resolveClose, rejectClose) => {
server.close(error => (error ? rejectClose(error) : resolveClose()));
});
return port;
}
async function listen(server) {
await new Promise((resolveListen, rejectListen) => {
server.once('error', rejectListen);
server.listen(0, '127.0.0.1', resolveListen);
});
const { port } = server.address();
return `http://127.0.0.1:${port}`;
}
function websocketAcceptKey(key) {
return createHash('sha1')
.update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`)
.digest('base64');
}
function websocketFrame(opcode, payload) {
const body = Buffer.from(payload);
if (body.length < 126) {
return Buffer.concat([Buffer.from([0x80 | opcode, body.length]), body]);
}
if (body.length <= 0xffff) {
const header = Buffer.alloc(4);
header[0] = 0x80 | opcode;
header[1] = 126;
header.writeUInt16BE(body.length, 2);
return Buffer.concat([header, body]);
}
throw new Error(`fixture websocket frame too large: ${body.length}`);
}
function websocketTextFrame(text) {
return websocketFrame(0x1, Buffer.from(text, 'utf8'));
}
function websocketCloseFrame(code = 1000, reason = '') {
const reasonBytes = Buffer.from(reason, 'utf8');
const payload = Buffer.alloc(2 + reasonBytes.length);
payload.writeUInt16BE(code, 0);
reasonBytes.copy(payload, 2);
return websocketFrame(0x8, payload);
}
function drainWebSocketFrames(buffer, onFrame) {
let offset = 0;
while (buffer.length - offset >= 2) {
const first = buffer[offset];
const second = buffer[offset + 1];
const opcode = first & 0x0f;
const masked = (second & 0x80) !== 0;
let payloadLength = second & 0x7f;
let headerLength = 2;
if (payloadLength === 126) {
if (buffer.length - offset < 4) {
break;
}
payloadLength = buffer.readUInt16BE(offset + 2);
headerLength = 4;
} else if (payloadLength === 127) {
throw new Error('fixture websocket does not support 64-bit frames');
}
const maskLength = masked ? 4 : 0;
const frameLength = headerLength + maskLength + payloadLength;
if (buffer.length - offset < frameLength) {
break;
}
const maskOffset = offset + headerLength;
const payloadOffset = maskOffset + maskLength;
const payload = Buffer.from(buffer.subarray(payloadOffset, payloadOffset + payloadLength));
if (masked) {
const mask = buffer.subarray(maskOffset, maskOffset + 4);
for (let index = 0; index < payload.length; index += 1) {
payload[index] ^= mask[index % 4];
}
}
onFrame(opcode, payload);
offset += frameLength;
}
return buffer.subarray(offset);
}
function startFixtureServer() {
const profileRequests = new Map();
const server = createServer((req, res) => {
const url = new URL(req.url || '/', 'http://127.0.0.1');
const send = (status, contentType, body) => {
res.writeHead(status, {
'content-type': contentType,
'cache-control': 'no-store',
});
res.end(body);
};
if (url.pathname === '/favicon.ico') {
res.writeHead(204);
res.end();
return;
}
if (url.pathname === '/plain') {
send(200, 'text/html; charset=utf-8', '<!doctype html><main>plain ok</main>');
return;
}
if (url.pathname === '/iframe') {
send(
200,
'text/html; charset=utf-8',
'<!doctype html><main>parent</main><iframe src="/child"></iframe>',
);
return;
}
if (url.pathname === '/child') {
send(200, 'text/html; charset=utf-8', '<!doctype html><body>child body text</body>');
return;
}
if (url.pathname === '/wait-for-function') {
send(
200,
'text/html; charset=utf-8',
'<!doctype html><body><script>setTimeout(() => { globalThis.__ready = true; }, 50);</script></body>',
);
return;
}
if (url.pathname === '/set-cookie') {
res.writeHead(200, {
'content-type': 'text/html; charset=utf-8',
'cache-control': 'no-store',
'set-cookie': 'serverCookie=server; Path=/; SameSite=Lax',
});
res.end('<!doctype html><main>cookie set</main>');
return;
}
if (url.pathname === '/echo-cookie') {
send(200, 'text/plain; charset=utf-8', req.headers.cookie || '');
return;
}
if (url.pathname === '/profile-headers') {
const token = url.searchParams.get('token') || '';
profileRequests.set(token, {
userAgent: req.headers['user-agent'] || null,
acceptLanguage: req.headers['accept-language'] || null,
extraHeader: req.headers['x-moli-profile-smoke'] || null,
referer: req.headers.referer || null,
});
send(200, 'text/html; charset=utf-8', '<!doctype html><main>profile headers captured</main>');
return;
}
if (url.pathname === '/profile-result') {
const token = url.searchParams.get('token') || '';
send(
200,
'application/json; charset=utf-8',
JSON.stringify(profileRequests.get(token) || null),
);
return;
}
if (url.pathname === '/redirect-start') {
res.writeHead(302, {
location: '/redirect-final',
'cache-control': 'no-store',
'set-cookie': 'redirectCookie=redirect; Path=/; SameSite=Lax',
});
res.end();
return;
}
if (url.pathname === '/redirect-final') {
send(200, 'text/html; charset=utf-8', '<!doctype html><main>redirect final</main>');
return;
}
if (url.pathname === '/history-a') {
send(200, 'text/html; charset=utf-8', '<!doctype html><main>history a</main>');
return;
}
if (url.pathname === '/history-b') {
send(200, 'text/html; charset=utf-8', '<!doctype html><main>history b</main>');
return;
}
if (url.pathname === '/document-continue') {
send(
200,
'text/html; charset=utf-8',
`<!doctype html><main>${req.headers['x-smoke-nav-route'] || 'missing-nav-route-header'}</main>`,
);
return;
}
if (url.pathname === '/route-redirect-destination') {
send(404, 'text/plain; charset=utf-8', 'redirect destination backend');
return;
}
if (url.pathname === '/api') {
send(500, 'text/plain; charset=utf-8', 'route did not intercept /api');
return;
}
if (url.pathname === '/api-continue') {
send(
200,
'application/json; charset=utf-8',
JSON.stringify({
method: req.method,
routeHeader: req.headers['x-smoke-route'] || null,
}),
);
return;
}
if (url.pathname === '/api-abort') {
send(200, 'text/plain; charset=utf-8', 'route abort did not intercept /api-abort');
return;
}
if (url.pathname === '/parser-script-page') {
send(
200,
'text/html; charset=utf-8',
'<!doctype html><body><script src="/parser-script.js"></script><main>parser script page</main></body>',
);
return;
}
if (url.pathname === '/parser-script.js') {
send(
200,
'text/javascript; charset=utf-8',
'globalThis.__smokeParserScriptValue = "parser script loaded";',
);
return;
}
if (url.pathname === '/worker.js') {
send(
200,
'text/javascript; charset=utf-8',
[
'self.onmessage = async event => {',
' if (event.data && event.data.kind === "fetch") {',
' try {',
' const response = await fetch(event.data.url);',
' const text = await response.text();',
' self.postMessage({ kind: "fetch", ok: true, status: response.status, text });',
' } catch (error) {',
' self.postMessage({',
' kind: "fetch",',
' ok: false,',
' error: `${error?.constructor?.name || "Error"}:${error?.message || String(error)}`,',
' });',
' }',
' return;',
' }',
' if (event.data && event.data.kind === "xhr") {',
' const xhr = new XMLHttpRequest();',
' xhr.open("GET", event.data.url, true);',
' xhr.onload = () => {',
' self.postMessage({ kind: "xhr", ok: true, status: xhr.status, text: xhr.responseText });',
' };',
' xhr.onerror = () => {',
' self.postMessage({ kind: "xhr", ok: false, error: `NetworkError:${xhr.status}` });',
' };',
' xhr.send();',
' return;',
' }',
' self.postMessage({',
' echoed: event.data,',
' pathname: self.location.pathname,',
' selfEqualsGlobal: self === globalThis,',
' });',
'};',
].join('\n'),
);
return;
}
if (url.pathname === '/download-page') {
send(
200,
'text/html; charset=utf-8',
[
'<!doctype html>',
'<a id="download" href="/download">download</a>',
'<a id="slow-download" href="/slow-download" download>slow download</a>',
].join(''),
);
return;
}
if (url.pathname === '/worker-route-continue') {
send(
200,
'application/json; charset=utf-8',
JSON.stringify({
method: req.method,
routeHeader: req.headers['x-smoke-worker-route'] || null,
}),
);
return;
}
if (url.pathname === '/worker-route-fulfill') {
send(500, 'text/plain; charset=utf-8', 'worker route did not fulfill /worker-route-fulfill');
return;
}
if (url.pathname === '/worker-route-abort') {
send(200, 'text/plain; charset=utf-8', 'worker route did not abort /worker-route-abort');
return;
}
if (url.pathname === '/download') {
res.writeHead(200, {
'content-type': 'text/plain; charset=utf-8',
'cache-control': 'no-store',
'content-disposition': 'attachment; filename="smoke-download.txt"',
});
res.end('download contents');
return;
}
if (url.pathname === '/slow-download') {
res.writeHead(200, {
'content-type': 'text/plain; charset=utf-8',
'cache-control': 'no-store',
'content-disposition': 'attachment; filename="slow-smoke-download.txt"',
});
res.write('slow download prefix\n');
const timer = setTimeout(() => {
if (!res.destroyed) {
res.end('slow download tail\n');
}
}, 5_000);
res.on('close', () => clearTimeout(timer));
return;
}
send(404, 'text/plain; charset=utf-8', `missing fixture: ${url.pathname}`);
});
server.on('upgrade', (req, socket) => {
const url = new URL(req.url || '/', 'http://127.0.0.1');
if (url.pathname !== '/ws-echo') {
socket.write('HTTP/1.1 404 Not Found\r\nConnection: close\r\n\r\n');
socket.destroy();
return;
}
const key = req.headers['sec-websocket-key'];
if (typeof key !== 'string') {
socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n');
socket.destroy();
return;
}
const protocols = String(req.headers['sec-websocket-protocol'] || '')
.split(',')
.map(protocol => protocol.trim())
.filter(Boolean);
const selectedProtocol = protocols.includes('smoke') ? 'smoke' : null;
const headers = [
'HTTP/1.1 101 Switching Protocols',
'Upgrade: websocket',
'Connection: Upgrade',
`Sec-WebSocket-Accept: ${websocketAcceptKey(key)}`,
];
if (selectedProtocol) {
headers.push(`Sec-WebSocket-Protocol: ${selectedProtocol}`);
}
socket.write(`${headers.join('\r\n')}\r\n\r\n`);
let buffered = Buffer.alloc(0);
socket.on('data', chunk => {
buffered = Buffer.concat([buffered, chunk]);
buffered = drainWebSocketFrames(buffered, (opcode, payload) => {
if (opcode === 0x1) {
socket.write(websocketTextFrame(`echo:${payload.toString('utf8')}`));
} else if (opcode === 0x8) {
socket.write(websocketCloseFrame(1000, 'bye'));
socket.end();
} else if (opcode === 0x9) {
socket.write(websocketFrame(0xA, payload));
}
});
});
socket.on('error', () => {});
});
return server;
}
async function waitForCdpServer(endpoint, processHandle, logs) {
const deadline = Date.now() + 10_000;
let lastError = '';
while (Date.now() < deadline) {
if (processHandle.exitCode !== null) {
throw new Error(`moli serve exited early with ${processHandle.exitCode}\n${logs()}`);
}
try {
const response = await fetch(`${endpoint}/json/version/`, { signal: AbortSignal.timeout(500) });
if (response.ok) {
return;
}
lastError = `HTTP ${response.status}`;
} catch (error) {
lastError = error.message;
}
await new Promise(resolveSleep => setTimeout(resolveSleep, 100));
}
throw new Error(`timed out waiting for moli serve at ${endpoint}: ${lastError}\n${logs()}`);
}
function startMoliServe(port) {
let logBuffer = '';
const appendLog = data => {
const text = data.toString();
logBuffer += text;
if (process.env.MOLI_SMOKE_TRACE_BG === '1') {
process.stderr.write(text);
}
if (logBuffer.length > 24_000) {
logBuffer = logBuffer.slice(-24_000);
}
};
const child = spawn(
moliBinary(),
['serve', '--host', '127.0.0.1', '--port', String(port), '--log-level', 'warn'],
{
cwd: repoRoot,
env: clearProxyEnv(process.env),
stdio: ['ignore', 'pipe', 'pipe'],
},
);
child.stdout.on('data', appendLog);
child.stderr.on('data', appendLog);
return {
child,
logs: () => logBuffer.trim(),
};
}
async function stopProcess(child) {
if (!child || child.exitCode !== null) {
return;
}
child.kill('SIGTERM');
await Promise.race([
new Promise(resolveExit => child.once('exit', resolveExit)),
new Promise(resolveTimeout => setTimeout(resolveTimeout, 2_000)),
]);
if (child.exitCode === null) {
child.kill('SIGKILL');
}
}
function assertEqual(actual, expected, label) {
if (actual !== expected) {
throw new Error(`${label}: expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
}
}
function record(results, name, data = {}) {
results.push({ name, ok: true, ...data });
}
function traceStep(label) {
if (process.env.MOLI_SMOKE_TRACE === '1') {
console.error(`[smoke] ${label}`);
}
}
async function waitUntil(predicate, label, timeoutMs = 5_000) {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
if (predicate()) {
return;
}
await new Promise(resolveSleep => setTimeout(resolveSleep, 25));
}
throw new Error(`timed out waiting for ${label}`);
}
async function runWorkerCommand(page, command, timeout = 5_000) {
await page.evaluate(command => {
globalThis.__smokeWorkerResult = null;
globalThis.__smokeWorkerError = null;
const worker = new Worker('/worker.js');
worker.onmessage = event => {
if (globalThis.__smokeTraceWorker === true) {
console.warn(`[smoke-worker] onmessage ${JSON.stringify(event.data)}`);
}
globalThis.__smokeWorkerResult = event.data;
worker.terminate();
};
worker.onerror = event => {
if (globalThis.__smokeTraceWorker === true) {
console.warn(`[smoke-worker] onerror ${event.message || 'unknown worker error'}`);
}
globalThis.__smokeWorkerError = event.message || 'unknown worker error';
worker.terminate();
};
worker.postMessage(command);
}, command);
const deadline = Date.now() + timeout;
while (Date.now() < deadline) {
const state = await page.evaluate(() => ({
result: globalThis.__smokeWorkerResult,
error: globalThis.__smokeWorkerError,
}));
if (state.error !== null) {
throw new Error(`worker failed: ${state.error}`);
}
if (state.result !== null) {
return state.result;
}
await new Promise(resolve => setTimeout(resolve, 50));
}
const workerFailure = await page.evaluate(() => globalThis.__smokeWorkerError);
if (workerFailure !== null) {
throw new Error(`worker failed: ${workerFailure}`);
}
throw new Error(`timed out waiting for worker result after ${timeout}ms`);
}
async function runBrowserContextProfileSmoke(browser, fixture, results) {
const profileUserAgent = 'MoliProfileSmoke/1.0';
const profileContext = await browser.newContext({
userAgent: profileUserAgent,
locale: 'zh-CN',
timezoneId: 'Asia/Shanghai',
extraHTTPHeaders: {
'x-moli-profile-smoke': 'context-extra-header',
},
});
try {
const profilePage = await profileContext.newPage();
const profileReferer = `${fixture}/profile-referer`;
const profileToken = `profile-${Date.now()}-${Math.random().toString(16).slice(2)}`;
await profilePage.goto(`${fixture}/profile-headers?token=${encodeURIComponent(profileToken)}`, {
waitUntil: 'load',
timeout: 10_000,
referer: profileReferer,
});
const profileHeadersResponse = await fetch(
`${fixture}/profile-result?token=${encodeURIComponent(profileToken)}`,
);
const profileHeaders = await profileHeadersResponse.json();
if (!profileHeaders) {
throw new Error(`profile fixture did not capture browser request for token ${profileToken}`);
}
assertEqual(profileHeaders.userAgent, profileUserAgent, 'profile context User-Agent header');
if (!String(profileHeaders.acceptLanguage || '').toLowerCase().includes('zh-cn')) {
throw new Error(`profile context Accept-Language header missing zh-CN: ${profileHeaders.acceptLanguage}`);
}
assertEqual(
profileHeaders.extraHeader,
'context-extra-header',
'profile context extra HTTP header',
);
assertEqual(profileHeaders.referer, profileReferer, 'profile context goto referer header');
const profileRuntime = await profilePage.evaluate(() => ({
userAgent: navigator.userAgent,
language: navigator.language,
languages: navigator.languages,
timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
}));
assertEqual(profileRuntime.userAgent, profileUserAgent, 'profile context navigator.userAgent');
assertEqual(profileRuntime.language, 'zh-CN', 'profile context navigator.language');
assertEqual(profileRuntime.languages?.[0], 'zh-CN', 'profile context navigator.languages[0]');
assertEqual(profileRuntime.timeZone, 'Asia/Shanghai', 'profile context timezone');
record(results, 'browser_context_profile_overrides');
} finally {
await profileContext.close();
}
}
async function runPopupRouteEvaluateSmoke(browser, fixture, results) {
const context = await browser.newContext();
try {
const page = await context.newPage();
await page.goto(`${fixture}/plain`, { waitUntil: 'load', timeout: 10_000 });
const popupUrl = `${fixture}/plain?popup=wait-for-event`;
const popupPromise = page.waitForEvent('popup', { timeout: 10_000 });
await page.evaluate(url => window.open(url, '_blank'), popupUrl);
const popup = await popupPromise;
await waitUntil(() => popup.url() === popupUrl, 'popup waitForEvent URL');
assertEqual(popup.url(), popupUrl, 'popup waitForEvent URL');
await popup.goto(popupUrl, { waitUntil: 'load', timeout: 10_000 });
assertEqual(await popup.textContent('main', { timeout: 5_000 }), 'plain ok', 'popup initial text');
await popup.route('**/popup-api', route =>
route.fulfill({
status: 200,
contentType: 'application/json; charset=utf-8',
body: JSON.stringify({ source: 'popup route', ok: true }),
}),
);
const payload = await popup.evaluate(async () => {
const response = await fetch('/popup-api');
return {
url: location.href,
mainText: document.querySelector('main')?.textContent,
api: await response.json(),
};
});
assertEqual(payload?.url, popupUrl, 'popup evaluate URL');
assertEqual(payload?.mainText, 'plain ok', 'popup evaluate document text');
assertEqual(payload?.api?.source, 'popup route', 'popup route fulfilled source');
assertEqual(payload?.api?.ok, true, 'popup route fulfilled ok');
await popup.unroute('**/popup-api');
await popup.close();
record(results, 'popup_wait_for_event_route_evaluate');
} finally {
await context.close();
}
}
async function runSmoke({ chromium, endpoint, fixture }) {
const results = [];
const tempDir = mkdtempSync(join(tmpdir(), 'moli-pw-smoke-'));
const browser = await chromium.connectOverCDP(endpoint, { timeout: 10_000 });
try {
let browserCdp = null;
try {
browserCdp = await browser.newBrowserCDPSession();
} catch (error) {
if (process.env.MOLI_SMOKE_TRACE === '1') {
traceStep(`browser_cdp:unavailable:${error?.message || String(error)}`);
}
}
if (browserCdp && process.env.MOLI_SMOKE_TRACE === '1') {
browserCdp.on('Target.attachedToTarget', event => {
traceStep(
`browser_cdp:attached:${event.targetInfo?.targetId || 'unknown'}:${event.sessionId || 'no-session'}`,
);
});
browserCdp.on('Target.detachedFromTarget', event => {
traceStep(
`browser_cdp:detached:${event.targetId || 'unknown'}:${event.sessionId || 'no-session'}`,
);
});
}
record(results, 'connect_over_cdp', { browserContexts: browser.contexts().length });
const context = await browser.newContext({ acceptDownloads: true });
record(results, 'browser_new_context');
const page = await context.newPage();
if (process.env.MOLI_SMOKE_TRACE === '1') {
page.on('console', message => {
traceStep(`page_console:${message.type()}:${message.text()}`);
});
}
const cdp = await context.newCDPSession(page);
const websocketEvents = [];
const subresourceNetworkEvents = [];
for (const method of [
'Network.webSocketCreated',
'Network.webSocketWillSendHandshakeRequest',
'Network.webSocketHandshakeResponseReceived',
'Network.webSocketFrameSent',
'Network.webSocketFrameReceived',
]) {
cdp.on(method, params => websocketEvents.push({ method, params }));
}
for (const method of [
'Network.requestWillBeSent',
'Network.responseReceived',
'Network.loadingFinished',
'Network.loadingFailed',
]) {
cdp.on(method, params => subresourceNetworkEvents.push({ method, params }));
}
await cdp.send('Network.enable');
await page.goto(`${fixture}/plain`, { waitUntil: 'load', timeout: 10_000 });
assertEqual(await page.textContent('main'), 'plain ok', 'plain page text');
record(results, 'new_page_goto_plain');
const second = await context.newPage();
await second.goto(`${fixture}/plain`, { waitUntil: 'load', timeout: 10_000 });
assertEqual(await second.textContent('main'), 'plain ok', 'second page text');
record(results, 'second_page_same_context');
await second.close();
await page.goto(`${fixture}/iframe`, { waitUntil: 'load', timeout: 10_000 });
const child = page.frames().find(frame => frame.url().includes('/child'));
if (!child) {
throw new Error(`missing child frame; frames=${page.frames().map(frame => frame.url()).join(', ')}`);
}
assertEqual((await child.textContent('body', { timeout: 5_000 })).trim(), 'child body text', 'child frame text');
record(results, 'iframe_child_text_content', { frameCount: page.frames().length });
await page.goto(`${fixture}/wait-for-function`, {
waitUntil: 'domcontentloaded',
timeout: 10_000,
});
await page.waitForFunction(() => globalThis.__ready === true, null, { timeout: 5_000 });
record(results, 'wait_for_function_timer');
await context.addCookies([{ name: 'manualCookie', value: 'manual', url: fixture }]);
await page.goto(`${fixture}/echo-cookie`, { waitUntil: 'load', timeout: 10_000 });
const manualCookieEcho = await page.textContent('body');
if (!manualCookieEcho.includes('manualCookie=manual')) {
throw new Error(`manual cookie was not sent: ${manualCookieEcho}`);
}
await page.goto(`${fixture}/set-cookie`, { waitUntil: 'load', timeout: 10_000 });
const serverCookies = await context.cookies(fixture);
if (!serverCookies.some(cookie => cookie.name === 'serverCookie' && cookie.value === 'server')) {
throw new Error(`server Set-Cookie did not reach browser context: ${JSON.stringify(serverCookies)}`);
}
await page.goto(`${fixture}/echo-cookie`, { waitUntil: 'load', timeout: 10_000 });
const serverCookieEcho = await page.textContent('body');
if (!serverCookieEcho.includes('serverCookie=server')) {
throw new Error(`server cookie was not sent back: ${serverCookieEcho}`);
}
record(results, 'cookie_profile_round_trip');
const redirectResponse = await page.goto(`${fixture}/redirect-start`, {
waitUntil: 'load',
timeout: 10_000,
});
assertEqual(page.url(), `${fixture}/redirect-final`, 'redirect final page URL');
assertEqual(redirectResponse?.url(), `${fixture}/redirect-final`, 'redirect final response URL');
assertEqual(redirectResponse?.status(), 200, 'redirect final response status');
assertEqual(await page.textContent('main'), 'redirect final', 'redirect final text');
record(results, 'redirect_final_response');
await page.goto(`${fixture}/history-a`, { waitUntil: 'load', timeout: 10_000 });
await page.goto(`${fixture}/history-b`, { waitUntil: 'load', timeout: 10_000 });
const backResponse = await page.goBack({ waitUntil: 'load', timeout: 10_000 });
assertEqual(page.url(), `${fixture}/history-a`, 'history goBack URL');
assertEqual(backResponse?.url(), `${fixture}/history-a`, 'history goBack response URL');
assertEqual(await page.textContent('main'), 'history a', 'history goBack text');
const forwardResponse = await page.goForward({ waitUntil: 'load', timeout: 10_000 });
assertEqual(page.url(), `${fixture}/history-b`, 'history goForward URL');
assertEqual(forwardResponse?.url(), `${fixture}/history-b`, 'history goForward response URL');
assertEqual(await page.textContent('main'), 'history b', 'history goForward text');
record(results, 'history_back_forward');
traceStep('history_back_forward_after_target_switch:start');
const parkedPage = await context.newPage();
parkedPage.on('close', () => traceStep('history_back_forward_after_target_switch:parked_page_close_event'));
traceStep('history_back_forward_after_target_switch:new_page_created');
await parkedPage.goto(`${fixture}/plain`, { waitUntil: 'load', timeout: 10_000 });
traceStep('history_back_forward_after_target_switch:parked_page_loaded');
await page.bringToFront();
traceStep('history_back_forward_after_target_switch:brought_to_front');
const parkedBackResponse = await page.goBack({ waitUntil: 'load', timeout: 10_000 });
traceStep('history_back_forward_after_target_switch:went_back');
assertEqual(page.url(), `${fixture}/history-a`, 'history goBack URL after target switch');
assertEqual(
parkedBackResponse?.url(),
`${fixture}/history-a`,
'history goBack response URL after target switch',
);
const parkedForwardResponse = await page.goForward({ waitUntil: 'load', timeout: 10_000 });
traceStep('history_back_forward_after_target_switch:went_forward');
assertEqual(page.url(), `${fixture}/history-b`, 'history goForward URL after target switch');
assertEqual(
parkedForwardResponse?.url(),
`${fixture}/history-b`,
'history goForward response URL after target switch',
);
traceStep('history_back_forward_after_target_switch:closing_parked_page');
const parkedPageClosePromise = parkedPage.close();
if (process.env.MOLI_SMOKE_TRACE === '1') {
const closeProbe = await Promise.race([
parkedPageClosePromise.then(() => 'resolved'),
new Promise(resolve => setTimeout(() => resolve('timeout'), 1_000)),
]);
traceStep(
`history_back_forward_after_target_switch:close_probe:${closeProbe}:pages=${context.pages().length}`,
);
}
await parkedPageClosePromise;
traceStep('history_back_forward_after_target_switch:parked_page_closed');
record(results, 'history_back_forward_after_target_switch');
traceStep('history_back_forward_after_target_switch:done');
traceStep('document_route_matrix:start');
await page.route('**/document-fulfill', route =>
route.fulfill({
status: 200,
contentType: 'text/html; charset=utf-8',
body: '<!doctype html><main>document fulfilled body</main>',
}),
);
const fulfilledDocumentResponse = await page.goto(`${fixture}/document-fulfill`, {
waitUntil: 'load',
timeout: 10_000,
});
assertEqual(
fulfilledDocumentResponse?.status(),
200,
'document route fulfill response status',
);
assertEqual(
await page.textContent('main'),
'document fulfilled body',
'document route fulfill body',
);
record(results, 'route_fulfill_document');
await page.unroute('**/document-fulfill');
await page.route('**/document-continue', route => {
const headers = {
...route.request().headers(),
'x-smoke-nav-route': 'continued-document',
};
return route.continue({ headers });
});
const documentContinueStartIndex = subresourceNetworkEvents.length;
const continuedDocumentResponse = await page.goto(`${fixture}/document-continue`, {
waitUntil: 'load',
timeout: 10_000,
});
assertEqual(
continuedDocumentResponse?.status(),
200,
'document route continue response status',
);
assertEqual(
await page.textContent('main'),
'continued-document',
'document route continue body',
);
await waitUntil(() => {
const events = subresourceNetworkEvents.slice(documentContinueStartIndex);
const request = events.find(
event =>
event.method === 'Network.requestWillBeSent' &&
event.params?.type === 'Document' &&
event.params?.request?.url === `${fixture}/document-continue`,
);
const requestId = request?.params?.requestId;
return (
requestId &&
events.some(
event =>
event.method === 'Network.responseReceived' &&
event.params?.requestId === requestId &&
event.params?.type === 'Document' &&
event.params?.response?.status === 200,
) &&
events.some(
event =>
event.method === 'Network.loadingFinished' &&
event.params?.requestId === requestId,
)
);
}, 'Document route continue Network events on auxiliary CDP session');
record(results, 'route_continue_document');
await page.unroute('**/document-continue');
await page.route('**/document-abort', route => route.abort('blockedbyclient'));
const documentAbortStartIndex = subresourceNetworkEvents.length;
let abortedDocumentError = null;
try {
await page.goto(`${fixture}/document-abort`, {
waitUntil: 'load',
timeout: 10_000,
});
} catch (error) {
abortedDocumentError = String(error?.message || error);
}
if (!abortedDocumentError || !abortedDocumentError.includes('ERR_BLOCKED_BY_CLIENT')) {
throw new Error(
`document route abort should reject navigation with ERR_BLOCKED_BY_CLIENT, got ${abortedDocumentError}`,
);
}
await waitUntil(() => {
const events = subresourceNetworkEvents.slice(documentAbortStartIndex);
const request = events.find(
event =>
event.method === 'Network.requestWillBeSent' &&
event.params?.type === 'Document' &&
event.params?.request?.url === `${fixture}/document-abort`,
);
const requestId = request?.params?.requestId;
return (
requestId &&
events.some(
event =>
event.method === 'Network.loadingFailed' &&
event.params?.requestId === requestId &&
event.params?.errorText === 'net::ERR_BLOCKED_BY_CLIENT',
)
);
}, 'Document route abort Network.loadingFailed on auxiliary CDP session');
record(results, 'route_abort_document');
await page.unroute('**/document-abort');
traceStep('document_route_matrix:done');
traceStep('post_history_switch_plain_goto:start');
await page.route('**/api', route =>
route.fulfill({
status: 200,
contentType: 'text/plain; charset=utf-8',
body: 'fulfilled body',
}),
);
await page.goto(`${fixture}/plain`, { waitUntil: 'load', timeout: 10_000 });
traceStep('post_history_switch_plain_goto:done');
const fetched = await page.evaluate(async () => await fetch('/api').then(response => response.text()));
assertEqual(fetched, 'fulfilled body', 'route fulfilled fetch body');
record(results, 'route_fulfill_fetch');
await checkFulfilledRedirectRouting(page, fixture);
record(results, 'route_fulfill_redirect_uses_playwright_first_hop_routing');
const xhrFulfilled = await page.evaluate(async () => {
return await new Promise(resolve => {
const xhr = new XMLHttpRequest();
xhr.open('GET', '/api', true);
xhr.onload = () => {
resolve({
phase: 'load',
status: xhr.status,
text: xhr.responseText,
});
};
xhr.onerror = () => {
resolve({
phase: 'error',
status: xhr.status,
readyState: xhr.readyState,
});
};
xhr.send();
});
});
assertEqual(xhrFulfilled?.phase, 'load', 'route fulfilled xhr phase');
assertEqual(xhrFulfilled?.status, 200, 'route fulfilled xhr status');
assertEqual(xhrFulfilled?.text, 'fulfilled body', 'route fulfilled xhr body');
record(results, 'route_fulfill_xhr');
await page.route('**/api-continue', route => {
const headers = {
...route.request().headers(),
'x-smoke-route': 'continued',
};
return route.continue({ headers });
});
const continued = await page.evaluate(async () => await fetch('/api-continue').then(response => response.json()));
assertEqual(continued.routeHeader, 'continued', 'route continue request header');
record(results, 'route_continue_fetch');
const xhrContinued = await page.evaluate(async () => {
return await new Promise(resolve => {
const xhr = new XMLHttpRequest();
xhr.open('POST', '/api-continue', true);
xhr.onload = () => {
resolve({
phase: 'load',
status: xhr.status,
payload: xhr.responseText,
});
};
xhr.onerror = () => {
resolve({
phase: 'error',
status: xhr.status,
readyState: xhr.readyState,
});
};
xhr.send('payload');
});
});
assertEqual(xhrContinued?.phase, 'load', 'route continue xhr phase');
assertEqual(xhrContinued?.status, 200, 'route continue xhr status');
assertEqual(
xhrContinued?.payload,
JSON.stringify({ method: 'POST', routeHeader: 'continued' }),
'route continue xhr body',
);
record(results, 'route_continue_xhr');
await page.route('**/api-abort', route => route.abort('blockedbyclient'));
const aborted = await page.evaluate(async () => {
try {
await fetch('/api-abort');
return 'resolved';
} catch (error) {
return `${error?.constructor?.name || 'Error'}:${error?.message || String(error)}`;
}
});
if (!aborted.startsWith('TypeError:')) {
throw new Error(`route abort should reject fetch with TypeError, got ${aborted}`);
}
record(results, 'route_abort_fetch');
const xhrAborted = await page.evaluate(async () => {
return await new Promise(resolve => {
const xhr = new XMLHttpRequest();
const events = [];
xhr.addEventListener('load', () => events.push('load'));
xhr.addEventListener('error', () => events.push('error'));
xhr.addEventListener('abort', () => events.push('abort'));
xhr.addEventListener('loadend', () => {
resolve({
events,
status: xhr.status,
readyState: xhr.readyState,
});
});
xhr.open('GET', '/api-abort', true);
xhr.send();
});
});
if (!xhrAborted?.events?.includes('error')) {
throw new Error(`route abort xhr should emit error, got ${JSON.stringify(xhrAborted)}`);
}
if (xhrAborted?.events?.includes('load')) {
throw new Error(`route abort xhr should not emit load, got ${JSON.stringify(xhrAborted)}`);
}
assertEqual(xhrAborted?.status, 0, 'route abort xhr status');
record(results, 'route_abort_xhr');
await page.unroute('**/api');
await page.unroute('**/api-continue');
await page.unroute('**/api-abort');
traceStep('page_route_matrix:done');
const subresourceStartIndex = subresourceNetworkEvents.length;
const networkObserved = await page.evaluate(async () => await fetch('/api-continue').then(response => response.json()));
assertEqual(networkObserved.routeHeader, null, 'unrouted fetch should reach fixture server');
await waitUntil(() => {
const events = subresourceNetworkEvents.slice(subresourceStartIndex);
const request = events.find(
event =>
event.method === 'Network.requestWillBeSent' &&
event.params?.type === 'Fetch' &&
event.params?.request?.url === `${fixture}/api-continue`,
);
const requestId = request?.params?.requestId;
return (
requestId &&
events.some(
event =>
event.method === 'Network.responseReceived' &&
event.params?.requestId === requestId &&
event.params?.response?.status === 200,
) &&
events.some(event => event.method === 'Network.loadingFinished' && event.params?.requestId === requestId)
);
}, 'Fetch Network events on auxiliary CDP session');
record(results, 'fetch_network_events');
traceStep('fetch_network_events:done');
const xhrSubresourceStartIndex = subresourceNetworkEvents.length;
const xhrObserved = await page.evaluate(async () => {
return await new Promise(resolve => {
const xhr = new XMLHttpRequest();
xhr.open('GET', '/api-continue', true);
xhr.onload = () => resolve(JSON.parse(xhr.responseText));
xhr.send();
});
});
assertEqual(xhrObserved.routeHeader, null, 'unrouted xhr should reach fixture server');
assertEqual(xhrObserved.method, 'GET', 'unrouted xhr should keep original method');
await waitUntil(() => {
const events = subresourceNetworkEvents.slice(xhrSubresourceStartIndex);
const request = events.find(
event =>
event.method === 'Network.requestWillBeSent' &&
event.params?.type === 'XHR' &&
event.params?.request?.url === `${fixture}/api-continue`,
);
const requestId = request?.params?.requestId;
return (
requestId &&
events.some(
event =>
event.method === 'Network.responseReceived' &&
event.params?.requestId === requestId &&
event.params?.response?.status === 200,
) &&
events.some(event => event.method === 'Network.loadingFinished' && event.params?.requestId === requestId)
);
}, 'XHR Network events on auxiliary CDP session');
record(results, 'xhr_network_events');
traceStep('xhr_network_events:done');
const parserScriptStartIndex = subresourceNetworkEvents.length;
await page.goto(`${fixture}/parser-script-page`, { waitUntil: 'load', timeout: 10_000 });
assertEqual(
await page.evaluate(() => globalThis.__smokeParserScriptValue),
'parser script loaded',
'parser script executed before load completion',
);
let parserScriptRequestId = null;
await waitUntil(() => {
const events = subresourceNetworkEvents.slice(parserScriptStartIndex);
const request = events.find(
event =>
event.method === 'Network.requestWillBeSent' &&
event.params?.type === 'Script' &&
event.params?.request?.url === `${fixture}/parser-script.js`,
);
const response = events.find(
event =>
event.method === 'Network.responseReceived' &&
event.params?.type === 'Script' &&
event.params?.response?.url === `${fixture}/parser-script.js`,
);
const requestId = request?.params?.requestId;
if (
!requestId ||
!response ||
!events.some(
event =>
event.method === 'Network.loadingFinished' && event.params?.requestId === requestId,
)
) {
return false;
}
parserScriptRequestId = requestId;
return true;
}, 'parser Script Network events on auxiliary CDP session');
const parserScriptBody = await cdp.send('Network.getResponseBody', {
requestId: parserScriptRequestId,
});
assertEqual(
parserScriptBody.body,
'globalThis.__smokeParserScriptValue = "parser script loaded";',
'parser script response body',
);
record(results, 'parser_script_network_events');
traceStep('parser_script_network_events:done');
const blockedWebSocketUrl = `${fixture.replace(/^http:/, 'ws:')}/ws-blocked`;
const blockedWebSocketStartIndex = subresourceNetworkEvents.length;
await cdp.send('Network.setBlockedURLs', { urls: [`${blockedWebSocketUrl}*`] });
const blockedWebSocketResult = await page.evaluate(async url => {
return await new Promise(resolve => {
const socket = new WebSocket(url);
const finish = value => resolve(value);
const timer = setTimeout(() => {
socket.close();
finish(`timeout:${socket.readyState}`);
}, 5_000);
socket.onopen = () => {
clearTimeout(timer);
finish('open');
};
socket.onerror = () => {
clearTimeout(timer);
finish(`error:${socket.readyState}`);
};
socket.onclose = event => {
clearTimeout(timer);
finish(`close:${event.code}:${event.wasClean}`);
};
});
}, blockedWebSocketUrl);
if (blockedWebSocketResult === 'open' || blockedWebSocketResult.startsWith('timeout:')) {
throw new Error(`blocked WebSocket should fail, got ${blockedWebSocketResult}`);
}
await waitUntil(() => {
const events = subresourceNetworkEvents.slice(blockedWebSocketStartIndex);
const request = events.find(
event =>
event.method === 'Network.requestWillBeSent' &&
event.params?.type === 'WebSocket' &&
event.params?.request?.url === blockedWebSocketUrl,
);
const requestId = request?.params?.requestId;
return (
requestId &&
events.some(
event =>
event.method === 'Network.loadingFailed' &&
event.params?.requestId === requestId &&
event.params?.errorText === 'net::ERR_BLOCKED_BY_CLIENT',
)
);
}, 'blocked WebSocket Network.loadingFailed on auxiliary CDP session');
await cdp.send('Network.setBlockedURLs', { urls: [] });
record(results, 'blocked_websocket_network_events');
traceStep('blocked_websocket_network_events:done');
await page.goto(`${fixture}/plain`, { waitUntil: 'load', timeout: 10_000 });
traceStep('worker_postmessage_round_trip:start');
await page.evaluate(enabled => {
globalThis.__smokeTraceWorker = enabled;
}, process.env.MOLI_SMOKE_TRACE === '1');
const workerResult = await runWorkerCommand(page, 'worker ping');
assertEqual(workerResult?.echoed, 'worker ping', 'worker echoed message');
assertEqual(workerResult?.pathname, '/worker.js', 'worker location pathname');
assertEqual(workerResult?.selfEqualsGlobal, true, 'worker global self identity');
record(results, 'worker_postmessage_round_trip');
traceStep('worker_postmessage_round_trip:done');
traceStep('worker_route_fulfill_fetch:start');
await context.route('**/worker-route-fulfill', route =>
(traceStep(`worker_route_fulfill_fetch:route_hit:${route.request().url()}`),
route.fulfill({
status: 200,
contentType: 'text/plain; charset=utf-8',
body: 'worker fulfilled body',
})),
);
const workerFetchFulfill = await runWorkerCommand(page, {
kind: 'fetch',
url: '/worker-route-fulfill',
});
assertEqual(workerFetchFulfill?.ok, true, 'worker fetch route fulfill ok');
assertEqual(workerFetchFulfill?.status, 200, 'worker fetch route fulfill status');
assertEqual(workerFetchFulfill?.text, 'worker fulfilled body', 'worker fetch route fulfill body');
record(results, 'worker_route_fulfill_fetch');
traceStep('worker_route_fulfill_fetch:done');
traceStep('worker_route_continue_xhr:start');
await context.route('**/worker-route-continue', route => {
traceStep(`worker_route_continue_xhr:route_hit:${route.request().url()}`);
const headers = {
...route.request().headers(),
'x-smoke-worker-route': 'continued-from-worker',
};
return route.continue({ headers });
});
const workerXhrContinue = await runWorkerCommand(page, {
kind: 'xhr',
url: '/worker-route-continue',
});
assertEqual(workerXhrContinue?.ok, true, 'worker xhr route continue ok');
assertEqual(workerXhrContinue?.status, 200, 'worker xhr route continue status');
assertEqual(
workerXhrContinue?.text,
JSON.stringify({ method: 'GET', routeHeader: 'continued-from-worker' }),
'worker xhr route continue body',
);
record(results, 'worker_route_continue_xhr');
traceStep('worker_route_continue_xhr:done');
traceStep('worker_route_abort_fetch:start');
await context.route('**/worker-route-abort', route => {
traceStep(`worker_route_abort_fetch:route_hit:${route.request().url()}`);
return route.abort('blockedbyclient');
});
const workerFetchAbort = await runWorkerCommand(page, {
kind: 'fetch',
url: '/worker-route-abort',
});
assertEqual(workerFetchAbort?.ok, false, 'worker fetch route abort should reject');
if (!String(workerFetchAbort?.error || '').startsWith('TypeError:')) {
throw new Error(
`worker fetch route abort should reject with TypeError, got ${JSON.stringify(workerFetchAbort)}`,
);
}
record(results, 'worker_route_abort_fetch');
await context.unroute('**/worker-route-fulfill');
await context.unroute('**/worker-route-continue');
await context.unroute('**/worker-route-abort');
traceStep('worker_route_abort_fetch:done');
const websocketResult = await page.evaluate(async () => {
return await new Promise((resolve, reject) => {
const url = new URL('/ws-echo', location.href);
url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
const socket = new WebSocket(url.href, 'smoke');
const timer = setTimeout(() => {
socket.close();
reject(new Error(`websocket timed out at readyState=${socket.readyState}`));
}, 5_000);
socket.onopen = () => socket.send('websocket ping');
socket.onmessage = event => {
clearTimeout(timer);
const result = {
data: event.data,
protocol: socket.protocol,
readyStateBeforeClose: socket.readyState,
};
socket.close(1000, 'done');
resolve(result);
};
socket.onerror = () => {
clearTimeout(timer);
reject(new Error(`websocket error at readyState=${socket.readyState}`));
};
});
});
assertEqual(websocketResult?.data, 'echo:websocket ping', 'websocket echoed message');
assertEqual(websocketResult?.protocol, 'smoke', 'websocket selected protocol');
assertEqual(websocketResult?.readyStateBeforeClose, 1, 'websocket ready state before close');
record(results, 'websocket_echo_round_trip');
await waitUntil(
() => websocketEvents.some(event => event.method === 'Network.webSocketFrameReceived'),
'Network.webSocketFrameReceived',
);
const expectedWebsocketUrl = `${fixture.replace(/^http:/, 'ws:')}/ws-echo`;
const websocketCreated = websocketEvents.find(
event => event.method === 'Network.webSocketCreated' && event.params?.url === expectedWebsocketUrl,
);
const websocketRequestId = websocketCreated?.params?.requestId;
if (!websocketRequestId) {
throw new Error(`missing Network.webSocketCreated event: ${JSON.stringify(websocketEvents)}`);
}
assertEqual(websocketCreated.params.url, expectedWebsocketUrl, 'websocket CDP created URL');
const websocketHandshake = websocketEvents.find(
event =>
event.method === 'Network.webSocketHandshakeResponseReceived' &&
event.params.requestId === websocketRequestId,
);
assertEqual(websocketHandshake?.params?.response?.status, 101, 'websocket CDP handshake status');
const websocketFrameSent = websocketEvents.find(
event =>
event.method === 'Network.webSocketFrameSent' &&
event.params.requestId === websocketRequestId,
);
assertEqual(websocketFrameSent?.params?.response?.opcode, 1, 'websocket CDP sent opcode');
assertEqual(websocketFrameSent?.params?.response?.payloadLength, 14, 'websocket CDP sent payload length');
const websocketFrameReceived = websocketEvents.find(
event =>
event.method === 'Network.webSocketFrameReceived' &&
event.params.requestId === websocketRequestId,
);
assertEqual(websocketFrameReceived?.params?.response?.opcode, 1, 'websocket CDP received opcode');
assertEqual(
websocketFrameReceived?.params?.response?.payloadLength,
19,
'websocket CDP received payload length',
);
record(results, 'websocket_network_events', { websocketEventCount: websocketEvents.length });
await page.setContent('<main id="set-content">set content ok</main>');
assertEqual(await page.textContent('#set-content'), 'set content ok', 'setContent text');
record(results, 'set_content_static_dom');
await page.setContent(
'<main id="set-content-inline">inline content ok</main><script>window.__moliSetContentInlineRan = (window.__moliSetContentInlineRan || 0) + 1;</script>',
);
assertEqual(await page.textContent('#set-content-inline'), 'inline content ok', 'setContent inline text');
assertEqual(
await page.evaluate(() => window.__moliSetContentInlineRan),
1,
'setContent inline script ran',
);
record(results, 'set_content_inline_script');
const uploadFile = join(tempDir, 'upload.txt');
writeFileSync(uploadFile, 'upload contents');
await page.setContent('<input id="upload" type="file">');
await page.setInputFiles('#upload', uploadFile);
const uploaded = await page.evaluate(() => {
const file = document.querySelector('#upload')?.files?.[0];
return file ? { name: file.name, size: file.size } : null;
});
assertEqual(uploaded?.name, 'upload.txt', 'uploaded file name');
assertEqual(uploaded?.size, 'upload contents'.length, 'uploaded file size');
record(results, 'set_input_files');
await page.setContent('<input id="chooser" type="file" multiple>');
const chooserSurface = await page
.locator('#chooser')
.evaluate(input =>
[
input instanceof HTMLInputElement,
input.constructor && input.constructor.name,
typeof input.type,
input.type,
input.multiple,
].join('|'),
);
assertEqual(
chooserSurface,
'true|HTMLInputElement|string|file|true',
'file chooser input surface before click',
);
const [fileChooser] = await Promise.all([
page.waitForEvent('filechooser', { timeout: 10_000 }),
page.click('#chooser'),
]);
await fileChooser.setFiles(uploadFile);
const chooserFiles = await page.evaluate(() =>
Array.from(document.querySelector('#chooser')?.files || []).map(file => ({
name: file.name,
size: file.size,
})),
);
assertEqual(chooserFiles.length, 1, 'file chooser selected file count');
assertEqual(chooserFiles[0]?.name, 'upload.txt', 'file chooser selected file name');
assertEqual(
chooserFiles[0]?.size,
'upload contents'.length,
'file chooser selected file size',
);
record(results, 'file_chooser_set_files');
await page.setContent(`
<button id="open-chooser" onclick="document.getElementById('picker-script').showPicker()">open chooser</button>
<input id="picker-script" type="file" multiple>
`);
const [scriptedChooser] = await Promise.all([
page.waitForEvent('filechooser', { timeout: 10_000 }),
page.click('#open-chooser'),
]);
await scriptedChooser.setFiles(uploadFile);
const scriptedChooserFiles = await page.evaluate(() =>
Array.from(document.querySelector('#picker-script')?.files || []).map(file => ({
name: file.name,
size: file.size,
})),
);
assertEqual(scriptedChooserFiles.length, 1, 'scripted file chooser selected file count');
assertEqual(
scriptedChooserFiles[0]?.name,
'upload.txt',
'scripted file chooser selected file name',
);
assertEqual(
scriptedChooserFiles[0]?.size,
'upload contents'.length,
'scripted file chooser selected file size',
);
record(results, 'file_chooser_show_picker');
await page.setContent(`<a id="go" href="${fixture}/plain">go</a>`);
await Promise.all([
page.waitForNavigation({ waitUntil: 'load', timeout: 10_000 }),
page.click('#go'),
]);
assertEqual(await page.textContent('main'), 'plain ok', 'click navigation target text');
record(results, 'click_navigation');
await page.goto(`${fixture}/download-page`, { waitUntil: 'load', timeout: 10_000 });
const [download] = await Promise.all([
page.waitForEvent('download', { timeout: 10_000 }),
page.click('#download'),
]);
assertEqual(download.suggestedFilename(), 'smoke-download.txt', 'download suggested filename');
const downloadPath = await download.path();
assertEqual(readFileSync(downloadPath, 'utf8'), 'download contents', 'download artifact contents');
record(results, 'download_event_and_artifact');
for (const name of await checkBlobDownloadDelivery(browser, page, tempDir, fixture)) {
record(results, name);
}
await page.goto(`${fixture}/download-page`, { waitUntil: 'load', timeout: 10_000 });
const [slowDownload] = await Promise.all([
page.waitForEvent('download', { timeout: 10_000 }),
page.click('#slow-download'),
]);
assertEqual(
slowDownload.suggestedFilename(),
'slow-smoke-download.txt',
'slow download suggested filename',
);
await slowDownload.cancel();
assertEqual(await slowDownload.failure(), 'canceled', 'slow download cancel failure state');
record(results, 'download_cancel');
await context.close();
await runBrowserContextProfileSmoke(browser, fixture, results);
await runPopupRouteEvaluateSmoke(browser, fixture, results);
return results;
} finally {
await browser.close().catch(() => {});
rmSync(tempDir, { recursive: true, force: true });
}
}
async function main() {
const { chromium } = loadPlaywright();
const fixtureServer = startFixtureServer();
let serve = null;
const results = [];
try {
const fixture = await listen(fixtureServer);
const cdpPort = process.env.MOLI_CDP_PORT
? Number.parseInt(process.env.MOLI_CDP_PORT, 10)
: await reservePort();
if (!Number.isInteger(cdpPort) || cdpPort <= 0 || cdpPort > 65_535) {
throw new Error(`invalid MOLI_CDP_PORT: ${process.env.MOLI_CDP_PORT}`);
}
serve = startMoliServe(cdpPort);
const endpoint = `http://127.0.0.1:${cdpPort}`;
await waitForCdpServer(endpoint, serve.child, serve.logs);
results.push(...(await runSmoke({ chromium, endpoint, fixture })));
console.log(JSON.stringify({ ok: true, endpoint, fixture, results }, null, 2));
} catch (error) {
console.error(JSON.stringify({ ok: false, error: String(error?.stack || error), results }, null, 2));
process.exitCode = 1;
} finally {
await stopProcess(serve?.child);
await new Promise(resolveClose => fixtureServer.close(() => resolveClose()));
}
}
await main();