Files
vibemake/tests/resource-loading.test.js
T
Jerry 1c837766cd feat: integrate robot assembly and simulation with resilient loading
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.
2026-10-30 18:38:39 +08:00

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);
});