2129 lines
87 KiB
JavaScript
Executable File
2129 lines
87 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
||
|
||
import { createServer } from 'node:http';
|
||
import { createReadStream, mkdirSync, mkdtempSync, rmSync, existsSync, accessSync, constants, readFileSync, writeFileSync } from 'node:fs';
|
||
import { join, normalize, resolve, sep } from 'node:path';
|
||
import { spawn } from 'node:child_process';
|
||
import { Readable } from 'node:stream';
|
||
import { inflateSync } from 'node:zlib';
|
||
import { verifyAppearanceCanvas, verifySunSalutationCanvas } from './web-sun-salutation-test.mjs';
|
||
import { verifyCanvasTextResolution } from './web-canvas-text-test.mjs';
|
||
import { waitForFirefoxBidi } from './firefox-startup.mjs';
|
||
import { musicAudioInstrumentation, verifyMusicAcrossTabs } from './web-music-test.mjs';
|
||
import { connectProtocol, fetchWithDeadline, withDeadline, validateChromiumSocketPath } from './web-smoke-protocol.mjs';
|
||
|
||
if (typeof WebSocket === 'undefined') {
|
||
console.error('web smoke: FAIL: this script needs the global WebSocket API. Use Node >= 21, or pass --experimental-websocket on Node 20.');
|
||
process.exit(1);
|
||
}
|
||
|
||
const root = resolve(process.argv[2] || 'build/dist/web');
|
||
const testSiteAssets = process.env.WEB_SMOKE_SITE_ASSETS === '1';
|
||
const siteRoot = resolve(root, '../..');
|
||
const siteWorker = testSiteAssets
|
||
? (await import('data:text/javascript;base64,' + readFileSync(join(siteRoot, '_worker.js')).toString('base64'))).default
|
||
: null;
|
||
const browserSetting = process.env.WEB_SMOKE_BROWSER || 'auto';
|
||
const browserArgs = (process.env.WEB_SMOKE_BROWSER_ARGS || '').split(/\s+/).filter(Boolean);
|
||
const timeoutMs = Number(process.env.WEB_SMOKE_TIMEOUT_MS || 90000);
|
||
const rendererSetting = (process.env.WEB_SMOKE_RENDERER || '').toLowerCase();
|
||
const renderer = rendererSetting || 'canvas';
|
||
if (renderer !== 'canvas') {
|
||
console.error(`web smoke: FAIL: Inbe web builds only support WEB_SMOKE_RENDERER="canvas" now; got ${JSON.stringify(renderer)}`);
|
||
process.exit(1);
|
||
}
|
||
const allowWebglDisabled = process.env.WEB_SMOKE_ALLOW_WEBGL_DISABLED
|
||
? !/^(0|false|no)$/i.test(process.env.WEB_SMOKE_ALLOW_WEBGL_DISABLED)
|
||
: false;
|
||
const useNoSandbox = process.env.WEB_SMOKE_NO_SANDBOX
|
||
? !/^(0|false|no)$/i.test(process.env.WEB_SMOKE_NO_SANDBOX)
|
||
: !!process.env.CI || (typeof process.getuid === 'function' && process.getuid() === 0);
|
||
const profileRoot = resolve(process.env.WEB_SMOKE_PROFILE_ROOT || 'build/scratch');
|
||
mkdirSync(profileRoot, { recursive: true });
|
||
const userDataDir = mkdtempSync(join(profileRoot, 'profile-'));
|
||
let smokeSignal;
|
||
const browserEnvironment = { ...process.env };
|
||
delete browserEnvironment.DISPLAY;
|
||
delete browserEnvironment.WAYLAND_DISPLAY;
|
||
delete browserEnvironment.XAUTHORITY;
|
||
delete browserEnvironment.DBUS_SESSION_BUS_ADDRESS;
|
||
browserEnvironment.YUE_DESKTOP_RECOVERY = '0';
|
||
browserEnvironment.TMPDIR = profileRoot;
|
||
const mime = new Map([
|
||
['.html', 'text/html; charset=utf-8'],
|
||
['.js', 'text/javascript; charset=utf-8'],
|
||
['.wasm', 'application/wasm'],
|
||
['.json', 'application/json; charset=utf-8'],
|
||
['.png', 'image/png'],
|
||
['.jpg', 'image/jpeg'],
|
||
['.jpeg', 'image/jpeg'],
|
||
['.css', 'text/css; charset=utf-8'],
|
||
['.zip', 'application/zip'],
|
||
['.ogg', 'audio/ogg']
|
||
]);
|
||
|
||
const hasWasm = existsSync(join(root, 'index.wasm')) || (testSiteAssets &&
|
||
(existsSync(join(root, 'index.wasm.gz')) || existsSync(join(root, 'index.wasm.parts.json'))));
|
||
if (!existsSync(join(root, 'index.html')) || !existsSync(join(root, 'index.js')) || !hasWasm) {
|
||
console.error(`web smoke: missing web build outputs in ${root}`);
|
||
process.exit(1);
|
||
}
|
||
|
||
function canExecute(path) {
|
||
try {
|
||
accessSync(path, constants.X_OK);
|
||
return true;
|
||
} catch {
|
||
return false;
|
||
}
|
||
}
|
||
|
||
function findOnPath(command) {
|
||
if (command.includes('/') || command.includes('\\'))
|
||
return canExecute(command) ? command : '';
|
||
|
||
for (const dir of (process.env.PATH || '').split(':')) {
|
||
if (!dir) continue;
|
||
const path = join(dir, command);
|
||
if (canExecute(path))
|
||
return path;
|
||
}
|
||
return '';
|
||
}
|
||
|
||
function browserCandidates() {
|
||
const candidates = [];
|
||
if (process.env.CHROME) candidates.push(process.env.CHROME);
|
||
if (process.platform === 'freebsd') {
|
||
candidates.push('firefox', 'librewolf');
|
||
}
|
||
candidates.push(
|
||
'/usr/bin/chromium',
|
||
'/usr/bin/chromium-browser',
|
||
'/usr/bin/google-chrome',
|
||
'/usr/bin/google-chrome-stable',
|
||
'/snap/bin/chromium',
|
||
'/opt/google/chrome/chrome',
|
||
'/opt/chromium/chrome',
|
||
'google-chrome',
|
||
'google-chrome-stable',
|
||
'chromium',
|
||
'chromium-browser',
|
||
'chrome',
|
||
'firefox',
|
||
'librewolf'
|
||
);
|
||
return [...new Set(candidates.filter(Boolean))];
|
||
}
|
||
|
||
function resolveBrowser() {
|
||
if (browserSetting && browserSetting !== 'auto') {
|
||
const resolved = findOnPath(browserSetting);
|
||
if (resolved) return resolved;
|
||
throw new Error(`browser not found: ${browserSetting}`);
|
||
}
|
||
|
||
const tried = browserCandidates();
|
||
for (const candidate of tried) {
|
||
const resolved = findOnPath(candidate);
|
||
if (resolved) return resolved;
|
||
}
|
||
throw new Error(`no Chrome/Chromium browser found; tried ${tried.join(', ')}`);
|
||
}
|
||
|
||
function isFirefoxBrowser(browser) {
|
||
return /(^|[/\\])(firefox|librewolf)(\.exe)?$/i.test(browser);
|
||
}
|
||
|
||
function contentType(path) {
|
||
const dot = path.lastIndexOf('.');
|
||
return dot >= 0 ? mime.get(path.slice(dot).toLowerCase()) || 'application/octet-stream' : 'application/octet-stream';
|
||
}
|
||
|
||
function isInside(base, path) {
|
||
const rel = normalize(path).startsWith(base.endsWith(sep) ? base : base + sep);
|
||
return path === base || rel;
|
||
}
|
||
|
||
const server = createServer(async (req, res) => {
|
||
const url = new URL(req.url || '/', 'http://127.0.0.1');
|
||
const practiceFixture = url.pathname.replace('/__test_practice_content__/', '');
|
||
if (url.pathname.startsWith('/__test_practice_content__/') &&
|
||
['whm.zx', 'meditation.zx', 'sunsalutation.zx', 'sunsalutation.es.zx', 'sunsalutation.es.male.zx',
|
||
'patterns.zx', 'taichi.zx', 'taichi.en.zx', 'taichi.es.zx'].includes(practiceFixture)) {
|
||
const fixture = new URL('../build/practice-content/' + practiceFixture, import.meta.url);
|
||
if (!existsSync(fixture)) {
|
||
res.writeHead(404);
|
||
res.end('Build the practice content fixtures before running the smoke test');
|
||
return;
|
||
}
|
||
res.writeHead(200, { 'content-type': 'application/octet-stream' });
|
||
createReadStream(fixture).pipe(res);
|
||
return;
|
||
}
|
||
if (url.pathname === '/__test_assets__/bell.ogg') {
|
||
res.writeHead(200, { 'content-type': 'audio/ogg' });
|
||
createReadStream(new URL('../assets/sounds/bell.ogg', import.meta.url)).pipe(res);
|
||
return;
|
||
}
|
||
if (url.pathname === '/__test_apps__/lists.zx' ||
|
||
url.pathname === '/__test_apps__/practices.zx') {
|
||
const name = url.pathname.split('/').pop();
|
||
const fixture = new URL('../build/apps/' + name, import.meta.url);
|
||
if (!existsSync(fixture)) {
|
||
res.writeHead(404);
|
||
res.end('Build the app fixtures before running the smoke test');
|
||
return;
|
||
}
|
||
res.writeHead(200, { 'content-type': 'application/octet-stream' });
|
||
createReadStream(fixture).pipe(res);
|
||
return;
|
||
}
|
||
const leaf = url.pathname === '/' ? '/index.html' : decodeURIComponent(url.pathname);
|
||
if (siteWorker) {
|
||
const assetUrl = new URL(url);
|
||
assetUrl.pathname = '/build/web' + leaf;
|
||
try {
|
||
const response = await siteWorker.fetch(new Request(assetUrl, {
|
||
method: req.method, headers: req.headers,
|
||
}), {
|
||
ASSETS: {
|
||
async fetch(request) {
|
||
const path = resolve(siteRoot, '.' + new URL(request.url).pathname);
|
||
if (!isInside(siteRoot, path) || !existsSync(path)) {
|
||
return new Response('not found', { status: 404 });
|
||
}
|
||
return new Response(request.method === 'HEAD' ? null :
|
||
Readable.toWeb(createReadStream(path)), {
|
||
headers: { 'Content-Type': contentType(path), 'Cache-Control': 'no-store' },
|
||
});
|
||
},
|
||
},
|
||
});
|
||
res.writeHead(response.status, Object.fromEntries(response.headers));
|
||
if (response.body) {
|
||
Readable.fromWeb(response.body).on('error', error => res.destroy(error)).pipe(res);
|
||
} else {
|
||
res.end();
|
||
}
|
||
} catch (error) {
|
||
res.destroy(error);
|
||
}
|
||
return;
|
||
}
|
||
const path = resolve(root, '.' + leaf);
|
||
|
||
if (!isInside(root, path) || !existsSync(path)) {
|
||
res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
|
||
res.end('not found');
|
||
return;
|
||
}
|
||
|
||
res.writeHead(200, {
|
||
'content-type': contentType(path),
|
||
'cache-control': 'no-store'
|
||
});
|
||
createReadStream(path).pipe(res);
|
||
});
|
||
|
||
function listen() {
|
||
return new Promise((resolveListen, reject) => {
|
||
server.once('error', reject);
|
||
server.listen(0, '127.0.0.1', () => resolveListen(server.address().port));
|
||
});
|
||
}
|
||
|
||
function delay(ms) {
|
||
return new Promise(resolveDelay => setTimeout(resolveDelay, ms));
|
||
}
|
||
|
||
function formatChromeLaunchError(stderrLines) {
|
||
const stderr = stderrLines.join('').trim();
|
||
const suffix = stderr ? `; chrome stderr: ${stderr.slice(-4000)}` : '';
|
||
return new Error(`Chrome exited before DevTools was ready${suffix}`);
|
||
}
|
||
|
||
function readDevtoolsPort() {
|
||
const path = join(userDataDir, 'DevToolsActivePort');
|
||
|
||
if (!existsSync(path))
|
||
return 0;
|
||
|
||
const port = Number(readFileSync(path, 'utf8').split('\n', 1)[0]);
|
||
return Number.isFinite(port) && port > 0 ? port : 0;
|
||
}
|
||
|
||
async function waitForDevtools(chrome, stderrLines) {
|
||
const start = Date.now();
|
||
let exited = false;
|
||
const onExit = () => {
|
||
exited = true;
|
||
};
|
||
chrome.once('exit', onExit);
|
||
|
||
try {
|
||
while (Date.now() - start < timeoutMs) {
|
||
smokeSignal?.throwIfAborted();
|
||
if (exited)
|
||
throw formatChromeLaunchError(stderrLines);
|
||
|
||
const port = readDevtoolsPort();
|
||
if (port > 0) {
|
||
try {
|
||
const response = await fetchWithDeadline(`http://127.0.0.1:${port}/json/version`, {}, timeoutMs, smokeSignal);
|
||
if (response.ok)
|
||
return port;
|
||
} catch {}
|
||
}
|
||
|
||
await delay(50);
|
||
}
|
||
} finally {
|
||
chrome.off('exit', onExit);
|
||
}
|
||
|
||
const stderr = stderrLines.join('').trim();
|
||
const suffix = stderr ? `; chrome stderr: ${stderr.slice(-4000)}` : '';
|
||
throw new Error(`timed out waiting for Chrome DevToolsActivePort${suffix}`);
|
||
}
|
||
|
||
async function jsonRequest(url, options = {}) {
|
||
return fetchWithDeadline(url, options, timeoutMs, smokeSignal, async response => {
|
||
if (!response.ok)
|
||
throw new Error(`${options.method || 'GET'} ${url} failed: ${response.status}`);
|
||
return response.json();
|
||
});
|
||
}
|
||
|
||
function connect(wsUrl) {
|
||
return connectProtocol(wsUrl, 'Chrome CDP', timeoutMs, smokeSignal);
|
||
}
|
||
|
||
function connectBidi(wsUrl) {
|
||
return connectProtocol(wsUrl, 'Firefox BiDi', timeoutMs, smokeSignal);
|
||
}
|
||
|
||
function eventText(event) {
|
||
if (event.method === 'log.entryAdded')
|
||
return event.params.text || '';
|
||
if (event.method === 'Runtime.consoleAPICalled') {
|
||
return (event.params.args || []).map(arg => arg.value ?? arg.description ?? '').join(' ');
|
||
}
|
||
if (event.method === 'Log.entryAdded')
|
||
return event.params.entry?.text || '';
|
||
if (event.method === 'Runtime.exceptionThrown')
|
||
return [
|
||
event.params.exceptionDetails?.text || event.params.exceptionDetails?.exception?.description || 'exception thrown',
|
||
...((event.params.exceptionDetails?.stackTrace?.callFrames || []).map(frame => {
|
||
const name = frame.functionName || '(anonymous)';
|
||
return `${name}@${frame.url}:${frame.lineNumber + 1}:${frame.columnNumber + 1}`;
|
||
}))
|
||
].join(' ');
|
||
if (event.method === 'Page.javascriptDialogOpening')
|
||
return event.params.message || 'javascript dialog opened';
|
||
return '';
|
||
}
|
||
|
||
function isBenignAsyncifyUnwind(text) {
|
||
return /\b(callUserCallback|doRewind|MainLoop_runner)\b/.test(text) &&
|
||
!/\b(RuntimeError|Aborted|memory access|unreachable)\b/i.test(text);
|
||
}
|
||
|
||
function fatalEvent(event) {
|
||
const text = eventText(event);
|
||
if (event.method === 'Runtime.exceptionThrown' && text.includes('transaction.oncomplete'))
|
||
return '';
|
||
if (event.method === 'Runtime.exceptionThrown' && isBenignAsyncifyUnwind(text))
|
||
return '';
|
||
if (event.method === 'Runtime.exceptionThrown' || event.method === 'Page.javascriptDialogOpening')
|
||
return text;
|
||
if (event.method === 'Runtime.consoleAPICalled' && event.params.type === 'error' &&
|
||
/Aborted|RuntimeError|unreachable|exception thrown/i.test(text))
|
||
return text;
|
||
if (event.method === 'Log.entryAdded' && event.params.entry?.level === 'error' &&
|
||
/Aborted|RuntimeError|unreachable/i.test(text))
|
||
return text;
|
||
return '';
|
||
}
|
||
|
||
function fatalBidiEvent(event) {
|
||
if (event.method !== 'log.entryAdded')
|
||
return '';
|
||
|
||
const params = event.params || {};
|
||
const text = params.text || params.args?.map(arg => arg.value ?? arg.text ?? '').join(' ') || '';
|
||
if (text === 'unwind' || text === 'uncaught exception: unwind')
|
||
return '';
|
||
if (params.type === 'javascript' && params.level === 'error')
|
||
return text || 'javascript error';
|
||
if (params.level === 'error' && /Aborted|RuntimeError|unreachable|exception thrown/i.test(text))
|
||
return text;
|
||
return '';
|
||
}
|
||
|
||
function isTransientTargetNavigationError(error) {
|
||
return /Inspected target navigated or closed|Execution context was destroyed|Cannot find context with specified id/.test(error?.message || '');
|
||
}
|
||
|
||
async function waitForHealthyPage(client) {
|
||
const start = Date.now();
|
||
let sawApp = false;
|
||
let lastState = null;
|
||
let healthySince = 0;
|
||
|
||
while (Date.now() - start < timeoutMs) {
|
||
for (const event of client.events) {
|
||
const fatal = fatalEvent(event);
|
||
if (fatal) {
|
||
const recent = client.events.slice(-16).map(eventText).filter(Boolean).join(' | ');
|
||
throw new Error(`${fatal}; recent=${recent}`);
|
||
}
|
||
if (/PLATFORM: WEB: Initialized successfully|INBE: Global app pointer set/.test(eventText(event)))
|
||
sawApp = true;
|
||
}
|
||
|
||
let result;
|
||
try {
|
||
result = await client.send('Runtime.evaluate', {
|
||
expression: `(() => {
|
||
const renderer = ${JSON.stringify(renderer)};
|
||
const canvas = document.querySelector('canvas');
|
||
const status = document.querySelector('#status')?.textContent || '';
|
||
if (/WebGL is disabled/.test(status)) return { ok: ${allowWebglDisabled ? 'true' : 'false'}, disabledWebgl: true, status };
|
||
if (!canvas) return { ok: false, reason: 'missing canvas', status };
|
||
const M = globalThis.Module;
|
||
const asyncifyState = M && M.Asyncify && typeof M.Asyncify.state === 'number' ? M.Asyncify.state : 0;
|
||
if (renderer === 'canvas') {
|
||
const ctx = canvas.getContext('2d');
|
||
const width = canvas.width || canvas.clientWidth;
|
||
const height = canvas.height || canvas.clientHeight;
|
||
return {
|
||
ok: width > 0 && height > 0 && !!ctx && asyncifyState === 0,
|
||
renderer,
|
||
width,
|
||
height,
|
||
asyncifyState,
|
||
loadingClass: document.querySelector('#loading-screen')?.className || '',
|
||
moduleLoaded: !!M,
|
||
appReady: !!(M && M.__inbeAppReady),
|
||
runtimeReady: !!(M && M.__inbeRuntimeReady),
|
||
moduleRenderer: M && M.__inbeRenderer,
|
||
moduleStatus: (M && M.setStatus && M.setStatus.last && M.setStatus.last.text) || '',
|
||
mainStarted: !!(M && M.__inbeAppReady) || /Global app pointer set/.test((M && M.__inbeLastLog) || ''),
|
||
runDependencies: M && (typeof M.monitorRunDependencies === 'function') ? M.totalDependencies : undefined
|
||
};
|
||
}
|
||
const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
|
||
if (!gl) return { ok: false, reason: 'missing webgl', status };
|
||
const width = gl.drawingBufferWidth;
|
||
const height = gl.drawingBufferHeight;
|
||
return {
|
||
ok: width > 0 && height > 0 && asyncifyState === 0,
|
||
renderer,
|
||
width,
|
||
height,
|
||
asyncifyState,
|
||
loadingClass: document.querySelector('#loading-screen')?.className || '',
|
||
moduleLoaded: !!M,
|
||
appReady: !!(M && M.__inbeAppReady),
|
||
runtimeReady: !!(M && M.__inbeRuntimeReady),
|
||
moduleStatus: (M && M.setStatus && M.setStatus.last && M.setStatus.last.text) || '',
|
||
mainStarted: !!(M && M.__inbeAppReady) || !!(typeof Module !== 'undefined' && Module._main) || /Global app pointer set/.test((M && M.__inbeLastLog) || ''),
|
||
runDependencies: M && (typeof M.monitorRunDependencies === 'function') ? M.totalDependencies : undefined
|
||
};
|
||
})()`,
|
||
returnByValue: true
|
||
});
|
||
} catch (error) {
|
||
if (!isTransientTargetNavigationError(error))
|
||
throw error;
|
||
lastState = { ok: false, reason: error.message };
|
||
healthySince = 0;
|
||
await delay(100);
|
||
continue;
|
||
}
|
||
const value = result.result?.value;
|
||
lastState = value;
|
||
if ((sawApp || value?.appReady || value?.mainStarted) && value?.ok && value?.runtimeReady) {
|
||
if (!healthySince)
|
||
healthySince = Date.now();
|
||
if (Date.now() - healthySince >= 1500)
|
||
return value;
|
||
} else {
|
||
healthySince = 0;
|
||
}
|
||
await new Promise(resolveDelay => setTimeout(resolveDelay, 250));
|
||
}
|
||
|
||
const recent = client.events.slice(-12).map(eventText).filter(Boolean).join(' | ');
|
||
const allExceptions = client.events
|
||
.filter(e => e.method === 'Runtime.exceptionThrown')
|
||
.map(eventText)
|
||
.filter(Boolean)
|
||
.join(' | ');
|
||
throw new Error(`web app did not become healthy within ${timeoutMs}ms; state=${JSON.stringify(lastState)}; recent=${recent || '(none)'}; exceptions=${allExceptions || '(none)'}`);
|
||
}
|
||
|
||
async function waitForHealthyBidiPage(client, context) {
|
||
const start = Date.now();
|
||
let lastState = null;
|
||
let healthySince = 0;
|
||
|
||
while (Date.now() - start < timeoutMs) {
|
||
for (const event of client.events) {
|
||
const fatal = fatalBidiEvent(event);
|
||
if (fatal)
|
||
throw new Error(fatal);
|
||
}
|
||
|
||
const result = await client.send('script.evaluate', {
|
||
target: { context },
|
||
awaitPromise: false,
|
||
resultOwnership: 'none',
|
||
expression: `JSON.stringify((() => {
|
||
const canvas = document.querySelector('canvas');
|
||
const status = document.querySelector('#status')?.textContent || '';
|
||
if (/WebGL is disabled/.test(status)) return { ok: ${allowWebglDisabled ? 'true' : 'false'}, disabledWebgl: true, status };
|
||
if (!canvas) return { ok: false, reason: 'missing canvas', status };
|
||
const boot = Array.from(document.querySelectorAll('script')).some(script => /index\\.js/.test(script.src || ''));
|
||
const M = globalThis.Module;
|
||
const asyncifyState = M && M.Asyncify && typeof M.Asyncify.state === 'number' ? M.Asyncify.state : 0;
|
||
if (${JSON.stringify(renderer)} === 'canvas') {
|
||
const ctx = canvas.getContext('2d');
|
||
const width = canvas.width || canvas.clientWidth;
|
||
const height = canvas.height || canvas.clientHeight;
|
||
return {
|
||
ok: width > 0 && height > 0 && !!ctx && boot && !!(M && M.__inbeRuntimeReady) && asyncifyState === 0,
|
||
renderer: 'canvas',
|
||
width,
|
||
height,
|
||
asyncifyState,
|
||
boot,
|
||
runtimeReady: !!(M && M.__inbeRuntimeReady),
|
||
moduleRenderer: M && M.__inbeRenderer,
|
||
hasOnboardingHook: !!(M && M._app_web_test_onboarding_state)
|
||
};
|
||
}
|
||
const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl');
|
||
if (!gl) return { ok: false, reason: 'missing webgl', status };
|
||
const width = gl.drawingBufferWidth;
|
||
const height = gl.drawingBufferHeight;
|
||
return {
|
||
ok: width > 0 && height > 0 && boot && !!(M && M.__inbeRuntimeReady) && asyncifyState === 0,
|
||
renderer: 'canvas',
|
||
width,
|
||
height,
|
||
asyncifyState,
|
||
boot,
|
||
runtimeReady: !!(M && M.__inbeRuntimeReady),
|
||
hasOnboardingHook: !!(M && M._app_web_test_onboarding_state)
|
||
};
|
||
})())`
|
||
});
|
||
try {
|
||
lastState = JSON.parse(result.result?.value || '{}');
|
||
} catch {
|
||
lastState = null;
|
||
}
|
||
if (lastState?.ok) {
|
||
if (!healthySince)
|
||
healthySince = Date.now();
|
||
if (Date.now() - healthySince >= 1500)
|
||
return lastState;
|
||
} else {
|
||
healthySince = 0;
|
||
}
|
||
await delay(250);
|
||
}
|
||
|
||
throw new Error(`Firefox web app did not become healthy within ${timeoutMs}ms; state=${JSON.stringify(lastState)}`);
|
||
}
|
||
|
||
function writeFirefoxPrefs() {
|
||
writeFileSync(join(userDataDir, 'user.js'), [
|
||
'user_pref("browser.shell.checkDefaultBrowser", false);',
|
||
'user_pref("browser.tabs.warnOnClose", false);',
|
||
'user_pref("browser.warnOnQuit", false);',
|
||
'user_pref("datareporting.policy.dataSubmissionEnabled", false);',
|
||
'user_pref("dom.webgpu.enabled", false);',
|
||
'user_pref("gfx.webrender.software", true);',
|
||
'user_pref("media.autoplay.default", 0);',
|
||
// Silence the test profile's output while keeping media playback active.
|
||
'user_pref("media.volume_scale", "0.0");',
|
||
'user_pref("privacy.fingerprintingProtection", false);',
|
||
'user_pref("privacy.resistFingerprinting", false);',
|
||
'user_pref("webgl.disabled", false);',
|
||
'user_pref("webgl.disable-fail-if-major-performance-caveat", false);',
|
||
'user_pref("webgl.enable-webgl2", true);',
|
||
'user_pref("webgl.force-enabled", true);',
|
||
''
|
||
].join('\n'));
|
||
}
|
||
|
||
async function waitForStorageIdle(client) {
|
||
const start = Date.now();
|
||
let lastState = null;
|
||
|
||
while (Date.now() - start < timeoutMs) {
|
||
const result = await client.send('Runtime.evaluate', {
|
||
expression: `(() => ({
|
||
syncing: !!Module.__inbeStorageSyncing,
|
||
pending: !!Module.__inbeStorageSyncPending,
|
||
timer: !!Module.__inbeStorageSyncTimer,
|
||
error: Module.__inbeStorageSyncLastError || ''
|
||
}))()`,
|
||
returnByValue: true
|
||
});
|
||
lastState = result.result?.value;
|
||
if (lastState && !lastState.syncing && !lastState.timer && lastState.error)
|
||
throw new Error('IDBFS save failed: ' + lastState.error);
|
||
if (lastState && !lastState.syncing && !lastState.pending && !lastState.timer)
|
||
return;
|
||
await new Promise(resolveDelay => setTimeout(resolveDelay, 50));
|
||
}
|
||
|
||
throw new Error(`IDBFS sync did not finish within ${timeoutMs}ms; state=${JSON.stringify(lastState)}`);
|
||
}
|
||
|
||
async function waitForStorageIdleBidi(client, context) {
|
||
const start = Date.now();
|
||
let lastState = null;
|
||
|
||
while (Date.now() - start < timeoutMs) {
|
||
const result = await client.send('script.evaluate', {
|
||
target: { context },
|
||
awaitPromise: false,
|
||
resultOwnership: 'none',
|
||
expression: "JSON.stringify((() => ({ syncing: !!Module.__inbeStorageSyncing, pending: !!Module.__inbeStorageSyncPending, timer: !!Module.__inbeStorageSyncTimer }))())"
|
||
});
|
||
try {
|
||
lastState = JSON.parse(result.result?.value || '{}');
|
||
} catch {
|
||
lastState = null;
|
||
}
|
||
if (lastState && !lastState.syncing && !lastState.pending && !lastState.timer)
|
||
return;
|
||
await delay(50);
|
||
}
|
||
|
||
throw new Error('Firefox IDBFS sync did not finish within ' + timeoutMs + 'ms; state=' + JSON.stringify(lastState));
|
||
}
|
||
|
||
function bidiResultValue(result, label) {
|
||
if (result.type === 'exception') {
|
||
const exception = result.exceptionDetails?.text ||
|
||
result.exceptionDetails?.exception?.value ||
|
||
result.exceptionDetails?.exception?.description ||
|
||
JSON.stringify(result.exceptionDetails || result);
|
||
throw new Error(`${label} threw in Firefox: ${exception}`);
|
||
}
|
||
if (!result.result || !Object.hasOwn(result.result, 'value'))
|
||
throw new Error(`${label} did not return a value in Firefox: ${JSON.stringify(result).slice(0, 1000)}`);
|
||
return result.result.value;
|
||
}
|
||
|
||
function bidiJsonResult(result, label) {
|
||
const value = bidiResultValue(result, label);
|
||
try {
|
||
return JSON.parse(value || '{}');
|
||
} catch (error) {
|
||
throw new Error(`${label} returned invalid JSON in Firefox: ${JSON.stringify(value)}; ${error.message}`);
|
||
}
|
||
}
|
||
|
||
function wasmHookEvalHelper() {
|
||
return `
|
||
async function callWasmHook(name, args = []) {
|
||
const M = globalThis.Module;
|
||
const fn = M && M['_' + name];
|
||
async function waitForAsyncifyIdle(phase) {
|
||
const idleDeadline = Date.now() + 5000;
|
||
while (true) {
|
||
const state = M.Asyncify ? M.Asyncify.state : 0;
|
||
// A suspended call can have normal state while its saved stack remains live.
|
||
if (state === 0 && !M.Asyncify?.currData)
|
||
return;
|
||
if (Date.now() > idleDeadline)
|
||
throw new Error(name + ' Asyncify ' + phase + ' wait timed out; state=' + state);
|
||
await new Promise(resolve => setTimeout(resolve, 5));
|
||
}
|
||
}
|
||
if (typeof fn !== 'function')
|
||
throw new Error('missing ' + name + ' hook');
|
||
await waitForAsyncifyIdle('idle');
|
||
let result = fn.apply(M, args);
|
||
if (M.Asyncify?.currData && typeof M.Asyncify.whenDone === 'function') {
|
||
const done = M.Asyncify.whenDone();
|
||
const timeout = new Promise((_, reject) =>
|
||
setTimeout(() => reject(new Error(name + ' Asyncify wait timed out')), 5000));
|
||
result = await Promise.race([done, timeout]);
|
||
}
|
||
await waitForAsyncifyIdle('settle');
|
||
return result;
|
||
}
|
||
`;
|
||
}
|
||
|
||
async function verifyReloadPersistence(client) {
|
||
await waitForStorageIdle(client);
|
||
const marker = `web-smoke-${Date.now()}`;
|
||
const flush = await client.send('Runtime.evaluate', {
|
||
expression: `(async () => {
|
||
try { FS.mkdir('/home/inbe'); } catch (e) {}
|
||
FS.writeFile('/home/inbe/web-smoke-persist.txt', ${JSON.stringify(marker)});
|
||
if (typeof Module.__inbeFlushStorageSync !== 'function')
|
||
throw new Error('missing immediate storage flush helper');
|
||
return await Module.__inbeFlushStorageSync(true);
|
||
})()`,
|
||
awaitPromise: true,
|
||
returnByValue: true
|
||
});
|
||
if (!flush.result?.value)
|
||
throw new Error('IDBFS flush failed before reload persistence check');
|
||
await waitForStorageIdle(client);
|
||
await client.send('Page.reload', { ignoreCache: true });
|
||
await waitForHealthyPage(client);
|
||
|
||
const result = await client.send('Runtime.evaluate', {
|
||
expression: `(() => {
|
||
try {
|
||
return FS.readFile('/home/inbe/web-smoke-persist.txt', { encoding: 'utf8' });
|
||
} catch (e) {
|
||
return '';
|
||
}
|
||
})()`,
|
||
returnByValue: true
|
||
});
|
||
if (result.result?.value !== marker)
|
||
throw new Error(`IDBFS reload persistence failed; got=${JSON.stringify(result.result?.value)}`);
|
||
}
|
||
|
||
async function verifyAppSettingsReloadPersistence(client) {
|
||
await waitForStorageIdle(client);
|
||
let ok = await pageJson(client, `(async () => { ${wasmHookEvalHelper()} await callWasmHook('app_web_test_save_onboarding_state'); await Module.__inbeFlushStorageSync(true); return true; })()`, true);
|
||
if (!ok)
|
||
throw new Error('failed to invoke app settings save test hook');
|
||
await waitForStorageIdle(client);
|
||
await client.send('Page.reload', { ignoreCache: true });
|
||
await waitForHealthyPage(client);
|
||
|
||
ok = await pageJson(client, "(() => typeof Module._app_web_test_onboarding_state === 'function' && Module._app_web_test_onboarding_state() === 1)()");
|
||
if (!ok)
|
||
throw new Error('app settings did not persist across reload');
|
||
}
|
||
|
||
async function verifyBrowserStartupScale(client, url) {
|
||
const desktop = { width: 1280, height: 800, deviceScaleFactor: 1, mobile: false };
|
||
const desktopAgent = await pageJson(client, 'navigator.userAgent');
|
||
await client.send('Page.addScriptToEvaluateOnNewDocument', { source: `(() => {
|
||
window.startupPaintScales = new Map();
|
||
const contexts = [CanvasRenderingContext2D];
|
||
if (typeof OffscreenCanvasRenderingContext2D !== 'undefined')
|
||
contexts.push(OffscreenCanvasRenderingContext2D);
|
||
for (const { prototype } of contexts) {
|
||
const fillText = prototype.fillText;
|
||
prototype.fillText = function(text, ...args) {
|
||
const canvas = window.Module?.canvas;
|
||
if (canvas && this.canvas.width === canvas.width && this.canvas.height === canvas.height)
|
||
window.startupPaintScales.set(text, this.getTransform().a / devicePixelRatio);
|
||
return fillText.call(this, text, ...args);
|
||
};
|
||
}
|
||
})()` });
|
||
|
||
let launch = 0;
|
||
async function check(metrics, expected) {
|
||
const startupUrl = new URL(url);
|
||
startupUrl.searchParams.set('startupScaleCase', String(++launch));
|
||
await client.send('Emulation.setDeviceMetricsOverride', metrics);
|
||
await client.send('Page.navigate', { url: startupUrl.href });
|
||
await waitForHealthyPage(client);
|
||
const state = await pageJson(client, `(() => {
|
||
const canvas = Module.canvas;
|
||
const rect = canvas.getBoundingClientRect();
|
||
return { width: rect.width, height: rect.height, ratio: devicePixelRatio,
|
||
backingWidth: canvas.width, backingHeight: canvas.height,
|
||
scales: [...window.startupPaintScales.values()] };
|
||
})()`);
|
||
const { width, height, deviceScaleFactor } = metrics;
|
||
const atExpectedScale = state.scales.filter(scale => Math.abs(scale - expected) < 0.01);
|
||
if (state.width !== width || state.height !== height || state.ratio !== deviceScaleFactor ||
|
||
state.backingWidth !== Math.round(width * deviceScaleFactor) ||
|
||
state.backingHeight !== Math.round(height * deviceScaleFactor) || atExpectedScale.length < 4) {
|
||
throw new Error(`web startup expected scale ${expected}, metrics ${JSON.stringify(metrics)}: ${JSON.stringify(state)}`);
|
||
}
|
||
}
|
||
|
||
await check(desktop, 1);
|
||
await check({ ...desktop, deviceScaleFactor: 2 }, 1);
|
||
await check({ ...desktop, width: 1600, height: 1000 }, 1);
|
||
|
||
await client.send('Emulation.setUserAgentOverride', {
|
||
userAgent: 'Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 Chrome/131.0.0.0 Mobile Safari/537.36'
|
||
});
|
||
await check({ width: 390, height: 844, deviceScaleFactor: 3, mobile: true }, 844 / 560);
|
||
await client.send('Emulation.setUserAgentOverride', { userAgent: desktopAgent });
|
||
|
||
const telegram = await client.send('Page.addScriptToEvaluateOnNewDocument', {
|
||
source: 'globalThis.InbeTelegramBridge = Object.freeze({});'
|
||
});
|
||
await check(desktop, 800 / 560);
|
||
await client.send('Page.removeScriptToEvaluateOnNewDocument', telegram);
|
||
|
||
await check(desktop, 1);
|
||
await pageJson(client, `(async () => {
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_show_appearance');
|
||
})()`, true);
|
||
await waitRouteTransition(client);
|
||
await waitAnimationFrames(client, 3);
|
||
const slider = await pageJson(client, `({
|
||
x: Module._app_web_test_control_x(140), y: Module._app_web_test_control_y(140),
|
||
width: Module._app_web_test_control_width(140), height: Module._app_web_test_control_height(140)
|
||
})`);
|
||
if (slider.width <= 0 || slider.height <= 0) throw new Error('Appearance UI scale slider is missing');
|
||
// The middle of the 50–250% slider selects 150%.
|
||
await dispatchCanvasClick(client, slider.x + slider.width / 2, slider.y + slider.height / 2);
|
||
await waitForStorageIdle(client);
|
||
const flushed = await pageJson(client, 'Module.__inbeFlushStorageSync(true)', true);
|
||
if (!flushed) throw new Error('Could not persist the Appearance UI scale');
|
||
await check({ ...desktop, deviceScaleFactor: 2 }, 1.5);
|
||
console.log('web startup scale: desktop 100% at DPR 1 and 2, mobile and Telegram fit, saved 150% restored');
|
||
}
|
||
|
||
async function verifySetupRouteDoesNotOverrideSavedOnboarding(client, port) {
|
||
await waitForStorageIdle(client);
|
||
await client.send('Page.navigate', { url: `http://127.0.0.1:${port}/index.html#/audio_setup` });
|
||
await waitForHealthyPage(client);
|
||
await waitForStorageIdle(client);
|
||
|
||
const result = await client.send('Runtime.evaluate', {
|
||
expression: `(() => ({
|
||
hash: location.hash || '',
|
||
onboarding: typeof Module._app_web_test_onboarding_state === 'function'
|
||
? Module._app_web_test_onboarding_state()
|
||
: -1
|
||
}))()`,
|
||
returnByValue: true
|
||
});
|
||
const value = result.result?.value || {};
|
||
if (value.onboarding !== 1)
|
||
throw new Error(`saved onboarding state missing before setup route check; state=${JSON.stringify(value)}`);
|
||
if (value.hash === '#/audio_setup')
|
||
throw new Error('saved onboarding state was overridden by stale #/audio_setup route');
|
||
}
|
||
|
||
async function verifySyncKeyImport(client) {
|
||
await waitForStorageIdle(client);
|
||
let state = await pageJson(client, `(async () => JSON.stringify(await (async () => {
|
||
if (typeof Module._app_web_test_import_sync_key !== 'function')
|
||
return { ok: false, code: -99 };
|
||
if (typeof Module._app_web_test_sync_key_state !== 'function')
|
||
return { ok: false, code: -98 };
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_import_sync_key');
|
||
const deadline = Date.now() + ${timeoutMs};
|
||
let code = 0;
|
||
while (Date.now() < deadline) {
|
||
code = Module._app_web_test_sync_key_state();
|
||
if (code !== 0)
|
||
return { ok: code === 1, code };
|
||
await new Promise(resolve => setTimeout(resolve, 50));
|
||
}
|
||
return { ok: false, code };
|
||
})()))()`, true);
|
||
if (!state.ok)
|
||
throw new Error(`web sync key import hook failed; code=${state.code}`);
|
||
const flush = await client.send('Runtime.evaluate', {
|
||
expression: "(async () => await Module.__inbeFlushStorageSync(true))()",
|
||
awaitPromise: true,
|
||
returnByValue: true
|
||
});
|
||
if (!flush.result?.value)
|
||
throw new Error('IDBFS flush failed after web sync key import hook');
|
||
await waitForStorageIdle(client);
|
||
state = await pageJson(client, "(() => JSON.stringify({ code: typeof Module._app_web_test_sync_key_state === 'function' ? Module._app_web_test_sync_key_state() : -99 }))()");
|
||
if (state.code !== 1)
|
||
throw new Error(`web sync key import did not save account settings; code=${state.code}`);
|
||
}
|
||
|
||
async function verifyAppSettingsReloadPersistenceBidi(client, context) {
|
||
await waitForStorageIdleBidi(client, context);
|
||
let result = await client.send('script.evaluate', {
|
||
target: { context },
|
||
awaitPromise: true,
|
||
resultOwnership: 'none',
|
||
expression: `(async () => JSON.stringify(await (async () => { ${wasmHookEvalHelper()} try { await callWasmHook('app_web_test_save_onboarding_state'); } catch (error) { return { ok: false, reason: String(error && error.message || error) }; } await Module.__inbeFlushStorageSync(true); return { ok: Module._app_web_test_onboarding_state && Module._app_web_test_onboarding_state() === 1 }; })()))()`
|
||
});
|
||
let state = JSON.parse(result.result?.value || '{}');
|
||
if (!state.ok)
|
||
throw new Error(state.reason || 'failed to invoke Firefox app settings save test hook or immediate readback failed');
|
||
await waitForStorageIdleBidi(client, context);
|
||
await client.send('browsingContext.reload', { context, wait: 'complete' });
|
||
await waitForHealthyBidiPage(client, context);
|
||
|
||
result = await client.send('script.evaluate', {
|
||
target: { context },
|
||
awaitPromise: false,
|
||
resultOwnership: 'none',
|
||
expression: "JSON.stringify((() => ({ ok: typeof Module._app_web_test_onboarding_state === 'function' && Module._app_web_test_onboarding_state() === 1 }))())"
|
||
});
|
||
state = JSON.parse(result.result?.value || '{}');
|
||
if (!state.ok)
|
||
throw new Error('Firefox app settings did not persist across reload');
|
||
}
|
||
|
||
async function verifyAppSettingsImmediateBidi(client, context) {
|
||
await waitForStorageIdleBidi(client, context);
|
||
const result = await client.send('script.evaluate', {
|
||
target: { context },
|
||
awaitPromise: true,
|
||
resultOwnership: 'none',
|
||
expression: `(async () => JSON.stringify(await (async () => { ${wasmHookEvalHelper()} try { await callWasmHook('app_web_test_save_onboarding_state'); } catch (error) { return { ok: false, reason: String(error && error.message || error) }; } await Module.__inbeFlushStorageSync(true); return { ok: Module._app_web_test_onboarding_state && Module._app_web_test_onboarding_state() === 1 }; })()))()`
|
||
});
|
||
let state = JSON.parse(result.result?.value || '{}');
|
||
if (!state.ok)
|
||
throw new Error(state.reason || 'Firefox app settings immediate save/readback failed');
|
||
await waitForStorageIdleBidi(client, context);
|
||
}
|
||
|
||
async function verifySyncKeyImportBidi(client, context) {
|
||
await waitForStorageIdleBidi(client, context);
|
||
let result = await client.send('script.evaluate', {
|
||
target: { context },
|
||
awaitPromise: true,
|
||
resultOwnership: 'none',
|
||
expression: `(async () => JSON.stringify(await (async () => {
|
||
if (typeof Module._app_web_test_import_sync_key !== 'function')
|
||
return { ok: false, code: -99 };
|
||
if (typeof Module._app_web_test_sync_key_state !== 'function')
|
||
return { ok: false, code: -98 };
|
||
try {
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_import_sync_key');
|
||
} catch (error) {
|
||
return { ok: false, code: -95, phase: 'import', error: String(error && error.stack || error) };
|
||
}
|
||
const deadline = Date.now() + ${timeoutMs};
|
||
let code = 0;
|
||
while (Date.now() < deadline) {
|
||
try {
|
||
code = Module._app_web_test_sync_key_state();
|
||
} catch (error) {
|
||
return { ok: false, code: -94, phase: 'state', error: String(error && error.stack || error) };
|
||
}
|
||
if (code !== 0)
|
||
break;
|
||
await new Promise(resolve => setTimeout(resolve, 50));
|
||
}
|
||
if (code !== 1)
|
||
return { ok: false, code };
|
||
if (typeof Module.__inbeFlushStorageSync !== 'function')
|
||
return { ok: false, code: -97 };
|
||
if (!await Module.__inbeFlushStorageSync(true))
|
||
return { ok: false, code: -96 };
|
||
try {
|
||
code = Module._app_web_test_sync_key_state();
|
||
} catch (error) {
|
||
return { ok: false, code: -93, phase: 'readback', error: String(error && error.stack || error) };
|
||
}
|
||
return { ok: code === 1, code };
|
||
})()))()`
|
||
});
|
||
let state = bidiJsonResult(result, 'sync key hook availability check');
|
||
if (!state.ok)
|
||
throw new Error(`Firefox web sync key import hook failed; code=${state.code}; phase=${state.phase || 'unknown'}; error=${state.error || ''}`);
|
||
await waitForStorageIdleBidi(client, context);
|
||
result = await client.send('script.evaluate', {
|
||
target: { context },
|
||
awaitPromise: false,
|
||
resultOwnership: 'none',
|
||
expression: "JSON.stringify((() => { const code = typeof Module._app_web_test_sync_key_state === 'function' ? Module._app_web_test_sync_key_state() : -99; return { ok: code === 1, code }; })())"
|
||
});
|
||
state = bidiJsonResult(result, 'sync key settings readback');
|
||
if (!state.ok)
|
||
throw new Error(`Firefox web sync key import did not save account settings; code=${state.code}`);
|
||
}
|
||
|
||
async function pageJson(client, expression, awaitPromise = false) {
|
||
const result = await client.send('Runtime.evaluate', {
|
||
expression,
|
||
awaitPromise,
|
||
returnByValue: true
|
||
});
|
||
if (result.exceptionDetails) {
|
||
const text = result.exceptionDetails.exception?.description ||
|
||
result.exceptionDetails.text || 'unknown page evaluation error';
|
||
throw new Error(`page evaluation failed: ${text}`);
|
||
}
|
||
const value = result.result?.value;
|
||
if (typeof value === 'string') {
|
||
try {
|
||
return JSON.parse(value);
|
||
} catch {}
|
||
}
|
||
return value;
|
||
}
|
||
|
||
// A route change fades over a fraction of a second and ignores input
|
||
// meanwhile, so a click must wait for the fade to finish. The app reports
|
||
// whether one is running.
|
||
async function waitRouteTransition(client) {
|
||
await waitAnimationFrames(client, 2);
|
||
for (let attempt = 0; attempt < 150; attempt++) {
|
||
const active = await pageJson(client, `(() => JSON.stringify(
|
||
typeof Module._app_web_test_route_transition_active === 'function' ?
|
||
Module._app_web_test_route_transition_active() : 0))()`);
|
||
if (!active)
|
||
return;
|
||
await delay(20);
|
||
}
|
||
throw new Error('route transition did not finish');
|
||
}
|
||
|
||
async function waitAnimationFrames(client, frameCount = 3) {
|
||
const result = await pageJson(client, `(async () => JSON.stringify(await new Promise(resolve => {
|
||
let frames = 0;
|
||
function tick() {
|
||
frames++;
|
||
if (frames >= ${frameCount}) resolve({ ok: true, frames });
|
||
else requestAnimationFrame(tick);
|
||
}
|
||
requestAnimationFrame(tick);
|
||
setTimeout(() => resolve({ ok: false, reason: 'timeout', frames }), 5000);
|
||
})))()`, true);
|
||
if (!result?.ok)
|
||
throw new Error(`animation frames stalled: ${JSON.stringify(result)}`);
|
||
}
|
||
|
||
async function dispatchCanvasClick(client, x, y) {
|
||
await waitRouteTransition(client);
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mouseMoved',
|
||
x,
|
||
y
|
||
});
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mousePressed',
|
||
x,
|
||
y,
|
||
button: 'left',
|
||
clickCount: 1
|
||
});
|
||
await waitAnimationFrames(client, 3);
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mouseReleased',
|
||
x,
|
||
y,
|
||
button: 'left',
|
||
clickCount: 1
|
||
});
|
||
await waitAnimationFrames(client, 3);
|
||
}
|
||
|
||
async function dispatchCanvasDrag(client, x, y, endX, endY) {
|
||
await waitRouteTransition(client);
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mousePressed', x, y, button: 'left', clickCount: 1
|
||
});
|
||
// The idle input sampler needs a held press. Wall-clock spacing keeps the
|
||
// complete swipe inside its 1.2 second limit even when frames arrive late.
|
||
await delay(45);
|
||
for (let step = 1; step <= 6; step++) {
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mouseMoved', x: x + (endX - x) * step / 6,
|
||
y: y + (endY - y) * step / 6, button: 'left', buttons: 1
|
||
});
|
||
await delay(45);
|
||
}
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mouseReleased', x: endX, y: endY, button: 'left', clickCount: 1
|
||
});
|
||
await waitAnimationFrames(client, 3);
|
||
}
|
||
|
||
async function firstRunGuideButtonTarget(client, kind) {
|
||
const suffix = kind === 'close' ? 'close' : 'next';
|
||
const target = await pageJson(client, `(() => JSON.stringify((() => {
|
||
const canvas = Module.canvas || document.querySelector('canvas');
|
||
if (!canvas)
|
||
return { ok: false, reason: 'missing canvas' };
|
||
const xFn = Module._app_web_test_first_run_guide_${suffix}_x;
|
||
const yFn = Module._app_web_test_first_run_guide_${suffix}_y;
|
||
if (typeof xFn !== 'function' || typeof yFn !== 'function')
|
||
return { ok: false, reason: 'missing guide ${suffix} hook' };
|
||
const rawX = xFn();
|
||
const rawY = yFn();
|
||
const rect = canvas.getBoundingClientRect();
|
||
const logicalW = window.__kryCanvas && window.__kryCanvas.w ? window.__kryCanvas.w : rect.width;
|
||
const logicalH = window.__kryCanvas && window.__kryCanvas.h ? window.__kryCanvas.h : rect.height;
|
||
const x = rect.left + rawX * rect.width / Math.max(1, logicalW);
|
||
const y = rect.top + rawY * rect.height / Math.max(1, logicalH);
|
||
return {
|
||
ok: rawX >= 0 && rawY >= 0 && x >= rect.left && y >= rect.top &&
|
||
x <= rect.right && y <= rect.bottom,
|
||
reason: 'invalid guide ${suffix} target',
|
||
x,
|
||
y,
|
||
rawX,
|
||
rawY,
|
||
guideActive: Module._app_web_test_first_run_guide_active(),
|
||
guideStep: Module._app_web_test_first_run_guide_step(),
|
||
transitionActive: Module._app_web_test_route_transition_active(),
|
||
rect: { left: rect.left, top: rect.top, right: rect.right, bottom: rect.bottom, width: rect.width, height: rect.height },
|
||
logical: { width: logicalW, height: logicalH },
|
||
canvas: { width: canvas.width, height: canvas.height }
|
||
};
|
||
})()))()`);
|
||
if (!target?.ok)
|
||
throw new Error(`${target?.reason || 'failed to compute guide click target'}; state=${JSON.stringify(target)}`);
|
||
return target;
|
||
}
|
||
|
||
async function firstRunGuideState(client, requireDebug = true, requireActive = false) {
|
||
const start = Date.now();
|
||
let state = null;
|
||
|
||
while (Date.now() - start < timeoutMs) {
|
||
state = await pageJson(client, `(() => ({
|
||
active: Module._app_web_test_first_run_guide_active(),
|
||
step: Module._app_web_test_first_run_guide_step(),
|
||
clipped: Module._app_web_test_first_run_guide_text_clipped(),
|
||
nextX: Module._app_web_test_first_run_guide_next_x(),
|
||
nextY: Module._app_web_test_first_run_guide_next_y()
|
||
}))()`);
|
||
if ((!requireActive || (state?.active === 1 && state?.step === 0)) &&
|
||
(!requireDebug || (state?.clipped !== -1 &&
|
||
state?.nextX >= 0 && state?.nextY >= 0)))
|
||
return state;
|
||
await waitAnimationFrames(client, 1);
|
||
}
|
||
|
||
return state;
|
||
}
|
||
|
||
async function firstRunGuideActionAnchor(client) {
|
||
return pageJson(client, `(() => {
|
||
const canvas = Module.canvas || document.querySelector('canvas');
|
||
const rect = canvas ? canvas.getBoundingClientRect() : { width: 0, height: 0 };
|
||
const logicalW = window.__kryCanvas && window.__kryCanvas.w ? window.__kryCanvas.w : rect.width;
|
||
const logicalH = window.__kryCanvas && window.__kryCanvas.h ? window.__kryCanvas.h : rect.height;
|
||
return {
|
||
x: Module._app_web_test_first_run_guide_anchor_x(),
|
||
y: Module._app_web_test_first_run_guide_anchor_y(),
|
||
width: Module._app_web_test_first_run_guide_anchor_w(),
|
||
height: Module._app_web_test_first_run_guide_anchor_h(),
|
||
logical: { width: logicalW, height: logicalH }
|
||
};
|
||
})()`);
|
||
}
|
||
|
||
async function verifyFirstRunGuideCanvasFlow(client) {
|
||
if (renderer !== 'canvas')
|
||
return;
|
||
|
||
await client.send('Emulation.setDeviceMetricsOverride', {
|
||
width: 450, height: 800, deviceScaleFactor: 1, mobile: false
|
||
});
|
||
await waitAnimationFrames(client, 4);
|
||
|
||
let state = await pageJson(client, `(async () => JSON.stringify(await (async () => {
|
||
if (typeof Module._app_web_test_show_first_run_guide !== 'function')
|
||
return { ok: false, reason: 'missing first-run guide show hook' };
|
||
if (typeof Module._app_web_test_first_run_guide_active !== 'function' ||
|
||
typeof Module._app_web_test_first_run_guide_step !== 'function' ||
|
||
typeof Module._app_web_test_first_run_guide_text_clipped !== 'function' ||
|
||
typeof Module._app_web_test_save_onboarding_state !== 'function')
|
||
return { ok: false, reason: 'missing first-run guide state hooks' };
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_show_first_run_guide');
|
||
await Module.__inbeFlushStorageSync(true);
|
||
return { ok: true };
|
||
})()))()`, true);
|
||
if (state?.ok) {
|
||
await waitRouteTransition(client);
|
||
state = { ok: true, ...(await firstRunGuideState(client, true, true)) };
|
||
}
|
||
if (!state?.ok || state.active !== 1 || state.step !== 0)
|
||
throw new Error(`failed to show Spanish first-run guide: ${JSON.stringify(state)}`);
|
||
if (state.clipped === -1)
|
||
state = { ok: true, ...(await firstRunGuideState(client)) };
|
||
if (state.clipped !== 0)
|
||
throw new Error(`Spanish first-run guide text is clipped: ${JSON.stringify(state)}`);
|
||
|
||
// With one practice installed the guide has no carousel step.
|
||
const guideSteps = await pageJson(client, 'Module._app_web_test_first_run_guide_count()');
|
||
if (guideSteps < 2)
|
||
throw new Error(`first-run guide has too few steps: ${guideSteps}`);
|
||
let previousTarget = null;
|
||
for (let expected = 1; expected < guideSteps; expected++) {
|
||
let target;
|
||
for (let attempt = 0; attempt < 30; attempt++) {
|
||
target = await firstRunGuideButtonTarget(client, 'next');
|
||
if (!previousTarget || target.rawY !== previousTarget.rawY)
|
||
break;
|
||
await waitAnimationFrames(client, 2);
|
||
}
|
||
if (previousTarget && target.rawY === previousTarget.rawY)
|
||
throw new Error(`guide Next layout did not advance at 1:1 scale: ${JSON.stringify({ expected, target })}`);
|
||
if (target.rect.width !== 450 || target.rect.height !== 800 ||
|
||
target.canvas.width !== 450 || target.canvas.height !== 800)
|
||
throw new Error(`guide canvas is not 1:1 at 450x800: ${JSON.stringify(target)}`);
|
||
await dispatchCanvasClick(client, target.x, target.y);
|
||
await waitRouteTransition(client);
|
||
state = await firstRunGuideState(client, false);
|
||
if (state.active !== 1 || state.step !== expected || state.clipped !== 0)
|
||
throw new Error(`guide Next missed or clipped at 1:1 scale: ${JSON.stringify({ expected, state, target })}`);
|
||
previousTarget = target;
|
||
}
|
||
|
||
state = await pageJson(client, `(async () => JSON.stringify(await (async () => {
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_save_onboarding_state');
|
||
await Module.__inbeFlushStorageSync(true);
|
||
return {
|
||
active: Module._app_web_test_first_run_guide_active(),
|
||
step: Module._app_web_test_first_run_guide_step(),
|
||
onboarding: Module._app_web_test_onboarding_state && Module._app_web_test_onboarding_state()
|
||
};
|
||
})()))()`, true);
|
||
if (state.onboarding !== 1)
|
||
throw new Error(`guide dismissed state did not persist before reload: ${JSON.stringify(state)}`);
|
||
|
||
await waitForStorageIdle(client);
|
||
await client.send('Page.reload', { ignoreCache: true });
|
||
await waitForHealthyPage(client);
|
||
await waitAnimationFrames(client, 3);
|
||
state = await pageJson(client, `(() => ({
|
||
active: Module._app_web_test_first_run_guide_active(),
|
||
step: Module._app_web_test_first_run_guide_step(),
|
||
onboarding: Module._app_web_test_onboarding_state && Module._app_web_test_onboarding_state()
|
||
}))()`);
|
||
if (state.active !== 0 || state.onboarding !== 1)
|
||
throw new Error(`guide reopened after reload: ${JSON.stringify(state)}`);
|
||
await client.send('Emulation.clearDeviceMetricsOverride');
|
||
await waitAnimationFrames(client, 4);
|
||
}
|
||
|
||
function installHabitsLifecycleWatchExpression() {
|
||
return `(() => {
|
||
window.__inbeSmokeLifecycle = { beforeunload: 0, pagehide: 0, visibilityHidden: 0 };
|
||
if (!window.__inbeSmokeLifecycleInstalled) {
|
||
window.__inbeSmokeLifecycleInstalled = true;
|
||
window.addEventListener('beforeunload', () => { window.__inbeSmokeLifecycle.beforeunload++; });
|
||
window.addEventListener('pagehide', () => { window.__inbeSmokeLifecycle.pagehide++; });
|
||
document.addEventListener('visibilitychange', () => {
|
||
if (document.visibilityState === 'hidden')
|
||
window.__inbeSmokeLifecycle.visibilityHidden++;
|
||
});
|
||
}
|
||
return true;
|
||
})()`;
|
||
}
|
||
|
||
function startHabitsFrameProbeExpression(frameCount) {
|
||
return `(() => {
|
||
const canvas = document.querySelector('canvas');
|
||
const frames = ${frameCount};
|
||
window.__inbeSmokeFrameProbe = new Promise(resolve => {
|
||
const samples = [];
|
||
let frame = 0;
|
||
function sample() {
|
||
const result = { frame, ok: false, bright: 0, total: 0, reason: '' };
|
||
try {
|
||
if (!canvas) {
|
||
result.reason = 'missing canvas';
|
||
} else if (canvas.clientWidth <= 0 || canvas.clientHeight <= 0) {
|
||
result.reason = 'zero-size canvas';
|
||
} else {
|
||
const w = 32;
|
||
const h = 32;
|
||
const copy = document.createElement('canvas');
|
||
copy.width = w;
|
||
copy.height = h;
|
||
const ctx = copy.getContext('2d', { willReadFrequently: true });
|
||
ctx.drawImage(canvas, 0, 0, w, h);
|
||
const data = ctx.getImageData(0, 0, w, h).data;
|
||
let bright = 0;
|
||
let alpha = 0;
|
||
for (let i = 0; i < data.length; i += 4) {
|
||
if (data[i + 3] > 0)
|
||
alpha++;
|
||
if (data[i + 3] > 0 && data[i] + data[i + 1] + data[i + 2] > 18)
|
||
bright++;
|
||
}
|
||
result.bright = bright;
|
||
result.alpha = alpha;
|
||
result.total = w * h;
|
||
result.ok = bright > result.total * 0.05;
|
||
if (!result.ok)
|
||
result.reason = 'blank or black canvas frame';
|
||
}
|
||
} catch (error) {
|
||
result.reason = error && error.message ? error.message : String(error);
|
||
}
|
||
samples.push(result);
|
||
frame++;
|
||
if (frame >= frames) {
|
||
const bad = samples.find(sample => !sample.ok);
|
||
resolve({ ok: !bad, bad, samples: samples.slice(0, 3).concat(samples.slice(-3)) });
|
||
} else {
|
||
requestAnimationFrame(sample);
|
||
}
|
||
}
|
||
requestAnimationFrame(sample);
|
||
});
|
||
return true;
|
||
})()`;
|
||
}
|
||
|
||
async function openHabitsOverview(client) {
|
||
const state = await pageJson(client, `(async () => JSON.stringify(await (async () => {
|
||
${wasmHookEvalHelper()}
|
||
if (typeof Module._app_web_test_save_onboarding_state === 'function') {
|
||
await callWasmHook('app_web_test_save_onboarding_state');
|
||
}
|
||
if (typeof Module._app_web_extension_open_habits !== 'function')
|
||
return { ok: false, reason: 'missing habits launch hook' };
|
||
await callWasmHook('app_web_extension_open_habits');
|
||
await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
|
||
return {
|
||
ok: typeof Module._app_web_test_habits_click_x === 'function' &&
|
||
typeof Module._app_web_test_habits_click_y === 'function',
|
||
reason: 'missing habits click hook'
|
||
};
|
||
})()))()`, true);
|
||
if (!state?.ok)
|
||
throw new Error(state?.reason || 'failed to open habits overview');
|
||
}
|
||
|
||
async function habitsClickTarget(client) {
|
||
const target = await pageJson(client, `(() => JSON.stringify((() => {
|
||
const canvas = Module.canvas || document.querySelector('canvas');
|
||
if (!canvas)
|
||
return { ok: false, reason: 'missing canvas' };
|
||
const rect = canvas.getBoundingClientRect();
|
||
const rawX = Module._app_web_test_habits_click_x();
|
||
const rawY = Module._app_web_test_habits_click_y();
|
||
const basisW = canvas.width || rect.width || 1;
|
||
const basisH = canvas.height || rect.height || 1;
|
||
const x = rect.left + rawX * rect.width / basisW;
|
||
const y = rect.top + rawY * rect.height / basisH;
|
||
return {
|
||
ok: rawX >= 0 && rawY >= 0 && x >= rect.left && y >= rect.top &&
|
||
x <= rect.right && y <= rect.bottom,
|
||
reason: 'invalid habits click target',
|
||
x,
|
||
y,
|
||
rawX,
|
||
rawY,
|
||
rect: { left: rect.left, top: rect.top, right: rect.right, bottom: rect.bottom, width: rect.width, height: rect.height },
|
||
canvas: { width: canvas.width, height: canvas.height }
|
||
};
|
||
})()))()`);
|
||
if (!target?.ok)
|
||
throw new Error(`${target?.reason || 'failed to compute habits click target'}; state=${JSON.stringify(target)}`);
|
||
return target;
|
||
}
|
||
|
||
async function openPracticeHome(client) {
|
||
const state = await pageJson(client, `(async () => JSON.stringify(await (async () => {
|
||
if (typeof Module._app_web_test_show_practice_home !== 'function')
|
||
return { ok: false, reason: 'missing practice home hook' };
|
||
if (typeof Module._app_web_test_screen !== 'function' ||
|
||
typeof Module._app_web_test_practice_start_click_x !== 'function' ||
|
||
typeof Module._app_web_test_practice_start_click_y !== 'function')
|
||
return { ok: false, reason: 'missing practice start hooks' };
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_show_practice_home');
|
||
// An idle app draws at 30 fps, so wait for the frame that lays out
|
||
// Start rather than a fixed number of browser frames.
|
||
const deadline = Date.now() + 3000;
|
||
do {
|
||
await new Promise(resolve => requestAnimationFrame(() => requestAnimationFrame(resolve)));
|
||
} while (Module._app_web_test_practice_start_click_x() < 0 && Date.now() < deadline);
|
||
return { ok: true, screen: Module._app_web_test_screen() };
|
||
})()))()`, true);
|
||
if (!state?.ok)
|
||
throw new Error(state?.reason || 'failed to open practice home');
|
||
}
|
||
|
||
async function practiceStartClickTarget(client) {
|
||
const target = await pageJson(client, `(() => JSON.stringify((() => {
|
||
const canvas = Module.canvas || document.querySelector('canvas');
|
||
if (!canvas)
|
||
return { ok: false, reason: 'missing canvas' };
|
||
const rect = canvas.getBoundingClientRect();
|
||
const rawX = Module._app_web_test_practice_start_click_x();
|
||
const rawY = Module._app_web_test_practice_start_click_y();
|
||
const basisW = canvas.width || rect.width || 1;
|
||
const basisH = canvas.height || rect.height || 1;
|
||
const x = rect.left + rawX * rect.width / basisW;
|
||
const y = rect.top + rawY * rect.height / basisH;
|
||
return {
|
||
ok: rawX >= 0 && rawY >= 0 && x >= rect.left && y >= rect.top &&
|
||
x <= rect.right && y <= rect.bottom,
|
||
reason: 'invalid practice start click target',
|
||
x,
|
||
y,
|
||
rawX,
|
||
rawY,
|
||
rect: { left: rect.left, top: rect.top, right: rect.right, bottom: rect.bottom, width: rect.width, height: rect.height },
|
||
canvas: { width: canvas.width, height: canvas.height }
|
||
};
|
||
})()))()`);
|
||
if (!target?.ok)
|
||
throw new Error(`${target?.reason || 'failed to compute practice start target'}; state=${JSON.stringify(target)}`);
|
||
return target;
|
||
}
|
||
|
||
async function verifyPracticeCarouselSwipe(client) {
|
||
await openPracticeHome(client);
|
||
const target = await practiceStartClickTarget(client);
|
||
const selected = () => pageJson(client, 'Module._app_web_test_practice_selected()');
|
||
const initial = await selected();
|
||
async function waitForSelectionChange(previous) {
|
||
const deadline = Date.now() + 500;
|
||
let current = await selected();
|
||
while (current === previous && Date.now() < deadline) {
|
||
await delay(50);
|
||
current = await selected();
|
||
}
|
||
return current;
|
||
}
|
||
const x = target.rect.left + target.rect.width / 2;
|
||
const y = target.rect.top + (target.y - target.rect.top) * 0.4;
|
||
const distance = target.rect.width * 0.4;
|
||
async function drag(dx, dy) {
|
||
const startX = x - dx / 2;
|
||
const startY = y - dy / 2;
|
||
await dispatchCanvasDrag(client, startX, startY, startX + dx, startY + dy);
|
||
}
|
||
async function swipeToNext(dx, previous, label) {
|
||
for (let attempt = 1; attempt <= 3; attempt++) {
|
||
await drag(dx, 0);
|
||
const current = await waitForSelectionChange(previous);
|
||
if (current !== previous) return current;
|
||
}
|
||
throw new Error(`${label} did not change practice after three gestures (selected=${previous})`);
|
||
}
|
||
const first = await swipeToNext(-distance, initial, 'left swipe');
|
||
if (await swipeToNext(distance, first, 'right swipe') !== initial)
|
||
throw new Error('right swipe did not return to practice');
|
||
await drag(0, distance / 2);
|
||
if (await selected() !== initial) throw new Error('vertical drag changed practice');
|
||
await dispatchCanvasClick(client, x, y);
|
||
await waitAnimationFrames(client, 3);
|
||
if (await selected() !== initial) throw new Error('artwork tap changed practice');
|
||
// Swipes go through every listed practice, across Practice's tabs, and
|
||
// wrap back to the first one; none comes twice before that.
|
||
const visited = new Set([initial]);
|
||
let previous = initial;
|
||
const maximumPractices = 12;
|
||
for (let i = 0; ; i++) {
|
||
if (i >= maximumPractices)
|
||
throw new Error(`carousel did not wrap after ${maximumPractices} swipes (selected=${previous}, initial=${initial})`);
|
||
const current = await swipeToNext(-distance, previous, `carousel swipe ${i + 1}`);
|
||
if (current === initial) {
|
||
if (visited.size < 2)
|
||
throw new Error(`carousel wrapped after one practice (selected=${current})`);
|
||
console.log(`web carousel: swipes cycled through ${visited.size} practices`);
|
||
break;
|
||
}
|
||
if (visited.has(current))
|
||
throw new Error(`carousel repeated practice early on swipe ${i + 1}: ${current}`);
|
||
visited.add(current);
|
||
previous = current;
|
||
}
|
||
}
|
||
|
||
async function verifyPracticeStartClick(client) {
|
||
await openPracticeHome(client);
|
||
const target = await practiceStartClickTarget(client);
|
||
await dispatchCanvasClick(client, target.x, target.y);
|
||
await waitAnimationFrames(client, 3);
|
||
const state = await pageJson(client, `(() => ({
|
||
screen: Module._app_web_test_screen && Module._app_web_test_screen(),
|
||
ready: !!Module.__inbeRuntimeReady,
|
||
loadingClass: document.querySelector('#loading-screen')?.className || ''
|
||
}))()`);
|
||
if (state.screen === 0 || state.screen === -1 || !state.ready)
|
||
throw new Error(`practice start click did not start a session: ${JSON.stringify(state)}`);
|
||
if (!/is-hidden/.test(state.loadingClass))
|
||
throw new Error(`practice start click showed loading overlay: ${JSON.stringify(state.loadingClass)}`);
|
||
}
|
||
|
||
async function verifyPracticeCompletionPersistence(client) {
|
||
await waitForStorageIdle(client);
|
||
const result = await pageJson(client, `(async () => {
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_complete_practice');
|
||
const persisted = !!Module._app_web_test_completed_practice_persisted();
|
||
const flushed = await Module.__inbeFlushStorageSync(true);
|
||
return { persisted, flushed, stage: Module._app_web_test_completion_stage(),
|
||
storageError: Module.__inbeStorageSyncLastError };
|
||
})()`, true);
|
||
if (!result.persisted || !result.flushed)
|
||
throw new Error('practice pause/resume/completion failed: ' + JSON.stringify(result));
|
||
await waitForStorageIdle(client);
|
||
await client.send('Page.reload', { ignoreCache: true });
|
||
await waitForHealthyPage(client);
|
||
const persisted = await pageJson(client,
|
||
'Module._app_web_test_completed_practice_persisted() === 1');
|
||
if (!persisted) throw new Error('completed practice mood did not survive reload');
|
||
}
|
||
|
||
function readPngBrightness(base64) {
|
||
const png = Buffer.from(base64, 'base64');
|
||
const signature = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
|
||
if (png.length < signature.length || !png.subarray(0, signature.length).equals(signature))
|
||
throw new Error('screenshot is not a PNG');
|
||
|
||
let offset = signature.length;
|
||
let width = 0;
|
||
let height = 0;
|
||
let colorType = -1;
|
||
const idat = [];
|
||
while (offset + 8 <= png.length) {
|
||
const length = png.readUInt32BE(offset);
|
||
const type = png.toString('ascii', offset + 4, offset + 8);
|
||
const dataStart = offset + 8;
|
||
const dataEnd = dataStart + length;
|
||
if (dataEnd + 4 > png.length)
|
||
throw new Error('truncated PNG chunk');
|
||
if (type === 'IHDR') {
|
||
width = png.readUInt32BE(dataStart);
|
||
height = png.readUInt32BE(dataStart + 4);
|
||
const bitDepth = png[dataStart + 8];
|
||
colorType = png[dataStart + 9];
|
||
if (bitDepth !== 8 || (colorType !== 2 && colorType !== 6))
|
||
throw new Error(`unsupported PNG format bitDepth=${bitDepth} colorType=${colorType}`);
|
||
} else if (type === 'IDAT') {
|
||
idat.push(png.subarray(dataStart, dataEnd));
|
||
} else if (type === 'IEND') {
|
||
break;
|
||
}
|
||
offset = dataEnd + 4;
|
||
}
|
||
if (width <= 0 || height <= 0 || !idat.length)
|
||
throw new Error('PNG is missing IHDR/IDAT data');
|
||
|
||
const bpp = colorType === 6 ? 4 : 3;
|
||
const stride = width * bpp;
|
||
const inflated = inflateSync(Buffer.concat(idat));
|
||
let input = 0;
|
||
let bright = 0;
|
||
const total = width * height;
|
||
let previous = Buffer.alloc(stride);
|
||
let current = Buffer.alloc(stride);
|
||
|
||
for (let y = 0; y < height; y++) {
|
||
const filter = inflated[input++];
|
||
for (let x = 0; x < stride; x++) {
|
||
const raw = inflated[input++];
|
||
const left = x >= bpp ? current[x - bpp] : 0;
|
||
const up = previous[x] || 0;
|
||
const upLeft = x >= bpp ? previous[x - bpp] : 0;
|
||
let value = raw;
|
||
if (filter === 1) {
|
||
value += left;
|
||
} else if (filter === 2) {
|
||
value += up;
|
||
} else if (filter === 3) {
|
||
value += Math.floor((left + up) / 2);
|
||
} else if (filter === 4) {
|
||
const p = left + up - upLeft;
|
||
const pa = Math.abs(p - left);
|
||
const pb = Math.abs(p - up);
|
||
const pc = Math.abs(p - upLeft);
|
||
value += pa <= pb && pa <= pc ? left : (pb <= pc ? up : upLeft);
|
||
} else if (filter !== 0) {
|
||
throw new Error(`unsupported PNG filter ${filter}`);
|
||
}
|
||
current[x] = value & 255;
|
||
}
|
||
for (let x = 0; x < width; x++) {
|
||
const pixel = x * bpp;
|
||
if (current[pixel] + current[pixel + 1] + current[pixel + 2] > 18)
|
||
bright++;
|
||
}
|
||
const swap = previous;
|
||
previous = current;
|
||
current = swap;
|
||
}
|
||
|
||
return { bright, total, width, height, ok: bright > total * 0.05 };
|
||
}
|
||
|
||
async function captureScreenshotProbe(client, samples) {
|
||
const frames = [];
|
||
for (let frame = 0; frame < samples; frame++) {
|
||
const screenshot = await client.send('Page.captureScreenshot', {
|
||
format: 'png',
|
||
fromSurface: true
|
||
});
|
||
const state = readPngBrightness(screenshot.data);
|
||
frames.push({ frame, ...state });
|
||
if (!state.ok)
|
||
return { ok: false, bad: frames[frames.length - 1], samples: frames.slice(0, 3).concat(frames.slice(-3)) };
|
||
await delay(25);
|
||
}
|
||
return { ok: true, samples: frames.slice(0, 3).concat(frames.slice(-3)) };
|
||
}
|
||
|
||
async function verifyHabitsClickDoesNotReload(client) {
|
||
await waitForStorageIdle(client);
|
||
await openHabitsOverview(client);
|
||
await verifyRenderingLive(client);
|
||
await client.send('Page.setLifecycleEventsEnabled', { enabled: true }).catch(() => {});
|
||
await pageJson(client, installHabitsLifecycleWatchExpression());
|
||
const target = await habitsClickTarget(client);
|
||
const marker = `habits-click-${Date.now()}`;
|
||
const before = await pageJson(client, `(() => {
|
||
window.__inbeSmokeModule = Module;
|
||
Module.__inbeSmokeMarker = ${JSON.stringify(marker)};
|
||
return {
|
||
href: location.href,
|
||
ready: !!Module.__inbeRuntimeReady,
|
||
loadingClass: document.querySelector('#loading-screen')?.className || '',
|
||
lifecycle: window.__inbeSmokeLifecycle
|
||
};
|
||
})()`);
|
||
const firstEvent = client.events.length;
|
||
if (renderer === 'canvas')
|
||
await pageJson(client, startHabitsFrameProbeExpression(30));
|
||
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mouseMoved',
|
||
x: target.x,
|
||
y: target.y
|
||
});
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mousePressed',
|
||
x: target.x,
|
||
y: target.y,
|
||
button: 'left',
|
||
clickCount: 1
|
||
});
|
||
await delay(50);
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mouseReleased',
|
||
x: target.x,
|
||
y: target.y,
|
||
button: 'left',
|
||
clickCount: 1
|
||
});
|
||
|
||
const probe = renderer === 'canvas'
|
||
? await pageJson(client, 'window.__inbeSmokeFrameProbe.then(value => JSON.stringify(value))', true)
|
||
: await captureScreenshotProbe(client, 12);
|
||
await delay(250);
|
||
const after = await pageJson(client, `(() => ({
|
||
href: location.href,
|
||
ready: !!Module.__inbeRuntimeReady,
|
||
sameModule: window.__inbeSmokeModule === Module,
|
||
sameMarker: Module.__inbeSmokeMarker === ${JSON.stringify(marker)},
|
||
loadingClass: document.querySelector('#loading-screen')?.className || '',
|
||
lifecycle: window.__inbeSmokeLifecycle
|
||
}))()`);
|
||
const events = client.events.slice(firstEvent);
|
||
const navigationEvents = events
|
||
.filter(event => event.method === 'Page.frameNavigated' ||
|
||
event.method === 'Page.frameStartedNavigating' ||
|
||
event.method === 'Page.domContentEventFired' ||
|
||
event.method === 'Page.loadEventFired' ||
|
||
(event.method === 'Page.lifecycleEvent' && event.params?.name === 'init'))
|
||
.map(event => event.method + (event.params?.name ? `:${event.params.name}` : ''));
|
||
|
||
if (navigationEvents.length)
|
||
throw new Error(`habits click triggered page navigation/reload events: ${navigationEvents.join(', ')}`);
|
||
if (before.href !== after.href)
|
||
throw new Error(`habits click changed location: before=${before.href} after=${after.href}`);
|
||
if (!after.ready || !after.sameModule || !after.sameMarker)
|
||
throw new Error(`habits click replaced or reset the app runtime: ${JSON.stringify(after)}`);
|
||
if ((after.lifecycle?.beforeunload || 0) > 0 || (after.lifecycle?.pagehide || 0) > 0)
|
||
throw new Error(`habits click fired unload lifecycle handlers: ${JSON.stringify(after.lifecycle)}`);
|
||
if (!/is-hidden/.test(after.loadingClass))
|
||
throw new Error(`habits click showed loading overlay: ${JSON.stringify(after.loadingClass)}`);
|
||
if (!probe?.ok)
|
||
throw new Error(`habits click produced a blank canvas frame: ${JSON.stringify(probe?.bad || probe)}`);
|
||
}
|
||
|
||
let chrome;
|
||
const browserStderr = [];
|
||
let client;
|
||
let failure;
|
||
|
||
/* Proves the page is actually rendering: a canvas with nonzero size, a live
|
||
* WebGL context, and a cycling requestAnimationFrame loop. Catches "boots to
|
||
* a black screen" that console-error checks cannot see. Runs in the page, so
|
||
* the same expression serves both the CDP and the Firefox BiDi paths. */
|
||
function renderLiveExpression(rendererKind) {
|
||
return `(async () => JSON.stringify(await (async () => {
|
||
const canvas = document.querySelector('canvas');
|
||
if (!canvas)
|
||
return { ok: false, reason: 'no canvas element' };
|
||
if (canvas.clientWidth === 0 || canvas.clientHeight === 0)
|
||
return { ok: false, reason: 'canvas has zero display size' };
|
||
const renderer = ${JSON.stringify(rendererKind)};
|
||
let ctx = null;
|
||
if (renderer === 'canvas') {
|
||
ctx = canvas.getContext('2d');
|
||
if (!ctx)
|
||
return { ok: false, reason: 'no Canvas2D context' };
|
||
} else {
|
||
const gl = canvas.getContext('webgl2') || canvas.getContext('webgl');
|
||
if (!gl)
|
||
return { ok: false, reason: 'no WebGL context' };
|
||
if (!gl.getParameter(gl.VERSION))
|
||
return { ok: false, reason: 'WebGL context unresponsive' };
|
||
}
|
||
let frames = 0;
|
||
await new Promise(resolve => {
|
||
const tick = () => {
|
||
frames++;
|
||
if (frames >= 3)
|
||
resolve();
|
||
else
|
||
requestAnimationFrame(tick);
|
||
};
|
||
requestAnimationFrame(tick);
|
||
setTimeout(resolve, 5000);
|
||
});
|
||
if (frames < 3)
|
||
return { ok: false, reason: 'render loop not cycling (rAF frames=' + frames + ')' };
|
||
if (renderer === 'canvas') {
|
||
const w = Math.max(1, Math.min(64, canvas.width || canvas.clientWidth || 1));
|
||
const h = Math.max(1, Math.min(64, canvas.height || canvas.clientHeight || 1));
|
||
const data = ctx.getImageData(0, 0, w, h).data;
|
||
let nonzero = 0;
|
||
for (let i = 0; i < data.length; i += 4) {
|
||
if (data[i] || data[i + 1] || data[i + 2] || data[i + 3]) nonzero++;
|
||
}
|
||
if (!nonzero)
|
||
return { ok: false, reason: 'Canvas2D pixels are blank' };
|
||
return { ok: true, renderer, frames, nonzero };
|
||
}
|
||
return { ok: true, renderer, frames };
|
||
})()))()`;
|
||
}
|
||
|
||
async function verifyRenderingLive(client) {
|
||
const result = await client.send('Runtime.evaluate', {
|
||
expression: renderLiveExpression(renderer),
|
||
awaitPromise: true,
|
||
returnByValue: true
|
||
});
|
||
const state = JSON.parse(result.result?.value || '{}');
|
||
if (!state.ok)
|
||
throw new Error(`page is not rendering: ${state.reason}`);
|
||
}
|
||
|
||
async function verifyRenderingLiveBidi(client, context) {
|
||
const result = await client.send('script.evaluate', {
|
||
target: { context },
|
||
awaitPromise: true,
|
||
resultOwnership: 'none',
|
||
expression: renderLiveExpression(renderer)
|
||
});
|
||
const state = JSON.parse(result.result?.value || '{}');
|
||
if (!state.ok)
|
||
throw new Error(`page is not rendering: ${state.reason}`);
|
||
}
|
||
|
||
async function installPracticeContentFixtures(client) {
|
||
await pageJson(client, `(async () => {
|
||
FS.mkdirTree('/home/inbe/packages');
|
||
// Sun Salutation's spoken cues are their own narration packs, like Tai Chi's;
|
||
// the Spanish run plays both voices without downloading them.
|
||
for (const name of ['whm', 'meditation', 'sunsalutation', 'sunsalutation.es', 'sunsalutation.es.male',
|
||
'patterns', 'taichi', 'taichi.en', 'taichi.es']) {
|
||
const response = await fetch('/__test_practice_content__/' + name + '.zx');
|
||
if (!response.ok) throw new Error('Missing practice fixture: ' + name);
|
||
FS.writeFile('/home/inbe/packages/practice-' + name + '.zx', new Uint8Array(await response.arrayBuffer()));
|
||
}
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_review_practice_cache');
|
||
})()`, true);
|
||
}
|
||
|
||
async function startCachedPractice(client, practice) {
|
||
// A reload since the fixtures went in starts the app with its own view of
|
||
// the cache and of what the account owns.
|
||
await pageJson(client, `(async () => {
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_test_review_practice_cache');
|
||
await callWasmHook('app_web_launch_practice', [${practice}]);
|
||
})()`, true);
|
||
await waitRouteTransition(client);
|
||
await waitAnimationFrames(client, 6);
|
||
// The first frame mounts the verified local content before Start opens it.
|
||
await pageJson(client, `(async () => {
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook('app_web_launch_practice', [${practice}]);
|
||
})()`, true);
|
||
await waitRouteTransition(client);
|
||
}
|
||
|
||
async function verifyTaiChiCourse(client) {
|
||
await startCachedPractice(client, 4);
|
||
const state = await pageJson(client, `(() => ({
|
||
screen: Module._app_web_test_screen(),
|
||
selected: Module._app_web_test_practice_selected(),
|
||
course: Module._app_web_test_tai_chi_course_open()
|
||
}))()`);
|
||
if (state.screen !== 0 || state.selected !== 4 || state.course !== 1)
|
||
throw new Error(`Tai Chi did not open its course chooser: ${JSON.stringify(state)}`);
|
||
await verifyRenderingLive(client);
|
||
const picture = await client.send('Page.captureScreenshot', { format: 'png', fromSurface: true });
|
||
mkdirSync('build/tai-chi-ui-test', { recursive: true });
|
||
writeFileSync('build/tai-chi-ui-test/web-course.png', Buffer.from(picture.data, 'base64'));
|
||
await dispatchCanvasClick(client, 1, 1);
|
||
console.log('web Tai Chi: course chooser opens and renders');
|
||
}
|
||
|
||
async function sunSalutationChecks(client, browser) {
|
||
await startCachedPractice(client, 2);
|
||
await waitAnimationFrames(client, 3);
|
||
await waitRouteTransition(client);
|
||
const launched = await pageJson(client, `(() => ({
|
||
screen: Module._app_web_test_screen(),
|
||
selected: Module._app_web_test_practice_selected()
|
||
}))()`);
|
||
if (launched.screen !== 3 || launched.selected !== 2) {
|
||
throw new Error(`web practice launch lost its route: ${JSON.stringify(launched)}`);
|
||
}
|
||
console.log(`web practice launch: session navigation preserved (${browser})`);
|
||
const driver = {
|
||
browser,
|
||
evaluate: (expression, awaitPromise = false) => pageJson(client, expression, awaitPromise),
|
||
callHook: (name, args = []) => pageJson(client, `(async () => {
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook(${JSON.stringify(name)}, ${JSON.stringify(args)});
|
||
})()`, true),
|
||
resize: (width, height, dpi = 1) => client.send('Emulation.setDeviceMetricsOverride', {
|
||
width, height, deviceScaleFactor: dpi, mobile: false
|
||
}),
|
||
capture: async () => {
|
||
const screenshot = await client.send('Page.captureScreenshot', { format: 'png', fromSurface: true });
|
||
return Buffer.from(screenshot.data, 'base64');
|
||
},
|
||
click: async (x, y, endX, endY) => {
|
||
if (endX === undefined) return dispatchCanvasClick(client, x, y);
|
||
await dispatchCanvasDrag(client, x, y, endX, endY);
|
||
},
|
||
scroll: async (x, y, deltaY) => {
|
||
await client.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
|
||
await waitAnimationFrames(client, 2);
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mouseWheel', x, y, deltaX: 0, deltaY
|
||
});
|
||
await waitAnimationFrames(client, 6);
|
||
}
|
||
};
|
||
await verifyAppearanceCanvas(driver);
|
||
await verifyCanvasTextResolution(driver);
|
||
await verifySunSalutationCanvas(driver);
|
||
}
|
||
|
||
async function musicChecks(client) {
|
||
try {
|
||
await verifyMusicAcrossTabs({
|
||
settle: () => waitRouteTransition(client),
|
||
evaluate: (expression, awaitPromise = false) => pageJson(client, expression, awaitPromise),
|
||
callHook: (name, args = []) => pageJson(client, `(async () => {
|
||
${wasmHookEvalHelper()}
|
||
await callWasmHook(${JSON.stringify(name)}, ${JSON.stringify(args)});
|
||
})()`, true),
|
||
resize: (width, height) => client.send('Emulation.setDeviceMetricsOverride', {
|
||
width, height, deviceScaleFactor: 1, mobile: false
|
||
}),
|
||
click: (x, y) => dispatchCanvasClick(client, x, y),
|
||
scroll: async (x, y, deltaY) => {
|
||
await client.send('Input.dispatchMouseEvent', { type: 'mouseMoved', x, y });
|
||
await waitAnimationFrames(client, 2);
|
||
await client.send('Input.dispatchMouseEvent', {
|
||
type: 'mouseWheel', x, y, deltaX: 0, deltaY
|
||
});
|
||
await waitAnimationFrames(client, 6);
|
||
}
|
||
});
|
||
} catch (error) {
|
||
const screenshot = await client.send('Page.captureScreenshot', { format: 'png', fromSurface: true });
|
||
writeFileSync('build/music-browser-failure.png', Buffer.from(screenshot.data, 'base64'));
|
||
const recent = client.events.map(eventText).filter(text => /AUDIO|music|decode/i.test(text)).slice(-8);
|
||
throw new Error(`${error.message}; audio logs: ${recent.join(' | ')}`);
|
||
}
|
||
}
|
||
|
||
// The same browser flows run through Firefox's WebDriver BiDi transport.
|
||
// This facade translates only the commands used by these tests.
|
||
function firefoxPageClient(bidi, context) {
|
||
return {
|
||
events: [],
|
||
async send(method, params = {}) {
|
||
if (method === 'Runtime.evaluate') {
|
||
const result = await bidi.send('script.evaluate', {
|
||
target: { context }, awaitPromise: true,
|
||
resultOwnership: 'none', expression: `(async () => JSON.stringify({ value: await (${params.expression}) }))()`
|
||
});
|
||
const value = bidiResultValue(result, 'browser test evaluation');
|
||
return { result: { value: JSON.parse(value).value } };
|
||
}
|
||
if (method === 'Page.reload') return bidi.send('browsingContext.reload', { context, wait: 'complete' });
|
||
if (method === 'Page.navigate') return bidi.send('browsingContext.navigate', { context, url: params.url, wait: 'complete' });
|
||
if (method === 'Page.captureScreenshot') return bidi.send('browsingContext.captureScreenshot', { context, origin: 'viewport' });
|
||
if (method === 'Page.setLifecycleEventsEnabled') return {};
|
||
if (method === 'Emulation.setDeviceMetricsOverride' || method === 'Emulation.clearDeviceMetricsOverride') {
|
||
return bidi.send('browsingContext.setViewport', {
|
||
context, viewport: method.endsWith('clearDeviceMetricsOverride') ? { width: 1280, height: 800 } :
|
||
{ width: params.width, height: params.height }, devicePixelRatio: params.deviceScaleFactor || 1
|
||
});
|
||
}
|
||
if (method === 'Input.dispatchMouseEvent') {
|
||
if (params.type === 'mouseWheel') {
|
||
return bidi.send('input.performActions', { context, actions: [{
|
||
type: 'wheel', id: 'inbe-test-wheel', actions: [{
|
||
type: 'scroll', x: Math.round(params.x), y: Math.round(params.y),
|
||
deltaX: Math.round(params.deltaX || 0), deltaY: Math.round(params.deltaY || 0),
|
||
origin: 'viewport', duration: 0
|
||
}]
|
||
}] });
|
||
}
|
||
const actions = [{ type: 'pointerMove', x: Math.round(params.x), y: Math.round(params.y), origin: 'viewport', duration: 0 }];
|
||
if (params.type === 'mousePressed') actions.push({ type: 'pointerDown', button: 0 });
|
||
if (params.type === 'mouseReleased') actions.push({ type: 'pointerUp', button: 0 });
|
||
return bidi.send('input.performActions', { context,
|
||
actions: [{ type: 'pointer', id: 'inbe-test-pointer', parameters: { pointerType: 'mouse' }, actions }] });
|
||
}
|
||
throw new Error(`unsupported Firefox test command: ${method}`);
|
||
}
|
||
};
|
||
}
|
||
|
||
try {
|
||
const totalTimeoutMs = Number(process.env.WEB_SMOKE_TOTAL_TIMEOUT_MS || 15 * 60 * 1000);
|
||
await withDeadline(async signal => {
|
||
smokeSignal = signal;
|
||
const port = await listen();
|
||
smokeSignal.throwIfAborted();
|
||
const browser = resolveBrowser();
|
||
if (process.platform === 'linux' && /(?:chromium(?:-browser)?|google-chrome|chrome)(?:-stable)?$/.test(browser))
|
||
validateChromiumSocketPath(profileRoot);
|
||
if (isFirefoxBrowser(browser)) {
|
||
writeFirefoxPrefs();
|
||
const args = [
|
||
'--headless',
|
||
'--new-instance',
|
||
'--profile',
|
||
userDataDir,
|
||
'--remote-debugging-port',
|
||
'0',
|
||
'--remote-allow-hosts',
|
||
'127.0.0.1',
|
||
'--remote-allow-origins',
|
||
'*',
|
||
...browserArgs,
|
||
'about:blank'
|
||
];
|
||
// Linux Firefox needs a display for WebGL, even in headless mode.
|
||
// Start our own server after scrubbing the owner's display variables.
|
||
const displayRunner = process.platform === 'linux' ? findOnPath('xvfb-run') : '';
|
||
if (process.platform === 'linux' && !displayRunner)
|
||
throw new Error('Firefox checks require xvfb-run for a private graphics display');
|
||
const command = displayRunner || browser;
|
||
const argumentsForBrowser = displayRunner ?
|
||
['-a', '-s', '-screen 0 1366x900x24', browser, ...args] : args;
|
||
chrome = spawn(command, argumentsForBrowser, { stdio: ['ignore', 'pipe', 'pipe'], detached: true, env: browserEnvironment });
|
||
chrome.once('error', error => {
|
||
if (!failure)
|
||
failure = error;
|
||
});
|
||
|
||
const bidiUrl = await waitForFirefoxBidi(chrome, timeoutMs);
|
||
client = await connectBidi(bidiUrl);
|
||
await client.send('session.new', { capabilities: {} });
|
||
await client.send('session.subscribe', { events: ['log.entryAdded'] });
|
||
const created = await client.send('browsingContext.create', { type: 'tab' });
|
||
const context = created.context;
|
||
await client.send('browsingContext.navigate', {
|
||
context,
|
||
url: `http://127.0.0.1:${port}/index.html`,
|
||
wait: 'complete'
|
||
});
|
||
await waitForHealthyBidiPage(client, context);
|
||
await verifyRenderingLiveBidi(client, context);
|
||
await verifyAppSettingsImmediateBidi(client, context);
|
||
await verifySyncKeyImportBidi(client, context);
|
||
const pageClient = firefoxPageClient(client, context);
|
||
await verifyReloadPersistence(pageClient);
|
||
await verifyAppSettingsReloadPersistence(pageClient);
|
||
await verifySetupRouteDoesNotOverrideSavedOnboarding(pageClient, port);
|
||
await verifyFirstRunGuideCanvasFlow(pageClient);
|
||
await verifyHabitsClickDoesNotReload(pageClient);
|
||
await installPracticeContentFixtures(pageClient);
|
||
await verifyPracticeCarouselSwipe(pageClient);
|
||
await verifyPracticeStartClick(pageClient);
|
||
await verifyPracticeCompletionPersistence(pageClient);
|
||
await sunSalutationChecks(pageClient, 'firefox');
|
||
} else {
|
||
const args = [
|
||
'--headless=new',
|
||
'--remote-debugging-port=0',
|
||
'--remote-debugging-address=127.0.0.1',
|
||
`--user-data-dir=${userDataDir}`,
|
||
'--no-first-run',
|
||
'--no-default-browser-check',
|
||
'--disable-background-networking',
|
||
'--disable-dev-shm-usage',
|
||
'--mute-audio',
|
||
'--enable-unsafe-swiftshader',
|
||
'--ignore-gpu-blocklist',
|
||
'--enable-webgl',
|
||
'--use-gl=angle',
|
||
// Emulate WebGL only; emulating 2D GPU composition as well makes
|
||
// canvas-to-canvas copies dominate animation on headless runners.
|
||
'--use-angle=swiftshader-webgl',
|
||
...browserArgs,
|
||
'about:blank'
|
||
];
|
||
if (useNoSandbox)
|
||
args.splice(1, 0, '--no-sandbox');
|
||
|
||
const chromeStderr = browserStderr;
|
||
chrome = spawn(browser, args, { stdio: ['ignore', 'ignore', 'pipe'], detached: true, env: browserEnvironment });
|
||
chrome.stderr.setEncoding('utf8');
|
||
chrome.stderr.on('data', chunk => {
|
||
chromeStderr.push(chunk);
|
||
while (chromeStderr.join('').length > 8000)
|
||
chromeStderr.shift();
|
||
});
|
||
chrome.once('error', error => {
|
||
if (!failure)
|
||
failure = error;
|
||
});
|
||
|
||
const devtoolsPort = await waitForDevtools(chrome, chromeStderr);
|
||
const devtools = `http://127.0.0.1:${devtoolsPort}`;
|
||
const url = `http://127.0.0.1:${port}/index.html`;
|
||
const browserTarget = await jsonRequest(`${devtools}/json/version`);
|
||
const browserClient = await connect(browserTarget.webSocketDebuggerUrl);
|
||
try {
|
||
// The saved zoom belongs to a disposable context with its own IndexedDB.
|
||
const { browserContextId } = await browserClient.send('Target.createBrowserContext', { disposeOnDetach: true });
|
||
const { targetId } = await browserClient.send('Target.createTarget', { url: 'about:blank', browserContextId });
|
||
const targets = await jsonRequest(`${devtools}/json/list`);
|
||
const target = targets.find(page => page.id === targetId);
|
||
if (!target?.webSocketDebuggerUrl) throw new Error('Chromium scale test could not attach to its page');
|
||
client = await connect(target.webSocketDebuggerUrl);
|
||
await client.send('Runtime.enable');
|
||
await client.send('Page.enable');
|
||
await verifyBrowserStartupScale(client, url);
|
||
} finally {
|
||
browserClient.close();
|
||
}
|
||
client.close();
|
||
|
||
const pages = await jsonRequest(`${devtools}/json/new?about:blank`, {
|
||
method: 'PUT'
|
||
});
|
||
client = await connect(pages.webSocketDebuggerUrl);
|
||
await client.send('Runtime.enable');
|
||
await client.send('Log.enable');
|
||
await client.send('Page.enable');
|
||
await client.send('Page.addScriptToEvaluateOnNewDocument', { source: musicAudioInstrumentation });
|
||
if (process.env.WEB_SMOKE_NO_WEBGL === '1') {
|
||
await client.send('Page.addScriptToEvaluateOnNewDocument', { source: `
|
||
for (const prototype of [HTMLCanvasElement.prototype, OffscreenCanvas.prototype]) {
|
||
const original = prototype.getContext;
|
||
prototype.getContext = function(kind, ...args) {
|
||
if (kind === 'webgl' || kind === 'webgl2' || kind === 'experimental-webgl') return null;
|
||
return original.call(this, kind, ...args);
|
||
};
|
||
}
|
||
` });
|
||
}
|
||
if (process.env.WEB_SMOKE_CPU_THROTTLE)
|
||
await client.send('Emulation.setCPUThrottlingRate', {
|
||
rate: Number(process.env.WEB_SMOKE_CPU_THROTTLE)
|
||
});
|
||
await client.send('Page.navigate', { url });
|
||
await waitForHealthyPage(client);
|
||
await musicChecks(client);
|
||
if (process.env.WEB_SMOKE_CPU_THROTTLE)
|
||
await client.send('Emulation.setCPUThrottlingRate', { rate: 1 });
|
||
await verifyRenderingLive(client);
|
||
await verifyReloadPersistence(client);
|
||
await verifyAppSettingsReloadPersistence(client);
|
||
await verifySetupRouteDoesNotOverrideSavedOnboarding(client, port);
|
||
await verifyFirstRunGuideCanvasFlow(client);
|
||
await verifySyncKeyImport(client);
|
||
// Check an empty habit day before completion links a session to it.
|
||
await verifyHabitsClickDoesNotReload(client);
|
||
await installPracticeContentFixtures(client);
|
||
await verifyPracticeCarouselSwipe(client);
|
||
await verifyPracticeStartClick(client);
|
||
await verifyPracticeCompletionPersistence(client);
|
||
await verifyTaiChiCourse(client);
|
||
if (process.env.WEB_SMOKE_CPU_PROFILE) {
|
||
await client.send('Profiler.enable');
|
||
await client.send('Profiler.start');
|
||
}
|
||
try {
|
||
await sunSalutationChecks(client, 'chromium');
|
||
} finally {
|
||
if (process.env.WEB_SMOKE_CPU_PROFILE) {
|
||
const { profile } = await client.send('Profiler.stop');
|
||
writeFileSync(process.env.WEB_SMOKE_CPU_PROFILE, JSON.stringify(profile));
|
||
}
|
||
}
|
||
}
|
||
const rejected = client.events.map(eventText).filter(text => text.includes('APP: frame rejected'));
|
||
if (rejected.length)
|
||
throw new Error(`Application rejected ${rejected.length} UI frames: ${rejected.join(' | ')}`);
|
||
console.log(`web smoke: PASS (${renderer})`);
|
||
}, totalTimeoutMs, `web smoke exceeded its ${totalTimeoutMs}ms fixture deadline`);
|
||
} catch (error) {
|
||
failure = error;
|
||
if (browserStderr.length)
|
||
console.error(`web smoke browser stderr (exit ${chrome?.exitCode}, signal ${chrome?.signalCode}):\n${browserStderr.join('').slice(-4000)}`);
|
||
const recent = (client?.events || []).map(eventText).filter(Boolean).slice(-30);
|
||
if (recent.length)
|
||
console.error(`web smoke browser logs:\n${recent.join('\n').slice(-12000)}`);
|
||
} finally {
|
||
if (client)
|
||
client.close();
|
||
if (chrome) {
|
||
const exited = new Promise(resolveExit => chrome.once('exit', resolveExit));
|
||
try {
|
||
process.kill(-chrome.pid, 'SIGTERM');
|
||
} catch {}
|
||
const stopped = await Promise.race([
|
||
exited.then(() => true),
|
||
new Promise(resolveDelay => setTimeout(() => resolveDelay(false), 2000))
|
||
]);
|
||
if (!stopped) {
|
||
try {
|
||
process.kill(-chrome.pid, 'SIGKILL');
|
||
} catch {}
|
||
await Promise.race([exited, new Promise(resolveDelay => setTimeout(resolveDelay, 1000))]);
|
||
}
|
||
}
|
||
server.close();
|
||
for (let attempt = 0; attempt < 10; attempt++) {
|
||
try {
|
||
rmSync(userDataDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
|
||
break;
|
||
} catch (error) {
|
||
if (attempt === 9 || !['ENOTEMPTY', 'EBUSY', 'EPERM'].includes(error.code))
|
||
throw error;
|
||
await delay(250);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (failure) {
|
||
console.error(`web smoke: FAIL: ${failure.message}`);
|
||
process.exit(1);
|
||
}
|