223 lines
18 KiB
JavaScript
223 lines
18 KiB
JavaScript
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 { encodeRecovery, decodeRecovery } from '../../src/lib/canvas-runtime/recovery.ts';
|
|
|
|
const registry = createRegistry(builtinComponents());
|
|
const original = createDocument('project', [{ id: 'canvas', parent: null }], [{ id: 'a', incarnation: 1, structure: 'node', ownerCanvasId: 'canvas', componentId: 'text', dataVersion: 1, data: { title: 'a', text: '' }, geometry: { x: 0, y: 0, width: 100, height: 100, rotation: 0 } }]);
|
|
const scope = { accountId: 'account', workspaceId: 'workspace', projectId: 'project' }, target = { id: 'a', incarnation: 1 };
|
|
const deferred = () => { let resolve; const promise = new Promise(yes => { resolve = yes; }); return { promise, resolve }; };
|
|
const tick = async () => { for (let i = 0; i < 30; i++) await Promise.resolve(); };
|
|
function storageFixture() {
|
|
let image = null, owner = null, fence = 0;
|
|
const saved = [], fixture = {
|
|
broken: false, saved,
|
|
async claim(scope) { assert.equal(owner, null); const leader = { scope, fence: ++fence, active: true, async release() { owner = null; leader.active = false; } }; owner = leader; return leader; },
|
|
async recover() { return image && structuredClone(image); },
|
|
async commit(leader, batch) { if (fixture.broken) throw new Error('quota'); assert.equal(owner, leader); assert.equal(leader.active, true); if (image) assert.ok(batch.image.rootRevision === image.rootRevision + 1 || batch.image.rootRevision === image.rootRevision); image = structuredClone(batch.image); saved.push(image); return { durableRootRevision: image.rootRevision }; },
|
|
async readFile() {}, close() {},
|
|
image: () => structuredClone(image), owner: () => owner,
|
|
};
|
|
return fixture;
|
|
}
|
|
function persistenceFixture(overrides = {}) {
|
|
let server = original, version = 1;
|
|
const calls = [], receipts = new Map();
|
|
const fixture = {
|
|
calls, receipts,
|
|
compile(intent, requestId, snapshot) { return { payload: { requestId, intent }, canvasIds: intent.canvasIds, expectedVersions: Object.fromEntries(intent.canvasIds.map(id => [id, snapshot.runtime.versions.get(id)])) }; },
|
|
async submit(request) {
|
|
calls.push(['submit', request]);
|
|
if (!receipts.has(request.id)) { const { intent } = JSON.parse(request.body); server = applyChanges(server, intent.changes); version++; receipts.set(request.id, { document: server, versions: new Map([['canvas', version]]) }); }
|
|
return { outcome: 'applied', canonical: { receipt: request.id } };
|
|
},
|
|
async query(request) { calls.push(['query', request]); return receipts.has(request.id) ? { outcome: 'applied', canonical: { receipt: request.id } } : { outcome: 'unresolved' }; },
|
|
canonical(request) { return receipts.get(request.id); }, ...overrides,
|
|
};
|
|
return fixture;
|
|
}
|
|
async function open(storage, persistence, extra = {}) {
|
|
let next = 0; const errors = [];
|
|
const engine = await openProjectEngine({ scope, registry, document: original, versions: new Map([['canvas', 1]]), storage, persistence, createId: () => `identity-${++next}`, onError: error => errors.push(error), ...extra });
|
|
return { engine, errors };
|
|
}
|
|
|
|
test('local document/history/ledger publish together; ACK replays edits made while a request is in flight', async () => {
|
|
const storage = storageFixture(), port = persistenceFixture(), gate = deferred(), realSubmit = port.submit;
|
|
port.submit = async request => { if (!port.calls.length) await gate.promise; return realSubmit(request); };
|
|
const { engine } = await open(storage, port); await engine.persist();
|
|
const first = engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'local' } });
|
|
assert.equal(engine.getSnapshot().history.undo.length, 1);
|
|
assert.ok(engine.getSnapshot().runtime.ledger.operations.has(first.operationIds[0]));
|
|
await tick();
|
|
engine.editor.dispatch({ type: 'element.geometry', target, patch: { x: 200 } });
|
|
assert.equal(engine.getSnapshot().document.elements.get('a').geometry.x, 200);
|
|
gate.resolve(); await engine.settle();
|
|
assert.equal(port.calls.length, 2);
|
|
assert.equal(port.calls[1][1].expectedVersions.canvas, 2);
|
|
assert.equal(engine.getSnapshot().document.elements.get('a').data.title, 'local');
|
|
assert.equal(engine.getSnapshot().document.elements.get('a').geometry.x, 200);
|
|
assert.equal(engine.getSnapshot().history.undo.length, 2);
|
|
assert.ok([...engine.getSnapshot().runtime.ledger.operations.values()].every(operation => operation.phase === 'resolved'));
|
|
assert.equal(engine.getDurability().durableRootRevision, engine.getSnapshot().rootRevision);
|
|
assert.equal(engine.getSnapshot().runtime.ledger.durableGeneration, engine.getSnapshot().runtime.ledger.generation);
|
|
const payload = storage.image().payload;
|
|
assert.equal(payload.history.undo.length, 2); assert.equal(payload.runtime.ledger.requests.length, 2);
|
|
await engine.close();
|
|
});
|
|
|
|
test('closing a view keeps jobs alive; closing/reopening the engine restores history and queries the original unknown request', async () => {
|
|
const storage = storageFixture(), port = persistenceFixture(), realSubmit = port.submit;
|
|
port.submit = async request => { await realSubmit(request); return { outcome: 'unresolved' }; };
|
|
const { engine } = await open(storage, port);
|
|
const detach = engine.sessions.attach('view');
|
|
engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'once' } }); detach();
|
|
await engine.settle();
|
|
assert.equal(port.calls.length, 1); const request = port.calls[0][1];
|
|
await engine.close();
|
|
const futureClock = { now: () => Date.now() + 100_000, setTimer: (callback, delay) => setTimeout(callback, delay), clearTimer: clearTimeout };
|
|
const recovered = await open(storage, port, { clock: futureClock });
|
|
await new Promise(resolve => setTimeout(resolve, 1)); await recovered.engine.settle();
|
|
assert.equal(port.calls[1][0], 'query'); assert.equal(port.calls[1][1].id, request.id); assert.equal(port.calls[1][1].body, request.body);
|
|
assert.equal(recovered.engine.getSnapshot().history.undo.length, 1);
|
|
assert.equal(recovered.engine.getSnapshot().document.elements.get('a').data.title, 'once');
|
|
assert.equal(recovered.engine.getSnapshot().operations.size, 1);
|
|
await recovered.engine.close();
|
|
});
|
|
|
|
test('failed local durability preserves editing, prevents sends, and failed close retains the recovery leader', async () => {
|
|
const storage = storageFixture(), port = persistenceFixture(), { engine, errors } = await open(storage, port);
|
|
await engine.persist(); storage.broken = true;
|
|
engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'unsaved' } }); await tick();
|
|
await assert.rejects(() => engine.persist(), /quota/); await tick();
|
|
assert.equal(engine.getSnapshot().document.elements.get('a').data.title, 'unsaved'); assert.equal(port.calls.length, 0); assert.ok(errors.length);
|
|
await assert.rejects(() => engine.close(), /quota/); assert.ok(storage.owner());
|
|
assert.equal(engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'too-late' } }).code, 'engine_closing');
|
|
storage.broken = false; await engine.close(); assert.equal(storage.owner(), null);
|
|
});
|
|
|
|
test('canonical replay conflict preserves working content and the known receipt without releasing the writer', async () => {
|
|
const storage = storageFixture(), port = persistenceFixture(), gate = deferred(), realSubmit = port.submit;
|
|
port.submit = async request => { await gate.promise; return realSubmit(request); };
|
|
const realCanonical = port.canonical;
|
|
port.canonical = request => { const proposal = realCanonical(request); return { ...proposal, document: applyChanges(proposal.document, [{ kind: 'field', target, field: 'geometry', before: original.elements.get('a').geometry, after: { ...original.elements.get('a').geometry, x: 500 } }]) }; };
|
|
const { engine } = await open(storage, port);
|
|
engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'first' } }); await tick();
|
|
engine.editor.dispatch({ type: 'element.geometry', target, patch: { x: 200 } });
|
|
gate.resolve(); await engine.settle();
|
|
assert.equal(engine.getSnapshot().document.elements.get('a').geometry.x, 200);
|
|
assert.equal(engine.getSnapshot().runtime.conflicts.size, 1); assert.equal(port.calls.length, 1);
|
|
const request = [...engine.getSnapshot().runtime.ledger.requests.values()][0];
|
|
assert.equal(request.outcome, 'applied'); assert.equal(request.phase, 'waiting');
|
|
assert.ok(engine.getSnapshot().runtime.receipts.has(request.id));
|
|
await engine.close();
|
|
});
|
|
|
|
test('recovery codec restores immutable maps and rejects broken history/dependency references', async () => {
|
|
const storage = storageFixture(), port = persistenceFixture(), { engine } = await open(storage, port);
|
|
engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'encoded' } }); await engine.settle();
|
|
const image = encodeRecovery(engine.getSnapshot()), restored = decodeRecovery(image, registry);
|
|
assert.equal(typeof restored.document.elements.set, 'undefined'); assert.equal(restored.history.undo.length, 1);
|
|
const corrupted = structuredClone(image); corrupted.payload.history.undo[0] = 'missing';
|
|
assert.throws(() => decodeRecovery(corrupted, registry), /corrupt_recovery_image/);
|
|
const cycle = structuredClone(image), record = cycle.payload.runtime.ledger.operations[0][1]; record.intent.dependencies = [record.intent.id];
|
|
assert.throws(() => decodeRecovery(cycle, registry), /corrupt_recovery_image/);
|
|
const changed = structuredClone(image); changed.payload.document.elements[0].data.title = 'mutated';
|
|
assert.equal(restored.document.elements.get('a').data.title, 'encoded');
|
|
await engine.close();
|
|
});
|
|
|
|
test('a fresh canonical read replaces a clean recovered base, keeps history and refuses older versions', async () => {
|
|
const storage = storageFixture(), port = persistenceFixture(), first = await open(storage, port);
|
|
first.engine.editor.dispatch({ type: 'element.data', target, patch: { title: 'local' } }); await first.engine.settle(); await first.engine.close();
|
|
const reopened = await open(storage, port), current = reopened.engine.getSnapshot();
|
|
const remote = applyChanges(current.runtime.acknowledged, [{ kind: 'field', target, field: 'geometry', before: current.document.elements.get('a').geometry, after: { ...current.document.elements.get('a').geometry, x: 400 } }]);
|
|
assert.equal(reopened.engine.refresh(remote, new Map([['canvas', 3]])).status, 'applied');
|
|
assert.equal(reopened.engine.getSnapshot().document.elements.get('a').geometry.x, 400);
|
|
assert.equal(reopened.engine.getSnapshot().history.undo.length, 1);
|
|
assert.equal(reopened.engine.refresh(original, new Map([['canvas', 1]])).code, 'stale_canonical_version');
|
|
assert.equal(reopened.engine.getSnapshot().document.elements.get('a').geometry.x, 400);
|
|
await reopened.engine.close();
|
|
});
|
|
|
|
test('recovery waits for admitted writes, reads a complete base, fences edits and publishes without changing history', async()=>{
|
|
const storage=storageFixture(),port=persistenceFixture(),response=deferred(),realSubmit=port.submit,readGate=deferred();
|
|
let reads=0;port.submit=async request=>{await response.promise;return realSubmit(request);};
|
|
port.read=async()=>{reads++;await readGate.promise;return{document:applyChanges(original,[{kind:'field',target,field:'data.title',before:'a',after:'local',beforePresent:true,afterPresent:true},{kind:'field',target,field:'geometry',before:original.elements.get('a').geometry,after:{...original.elements.get('a').geometry,x:300}}]),versions:new Map([['canvas',3]])};};
|
|
const{engine}=await open(storage,port);engine.editor.dispatch({type:'element.data',target,patch:{title:'local'}});await tick();
|
|
const preparing=engine.prepareRecovery();await tick();assert.equal(reads,0);
|
|
assert.equal(engine.editor.dispatch({type:'element.data',target,patch:{title:'blocked'}}).code,'recovery_in_progress');
|
|
assert.equal(engine.startRun({}).code,'recovery_in_progress');assert.equal(engine.refresh(original,new Map([['canvas',1]])).code,'recovery_in_progress');
|
|
await assert.rejects(engine.prepareRecovery(),/recovery_in_progress/);
|
|
response.resolve();await tick();assert.equal(reads,1);const history=engine.getSnapshot().history;
|
|
readGate.resolve();const session=await preparing;assert.equal(session.conflict,undefined);assert.equal(session.canonical.document.elements.get('a').geometry.x,300);
|
|
assert.equal(engine.getSnapshot().document.elements.get('a').geometry.x,0);assert.equal(engine.editor.history.undo().code,'recovery_in_progress');
|
|
assert.equal((await session.apply()).status,'applied');assert.equal(engine.getSnapshot().document.elements.get('a').geometry.x,300);assert.equal(engine.getSnapshot().history,history);
|
|
assert.equal(engine.getDurability().durableRootRevision,engine.getSnapshot().rootRevision);await assert.rejects(session.apply(),/recovery_session_closed/);
|
|
await engine.close();
|
|
});
|
|
|
|
test('unknown receipts prevent a recovery read and preserve the frozen request identity',async()=>{
|
|
const storage=storageFixture();let reads=0;const port=persistenceFixture({async submit(){return{outcome:'unresolved'};},async read(){reads++;return{document:original,versions:new Map([['canvas',1]])};}});
|
|
const{engine}=await open(storage,port);engine.editor.dispatch({type:'element.data',target,patch:{title:'local'}});await engine.settle();
|
|
const before=engine.getSnapshot(),request=[...before.runtime.ledger.requests.values()][0];
|
|
await assert.rejects(engine.prepareRecovery(),/recovery_waiting_for_receipts/);assert.equal(reads,0);
|
|
const after=engine.getSnapshot();assert.equal(after.document,before.document);assert.equal(after.history,before.history);assert.equal(after.runtime.ledger.requests.get(request.id).body,request.body);
|
|
assert.equal(engine.editor.can({type:'element.data',target,patch:{title:'allowed'}}).enabled,true);await engine.close();
|
|
});
|
|
|
|
test('recovery conflict previews preserve local data/history and cancel releases the edit fence',async()=>{
|
|
const remote=applyChanges(original,[{kind:'field',target,field:'data.title',before:'a',after:'remote',beforePresent:true,afterPresent:true}]);
|
|
const storage=storageFixture(),port=persistenceFixture({async submit(){return{outcome:'not-applied',error:'version_conflict'};},async read(){return{document:remote,versions:new Map([['canvas',2]])};}});
|
|
const{engine}=await open(storage,port);engine.editor.dispatch({type:'element.data',target,patch:{title:'local'}});await engine.settle();
|
|
const before=engine.getSnapshot(),session=await engine.prepareRecovery();assert.ok(session.conflict);assert.equal(session.pendingOperationIds.length,1);
|
|
assert.equal((await session.apply()).status,'rejected');assert.equal(engine.getSnapshot(),before);assert.equal(engine.getSnapshot().document.elements.get('a').data.title,'local');
|
|
await session.cancel();await session.cancel();assert.equal(engine.editor.can({type:'element.data',target,patch:{title:'more'}}).enabled,true);await engine.close();
|
|
});
|
|
|
|
test('failed recovery durability retains its fence and retries the same published root',async()=>{
|
|
const storage=storageFixture(),port=persistenceFixture({async read(){return{document:original,versions:new Map([['canvas',1]])};}}),{engine}=await open(storage,port);
|
|
const session=await engine.prepareRecovery();storage.broken=true;await assert.rejects(session.apply(),/quota/);const revision=engine.getSnapshot().rootRevision;
|
|
assert.equal(engine.editor.can({type:'element.data',target,patch:{title:'blocked'}}).code,'recovery_in_progress');await assert.rejects(session.cancel(),/quota/);
|
|
storage.broken=false;assert.equal((await session.apply()).status,'applied');assert.equal(engine.getSnapshot().rootRevision,revision);assert.equal(engine.getDurability().durableRootRevision,revision);
|
|
await engine.close();
|
|
});
|
|
|
|
test('closing the engine aborts a recovery read and rejects a late canonical response',async()=>{
|
|
const storage=storageFixture(),response=deferred();let signal;
|
|
const port=persistenceFixture({async read(input){signal=input;return response.promise;}}),{engine}=await open(storage,port);
|
|
const preparing=engine.prepareRecovery();await tick();assert.ok(signal);await engine.close();assert.equal(signal.aborted,true);
|
|
response.resolve({document:original,versions:new Map([['canvas',1]])});await assert.rejects(preparing,/engine_closing/);assert.equal(storage.owner(),null);
|
|
});
|
|
|
|
test('complete recovery reads reject same-version rewrites and lifecycle regression before creating a session',async()=>{
|
|
const remote=applyChanges(original,[{kind:'field',target,field:'data.title',before:'a',after:'remote',beforePresent:true,afterPresent:true}]);
|
|
const storage=storageFixture(),port=persistenceFixture({async read(){return{document:remote,versions:new Map([['canvas',1]])};}}),{engine}=await open(storage,port);
|
|
await assert.rejects(engine.prepareRecovery(),/canonical_version_mismatch/);
|
|
assert.equal(engine.getSnapshot().document.elements.get('a').data.title,'a');
|
|
assert.equal(engine.editor.can({type:'element.data',target,patch:{title:'allowed'}}).enabled,true);
|
|
assert.equal(engine.refresh(remote,new Map([['canvas',1]])).code,'canonical_version_mismatch');
|
|
const {validateCanonicalRead}=await import('../../src/lib/canvas-runtime/reconcile.ts');
|
|
const withTombstone=createDocument(original.projectId,[...original.canvases.values()],[...original.elements.values()],new Map([['deleted',2]]));
|
|
assert.throws(()=>validateCanonicalRead(withTombstone,new Map([['canvas',1]]),original,new Map([['canvas',2]]),registry),/stale_canonical_lifecycle/);
|
|
assert.throws(()=>validateCanonicalRead(original,new Map([['canvas',1]]),withTombstone,new Map([['canvas',1]]),registry),/canonical_version_mismatch/);
|
|
await engine.close();
|
|
});
|
|
|
|
test('one transaction captures the first presence baseline even when its created element is later deleted', async () => {
|
|
const storage = storageFixture(), port = persistenceFixture(), { engine } = await open(storage, port);
|
|
try {
|
|
const node = { ...original.elements.get('a'), id: 'temporary' };
|
|
const result = engine.editor.transaction(tx => {
|
|
tx.dispatch({ type: 'element.create', element: node });
|
|
tx.dispatch({ type: 'element.remove', target: { id: node.id, incarnation: 1 } });
|
|
});
|
|
assert.equal(result.status, 'applied'); assert.equal(result.operationIds.length, 1);
|
|
const operation = engine.getSnapshot().runtime.ledger.operations.get(result.operationIds[0]);
|
|
assert.equal(operation.basePresence.temporary, 'absent');
|
|
assert.equal(engine.getSnapshot().document.tombstones.get(node.id), 1);
|
|
await engine.settle(); assert.equal(port.calls.length, 1);
|
|
} finally { await engine.close(); }
|
|
});
|