1c837766cd
Add backend-driven assembly and simulation experiences, MAKE branding, mobile rendering budgets and desktop-only CAD/PCB routes. Improve logo loading progress, document image recovery and URDF request handling; include dev packaging and regression coverage.
82 lines
3.5 KiB
JavaScript
82 lines
3.5 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { fetchResource, createLoadQueue } from '../js/resource-loading.js';
|
|
|
|
test('retries interrupted reads and 503 without changing a signed URL', async () => {
|
|
const urls = [], caches = [];
|
|
const url = 'https://assets.example/model.stl?signature=keep-exactly';
|
|
const value = await fetchResource(url, { type: 'text', retryDelay: 1, fetchImpl: async (actual, opts) => {
|
|
urls.push(actual); caches.push(opts.cache);
|
|
if (urls.length === 1) throw new TypeError('connection interrupted');
|
|
if (urls.length === 2) return new Response('unavailable', { status: 503 });
|
|
return new Response('solid');
|
|
} });
|
|
assert.equal(value, 'solid');
|
|
assert.deepEqual(urls, [url, url, url]);
|
|
assert.deepEqual(caches, ['default', 'reload', 'reload']);
|
|
});
|
|
|
|
test('missing and forbidden files fail without repeated requests', async () => {
|
|
for (const status of [403, 404]) {
|
|
let requests = 0;
|
|
await assert.rejects(fetchResource('/missing.stl', { fetchImpl: async () => { requests++; return new Response('', { status }); } }), { status });
|
|
assert.equal(requests, 1);
|
|
}
|
|
});
|
|
|
|
test('slow downloads remain alive while bytes keep arriving', async () => {
|
|
let timer;
|
|
const value = await fetchResource('/slow.stl', { type: 'text', idleTimeout: 80, retries: 0, fetchImpl: async () => new Response(new ReadableStream({
|
|
start(controller) {
|
|
let chunks = 0;
|
|
timer = setInterval(() => { controller.enqueue(new TextEncoder().encode('a')); if (++chunks === 8) { clearInterval(timer); controller.close(); } }, 20);
|
|
}, cancel() { clearInterval(timer); },
|
|
})) });
|
|
assert.equal(value, 'aaaaaaaa'); // 160 ms total > 80 ms silence timeout.
|
|
});
|
|
|
|
test('stalled transfers abort and retry within the bounded attempt count', async () => {
|
|
let attempts = 0;
|
|
await assert.rejects(fetchResource('/stalled.stl', { idleTimeout: 10, retryDelay: 1, retries: 1,
|
|
fetchImpl: async (_url, { signal }) => {
|
|
attempts++;
|
|
return new Response(new ReadableStream({ start(controller) {
|
|
signal.addEventListener('abort', () => controller.error(signal.reason), { once: true });
|
|
} }));
|
|
},
|
|
}), /长时间没有响应/);
|
|
assert.equal(attempts, 2);
|
|
});
|
|
|
|
test('user cancellation stops the active request without retrying', async () => {
|
|
const controller = new AbortController();
|
|
let attempts = 0;
|
|
const job = fetchResource('/cancelled.stl', { signal: controller.signal, fetchImpl: (_url, { signal }) => new Promise((_resolve, reject) => {
|
|
attempts++;
|
|
signal.addEventListener('abort', () => reject(signal.reason), { once: true });
|
|
}) });
|
|
controller.abort();
|
|
await assert.rejects(job, { name: 'AbortError' });
|
|
assert.equal(attempts, 1);
|
|
});
|
|
|
|
test('queue bounds concurrency, cancels waiting jobs and continues after failures', async () => {
|
|
const queue = createLoadQueue(2);
|
|
let active = 0, peak = 0;
|
|
const jobs = Array.from({ length: 12 }, (_, i) => queue(async () => {
|
|
active++; peak = Math.max(peak, active);
|
|
await new Promise((resolve) => setTimeout(resolve, 2)); active--;
|
|
if (i === 1) throw new Error('expected failure');
|
|
return i;
|
|
}));
|
|
const controller = new AbortController();
|
|
let started = false;
|
|
const cancelled = queue(() => { started = true; }, controller.signal);
|
|
controller.abort();
|
|
await assert.rejects(cancelled, { name: 'AbortError' });
|
|
const outcomes = await Promise.allSettled(jobs);
|
|
assert.equal(peak, 2);
|
|
assert.equal(started, false);
|
|
assert.equal(outcomes.filter((x) => x.status === 'fulfilled').length, 11);
|
|
});
|