Files
vibemake/tests/document-images.browser.mjs

123 lines
7.2 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 { chromium } from 'playwright';
const svg = '<svg xmlns="http://www.w3.org/2000/svg" width="240" height="80" viewBox="0 0 240 80" onload="window.svgExecuted=true"><script>window.svgExecuted=true</script><rect width="240" height="80" fill="#c8ff3e"/></svg>';
const png = Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aGasAAAAASUVORK5CYII=', 'base64');
const moduleSource = await readFile(new URL('../js/document-images.js', import.meta.url));
test('repository SVG images in rendered Markdown', async (t) => {
const requests = [], counts = new Map();
let missingAvailable = false;
const server = createServer((req, res) => {
const url = new URL(req.url, 'http://localhost');
requests.push(req.url);
if (url.pathname === '/document-images.js') {
res.writeHead(200, { 'Content-Type': 'text/javascript' }).end(moduleSource);
} else if (url.pathname === '/') {
res.writeHead(200, { 'Content-Type': 'text/html' }).end('<!doctype html><base href="/"><main id="root"></main>');
} else if (url.pathname === '/files') {
const path = url.searchParams.get('path'), count = (counts.get(path) || 0) + 1;
counts.set(path, count);
const headers = { 'Access-Control-Allow-Origin': '*', 'Content-Type': 'application/octet-stream', 'X-Content-Type-Options': 'nosniff', 'Content-Disposition': 'attachment; filename="diagram.svg"' };
if (path === 'missing.svg' && !missingAvailable) res.writeHead(404, headers).end();
else if (path === 'retry.svg' && count === 1) res.writeHead(503, headers).end();
else res.writeHead(200, headers).end(svg);
} else if (url.pathname === '/external.svg') {
// External image servers need not allow fetch CORS.
res.writeHead(200, { 'Content-Type': 'image/svg+xml' }).end(svg);
} else if (url.pathname === '/external.png') {
res.writeHead(200, { 'Content-Type': 'image/png' }).end(png);
} else res.writeHead(404).end();
});
await new Promise((resolve) => server.listen(0, '0.0.0.0', resolve));
const port = server.address().port, base = `http://127.0.0.1:${port}`, assets = `http://localhost:${port}`;
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 errors = [];
page.on('pageerror', (error) => errors.push(error.message));
const prepare = async (html, retryDelays = []) => {
await page.goto(base);
await page.evaluate(async ({ html, assets, retryDelays }) => {
const { prepareDocumentImages, hydrateDocumentImages } = await import('/document-images.js');
// Exercise loading immediately, independently of viewport scheduling.
delete window.IntersectionObserver;
const root = document.getElementById('root');
root.innerHTML = prepareDocumentImages(html, { filePath: 'docs/guide.md', rawUrl: (path) => `${assets}/files?${new URLSearchParams({ path, download: 'true' })}` });
window.cleanupImages = hydrateDocumentImages(root, { retryDelays });
}, { html, assets, retryDelays });
};
const loaded = (selector) => page.waitForFunction((selector) => {
const img = document.querySelector(selector);
return img?.complete && img.naturalWidth > 0 && !img.hidden;
}, selector);
await t.test('decodes octet-stream SVG, retains fragments, and keeps external images native', async () => {
const external = `${assets}/external.svg?signature=x%2Fy`;
await prepare(`<img id="svg" src="../assets/diagram.SVG#layer-1" data-document-src="untrusted"><img id="external" src="${external}" data-document-svg="true"><img id="png" src="${assets}/external.png?signature=a%2Fb">`);
await Promise.all(['#svg', '#external', '#png'].map(loaded));
const result = await page.evaluate(async () => {
const img = document.getElementById('svg'), blobUrl = img.src.split('#')[0];
const result = {
original: img.dataset.documentSrc, rendered: img.src,
type: (await fetch(blobUrl)).headers.get('content-type'),
width: img.naturalWidth, height: img.naturalHeight,
external: document.getElementById('external').src,
externalMarked: document.getElementById('external').dataset.documentSvg,
scriptExecuted: window.svgExecuted === true,
};
window.cleanupImages();
try { await fetch(blobUrl); result.revoked = false; } catch { result.revoked = true; }
return result;
});
assert.equal(result.original, `${assets}/files?path=assets%2Fdiagram.SVG&download=true#layer-1`);
assert.match(result.rendered, /^blob:.*#layer-1$/);
assert.equal(result.type, 'image/svg+xml');
assert.deepEqual([result.width, result.height], [240, 80]);
assert.equal(result.external, external);
assert.equal(result.externalMarked, undefined);
assert.equal(result.scriptExecuted, false);
assert.equal(result.revoked, true);
assert.ok(requests.includes('/external.svg?signature=x%2Fy'));
assert.ok(requests.includes('/external.png?signature=a%2Fb'));
assert.equal(counts.get('assets/diagram.SVG'), 1);
});
await t.test('retries transient SVG failures and allows a manual retry after failure', async () => {
await prepare('<img id="retry" src="/retry.svg">', [1]);
await loaded('#retry');
assert.equal(counts.get('retry.svg'), 2);
await prepare('<img id="missing" src="/missing.svg#view">');
await page.waitForFunction(() => document.querySelector('[role="status"]')?.textContent === '图片暂时未能加载');
assert.equal(counts.get('missing.svg'), 1);
assert.equal(await page.getByRole('link', { name: '查看原图' }).getAttribute('href'), `${assets}/files?path=missing.svg&download=true#view`);
missingAvailable = true;
await page.getByRole('button', { name: '重新加载图片' }).click();
await loaded('#missing');
assert.equal(counts.get('missing.svg'), 2);
assert.equal(await page.locator('.document-image-status').evaluate((el) => el.hidden), true);
});
await t.test('cleanup aborts SVG requests and ignores late responses', async () => {
await page.goto(base);
const result = await page.evaluate(async (svg) => {
const { prepareDocumentImages, hydrateDocumentImages } = await import('/document-images.js');
delete window.IntersectionObserver;
const root = document.getElementById('root');
root.innerHTML = prepareDocumentImages('<img src="pending.svg">', { rawUrl: (path) => `/files?path=${path}&download=true` });
let signal, resolveFetch;
window.fetch = (_url, options) => { signal = options.signal; return new Promise((resolve) => { resolveFetch = resolve; }); };
const cleanup = hydrateDocumentImages(root);
cleanup();
resolveFetch(new Response(svg));
await new Promise((resolve) => setTimeout(resolve, 0));
return { aborted: signal.aborted, src: root.querySelector('img').getAttribute('src') };
}, svg);
assert.deepEqual(result, { aborted: true, src: null });
});
assert.deepEqual(errors, []);
});