2076 lines
82 KiB
JavaScript
Executable File
2076 lines
82 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 { tmpdir } from 'node:os';
|
|
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 { musicAudioInstrumentation, verifyMusicAcrossTabs } from './web-music-test.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 userDataDir = mkdtempSync(join(tmpdir(), 'inbe-web-smoke-'));
|
|
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';
|
|
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.zib', 'meditation.zib', 'sunsalutation.zib', 'patterns.zib', 'taichi.zib', 'taichi.en.zib', 'taichi.es.zib'].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_cells__/lists.zib' ||
|
|
url.pathname === '/__test_cells__/practices.zib') {
|
|
const name = url.pathname.split('/').pop();
|
|
const fixture = new URL('../build/cells/' + name, import.meta.url);
|
|
if (!existsSync(fixture)) {
|
|
res.writeHead(404);
|
|
res.end('Build the cell 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) {
|
|
if (exited)
|
|
throw formatChromeLaunchError(stderrLines);
|
|
|
|
const port = readDevtoolsPort();
|
|
if (port > 0) {
|
|
try {
|
|
const response = await fetch(`http://127.0.0.1:${port}/json/version`);
|
|
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 = {}) {
|
|
const response = await fetch(url, options);
|
|
if (!response.ok)
|
|
throw new Error(`${options.method || 'GET'} ${url} failed: ${response.status}`);
|
|
return response.json();
|
|
}
|
|
|
|
function connect(wsUrl) {
|
|
return new Promise((resolveConnect, reject) => {
|
|
const ws = new WebSocket(wsUrl);
|
|
const pending = new Map();
|
|
const events = [];
|
|
let nextId = 1;
|
|
|
|
ws.addEventListener('open', () => {
|
|
resolveConnect({
|
|
events,
|
|
send(method, params = {}) {
|
|
const id = nextId++;
|
|
ws.send(JSON.stringify({ id, method, params }));
|
|
return new Promise((resolveSend, rejectSend) => {
|
|
pending.set(id, { resolve: resolveSend, reject: rejectSend, method });
|
|
});
|
|
},
|
|
close() {
|
|
ws.close();
|
|
}
|
|
});
|
|
});
|
|
ws.addEventListener('message', event => {
|
|
const message = JSON.parse(event.data);
|
|
if (message.id && pending.has(message.id)) {
|
|
const item = pending.get(message.id);
|
|
pending.delete(message.id);
|
|
if (message.error)
|
|
item.reject(new Error(`${item.method}: ${message.error.message}`));
|
|
else
|
|
item.resolve(message.result || {});
|
|
} else if (message.method) {
|
|
events.push(message);
|
|
}
|
|
});
|
|
ws.addEventListener('error', reject);
|
|
});
|
|
}
|
|
|
|
function connectBidi(wsUrl) {
|
|
return new Promise((resolveConnect, reject) => {
|
|
const ws = new WebSocket(wsUrl);
|
|
const pending = new Map();
|
|
const events = [];
|
|
let nextId = 1;
|
|
let closed = '';
|
|
|
|
ws.addEventListener('open', () => {
|
|
resolveConnect({
|
|
events,
|
|
send(method, params = {}) {
|
|
if (closed)
|
|
return Promise.reject(new Error(`${method}: ${closed}`));
|
|
const id = nextId++;
|
|
ws.send(JSON.stringify({ id, method, params }));
|
|
return new Promise((resolveSend, rejectSend) => {
|
|
pending.set(id, { resolve: resolveSend, reject: rejectSend, method });
|
|
});
|
|
},
|
|
close() {
|
|
ws.close();
|
|
}
|
|
});
|
|
});
|
|
ws.addEventListener('message', event => {
|
|
const message = JSON.parse(event.data);
|
|
if (message.id && pending.has(message.id)) {
|
|
const item = pending.get(message.id);
|
|
pending.delete(message.id);
|
|
if (message.error)
|
|
item.reject(new Error(`${item.method}: ${message.message || message.error || JSON.stringify(message)}`));
|
|
else
|
|
item.resolve(message.result || {});
|
|
} else if (message.method) {
|
|
events.push(message);
|
|
}
|
|
});
|
|
ws.addEventListener('error', event => reject(new Error(event.message || `WebSocket error for ${wsUrl}`)));
|
|
// A dropped connection fails waiting and later commands instead of
|
|
// leaving them unanswered.
|
|
ws.addEventListener('close', event => {
|
|
closed = `Firefox closed the BiDi connection (${event.code})`;
|
|
for (const item of pending.values())
|
|
item.reject(new Error(`${item.method}: ${closed}`));
|
|
pending.clear();
|
|
});
|
|
});
|
|
}
|
|
|
|
function eventText(event) {
|
|
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: 'raylib',
|
|
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)}`);
|
|
}
|
|
|
|
async function waitForFirefoxBidi(browser, stderrLines) {
|
|
const start = Date.now();
|
|
let exited = false;
|
|
const onExit = () => {
|
|
exited = true;
|
|
};
|
|
browser.once('exit', onExit);
|
|
|
|
try {
|
|
while (Date.now() - start < timeoutMs) {
|
|
if (exited) {
|
|
const stderr = stderrLines.join('').trim();
|
|
throw new Error(`Firefox exited before BiDi was ready${stderr ? `; firefox stderr: ${stderr.slice(-4000)}` : ''}`);
|
|
}
|
|
|
|
const stderr = stderrLines.join('');
|
|
const match = stderr.match(/WebDriver BiDi listening on (ws:\/\/[^\s]+)/);
|
|
if (match)
|
|
return match[1].replace(/\/?$/, '/session');
|
|
|
|
await delay(50);
|
|
}
|
|
} finally {
|
|
browser.off('exit', onExit);
|
|
}
|
|
|
|
const stderr = stderrLines.join('').trim();
|
|
throw new Error(`timed out waiting for Firefox BiDi${stderr ? `; firefox stderr: ${stderr.slice(-4000)}` : ''}`);
|
|
}
|
|
|
|
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);',
|
|
'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
|
|
}))()`,
|
|
returnByValue: true
|
|
});
|
|
lastState = result.result?.value;
|
|
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 verifyLanguageRouteDoesNotOverrideSavedOnboarding(client, port) {
|
|
await waitForStorageIdle(client);
|
|
await client.send('Page.navigate', { url: `http://127.0.0.1:${port}/index.html#/language` });
|
|
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 language route check; state=${JSON.stringify(value)}`);
|
|
if (value.hash === '#/language')
|
|
throw new Error('saved onboarding state was overridden by stale #/language 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 }; })()))()`
|
|
});
|
|
const 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 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) {
|
|
await waitRouteTransition(client);
|
|
const startX = x - dx / 2;
|
|
const startY = y - dy / 2;
|
|
await client.send('Input.dispatchMouseEvent', {
|
|
type: 'mousePressed', x: startX, y: startY, button: 'left', clickCount: 1
|
|
});
|
|
await waitAnimationFrames(client, 2);
|
|
for (let step = 1; step <= 6; step++) {
|
|
await client.send('Input.dispatchMouseEvent', {
|
|
type: 'mouseMoved', x: startX + dx * step / 6, y: startY + dy * step / 6,
|
|
button: 'left', buttons: 1
|
|
});
|
|
// The app samples idle input at 30 fps; one 60 Hz browser frame
|
|
// can otherwise skip a move entirely.
|
|
await waitAnimationFrames(client, 2);
|
|
}
|
|
await client.send('Input.dispatchMouseEvent', {
|
|
type: 'mouseReleased', x: startX + dx, y: startY + dy, button: 'left', clickCount: 1
|
|
});
|
|
await waitAnimationFrames(client, 3);
|
|
}
|
|
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;
|
|
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');
|
|
for (const name of ['whm', 'meditation', 'sunsalutation', 'patterns', 'taichi', 'taichi.en', 'taichi.es']) {
|
|
const response = await fetch('/__test_practice_content__/' + name + '.zib');
|
|
if (!response.ok) throw new Error('Missing practice fixture: ' + name);
|
|
FS.writeFile('/home/inbe/packages/practice-' + name + '.zib', 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 waitRouteTransition(client);
|
|
await client.send('Input.dispatchMouseEvent', { type: 'mousePressed', x, y, button: 'left', clickCount: 1 });
|
|
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 waitAnimationFrames(client, 1);
|
|
}
|
|
await client.send('Input.dispatchMouseEvent', {
|
|
type: 'mouseReleased', x: endX, y: endY, button: 'left', clickCount: 1
|
|
});
|
|
await waitAnimationFrames(client, 3);
|
|
}
|
|
};
|
|
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') {
|
|
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 port = await listen();
|
|
const browser = resolveBrowser();
|
|
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'
|
|
];
|
|
const firefoxStderr = [];
|
|
chrome = spawn(browser, args, { stdio: ['ignore', 'ignore', 'pipe'], detached: true, env: browserEnvironment });
|
|
chrome.stderr.setEncoding('utf8');
|
|
chrome.stderr.on('data', chunk => {
|
|
firefoxStderr.push(chunk);
|
|
while (firefoxStderr.join('').length > 8000)
|
|
firefoxStderr.shift();
|
|
});
|
|
chrome.once('error', error => {
|
|
if (!failure)
|
|
failure = error;
|
|
});
|
|
|
|
const bidiUrl = await waitForFirefoxBidi(chrome, firefoxStderr);
|
|
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 verifyLanguageRouteDoesNotOverrideSavedOnboarding(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',
|
|
'--use-angle=swiftshader',
|
|
...browserArgs,
|
|
'about:blank'
|
|
];
|
|
if (useNoSandbox)
|
|
args.splice(1, 0, '--no-sandbox');
|
|
|
|
const chromeStderr = [];
|
|
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 pages = await jsonRequest(`http://127.0.0.1:${devtoolsPort}/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_CPU_THROTTLE)
|
|
await client.send('Emulation.setCPUThrottlingRate', {
|
|
rate: Number(process.env.WEB_SMOKE_CPU_THROTTLE)
|
|
});
|
|
await client.send('Page.navigate', { url: `http://127.0.0.1:${port}/index.html` });
|
|
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 verifyLanguageRouteDoesNotOverrideSavedOnboarding(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);
|
|
await sunSalutationChecks(client, 'chromium');
|
|
}
|
|
console.log(`web smoke: PASS (${renderer})`);
|
|
} catch (error) {
|
|
failure = error;
|
|
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);
|
|
}
|