Add durable canvas runtime, scheduling and crash recovery
This commit is contained in:
@@ -0,0 +1,101 @@
|
||||
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';
|
||||
|
||||
async function engineRecoveryCase(name, assert) {
|
||||
const scope = { accountId: 'account', workspaceId: 'workspace', projectId: 'project' }, registry = createRegistry(builtinComponents());
|
||||
const document = createDocument('project', [{ id: 'canvas', parent: null }], [{ id: 'element', incarnation: 1, ownerCanvasId: 'canvas', componentId: 'text', dataVersion: 1, structure: 'node', geometry: { x: 0, y: 0, width: 100, height: 100, rotation: 0 }, data: { title: 'initial', text: '' } }]);
|
||||
let server = document; const receipts = new Map(), calls = [];
|
||||
const port = {
|
||||
compile(intent, requestId, snapshot) { return { payload: { intent, requestId }, canvasIds: intent.canvasIds, expectedVersions: Object.fromEntries(snapshot.runtime.versions) }; },
|
||||
async submit(request) { calls.push(['submit', request]); const intent = JSON.parse(request.body).intent; server = applyChanges(server, intent.changes); receipts.set(request.id, { document: server, versions: new Map([['canvas', 2]]) }); return { outcome: 'unresolved' }; },
|
||||
async query(request) { calls.push(['query', request]); return { outcome: 'applied', canonical: { receiptId: request.id } }; },
|
||||
canonical(request) { return receipts.get(request.id); },
|
||||
};
|
||||
const storage = createBrowserStorage({ name: `${name}-engine`, checkpointEvery: 4 }), options = { scope, registry, document, versions: new Map([['canvas', 1]]), storage, persistence: port };
|
||||
let engine;
|
||||
try {
|
||||
engine = await openProjectEngine(options);
|
||||
const detach = engine.sessions.attach('view');
|
||||
engine.editor.dispatch({ type: 'element.data', target: { id: 'element', incarnation: 1 }, patch: { title: 'durable edit' } });
|
||||
detach(); await engine.settle();
|
||||
assert(calls.length === 1, 'detaching last view must not abort persistent work');
|
||||
const request = calls[0][1];
|
||||
await engine.close();
|
||||
const futureClock = { now: () => Date.now() + 100_000, setTimer: (callback, delay) => setTimeout(callback, delay), clearTimer: handle => clearTimeout(handle) };
|
||||
engine = await openProjectEngine({ ...options, clock: futureClock });
|
||||
await new Promise(resolve => setTimeout(resolve, 10)); await engine.settle();
|
||||
assert(calls.length === 2 && calls[1][0] === 'query', 'recovered dispatched request must query before a new submit');
|
||||
assert(calls[1][1].id === request.id && calls[1][1].body === request.body, 'request ID/body must survive real IndexedDB recovery exactly');
|
||||
assert(engine.getSnapshot().document.elements.get('element').data.title === 'durable edit', 'recovered pending changes must not replay twice');
|
||||
assert(engine.getSnapshot().history.undo.length === 1 && engine.getSnapshot().operations.size === 1, 'history and ledger must recover the same state cut');
|
||||
assert(engine.sessions.getSnapshot().views.size === 0, 'transient views must not be recovered as document data');
|
||||
assert(engine.getDurability().rootRevision === engine.getDurability().durableRootRevision, 'final receipt and replay must cross the durable barrier');
|
||||
} finally { await engine?.close(); storage.close(); indexedDB.deleteDatabase(`${name}-engine`); }
|
||||
}
|
||||
|
||||
export async function run() {
|
||||
const results = [], name = `headless-test-${crypto.randomUUID()}`;
|
||||
const scope = { accountId: 'test-account', workspaceId: 'test-workspace', projectId: 'test-project' };
|
||||
const storage = createBrowserStorage({ name, checkpointEvery: 3 });
|
||||
const image = revision => ({ formatVersion: 1, rootRevision: revision, localRevision: Math.min(revision, 1), payload: { document: { title: `v${revision}` }, ledger: { frozenBody: '{"request_id":"stable"}' }, history: ['history-id'] } });
|
||||
const assert = (condition, message) => { if (!condition) throw new Error(message); };
|
||||
const rejects = async (callback, message) => { try { await callback(); } catch (error) { assert(error.message === message, `expected ${message}, received ${error.message}`); return; } throw new Error(`expected ${message}`); };
|
||||
let leader, other;
|
||||
try {
|
||||
leader = await storage.claim(scope);
|
||||
assert(await storage.recover(leader) === null, 'empty scope must be distinguishable from a corrupt checkpoint');
|
||||
await rejects(() => storage.claim(scope), 'storage_scope_in_use');
|
||||
await storage.commit(leader, { image: image(0), files: [{ id: 'asset', bytes: new Blob(['original']) }] });
|
||||
assert((await storage.recover(leader)).rootRevision === 0, 'initial checkpoint should recover');
|
||||
assert(await (await storage.readFile(leader, 'asset')).text() === 'original', 'committed bytes should survive');
|
||||
results.push('initial checkpoint and file bytes commit together; duplicate leader rejected');
|
||||
|
||||
await storage.commit(leader, { image: image(1) });
|
||||
await storage.commit(leader, { image: image(1) });
|
||||
await rejects(() => storage.commit(leader, { image: { ...image(1), payload: null } }), 'storage_revision_conflict');
|
||||
await rejects(() => storage.commit(leader, { image: image(3) }), 'storage_revision_gap');
|
||||
await rejects(() => storage.commit(leader, { image: { ...image(2), formatVersion: 2 } }), 'unsupported_recovery_version');
|
||||
results.push('same-cut retry is idempotent; conflicting, skipped and future-format cuts reject');
|
||||
|
||||
// The first put succeeds before a later duplicate resource aborts the whole transaction.
|
||||
await rejects(() => storage.commit(leader, { image: image(2), files: [{ id: 'orphan', bytes: new Blob(['must-rollback']) }, { id: 'asset', bytes: new Blob(['replacement']) }] }), 'resource_identity_conflict');
|
||||
assert(await storage.readFile(leader, 'orphan') === undefined, 'aborted resource bytes must roll back');
|
||||
assert((await storage.recover(leader)).rootRevision === 1, 'aborted document/history/ledger cut must not advance');
|
||||
assert(await (await storage.readFile(leader, 'asset')).text() === 'original', 'existing resource bytes must remain immutable');
|
||||
results.push('late transaction failure rolls back new bytes and the entire state cut');
|
||||
|
||||
await storage.commit(leader, { image: image(2) });
|
||||
const originalFence = leader.fence;
|
||||
await leader.release();
|
||||
other = createBrowserStorage({ name, checkpointEvery: 3 });
|
||||
const next = await other.claim(scope);
|
||||
await rejects(() => storage.commit(leader, { image: image(3) }), 'storage_leader_lost');
|
||||
assert(next.fence > originalFence, 'reacquire must advance fencing generation');
|
||||
assert((await other.recover(next)).rootRevision === 2, 'new adapter must replay the durable journal');
|
||||
await other.commit(next, { image: image(3) });
|
||||
assert((await other.recover(next)).payload.document.title === 'v3', 'compacted checkpoint must cover the same document/history/ledger cut');
|
||||
leader = next;
|
||||
results.push('fresh adapter replays journal; released handle is fenced; checkpoint compaction preserves latest state');
|
||||
|
||||
// Deliberately remove a journal item to exercise the corruption boundary, not an empty fallback.
|
||||
await other.commit(next, { image: image(4) });
|
||||
const database = await new Promise((resolve, reject) => { const request = indexedDB.open(name); request.onsuccess = () => resolve(request.result); request.onerror = () => reject(request.error); });
|
||||
const storageKey = [JSON.stringify([scope.accountId, scope.workspaceId, scope.projectId]), 4];
|
||||
const tamper = database.transaction('journal', 'readwrite'), read = tamper.objectStore('journal').get(storageKey);
|
||||
let intact;
|
||||
read.onsuccess = () => { intact = read.result; const corrupted = structuredClone(intact); corrupted.image.payload.document.title = 'altered'; tamper.objectStore('journal').put(corrupted, storageKey); };
|
||||
await new Promise((resolve, reject) => { tamper.oncomplete = resolve; tamper.onabort = () => reject(tamper.error); });
|
||||
await rejects(() => other.recover(next), 'recovery_checksum_mismatch');
|
||||
results.push('well-formed data tampering is detected by the stored checksum');
|
||||
const transaction = database.transaction('journal', 'readwrite');
|
||||
transaction.objectStore('journal').delete(storageKey);
|
||||
await new Promise((resolve, reject) => { transaction.oncomplete = resolve; transaction.onabort = () => reject(transaction.error); });
|
||||
database.close();
|
||||
await rejects(() => other.recover(next), 'recovery_journal_gap');
|
||||
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');
|
||||
return results;
|
||||
} finally { await leader?.release(); other?.close(); storage.close(); indexedDB.deleteDatabase(name); }
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
/** Real Chromium IndexedDB/Web Locks checks, in an isolated temporary browser profile. */
|
||||
import { createServer } from 'node:http';
|
||||
import { readFile, mkdtemp, rm } from 'node:fs/promises';
|
||||
import { tmpdir } from 'node:os';
|
||||
import { resolve, join } from 'node:path';
|
||||
import { spawn } from 'node:child_process';
|
||||
import { stripTypeScriptTypes } from 'node:module';
|
||||
import { setTimeout as pause } from 'node:timers/promises';
|
||||
|
||||
const root = resolve(import.meta.dirname, '../..'), profile = await mkdtemp(join(tmpdir(), 'endoleap-storage-browser-'));
|
||||
const server = createServer(async (request, response) => {
|
||||
try {
|
||||
const path = new URL(request.url, 'http://localhost').pathname;
|
||||
if (path === '/') { response.setHeader('Content-Type', 'text/html'); response.end('<title>Headless storage checks</title>'); return; }
|
||||
const filename = resolve(root, `.${path}`);
|
||||
if (!filename.startsWith(`${root}/src/lib/`) && !filename.startsWith(`${root}/tests/headless/`)) { response.writeHead(404).end(); return; }
|
||||
let source = await readFile(filename, 'utf8');
|
||||
if (filename.endsWith('.ts')) source = stripTypeScriptTypes(source);
|
||||
response.setHeader('Content-Type', 'text/javascript'); response.end(source);
|
||||
} catch (error) { response.writeHead(500).end(String(error)); }
|
||||
});
|
||||
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
|
||||
const chrome = spawn(process.env.CHROME_BIN ?? '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', ['--headless=new', '--no-first-run', '--disable-background-networking', '--disable-component-update', '--remote-debugging-port=0', `--user-data-dir=${profile}`, `http://127.0.0.1:${server.address().port}/`], { stdio: 'ignore' });
|
||||
let socket;
|
||||
try {
|
||||
let port;
|
||||
for (let attempt = 0; attempt < 100; attempt++) {
|
||||
try { port = Number((await readFile(join(profile, 'DevToolsActivePort'), 'utf8')).split('\n')[0]); break; } catch { await pause(100); }
|
||||
}
|
||||
if (!port) throw new Error('isolated Chromium did not start');
|
||||
const tabs = await fetch(`http://127.0.0.1:${port}/json/list`).then(response => response.json());
|
||||
socket = new WebSocket(tabs.find(tab => tab.type === 'page').webSocketDebuggerUrl);
|
||||
await new Promise((resolve, reject) => { socket.onopen = resolve; socket.onerror = reject; });
|
||||
let next = 0; const pending = new Map();
|
||||
socket.onmessage = event => { const message = JSON.parse(event.data); if (message.id) { const callbacks = pending.get(message.id); pending.delete(message.id); if (message.error) callbacks.reject(new Error(JSON.stringify(message.error))); else callbacks.resolve(message.result); } };
|
||||
const call = (method, params) => new Promise((resolve, reject) => { const id = ++next; pending.set(id, { resolve, reject }); socket.send(JSON.stringify({ id, method, params })); });
|
||||
const origin = `http://127.0.0.1:${server.address().port}`;
|
||||
await call('Page.navigate', { url: `${origin}/` });
|
||||
let loaded = false;
|
||||
for (let attempt = 0; attempt < 100; attempt++) {
|
||||
const state = await call('Runtime.evaluate', { expression: `location.origin === ${JSON.stringify(origin)} && document.readyState === 'complete'`, returnByValue: true });
|
||||
if (state.result?.value === true) { loaded = true; break; }
|
||||
await pause(50);
|
||||
}
|
||||
if (!loaded) throw new Error('browser test origin did not finish loading');
|
||||
const result = await call('Runtime.evaluate', { expression: "import('/tests/headless/browser-storage-cases.mjs').then(module => module.run())", awaitPromise: true, returnByValue: true, timeout: 30000 });
|
||||
if (result.exceptionDetails) throw new Error(result.exceptionDetails.exception?.description ?? result.exceptionDetails.text);
|
||||
for (const message of result.result.value) console.log(`PASS ${message}`);
|
||||
} finally {
|
||||
socket?.close();
|
||||
const exited = new Promise(resolve => { if (chrome.exitCode !== null) resolve(); else chrome.once('exit', resolve); });
|
||||
chrome.kill(); await exited;
|
||||
await new Promise(resolve => server.close(resolve));
|
||||
await rm(profile, { recursive: true, force: true, maxRetries: 3 });
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
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();
|
||||
});
|
||||
@@ -0,0 +1,59 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createDeque, createMinHeap } from '../../src/lib/canvas-runtime/structures.ts';
|
||||
import { createLedger, compressChanges } from '../../src/lib/canvas-runtime/ledger.ts';
|
||||
const node = { id: 'a', incarnation: 1, ownerCanvasId: 'root', componentId: 'text', dataVersion: 1, data: { title: 'a', text: '' }, structure: 'node', geometry: { x: 0, y: 0, width: 20, height: 20, rotation: 0 } };
|
||||
const intent = (id, changes = [], dependencies = []) => ({ id, operationType: 'document.change', operationSchemaVersion: 1, sequence: 1, origin: 'user', changes, dependencies });
|
||||
const frozen = ledger => ledger.freeze({ id: 'request', operationIds: ['create'], canvasIds: ['root'], expectedVersions: { root: 1 }, payload: { changes: [] } });
|
||||
|
||||
test('FIFO retains order across compaction; retry heap orders deadline then sequence', () => {
|
||||
const queue = createDeque(); for (let i = 0; i < 4000; i++) queue.push(i);
|
||||
for (let i = 0; i < 4000; i++) assert.equal(queue.pop(), i);
|
||||
assert.equal(queue.size, 0); assert.equal(queue.pop(), undefined);
|
||||
const heap = createMinHeap((a, b) => a.due - b.due || a.sequence - b.sequence);
|
||||
for (const value of [{ due: 5, sequence: 2 }, { due: 2, sequence: 9 }, { due: 5, sequence: 1 }, { due: 1, sequence: 8 }]) heap.push(value);
|
||||
assert.deepEqual([heap.pop(), heap.pop(), heap.pop(), heap.pop()].map(item => [item.due, item.sequence]), [[1,8],[2,9],[5,1],[5,2]]);
|
||||
assert.equal(heap.pop(), undefined);
|
||||
});
|
||||
|
||||
test('wholly unsent create-data-delete disappears but a position update preserves the title', () => {
|
||||
const create = { kind: 'element', id: 'a', before: null, after: node };
|
||||
const rename = { kind: 'field', target: { id: 'a', incarnation: 1 }, field: 'data.title', before: 'a', after: 'renamed', beforePresent: true, afterPresent: true };
|
||||
const move = { kind: 'field', target: { id: 'a', incarnation: 1 }, field: 'geometry', before: node.geometry, after: { ...node.geometry, x: 100 } };
|
||||
const compressed = compressChanges([create, rename, move]);
|
||||
assert.equal(compressed.length, 1); assert.equal(compressed[0].after.data.title, 'renamed');
|
||||
assert.deepEqual(compressChanges([...compressed, { kind: 'element', id: 'a', before: compressed[0].after, after: null }]), []);
|
||||
});
|
||||
|
||||
test('frozen identity remains exact after unknown/accepted outcomes and deletion is a separate pending operation', () => {
|
||||
const ledger = createLedger(); ledger.add(intent('create'), { a: 'absent' });
|
||||
const request = frozen(ledger), body = request.body;
|
||||
ledger.markDurable(ledger.getSnapshot().generation); ledger.markDispatch('request');
|
||||
ledger.result('request', 'unresolved', 'transport_unknown');
|
||||
ledger.add(intent('delete', [], ['create']), { a: 'exists' });
|
||||
assert.equal(ledger.eligible('delete'), false); assert.equal(ledger.possiblyApplied('request'), true);
|
||||
ledger.result('request', 'accepted');
|
||||
assert.equal(ledger.eligible('delete'), false); assert.equal(ledger.getSnapshot().requests.get('request').body, body);
|
||||
ledger.markDispatch('request'); assert.equal(ledger.getSnapshot().requests.get('request').body, body);
|
||||
ledger.result('request', 'applied'); assert.equal(ledger.eligible('delete'), true);
|
||||
});
|
||||
|
||||
test('dependencies are explicit, duplicate identities conflict and late durable completion does not mark newer work durable', () => {
|
||||
const ledger = createLedger();
|
||||
assert.throws(() => ledger.add(intent('child', [], ['missing']), {}), /dependency_missing/);
|
||||
ledger.add(intent('first'), {}); const oldGeneration = ledger.getSnapshot().generation;
|
||||
ledger.add(intent('second', [], ['first']), {}); ledger.markDurable(oldGeneration);
|
||||
assert.ok(ledger.getSnapshot().durableGeneration < ledger.getSnapshot().generation);
|
||||
assert.throws(() => ledger.add(intent('first', [], ['second']), {}), /operation_identity_conflict/);
|
||||
assert.equal(ledger.eligible('second'), false);
|
||||
});
|
||||
|
||||
test('recovery retains possible application; explicit terminal zero-write does not pretend dependent writes succeeded', () => {
|
||||
const original = createLedger(); original.add(intent('create'), {}); frozen(original); original.markDispatch('request');
|
||||
const restored = createLedger(original.getSnapshot());
|
||||
assert.equal(restored.possiblyApplied('request'), true);
|
||||
restored.result('request', 'not-applied', 'permission');
|
||||
assert.equal(restored.possiblyApplied('request'), false);
|
||||
assert.equal(restored.getSnapshot().operations.get('create').phase, 'blocked');
|
||||
assert.throws(() => restored.result('request', 'applied'), /receipt_conflict/);
|
||||
});
|
||||
@@ -0,0 +1,100 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { createLedger } from '../../src/lib/canvas-runtime/ledger.ts';
|
||||
import { createScheduler } from '../../src/lib/canvas-runtime/scheduler.ts';
|
||||
|
||||
const deferred = () => { let resolve, reject; const promise = new Promise((yes, no) => { resolve = yes; reject = no; }); return { promise, resolve, reject }; };
|
||||
const tick = async () => { for (let i = 0; i < 20; i++) await Promise.resolve(); };
|
||||
function setup(overrides = {}, initial) {
|
||||
let ledger = createLedger(initial), time = 1000, next = 0, timerId = 0;
|
||||
const timers = new Map(), calls = [], persisted = [], errors = [];
|
||||
const scheduler = createScheduler({
|
||||
getLedger: () => ledger.getSnapshot(),
|
||||
mutate(reduce) { const draft = createLedger(ledger.getSnapshot()); reduce(draft); ledger = draft; },
|
||||
async persist() { persisted.push(ledger.getSnapshot()); },
|
||||
createId: () => `request-${++next}`,
|
||||
participants: intent => intent.changes.map(change => change.id),
|
||||
compile: (intent, requestId) => ({ canvasIds: intent.changes.map(change => change.id), expectedVersions: Object.fromEntries(intent.changes.map(change => [change.id, 1])), payload: { requestId, operationId: intent.id } }),
|
||||
async submit(request) { calls.push(['submit', request]); return { outcome: 'applied' }; },
|
||||
async query(request) { calls.push(['query', request]); return { outcome: 'applied' }; },
|
||||
complete(request, status) { const draft = createLedger(ledger.getSnapshot()); draft.result(request.id, status.outcome, status.error); ledger = draft; },
|
||||
clock: { now: () => time, setTimer(callback, delay) { const id = ++timerId; timers.set(id, { callback, at: time + delay }); return id; }, clearTimer: id => timers.delete(id) },
|
||||
retryDelay: () => 100,
|
||||
onError: error => errors.push(error), ...overrides,
|
||||
});
|
||||
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(); },
|
||||
timerCount: () => timers.size,
|
||||
};
|
||||
}
|
||||
|
||||
test('freeze and dispatch evidence must be durable before submit, then dependencies wake', async () => {
|
||||
const barrier = deferred(), sent = [], state = setup({ persist: () => barrier.promise, submit: async request => { sent.push(request); return { outcome: 'applied' }; } });
|
||||
state.add('create'); state.add('delete', ['canvas'], ['create']); state.scheduler.start(); await tick();
|
||||
assert.equal(sent.length, 0);
|
||||
const frozen = [...state.ledger().getSnapshot().requests.values()][0];
|
||||
assert.equal(frozen.phase, 'dispatch-marked'); assert.equal(state.scheduler.getClaims().get('canvas'), frozen.id);
|
||||
barrier.resolve(); await state.scheduler.settle();
|
||||
assert.equal(sent.length, 2); assert.equal(state.ledger().getSnapshot().operations.get('delete').phase, 'resolved');
|
||||
assert.equal(state.scheduler.getClaims().size, 0); state.scheduler.stop();
|
||||
});
|
||||
|
||||
test('unknown request holds its canvas; another canvas proceeds; accepted stays on query path', async () => {
|
||||
const calls = []; let queries = 0;
|
||||
const state = setup({
|
||||
async submit(request) { calls.push(['submit', request]); return request.operationIds[0] === 'create' ? { outcome: 'unresolved' } : { outcome: 'applied' }; },
|
||||
async query(request) { calls.push(['query', request]); return { outcome: ++queries === 1 ? 'accepted' : 'applied' }; },
|
||||
});
|
||||
state.add('create'); state.add('same-canvas'); state.add('independent', ['other']); state.scheduler.start(); await state.scheduler.settle();
|
||||
assert.deepEqual(calls.map(([_, request]) => request.operationIds[0]), ['create', 'independent']);
|
||||
assert.equal(state.scheduler.getClaims().size, 1); assert.equal(state.timerCount(), 1);
|
||||
await state.advance(100); assert.equal(calls.at(-1)[0], 'query');
|
||||
assert.equal(state.ledger().getSnapshot().operations.get('create').phase, 'frozen');
|
||||
await state.advance(100);
|
||||
assert.deepEqual(calls.map(([action, request]) => [action, request.operationIds[0]]), [['submit','create'], ['submit','independent'], ['query','create'], ['query','create'], ['submit','same-canvas']]);
|
||||
assert.equal(state.scheduler.getClaims().size, 0); state.scheduler.stop();
|
||||
});
|
||||
|
||||
test('receipt missing after recovery triggers exact retry, never a new identity/body', async () => {
|
||||
const original = setup({ submit: async () => ({ outcome: 'unresolved' }) });
|
||||
original.add('create'); original.scheduler.start(); await original.scheduler.settle();
|
||||
const saved = original.ledger().getSnapshot(), before = saved.requests.get('request-1'); original.scheduler.stop();
|
||||
const calls = [];
|
||||
const restored = setup({ query: async request => { calls.push(['query', request]); return { outcome: 'unresolved', error: 'receipt_unknown' }; }, submit: async request => { calls.push(['submit', request]); return { outcome: 'applied' }; } }, saved);
|
||||
restored.scheduler.start(); await restored.advance(100); await restored.advance(100);
|
||||
assert.deepEqual(calls.map(([action]) => action), ['query', 'submit']);
|
||||
for (const [, request] of calls) { assert.equal(request.id, before.id); assert.equal(request.body, before.body); }
|
||||
assert.equal(restored.ledger().getSnapshot().requests.size, 1); restored.scheduler.stop();
|
||||
});
|
||||
|
||||
test('storage failure never sends and keeps claims; explicit resume retries persistence first', async () => {
|
||||
let broken = true; const sent = [];
|
||||
const state = setup({ persist: async () => { if (broken) throw new Error('quota'); }, submit: async request => { sent.push(request); return { outcome: 'applied' }; } });
|
||||
state.add('create'); state.scheduler.start(); await state.scheduler.settle();
|
||||
assert.equal(sent.length, 0); assert.equal(state.errors[0].message, 'quota'); assert.equal(state.scheduler.getClaims().size, 1);
|
||||
broken = false; await state.scheduler.resume(); await state.scheduler.settle();
|
||||
// Dispatch evidence means query first, even if the failed barrier preceded the network call.
|
||||
assert.equal(state.calls[0][0], 'query'); assert.equal(sent.length, 0); assert.equal(state.scheduler.getClaims().size, 0); state.scheduler.stop();
|
||||
});
|
||||
|
||||
test('multi-canvas claims are atomic and stop fences late results', async () => {
|
||||
const response = deferred(), state = setup({ submit: () => response.promise });
|
||||
state.add('cross', ['a', 'b']); state.add('single', ['b']); state.scheduler.start(); await tick();
|
||||
assert.equal(new Set(state.scheduler.getClaims().values()).size, 1); assert.equal(state.scheduler.getClaims().size, 2);
|
||||
state.scheduler.stop(); response.resolve({ outcome: 'applied' }); await state.scheduler.settle();
|
||||
assert.equal(state.ledger().getSnapshot().requests.get('request-1').outcome, 'unresolved');
|
||||
assert.throws(() => state.scheduler.start(), /scheduler_closed/);
|
||||
});
|
||||
|
||||
test('missing frozen-request interpreter preserves bytes and claims while unrelated work proceeds', async () => {
|
||||
const initial = setup({ submit: async () => ({ outcome: 'unresolved' }) }); initial.add('create'); initial.scheduler.start(); await initial.scheduler.settle(); initial.scheduler.stop();
|
||||
const saved = initial.ledger().getSnapshot(), requests = new Map(saved.requests), old = requests.get('request-1');
|
||||
requests.set(old.id, { ...old, protocolVersion: 99 });
|
||||
const restored = setup({ createId: () => 'other-request' }, { ...saved, requests });
|
||||
restored.add('other', ['other']); restored.scheduler.start(); await restored.scheduler.settle();
|
||||
assert.equal(restored.calls.length, 1); assert.equal(restored.calls[0][1].id, 'other-request');
|
||||
assert.equal(restored.ledger().getSnapshot().requests.get(old.id).body, old.body);
|
||||
assert.equal(restored.ledger().getSnapshot().requests.get(old.id).error, 'request_interpreter_unavailable');
|
||||
assert.equal(restored.scheduler.getClaims().get('canvas'), old.id); restored.scheduler.stop();
|
||||
});
|
||||
Reference in New Issue
Block a user