123 lines
7.2 KiB
JavaScript
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, []);
|
|
});
|