Files
vibemake/tests/cad/engine-updates.browser.mjs
T
2026-11-12 11:05:55 +08:00

268 lines
16 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import { createServer } from 'node:http';
import { readFile } from 'node:fs/promises';
import { createGzip, constants } from 'node:zlib';
import { chromium } from 'playwright';
import { cadWorker } from '../../scripts/cad-engine.mjs';
const root = new URL('../../', import.meta.url);
const html = `<!doctype html><button hidden>Refresh</button><script type="module">
import { loadEngine, prepareEngineRefresh } from '/js/cad/engine.js';
window.notices = 0;
window.manifestChecks = 0;
const nativeFetch = window.fetch;
window.fetch = async (...args) => {
const response = await nativeFetch(...args);
if (args[0] === '/cad/engine.json') {
const json = response.json.bind(response);
response.json = async () => { const value = await json(); window.manifestChecks++; return value; };
}
return response;
};
const button = document.querySelector('button');
addEventListener('vm:cad:update', () => { window.notices++; button.hidden = false; });
button.onclick = async () => {
button.disabled = true;
try { await prepareEngineRefresh(); location.reload(); }
catch { window.refreshFailed = true; button.disabled = false; }
};
await loadEngine(); window.engineReady = true;
</script>`;
// Exact lifecycle behaviour of packages shipped before explicit activation existed.
const legacyWorker = (manifest) => `
const FILES=new Set(${JSON.stringify(manifest.files.map((f) => f.path))});
const CACHE='vm.cad.static.${manifest.buildId}';
self.addEventListener('install',()=>{});
self.addEventListener('activate',()=>{});
self.addEventListener('fetch',event=>{const u=new URL(event.request.url);if(event.request.method!=='GET'||u.origin!==self.location.origin||u.search||!FILES.has(u.pathname))return;event.respondWith((async()=>{const cache=await caches.open(CACHE);const hit=await cache.match(event.request);if(hit)return hit;const response=await fetch(event.request);if(response.ok)await cache.put(event.request,response.clone());return response;})());});
`;
test('CAD loading measures decoded bytes, waits for readiness and detaches cancelled openings', async (t) => {
// A real, valid WASM with a custom section large enough to pause mid-download.
const leb = (number) => { const bytes = []; do { const byte = number & 127; number >>>= 7; bytes.push(byte | (number ? 128 : 0)); } while (number); return bytes; };
const padding = 256 * 1024;
const wasm = Buffer.concat([Buffer.from([0, 97, 115, 109, 1, 0, 0, 0, 0, ...leb(padding), 0]), Buffer.alloc(padding - 1)]);
const split = Math.floor(wasm.length / 2);
const module = `export default async function({module_or_path}) {
window.receivedResponse = module_or_path instanceof Response;
await WebAssembly.instantiateStreaming(module_or_path);
window.vibemakeCad = { ready: async () => {
if (window.failFont) throw Object.assign(new Error('Font unavailable'), {code:'FONT_UNAVAILABLE'});
await new Promise(resolve => { window.releaseReady = resolve; });
return {};
}};
}`;
const prefix = '/cad/_assets/progress-v1/';
const manifest = { bridgeVersion: 1, buildId: 'progress-v1', js: prefix + 'engine.js', wasm: prefix + 'engine.wasm', chineseFont: prefix + 'font.otf',
files: [{ path: prefix + 'engine.js', size: Buffer.byteLength(module) }, { path: prefix + 'engine.wasm', size: wasm.length }] };
let releaseDownload, paused = true, failDownload = false, wasmRequests = 0;
const html = `<!doctype html><script type="module">
import {loadEngine} from '/js/cad/engine.js';
window.beginLoad = () => {
window.controller = new AbortController(); window.samples = []; window.engineReady = false; window.engineError = null;
loadEngine({signal:controller.signal,onProgress:p=>samples.push(p)}).then(()=>{window.engineReady=true},error=>{window.engineError=typeof error.code==='string'?error.code:error.name});
};
window.harnessReady = true;
</script>`;
const server = createServer(async (req, res) => {
const path = new URL(req.url, 'http://localhost').pathname;
res.setHeader('Cache-Control', 'no-store');
if (path === '/') res.writeHead(200, { 'Content-Type': 'text/html' }).end(html);
else if (path === '/cad/engine.json') res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify(manifest));
else if (path === manifest.js) res.writeHead(200, { 'Content-Type': 'text/javascript' }).end(module);
else if (path === manifest.wasm) {
wasmRequests++;
if (failDownload) { res.writeHead(503).end(); return; }
res.writeHead(200, { 'Content-Type': 'application/wasm', 'Content-Encoding': 'gzip' });
const gzip = createGzip(); gzip.pipe(res);
if (paused) { gzip.write(wasm.subarray(0, split)); gzip.flush(constants.Z_SYNC_FLUSH); releaseDownload = () => gzip.end(wasm.subarray(split)); }
else gzip.end(wasm);
} else if (path.startsWith('/js/')) {
try { res.writeHead(200, { 'Content-Type': 'text/javascript' }).end(await readFile(new URL(path.slice(1), root))); }
catch { res.writeHead(404).end(); }
} else res.writeHead(404).end();
});
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
const browser = await chromium.launch({ headless: true });
t.after(async () => { await browser.close(); server.closeAllConnections(); await new Promise((resolve) => server.close(resolve)); });
const page = await browser.newPage();
const openHarness = async () => { await page.goto(`http://127.0.0.1:${server.address().port}/`); await page.waitForFunction(() => window.harnessReady); };
await openHarness();
await page.evaluate(() => beginLoad());
const partial = Buffer.byteLength(module) + split, total = Buffer.byteLength(module) + wasm.length;
await page.waitForFunction((bytes) => samples.at(-1)?.loaded === bytes, partial);
assert.equal(await page.evaluate(() => samples.at(-1).total), total);
assert.equal(await page.evaluate(() => window.receivedResponse), true);
await page.clock.install(); await page.clock.fastForward(12000);
assert.equal(await page.evaluate(() => samples.at(-1).loaded), partial, 'elapsed time must not advance progress');
await page.clock.resume();
await page.evaluate(() => controller.abort());
await page.waitForFunction(() => engineError === 'AbortError');
const cancelledSamples = await page.evaluate(() => samples.length);
releaseDownload();
await page.waitForFunction(() => !!window.releaseReady);
assert.equal(await page.evaluate(() => samples.length), cancelledSamples, 'cancelled progress observers must be detached');
await page.evaluate(() => beginLoad());
assert.deepEqual(await page.evaluate(() => samples.at(-1)), { phase: 'initialize', loaded: total, total });
assert.equal(await page.evaluate(() => engineReady), false, 'download completion must still wait for fonts and the bridge');
await page.evaluate(() => releaseReady());
await page.waitForFunction(() => engineReady);
assert.equal(wasmRequests, 1, 'retrying an opening must share its engine download');
assert.equal(await page.evaluate(() => samples.at(-1).phase), 'ready');
// An HTTP failure is retryable and never reports successful initialization.
await page.clock.resume();
failDownload = true; paused = false;
await openHarness(); await page.evaluate(() => beginLoad());
await page.waitForFunction(() => engineError === 'ENGINE_MISSING');
assert.equal(await page.evaluate(() => samples.some((p) => p.phase === 'ready')), false);
failDownload = false;
await page.evaluate(() => { window.failFont = true; beginLoad(); });
await page.waitForFunction(() => engineError === 'FONT_UNAVAILABLE');
const requestsBeforeFontRetry = wasmRequests;
await page.evaluate(() => { window.failFont = false; window.releaseReady = null; beginLoad(); });
await page.waitForFunction(() => !!window.releaseReady);
await page.evaluate(() => releaseReady());
await page.waitForFunction(() => engineReady);
assert.equal(wasmRequests, requestsBeforeFontRetry, 'font retries must reuse initialized WASM');
});
test('CAD engine updates complete without clearing browser data', async (t) => {
let buildId = 'v1', legacy = false, workerUnavailable = false;
const manifest = () => ({
bridgeVersion: 1, buildId,
js: `/cad/_assets/${buildId}/engine.js`, wasm: `/cad/_assets/${buildId}/engine.wasm`, chineseFont: `/cad/_assets/${buildId}/font.otf`,
files: ['engine.js', 'engine.wasm', 'font.otf'].map((name) => ({ path: `/cad/_assets/${buildId}/${name}` })),
});
const server = createServer(async (req, res) => {
const path = new URL(req.url, 'http://localhost').pathname;
res.setHeader('Cache-Control', 'no-store');
if (path === '/cad/editor/') res.writeHead(200, { 'Content-Type': 'text/html' }).end(html);
else if (path === '/cad/seed/') res.writeHead(200, { 'Content-Type': 'text/html' }).end('<!doctype html><title>Previous editor</title>');
else if (path === '/cad/worker.js') res.writeHead(workerUnavailable ? 503 : 200, { 'Content-Type': 'text/javascript' }).end(await readFile(new URL('cad/worker.js', root)));
else if (path === '/cad/engine.json') res.writeHead(200, { 'Content-Type': 'application/json' }).end(JSON.stringify(manifest()));
else if (path === '/cad/sw.js') res.writeHead(workerUnavailable ? 503 : 200, { 'Content-Type': 'text/javascript' }).end(legacy ? legacyWorker(manifest()) : cadWorker(manifest()));
else if (path === '/other/sw.js') res.writeHead(200, { 'Content-Type': 'text/javascript' }).end("self.addEventListener('install',()=>{});");
else if (/^\/cad\/_assets\/[^/]+\/engine.js$/.test(path)) {
const version = path.split('/')[3];
res.writeHead(200, { 'Content-Type': 'text/javascript' }).end(`export default async function() { window.engineBuild=${JSON.stringify(version)}; window.vibemakeCad={ready:async()=>({})}; }`);
} else if (path.startsWith('/cad/_assets/')) res.writeHead(200).end('asset');
else if (path.startsWith('/js/')) {
try { res.writeHead(200, { 'Content-Type': 'text/javascript' }).end(await readFile(new URL(path.slice(1), root))); }
catch { res.writeHead(404).end(); }
} else res.writeHead(404).end();
});
await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
const base = `http://127.0.0.1:${server.address().port}`;
const browser = await chromium.launch({ headless: true });
t.after(async () => { await browser.close(); server.closeAllConnections(); await new Promise((resolve) => server.close(resolve)); });
const loaded = (page, expected) => page.waitForFunction((version) => window.engineReady && window.engineBuild === version, expected);
const open = async (context) => {
const page = await context.newPage();
await page.goto(`${base}/cad/editor/`);
await loaded(page, buildId);
await page.evaluate(() => navigator.serviceWorker.ready);
await page.reload();
await loaded(page, buildId);
await page.waitForFunction(() => !!navigator.serviceWorker.controller);
return page;
};
const publish = async (page) => {
await page.evaluate(async () => { await (await navigator.serviceWorker.getRegistration('/cad/')).update(); });
await page.waitForFunction(async () => !!(await navigator.serviceWorker.getRegistration('/cad/')).waiting);
};
const preserveData = async (page) => page.evaluate(async () => {
localStorage.setItem('vm.auth', 'preserved-login');
const { DraftStore } = await import('/js/cad/drafts.js');
const store = new DraftStore();
await store.put('owner', 'project', 'session', 'draft', { snapshotId: 'keep-draft', bytes: new Uint8Array([1, 2, 3]) });
await (await caches.open('unrelated-cache')).put('/keep', new Response('keep'));
await navigator.serviceWorker.register('/other/sw.js', { scope: '/other/' });
});
const assertData = async (page) => {
const data = await page.evaluate(async () => {
const { DraftStore } = await import('/js/cad/drafts.js');
const drafts = await new DraftStore().list('owner', 'project', 'draft');
return { auth: localStorage.getItem('vm.auth'), draft: [...drafts[0].bytes], cache: await (await caches.match('/keep')).text(), otherWorker: !!await navigator.serviceWorker.getRegistration('/other/') };
});
assert.deepEqual(data, { auth: 'preserved-login', draft: [1, 2, 3], cache: 'keep', otherWorker: true });
};
await t.test('activates the new worker before refresh and leaves other editor tabs intact', async () => {
buildId = 'v1'; legacy = false;
const context = await browser.newContext();
try {
const first = await open(context), second = await open(context);
await second.evaluate(() => { window.unsavedDesign = 'keep editing'; });
await preserveData(first);
buildId = 'v2';
await publish(first);
await first.waitForFunction(() => window.notices === 1);
assert.equal(await first.evaluate(() => window.engineBuild), 'v1');
await first.getByRole('button', { name: 'Refresh' }).click();
await loaded(first, 'v2');
assert.equal(await first.evaluate(() => window.notices), 0);
assert.equal(await first.evaluate(async () => !!(await navigator.serviceWorker.getRegistration('/cad/')).waiting), false);
assert.deepEqual(await second.evaluate(() => ({ build: window.engineBuild, design: window.unsavedDesign })), { build: 'v1', design: 'keep editing' });
await assertData(first);
await first.reload(); await loaded(first, 'v2');
assert.equal(await first.evaluate(() => window.notices), 0);
} finally { await context.close(); }
});
await t.test('recovers from a legacy waiting worker without clearing auth, drafts or other scopes', async () => {
buildId = 'legacy-v1'; legacy = true;
const context = await browser.newContext();
try {
const previous = await context.newPage();
await previous.goto(`${base}/cad/seed/`);
await previous.evaluate(async () => {
await navigator.serviceWorker.register('/cad/sw.js', { scope: '/cad/', updateViaCache: 'none' });
await navigator.serviceWorker.ready;
});
const page = await open(context), other = await open(context);
await preserveData(page);
buildId = 'legacy-v2'; await publish(page);
await page.waitForFunction(() => window.notices === 1);
await page.getByRole('button', { name: 'Refresh' }).click();
await loaded(page, 'legacy-v2');
await page.evaluate(() => navigator.serviceWorker.ready);
assert.equal(await page.evaluate(() => window.notices), 0);
assert.equal(await page.evaluate(async () => !!(await navigator.serviceWorker.getRegistration('/cad/')).waiting), false);
assert.equal(await other.evaluate(() => window.engineBuild), 'legacy-v1');
await assertData(page);
} finally { await context.close(); }
});
await t.test('a fresh engine does not show an update merely because a cache worker is waiting', async () => {
buildId = 'same-v1'; legacy = true;
const context = await browser.newContext();
try {
const page = await open(context), other = await open(context);
buildId = 'same-v2'; await publish(page);
await page.reload(); await loaded(page, 'same-v2');
await page.waitForFunction(() => window.manifestChecks === 2);
assert.equal(await page.evaluate(() => window.notices), 0);
assert.equal(await page.evaluate(async () => !!(await navigator.serviceWorker.getRegistration('/cad/')).waiting), true);
assert.equal(await other.evaluate(() => window.engineBuild), 'same-v1');
} finally { await context.close(); }
});
await t.test('failed worker checks keep the editor open for retry', async () => {
buildId = 'offline-v1'; legacy = false;
const context = await browser.newContext();
try {
const page = await open(context);
buildId = 'offline-v2'; await publish(page);
await page.waitForFunction(() => window.notices === 1);
workerUnavailable = true;
await page.getByRole('button', { name: 'Refresh' }).click();
await page.waitForFunction(() => window.refreshFailed);
assert.equal(await page.evaluate(() => window.engineBuild), 'offline-v1');
assert.equal(await page.getByRole('button', { name: 'Refresh' }).isEnabled(), true);
} finally { workerUnavailable = false; await context.close(); }
});
});