Persist staged image uploads alongside document operations
This commit is contained in:
@@ -0,0 +1,50 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createFoundryAssets, createFoundryTransport } from '../../src/lib/canvas-service/index.ts';
|
||||
const id = n => `10000000-0000-4000-8000-${String(n).padStart(12, '0')}`;
|
||||
async function fixture() {
|
||||
const blob = new Blob(['immutable image'], { type: 'image/png' });
|
||||
const digest = [...new Uint8Array(await crypto.subtle.digest('SHA-256', await blob.arrayBuffer()))].map(value => value.toString(16).padStart(2, '0')).join('');
|
||||
const resource = { id: id(1), operationId: id(2), name: 'picture.png', byteLength: blob.size, mimeType: blob.type, digest };
|
||||
const request = { kind: 'asset.upload', protocolVersion: 2, id: id(3), operationIds: [resource.operationId], canvasIds: [], expectedVersions: {}, phase: 'frozen', outcome: 'unresolved', generation: 1, attempt: 0,
|
||||
body: JSON.stringify({ protocol_version: 2, request_id: id(3), resource_id: resource.id, operation_id: resource.operationId, name: resource.name, mime_type: resource.mimeType, byte_length: resource.byteLength, sha256: resource.digest }) };
|
||||
const calls = [], receipt = { protocol_version: 2, request_id: request.id, status: 'applied', asset: { id: resource.id, bytes: resource.byteLength, mime_type: 'image/png', width: 2, height: 1, url: `https://api.foundry.entroia.com/projects/endoleap/workspaces/${id(4)}/assets/${resource.id}` } };
|
||||
let response = { status: 201, body: receipt };
|
||||
const assets = createFoundryAssets({ workspaceId: id(4), transport: async input => { calls.push(input); return response; } });
|
||||
return { blob, resource, request, calls, receipt, assets, respond: next => { response = next; } };
|
||||
}
|
||||
|
||||
test('asset adapter preserves byte identity and headers and validates the scoped applied receipt', async () => {
|
||||
const f = await fixture(), result = await f.assets.upload(f.request, f.blob, new AbortController().signal);
|
||||
assert.equal(result.outcome, 'applied'); assert.equal(f.calls[0].requestId, f.request.id); assert.equal(f.calls[0].resourceId, f.resource.id);
|
||||
assert.equal(f.calls[0].body.get('image').name, f.resource.name); assert.equal(await f.calls[0].body.get('image').text(), await f.blob.text());
|
||||
assert.equal(f.assets.accept(f.request, result, f.resource).id, f.resource.id);
|
||||
for (const patch of [{ id: id(99) }, { bytes: 100 }, { url: 'https://other.example/image' }, { width: 0 }, { width: 1000000, height: 1000000 }]) {
|
||||
const altered = { ...result, canonical: { ...f.receipt, asset: { ...f.receipt.asset, ...patch } } };
|
||||
assert.throws(() => f.assets.accept(f.request, altered, f.resource), /asset_receipt_mismatch/);
|
||||
}
|
||||
const changed = await f.assets.upload(f.request, new Blob(['different']), new AbortController().signal);
|
||||
assert.equal(changed.outcome, 'unresolved'); assert.equal(changed.blocked, true); assert.equal(f.calls.length, 1);
|
||||
});
|
||||
|
||||
test('missing and rejected upload receipts never become proof of zero writes', async () => {
|
||||
const f = await fixture(), signal = new AbortController().signal;
|
||||
f.respond({ status: 404, body: { protocol_version: 2, request_id: f.request.id, status: 'unknown' } });
|
||||
const unknown = await f.assets.query(f.request, signal);
|
||||
assert.equal(unknown.outcome, 'unresolved'); assert.equal(unknown.blocked, undefined);
|
||||
assert.ok(f.calls[0].path.endsWith(`/assets/operations/${f.request.id}`));
|
||||
f.respond({ status: 403, body: { error: 'forbidden' } });
|
||||
assert.equal((await f.assets.query(f.request, signal)).blocked, true);
|
||||
f.respond({ status: 201, body: { ...f.receipt, request_id: id(99) } });
|
||||
assert.equal((await f.assets.upload(f.request, f.blob, signal)).outcome, 'unresolved');
|
||||
});
|
||||
|
||||
test('multipart browser transport leaves the boundary to fetch and binds the expected account', async () => {
|
||||
let captured;
|
||||
const transport = createFoundryTransport({ accountId: id(5), isCurrentIdentity: () => true, fetch: async (url, init) => { captured = { url, init }; return Response.json({ status: 'applied' }); } });
|
||||
const body = new FormData(); body.append('image', new Blob(['image']), 'a.png');
|
||||
await transport({ method: 'POST', path: 'workspaces/example/assets', body, requestId: id(3), resourceId: id(1) });
|
||||
const headers = new Headers(captured.init.headers);
|
||||
assert.equal(headers.has('content-type'), false); assert.equal(headers.get('X-Expected-Account'), id(5));
|
||||
assert.equal(headers.get('X-Resource-Id'), id(1)); assert.equal(headers.get('Idempotency-Key'), id(3)); assert.equal(captured.init.body, body);
|
||||
});
|
||||
@@ -1,8 +1,54 @@
|
||||
import { createBrowserStorage } from '../../src/lib/canvas-runtime/storage.ts';
|
||||
import { openProjectEngine } from '../../src/lib/canvas-runtime/engine.ts';
|
||||
import { createDocument, createRegistry, builtinComponents, applyChanges } from '../../src/lib/canvas-core/index.ts';
|
||||
import { createFoundryAssets } from '../../src/lib/canvas-service/assets.ts';
|
||||
import { createFoundryPersistence } from '../../src/lib/canvas-service/foundry.ts';
|
||||
|
||||
async function resourceRecoveryCase(name, assert) {
|
||||
const scope = { accountId: crypto.randomUUID(), workspaceId: crypto.randomUUID(), projectId: crypto.randomUUID() };
|
||||
const registry = createRegistry(builtinComponents()), document = createDocument(scope.projectId, [{ id: scope.projectId, parent: null }], []);
|
||||
const storage = createBrowserStorage({ name: `${name}-resources` }), receipts = new Map(), uploads = [], queries = [], writes = [];
|
||||
const assets = createFoundryAssets({ workspaceId: scope.workspaceId, transport: async input => {
|
||||
if (input.method === 'POST') {
|
||||
uploads.push(input); const file = input.body.get('image');
|
||||
assert(await file.text() === 'durable-image-bytes', 'upload reconstructed different file bytes');
|
||||
receipts.set(input.requestId, { protocol_version: 2, request_id: input.requestId, status: 'applied', asset: { id: input.resourceId, bytes: file.size, mime_type: 'image/png', width: 2, height: 1, url: assets.sourceURL(input.resourceId) } });
|
||||
return { status: 502, body: { error: 'lost_upload_ack' } };
|
||||
}
|
||||
queries.push(input); return { status: 200, body: receipts.get(input.path.split('/').at(-1)) };
|
||||
} });
|
||||
let server = document;
|
||||
const persistence = {
|
||||
compile: (intent, id, snapshot) => ({ payload: { intent, id }, canvasIds: intent.canvasIds, expectedVersions: { [scope.projectId]: snapshot.runtime.versions.get(scope.projectId) } }),
|
||||
async submit(request) { writes.push(request); server = applyChanges(server, JSON.parse(request.body).intent.changes); return { outcome: 'applied' }; },
|
||||
async query() { return { outcome: 'unresolved' }; },
|
||||
canonical: () => ({ document: server, versions: new Map([[scope.projectId, writes.length + 1]]) }),
|
||||
};
|
||||
const options = { scope, registry, document, versions: new Map([[scope.projectId, 1]]), storage, persistence, assets };
|
||||
let engine, resource;
|
||||
try {
|
||||
engine = await openProjectEngine(options);
|
||||
const result = engine.stageFiles([{ name: 'picture.png', bytes: new Blob(['durable-image-bytes'], { type: 'image/png' }) }], ([ref], tx) => {
|
||||
resource = ref;
|
||||
tx.dispatch({ type: 'element.create', element: { id: 'picture', incarnation: 1, componentId: 'image', dataVersion: 1, structure: 'node', ownerCanvasId: scope.projectId, data: { title: 'Picture', text: '', src: ref.src, assetId: ref.id }, geometry: { x: 10, y: 20, width: 100, height: 80, rotation: 0 } } });
|
||||
});
|
||||
assert(result.status === 'applied' && engine.getSnapshot().document.elements.has('picture'), 'pending image was hidden until prepare/upload');
|
||||
const handle = await engine.displayResource(resource.id); assert(handle.url.startsWith('blob:'), 'pending image did not expose a local preview'); handle.release();
|
||||
await engine.settle(); assert(uploads.length === 1 && writes.length === 0, 'document was sent before its resource was confirmed');
|
||||
await engine.close();
|
||||
const leader = await storage.claim(scope), image = await storage.recover(leader);
|
||||
assert(await (await storage.readFile(leader, resource.id)).text() === 'durable-image-bytes', 'file bytes did not survive actual IndexedDB recovery');
|
||||
assert(image.payload.runtime.resources[0][1].id === resource.id && image.payload.document.elements[0].data.assetId === resource.id, 'resource metadata and element belong to different durable cuts');
|
||||
await leader.release();
|
||||
engine = await openProjectEngine({ ...options, clock: { now: () => Date.now() + 100000, setTimer: (fn, ms) => setTimeout(fn, ms), clearTimer: id => clearTimeout(id) } });
|
||||
await new Promise(resolve => setTimeout(resolve, 10)); await engine.settle();
|
||||
assert(uploads.length === 1 && queries.length === 1 && writes.length === 1, 'reopen uploaded again or lost the pending element operation');
|
||||
assert(queries[0].path.endsWith(uploads[0].requestId), 'recovery queried a replacement request identity');
|
||||
assert(engine.getSnapshot().runtime.resources.get(resource.id).stored.id === resource.id, 'confirmed asset changed resource identity');
|
||||
assert(engine.getSnapshot().history.undo.length === 1 && engine.getSnapshot().document.elements.size === 1, 'resource ACK recreated the node/history');
|
||||
} finally { await engine?.close(); storage.close(); indexedDB.deleteDatabase(`${name}-resources`); }
|
||||
}
|
||||
|
||||
async function protocolRecoveryCase(name,assert){
|
||||
const root='10000000-0000-4000-8000-000000000001',workspace='10000000-0000-4000-8000-000000000003',account='10000000-0000-4000-8000-000000000004';
|
||||
const registry=createRegistry(builtinComponents()),document=createDocument(root,[{id:root,parent:null}],[{id:'a',incarnation:1,ownerCanvasId:root,componentId:'text',dataVersion:1,structure:'node',geometry:{x:0,y:0,width:260,height:200,rotation:0},data:{title:'a',text:''}}]);
|
||||
@@ -123,6 +169,8 @@ export async function run() {
|
||||
results.push('journal gap is reported as corruption and never converted to an empty document');
|
||||
await engineRecoveryCase(name, assert);
|
||||
results.push('project engine reopens real IndexedDB with one history unit and the original request; ACK resolves without duplicate edit');
|
||||
await resourceRecoveryCase(name, assert);
|
||||
results.push('staged file and image recover from real IndexedDB; lost upload ACK queries stable resource identity');
|
||||
await protocolRecoveryCase(name,assert);
|
||||
results.push('protocol 2 service adapter recovers exact frozen bytes and reconciles a lost ACK through real IndexedDB');
|
||||
return results;
|
||||
|
||||
@@ -42,6 +42,13 @@ try{
|
||||
assert.equal(response.status,409);assert.equal(await response.text(),responseBytes);
|
||||
const request=received.find(item=>item.path.endsWith('/model/operations'));
|
||||
assert.ok(request);assert.equal(request.body.toString(),body);assert.equal(request.headers['idempotency-key'],key);assert.equal(request.headers['x-expected-account'],account);assert.equal(request.headers.authorization,'Bearer fixture-session');
|
||||
const receiptPath=`workspaces/10000000-0000-4000-8000-000000000003/assets/operations/${key}`;
|
||||
const assetReceipt=await fetch(`http://127.0.0.1:${port}/api/foundry/${receiptPath}`);assert.equal(assetReceipt.status,200);assert.deepEqual(await assetReceipt.json(),{id:'fixture'});
|
||||
const multipart=new FormData();multipart.append('image',new Blob(['immutable file'],{type:'image/png'}),'fixture.png');
|
||||
const assetPath=receiptPath.split('/operations/')[0],resourceId='10000000-0000-4000-8000-000000000006';
|
||||
const uploaded=await fetch(`http://127.0.0.1:${port}/api/foundry/${assetPath}`,{method:'POST',body:multipart,headers:{'X-Resource-Id':resourceId,'Idempotency-Key':key,'X-Expected-Account':account}});await uploaded.text();assert.equal(uploaded.status,200);
|
||||
const upload=received.find(item=>item.path.endsWith('/assets'));assert.equal(upload.headers['x-resource-id'],resourceId);assert.equal(upload.headers['idempotency-key'],key);assert.match(upload.body.toString(),/immutable file/);assert.match(upload.headers['content-type'],/^multipart\/form-data; boundary=/);
|
||||
console.log('PASS asset receipt JSON and multipart resource identity cross the actual Next proxy');
|
||||
const before=received.length,invalid=await fetch(`http://127.0.0.1:${port}/api/foundry/${path}/unexpected/extra`,{signal:AbortSignal.timeout(10000)});await invalid.text();assert.equal(invalid.status,404);assert.equal(received.length,before);
|
||||
console.log('PASS actual Next proxy preserves frozen request bytes/key/account and raw terminal receipt above 1 MiB');
|
||||
console.log('PASS canonical route allowlist rejects unexpected paths without contacting the upstream');
|
||||
|
||||
@@ -0,0 +1,156 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createDocument, applyChanges, builtinComponents, createRegistry } from '../../src/lib/canvas-core/index.ts';
|
||||
import { openProjectEngine } from '../../src/lib/canvas-runtime/engine.ts';
|
||||
import { decodeRecovery } from '../../src/lib/canvas-runtime/recovery.ts';
|
||||
import { resourcePins } from '../../src/lib/canvas-runtime/resources.ts';
|
||||
|
||||
const registry = createRegistry(builtinComponents());
|
||||
const scope = { accountId: 'account', workspaceId: 'workspace', projectId: 'project' };
|
||||
const geometry = { x: 0, y: 0, width: 100, height: 100, rotation: 0 };
|
||||
const node = (id, data = {}) => ({ id, incarnation: 1, structure: 'node', componentId: 'image', dataVersion: 1, ownerCanvasId: 'canvas', geometry, data: { title: id, text: '', ...data } });
|
||||
const original = createDocument('project', [{ id: 'canvas', parent: null }], [node('a')]);
|
||||
const deferred = () => { let resolve; const promise = new Promise(yes => { resolve = yes; }); return { promise, resolve }; };
|
||||
async function until(predicate) { for (let i = 0; i < 100; i++) { if (predicate()) return; await new Promise(resolve => setTimeout(resolve, 1)); } assert.fail('condition did not become true'); }
|
||||
function fixture() {
|
||||
let image = null, owner, counter = 0, server = original, version = 1;
|
||||
const files = new Map(), batches = [], uploads = [], writes = [], receipts = new Map(), assetReceipts = new Map();
|
||||
const storage = {
|
||||
async claim(scope) { assert.equal(owner, undefined); const handle = { scope, fence: 1, active: true, async release() { owner = undefined; handle.active = false; } }; owner = handle; return handle; },
|
||||
async recover() { return structuredClone(image); },
|
||||
async commit(_leader, batch) { for (const file of batch.files ?? []) { assert.equal(files.has(file.id), false); files.set(file.id, file.bytes); } image = structuredClone(batch.image); batches.push({ ...batch, image }); return { durableRootRevision: image.rootRevision }; },
|
||||
async readFile(_leader, id) { return files.get(id); }, close() {},
|
||||
};
|
||||
const assets = {
|
||||
sourceURL: id => `https://assets.example/${id}`, displayURL: id => `/assets/${id}`,
|
||||
async upload(request, bytes) {
|
||||
const payload = JSON.parse(request.body); assert.equal(await files.get(payload.resource_id).text(), await bytes.text());
|
||||
assert.ok(image.payload.runtime.ledger.requests.some(([id, row]) => id === request.id && row.phase === 'dispatch-marked'));
|
||||
uploads.push(request);
|
||||
const asset = { id: payload.resource_id, url: assets.sourceURL(payload.resource_id), width: 20, height: 10, bytes: bytes.size, mime_type: bytes.type };
|
||||
assetReceipts.set(request.id, asset);
|
||||
return { outcome: 'applied', canonical: asset };
|
||||
},
|
||||
async query(request) { return assetReceipts.has(request.id) ? { outcome: 'applied', canonical: assetReceipts.get(request.id) } : { outcome: 'unresolved' }; },
|
||||
accept: (_request, status) => status.canonical,
|
||||
};
|
||||
const persistence = {
|
||||
compile(intent, id, snapshot) { return { payload: { intent, id }, canvasIds: intent.canvasIds, expectedVersions: Object.fromEntries(intent.canvasIds.map(id => [id, snapshot.runtime.versions.get(id)])) }; },
|
||||
async submit(request) { const { intent } = JSON.parse(request.body); writes.push(request); server = applyChanges(server, intent.changes); receipts.set(request.id, { document: server, versions: new Map([['canvas', ++version]]) }); return { outcome: 'applied' }; },
|
||||
async query(request) { return receipts.has(request.id) ? { outcome: 'applied' } : { outcome: 'unresolved' }; },
|
||||
canonical(request) { return receipts.get(request.id); },
|
||||
};
|
||||
return { storage, assets, persistence, files, batches, uploads, writes, assetReceipts, image: () => image,
|
||||
open: extra => openProjectEngine({ scope, registry, document: original, versions: new Map([['canvas', 1]]), storage, assets, persistence, createId: () => `id-${++counter}`, ...extra }),
|
||||
};
|
||||
}
|
||||
function addImage(engine, id = 'picture') {
|
||||
let resource;
|
||||
const result = engine.stageFiles([{ name: 'image.png', bytes: new Blob(['image bytes'], { type: 'image/png' }) }], ([ref], tx) => {
|
||||
resource = ref;
|
||||
tx.dispatch({ type: 'element.create', element: node(id, { assetId: ref.id, src: ref.src }) });
|
||||
});
|
||||
assert.equal(result.status, 'applied'); return resource;
|
||||
}
|
||||
|
||||
test('pending images publish immediately, bytes share the durable cut, and independent canvas edits overtake upload', async () => {
|
||||
const f = fixture(), gate = deferred(), upload = f.assets.upload;
|
||||
f.assets.upload = async (...args) => { await gate.promise; return upload(...args); };
|
||||
const engine = await f.open(), ref = addImage(engine);
|
||||
assert.equal(engine.getSnapshot().document.elements.get('picture').data.assetId, ref.id);
|
||||
assert.equal(engine.getSnapshot().history.undo.length, 1);
|
||||
assert.equal(engine.getSnapshot().runtime.ledger.operations.size, 2);
|
||||
const sequences = [...engine.getSnapshot().runtime.ledger.operations.values()].map(record => record.intent.sequence);
|
||||
assert.equal(new Set(sequences).size, 2);
|
||||
const handle = await engine.displayResource(ref.id); assert.match(handle.url, /^blob:/); handle.release(); handle.release();
|
||||
engine.editor.dispatch({ type: 'element.data', target: { id: 'a', incarnation: 1 }, patch: { title: 'independent' } });
|
||||
await until(() => f.writes.length === 1);
|
||||
assert.equal(f.uploads.length, 0);
|
||||
const fileBatch = f.batches.find(batch => batch.files?.length);
|
||||
assert.equal(fileBatch.image.payload.document.elements.some(element => element.id === 'picture'), true);
|
||||
assert.equal(fileBatch.image.payload.runtime.resources.length, 1);
|
||||
gate.resolve(); await engine.settle();
|
||||
assert.equal(f.uploads.length, 1); assert.equal(f.writes.length, 2);
|
||||
assert.equal(engine.getSnapshot().history.undo.length, 2);
|
||||
assert.ok(engine.getSnapshot().runtime.resources.get(ref.id).stored);
|
||||
assert.equal(engine.getSnapshot().document.elements.get('a').data.title, 'independent');
|
||||
engine.editor.dispatch({ type: 'element.create', element: node('copy', { assetId: ref.id, src: ref.src }) });
|
||||
await engine.settle(); assert.equal(f.uploads.length, 1);
|
||||
assert.equal(engine.editor.history.undo().status, 'applied'); await engine.settle();
|
||||
assert.equal(f.uploads.length, 1); assert.equal(engine.getSnapshot().document.elements.has('copy'), false);
|
||||
const pins = resourcePins(engine.getSnapshot(), engine.getSnapshot().runtime.ledger, registry, new Map());
|
||||
assert.equal(pins.complete, true); assert.ok([...pins.pins.get(ref.id)].some(owner => owner.startsWith('history:')));
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
test('lost upload acknowledgment recovers original byte identity and query receipt without recreating a node', async () => {
|
||||
const f = fixture(), upload = f.assets.upload;
|
||||
f.assets.upload = async (...args) => { await upload(...args); return { outcome: 'unresolved' }; };
|
||||
const engine = await f.open(), ref = addImage(engine); await engine.settle();
|
||||
const frozen = f.uploads[0]; assert.ok(frozen); assert.equal(f.writes.length, 0);
|
||||
const decoded = decodeRecovery(f.image(), registry);
|
||||
assert.equal(decoded.runtime.resources.get(ref.id).id, ref.id); assert.equal(decoded.operations.size, 1); assert.equal(decoded.runtime.ledger.operations.size, 2);
|
||||
const bad = structuredClone(f.image()); bad.payload.runtime.resources[0][1].operationId = 'not-the-upload';
|
||||
assert.throws(() => decodeRecovery(bad, registry), /corrupt_recovery_image/);
|
||||
await engine.close();
|
||||
const queries = [], query = f.assets.query;
|
||||
f.assets.query = async request => { queries.push(request); return query(request); };
|
||||
const recovered = await f.open({ clock: { now: () => Date.now() + 100000, setTimer: (fn, ms) => setTimeout(fn, ms), clearTimer: id => clearTimeout(id) } });
|
||||
await new Promise(resolve => setTimeout(resolve, 1)); await recovered.settle();
|
||||
assert.equal(queries.length, 1); assert.equal(queries[0].id, frozen.id); assert.equal(queries[0].body, frozen.body);
|
||||
assert.equal(f.uploads.length, 1); assert.equal(f.writes.length, 1);
|
||||
assert.equal(recovered.getSnapshot().document.elements.size, 2); assert.equal(recovered.getSnapshot().history.undo.length, 1);
|
||||
assert.ok(recovered.getSnapshot().runtime.resources.get(ref.id).stored);
|
||||
await recovered.close();
|
||||
});
|
||||
|
||||
test('rejected and empty staging do not retain file bytes or create upload work', async () => {
|
||||
const f = fixture(), engine = await f.open();
|
||||
const files = [{ name: 'image.png', bytes: new Blob(['image'], { type: 'image/png' }) }];
|
||||
const result = engine.stageFiles(files, ([ref], tx) => { tx.dispatch({ type: 'element.create', element: node('a', { assetId: ref.id }) }); });
|
||||
assert.equal(result.status, 'rejected');
|
||||
assert.equal(engine.stageFiles(files, () => {}).operationIds.length, 0);
|
||||
await engine.settle();
|
||||
assert.equal(f.files.size, 0); assert.equal(f.uploads.length, 0); assert.equal(engine.getSnapshot().runtime.resources.size, 0);
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
test('unknown resource reference schemas prevent claiming complete garbage-collection coverage', async () => {
|
||||
const f = fixture(), engine = await f.open();
|
||||
const opaque = { ...node('future'), componentId: 'future-image', data: { privateResource: 'unknown' } };
|
||||
const doc = createDocument('project', [...original.canvases.values()], [...original.elements.values(), opaque]);
|
||||
const snapshot = { ...engine.getSnapshot(), document: doc };
|
||||
assert.equal(resourcePins(snapshot, snapshot.runtime.ledger, registry, new Map()).complete, false);
|
||||
const pinned = resourcePins(engine.getSnapshot(), engine.getSnapshot().runtime.ledger, registry, new Map([['export-job', ['keep']]]));
|
||||
assert.deepEqual([...pinned.pins.get('keep')], ['export-job']);
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
test('invalid applied asset metadata retains the receipt and pending document without releasing the dependency', async () => {
|
||||
const f = fixture(), upload = f.assets.upload;
|
||||
f.assets.upload = async (...args) => { const result = await upload(...args); return { ...result, canonical: { ...result.canonical, id: 'different-resource' } }; };
|
||||
const errors = [], engine = await f.open({ onError: error => errors.push(error) });
|
||||
const ref = addImage(engine); await engine.settle();
|
||||
const request = f.uploads[0], stored = engine.getSnapshot().runtime.ledger.requests.get(request.id);
|
||||
assert.equal(stored.outcome, 'applied'); assert.equal(stored.phase, 'waiting'); assert.equal(f.writes.length, 0);
|
||||
assert.equal(engine.getSnapshot().runtime.receipts.get(request.id).id, 'different-resource');
|
||||
assert.equal(engine.getSnapshot().document.elements.get('picture').data.assetId, ref.id);
|
||||
assert.equal(engine.getSnapshot().runtime.resources.get(ref.id).stored, undefined); assert.equal(errors[0].message, 'asset_receipt_mismatch');
|
||||
await engine.close();
|
||||
});
|
||||
|
||||
test('a failed image durable cut keeps the visible element and sends neither bytes nor document', async () => {
|
||||
const f = fixture(), errors = [], engine = await f.open({ onError: error => errors.push(error) });
|
||||
await engine.persist();
|
||||
const commit = f.storage.commit;
|
||||
f.storage.commit = async () => { throw new Error('quota'); };
|
||||
const ref = addImage(engine); await new Promise(resolve => setTimeout(resolve, 5));
|
||||
await assert.rejects(() => engine.settle(), /quota/);
|
||||
assert.equal(f.uploads.length, 0); assert.equal(f.writes.length, 0); assert.equal(f.files.size, 0);
|
||||
assert.equal(engine.getSnapshot().document.elements.get('picture').data.assetId, ref.id);
|
||||
await assert.rejects(() => engine.close(), /quota/);
|
||||
f.storage.commit = commit; await engine.close();
|
||||
assert.equal(await f.files.get(ref.id).text(), 'image bytes');
|
||||
assert.equal(decodeRecovery(f.image(), registry).history.undo.length, 1);
|
||||
assert.ok(errors.length);
|
||||
});
|
||||
@@ -24,7 +24,7 @@ function setup(overrides = {}, initial) {
|
||||
});
|
||||
return { scheduler, calls, persisted, errors, ledger: () => ledger,
|
||||
add(id, canvases = ['canvas'], dependencies = []) { ledger.add({ id, operationType: 'document.change', operationSchemaVersion: 1, sequence: ledger.getSnapshot().operations.size + 1, origin: 'user', changes: canvases.map(id => ({ kind: 'canvas', id, before: null, after: { id, parent: null } })), dependencies }, {}); scheduler.notify([id]); },
|
||||
async advance(ms) { time += ms; for (const [id, timer] of [...timers]) if (timer.at <= time) { timers.delete(id); timer.callback(); } await tick(); await scheduler.settle(); },
|
||||
async advance(ms, settle = true) { time += ms; for (const [id, timer] of [...timers]) if (timer.at <= time) { timers.delete(id); timer.callback(); } await tick(); if (settle) await scheduler.settle(); },
|
||||
timerCount: () => timers.size,
|
||||
};
|
||||
}
|
||||
@@ -105,3 +105,41 @@ test('permission/protocol rejection keeps unknown claims without an automatic re
|
||||
assert.equal(state.ledger().getSnapshot().requests.get('request-1').outcome,'unresolved');assert.equal(state.scheduler.getClaims().size,1);assert.equal(state.timerCount(),0);
|
||||
await state.advance(10000);assert.equal(calls.length,1);state.scheduler.stop();
|
||||
});
|
||||
|
||||
const mixedCompile = (intent, requestId) => ({ kind: intent.operationType, protocolVersion: 2, canvasIds: intent.operationType === 'asset.upload' ? [] : intent.changes.map(change => change.id), expectedVersions: Object.fromEntries(intent.changes.map(change => [change.id, 1])), payload: { requestId, operationId: intent.id } });
|
||||
function addAsset(state, id) {
|
||||
state.ledger().add({ id, operationType: 'asset.upload', operationSchemaVersion: 1, sequence: state.ledger().getSnapshot().operations.size + 1, origin: 'user', changes: [], canvasIds: [], dependencies: [], resourceId: `resource-${id}` }, {});
|
||||
state.scheduler.notify([id]);
|
||||
}
|
||||
|
||||
test('an upload burst yields without filling both network slots or starving independent edits', async () => {
|
||||
const gate = deferred(), calls = [];
|
||||
const state = setup({ compile: mixedCompile, submit: async request => { calls.push(request); if (request.operationIds[0] === 'asset-0') await gate.promise; return { outcome: 'applied' }; } });
|
||||
for (let index = 0; index < 80; index++) addAsset(state, `asset-${index}`);
|
||||
state.add('independent', ['canvas']); state.scheduler.start(); await tick();
|
||||
await state.advance(0, false);
|
||||
assert.deepEqual(calls.map(request => request.operationIds[0]), ['asset-0', 'independent']);
|
||||
assert.equal(state.timerCount(), 0);
|
||||
gate.resolve(); await state.scheduler.settle();
|
||||
assert.equal(calls.length, 81); assert.equal(state.errors.length, 0); state.scheduler.stop();
|
||||
});
|
||||
|
||||
test('a capacity-blocked upload retry does not spin or hide a later document retry deadline', async () => {
|
||||
const gate = deferred(), calls = [];
|
||||
const state = setup({ compile: mixedCompile,
|
||||
submit: async request => {
|
||||
const id = request.operationIds[0]; calls.push(['submit', id]);
|
||||
if (id === 'asset-2') { await gate.promise; return { outcome: 'applied' }; }
|
||||
return { outcome: 'unresolved', retryAfterMs: id === 'doc' ? 200 : 100 };
|
||||
},
|
||||
query: async request => { calls.push(['query', request.operationIds[0]]); return { outcome: 'applied' }; },
|
||||
});
|
||||
addAsset(state, 'asset-1'); addAsset(state, 'asset-2'); state.add('doc'); state.scheduler.start(); await tick();
|
||||
await state.advance(100, false); assert.equal(state.timerCount(), 1);
|
||||
await state.advance(100, false);
|
||||
assert.ok(calls.some(([action, id]) => action === 'query' && id === 'doc'));
|
||||
assert.equal(calls.some(([action, id]) => action === 'query' && id === 'asset-1'), false);
|
||||
assert.equal(state.timerCount(), 0);
|
||||
gate.resolve(); await state.scheduler.settle();
|
||||
assert.ok(calls.some(([action, id]) => action === 'query' && id === 'asset-1')); state.scheduler.stop();
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user