Files
Agent-Workbench/tests/request-ledger.test.mjs
Agent Workbench Dev e306f40cae
Official contracts and Windows source CI / windows-source (push) Has been cancelled
feat(memory): release Mnemo project bridge and schema2 recovery
2026-11-11 03:03:43 +08:00

258 lines
26 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import http from 'node:http';
import fs from 'node:fs';
import path from 'node:path';
import { EventEmitter } from 'node:events';
import { fixture, until, workspace } from './helpers.mjs';
import { Provider } from '../src/server/provider.mjs';
import { Runtime } from '../src/server/runtime.mjs';
import { Store } from '../src/server/store.mjs';
import { createRequestHandler } from '../src/server/app.mjs';
import { ModelRequestLedger, ledgerQuery, streamLedgerExport } from '../src/core/models/request-ledger.mjs';
import { usageSamples, usageModelId, cacheUsageFixture } from './fixtures/cache-usage-model.mjs';
import { historicalAttempts, inspectExport, hash } from './fixtures/request-ledger-data.mjs';
import { StateDatabase as LegacyStateDatabase } from './fixtures/legacy-request-ledger/state-database.mjs';
import { ModelHub } from '../src/core/models/model-hub.mjs';
import { installUpgrade, rollbackUnchangedUpgrade } from '../src/server/hot-upgrade.mjs';
import { HostAuthority } from '../src/core/desktop/host-authority.mjs';
const originalMeta = store => store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get()?.value;
const provider = () => Object.assign(Object.create(Provider.prototype), { apiKey: '' });
const owned = (id, status = 'completed') => ({ id, connectionId: 'owned-alpha', model: 'owned-new', runId: id, status, usageStatus: 'unknown', usage: null, startedAt: '2026-11-07T00:00:00Z' });
class Response extends EventEmitter {
constructor(onWrite = () => {}) { super(); this.chunks = []; this.onWrite = onWrite; }
write(value, callback) { this.chunks.push(value); const writable = this.onWrite(value) !== false; if (writable) queueMicrotask(() => callback?.()); return writable; }
end() { this.writableEnded = true; }
}
test('legacy >1000 entries migrate exactly in both permission modes; metadata is unchanged and lazy normal reads do not load all receipts', t => {
for (const modernDefaults of [true, false]) {
const f = fixture(t, { modernDefaults }), rows = historicalAttempts(); f.store.storage.setMeta('modelAttempts', rows); const original = originalMeta(f.store);
const hub = provider().modelHub(f.store); assert.equal(hub.compatAttempts, undefined);
assert.equal(hub.view().attemptCount, rows.length); assert.equal(hub.view().attempts.length, 100); assert.equal(hub.view().storage.attemptsRetained, null);
assert.equal(hub.compatAttempts, undefined); assert.equal(originalMeta(f.store), original); assert.deepEqual(f.store.storage.meta('modelAttempts'), rows);
assert.equal(hub.ledger.state.legacyMetadataSha256, hash(original));
const result = hub.ledger.page({ limit: 2000 }); assert.deepEqual(result.items, [...rows].reverse()); assert.equal(result.hasMore, false);
assert.equal(result.references.at(-1).legacyIndex, 0); assert.equal(hub.ledger.record(1).initial.sha256, hash(JSON.stringify(rows[0])));
}
});
test('ordinary progress writes only one current receipt, keeps older payload SHA unchanged and rolls back injected commit failures', t => {
const f = fixture(t, { modernDefaults: true }), rows = historicalAttempts(); f.store.storage.setMeta('modelAttempts', rows);
const hub = provider().modelHub(f.store), original = originalMeta(f.store), first = hub.ledger.record(1);
f.store.storage.database.exec('CREATE TEMP TABLE owned_ledger_writes(seq INTEGER,bytes INTEGER); CREATE TEMP TRIGGER owned_ledger_update AFTER UPDATE ON model_attempts BEGIN INSERT INTO owned_ledger_writes VALUES(new.seq,length(new.payload)); END;');
const current = owned('owned-current', 'running'); hub.addAttempt(current); current.status = 'completed'; current.reason = '只改当前记录'; hub.saveAttempts(current);
assert.equal(hub.compatAttempts, undefined); assert.equal(originalMeta(f.store), original); assert.deepEqual(hub.ledger.record(1), first);
const writes = f.store.storage.database.prepare('SELECT * FROM owned_ledger_writes').all(); assert.equal(writes.length, 1); assert.equal(writes[0].seq, 1108);
const final = hub.ledger.record(1108); current.reason = '未提交修改'; f.store.storage.faultInjector = phase => { if (phase === 'before_commit') throw new Error('owned ledger commit failure'); };
assert.throws(() => hub.saveAttempts(current), /owned ledger commit failure/); assert.deepEqual(hub.ledger.record(1108), final);
f.store.storage.faultInjector = null; hub.saveAttempts(current); assert.equal(hub.ledger.record(1108).item.reason, '未提交修改'); assert.equal(hub.ledger.record(1108).initial.item.status, 'running');
assert.equal(f.store.storage.database.prepare('SELECT COUNT(*) AS n FROM owned_ledger_writes').get().n, 2);
});
test('migration failure is atomic, malformed old metadata stays original, duplicate legacy IDs keep separate origins and recovery never replays', t => {
const f = fixture(t, { modernDefaults: true }), rows = [owned('owned-duplicate'), owned('owned-duplicate', 'running')]; f.store.storage.setMeta('modelAttempts', rows); const original = originalMeta(f.store);
f.store.storage.faultInjector = phase => { if (phase === 'before_commit') throw new Error('owned migration failure'); };
assert.throws(() => new ModelRequestLedger(f.store.storage), /owned migration failure/); assert.equal(originalMeta(f.store), original); assert.equal(f.store.storage.meta('modelAttemptLedger'), null);
f.store.storage.faultInjector = null; const hub = provider().modelHub(f.store); assert.equal(hub.view().attemptCount, 2);
assert.equal(hub.ledger.record(2).item.status, 'unknown'); assert.deepEqual(hub.ledger.record(2).initial.item, rows[1]); assert.equal(originalMeta(f.store), original);
assert.throws(() => hub.ledger.find('owned-duplicate'), /不唯一/); assert.equal(new ModelRequestLedger(f.store.storage).page().total, 2);
const broken = fixture(t, { modernDefaults: true }); broken.store.storage.setMeta('modelAttempts', [null]); const raw = originalMeta(broken.store);
assert.throws(() => provider().modelHub(broken.store), /完整迁移/); assert.equal(originalMeta(broken.store), raw); assert.equal(broken.store.storage.meta('modelAttemptLedger'), null);
});
test('keyset pages include every old entry once despite new arrivals and cursor scope, numeric boundaries and literal searches are validated', t => {
const f = fixture(t, { modernDefaults: true }), rows = historicalAttempts(); f.store.storage.setMeta('modelAttempts', rows); const ledger = new ModelRequestLedger(f.store.storage);
let page = ledger.page({ limit: 65 }), collected = [...page.items]; ledger.save(owned('owned-late-arrival'));
while (page.hasMore) { page = ledger.page({ cursor: page.nextCursor, limit: 65 }); collected.push(...page.items); }
assert.deepEqual(collected, [...rows].reverse()); assert.equal(page.total, rows.length); assert.equal(page.retainedTotal, rows.length + 1); assert.equal(ledger.page().items[0].id, 'owned-late-arrival');
const filtered = ledger.page({ filters: { connectionId: 'owned-beta', status: 'failed' }, limit: 1 });
assert.throws(() => ledger.page({ cursor: filtered.nextCursor, filters: { connectionId: 'owned-alpha', status: 'failed' } }), /当前筛选/);
const other = new ModelRequestLedger(fixture(t, { modernDefaults: true }).store.storage); assert.throws(() => other.page({ cursor: filtered.nextCursor, filters: { connectionId: 'owned-beta', status: 'failed' } }), /当前筛选/);
for (const limit of [0, -1, '1.5', 'Infinity', Number.MAX_SAFE_INTEGER + 1]) assert.throws(() => ledger.page({ limit }), /正整数/);
assert.equal(ledger.page({ limit: Number.MAX_SAFE_INTEGER }).items.length, 1108);
ledger.save({ ...owned('owned-literal'), reason: '仅这条记录有 100%_literal' }); assert.equal(ledger.page({ filters: { query: '100%_literal' } }).total, 1);
assert.equal(ledger.page({ filters: { query: "' OR 1=1 --" } }).total, 0);
assert.throws(() => ledgerQuery(new URL('http://localhost/?limit=1&limit=2')), /参数/); assert.throws(() => ledgerQuery(new URL('http://localhost/?cursor=bad'), { exportOnly: true }), /参数/);
});
test('record source checks reject reassignment and corrupted payload while initial and historical receipts remain intact', t => {
const f = fixture(t, { modernDefaults: true }), ledger = new ModelRequestLedger(f.store.storage), value = owned('owned-provenance'); ledger.save(value);
for (const key of ['id', 'connectionId', 'poolId', 'sessionId', 'taskId', 'runId', 'projectId', 'requestId', 'model', 'protocol']) {
const changed = { ...value, [key]: 'owned-wrong' };
if (key === 'id') continue; assert.throws(() => ledger.save(changed), /不能移动/);
}
const before = ledger.record(1); f.store.storage.database.prepare('UPDATE model_attempts SET payload=? WHERE seq=1').run(JSON.stringify({ ...value, reason: 'external corrupt payload' }));
assert.throws(() => ledger.record(1), /SHA256/); assert.throws(() => ledger.page(), /SHA256/);
assert.throws(() => f.store.storage.meta('modelAttempts'), /SHA256/);
f.store.storage.database.prepare('UPDATE model_attempts SET payload=? WHERE seq=1').run(JSON.stringify(value)); assert.deepEqual(ledger.record(1), before);
});
test('versioned migration prevents a previous storage program from silently opening a partial ledger; only untouched initialization can roll back', t => {
const f = fixture(t, { modernDefaults: true }), rows = historicalAttempts(7); f.store.storage.setMeta('modelAttempts', rows); const original = originalMeta(f.store);
assert.equal(f.store.storage.database.prepare('PRAGMA user_version').get().user_version, 1);
assert.equal(f.store.storageInfo().schemaVersion, 1);
const ledger = new ModelRequestLedger(f.store.storage); assert.equal(f.store.storage.database.prepare('PRAGMA user_version').get().user_version, 2);
assert.equal(f.store.storageInfo().schemaVersion, 2);
assert.throws(() => new LegacyStateDatabase(f.data), /更新版本/); assert.equal(ledger.page().total, rows.length);
assert.equal(ledger.rollbackInitialization(), true); assert.equal(originalMeta(f.store), original);
assert.equal(f.store.storageInfo().schemaVersion, 1);
const prior = new LegacyStateDatabase(f.data); f.onCleanup(() => prior.close()); assert.deepEqual(prior.meta('modelAttempts'), rows);
const active = new ModelRequestLedger(f.store.storage); active.save(owned('owned-after-migration'));
assert.throws(() => active.rollbackInitialization(), /已有新记录/); assert.equal(active.page().total, 8); assert.equal(originalMeta(f.store), original);
});
test('a stale cached receipt cannot overwrite another writer; unchanged progress is a read-only no-op and the full compatibility view stays current', t => {
const f = fixture(t, { modernDefaults: true }), hub = provider().modelHub(f.store), current = owned('owned-cache-current', 'running'); hub.addAttempt(current);
assert.equal(hub.attempts[0].status, 'running'); current.status = 'completed'; hub.saveAttempts(current); assert.equal(hub.attempts[0].status, 'completed');
f.store.storage.faultInjector = phase => { if (phase === 'before_commit') throw new Error('unchanged receipts must not commit'); };
assert.doesNotThrow(() => hub.saveAttempts(current)); f.store.storage.faultInjector = null;
hub.ledger.save({ ...current, reason: 'owned concurrent progress' }); current.reason = 'stale overwritten progress';
assert.throws(() => hub.saveAttempts(current), /已更新/); assert.equal(hub.ledger.record(1).item.reason, 'owned concurrent progress');
});
async function retainedLegacy(t) {
const f = fixture(t, { modernDefaults: true }); f.store.storage.close(); f.store.storage = new LegacyStateDatabase(f.data);
const rows = historicalAttempts(107); f.store.storage.setMeta('modelAttempts', rows); const actual = new Provider(), runtime = new Runtime(f.store, actual);
actual.credentials = new Map();
const hub = Object.assign(Object.create(ModelHub.prototype), { store: f.store, provider: actual,
state: { schema: 1, revision: 0, selected: { type: 'legacy', id: 'legacy-default' }, connections: [], pools: [], imports: {} },
health: new Map(), leases: new Map(), cursors: new Map(), sticky: new Map(), waiting: 0 });
Object.defineProperty(hub, 'attempts', { value: structuredClone(rows), writable: true, configurable: true, enumerable: true }); actual.hub = hub;
const originalHandler = (_request, response) => response.end('owned previous handler'), server = http.createServer(originalHandler);
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); f.onCleanup(() => runtime.stopAll());
f.onCleanup(() => new Promise(resolve => { server.closeAllConnections(); server.close(resolve); }));
return { ...f, hub, rows, server, actual, originalHandler, context: { store: f.store, server, provider: actual, runtime, token: 'owned-legacy-ledger-token', clients: new Set(), started: Date.now() } };
}
test('retained legacy hub shape adopts the new ledger on the same previous source storage connection, keeping saved bytes and credential objects', async t => {
const f = await retainedLegacy(t), storage = f.store.storage, database = storage.database, original = originalMeta(f.store), credentials = f.actual.credentials;
installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false });
assert.equal(f.store.storage, storage); assert.equal(storage.database, database); assert.equal(f.actual.hub, f.hub); assert.equal(f.actual.credentials, credentials);
assert.equal(Object.hasOwn(f.hub, 'attempts'), false); assert.equal(f.hub.view().attemptCount, 107); assert.equal(originalMeta(f.store), original);
assert.equal(database.prepare('PRAGMA user_version').get().user_version, 2); assert.deepEqual(storage.meta('modelAttempts'), f.rows);
});
test('failed retained handler adoption restores the original storage prototype, ledger shape, handler, schema and exact original metadata', async t => {
const f = await retainedLegacy(t), storage = f.store.storage, prototype = Object.getPrototypeOf(storage), attempts = f.hub.attempts, original = originalMeta(f.store);
const on = f.server.on; let failed = false; t.mock.method(f.server, 'on', function(event, handler) {
if (event === 'request' && !failed) { failed = true; throw new Error('owned failure after ledger adoption'); } return on.call(this, event, handler);
});
assert.throws(() => installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false }), /owned failure after ledger adoption/);
assert.equal(Object.getPrototypeOf(storage), prototype); assert.equal(f.store.storage, storage); assert.equal(f.hub.attempts, attempts); assert.equal(f.hub.ledger, undefined);
assert.equal(f.server.listeners('request')[0], f.originalHandler); assert.equal(storage.database.prepare('PRAGMA user_version').get().user_version, 1);
assert.equal(originalMeta(f.store), original); assert.equal(storage.meta('modelAttemptLedger'), null);
assert.equal(storage.database.prepare("SELECT COUNT(*) AS n FROM sqlite_schema WHERE name='model_attempts'").get().n, 0);
});
test('source-bound untouched hot adoption restores the exact legacy shape while new outcomes refuse schema downgrade or handler rollback', async t => {
const f = await retainedLegacy(t), storage = f.store.storage, prototype = Object.getPrototypeOf(storage), attempts = f.hub.attempts, original = originalMeta(f.store);
const credentials = f.actual.credentials;
installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false });
assert.throws(() => rollbackUnchangedUpgrade(f.context, { appDirectory: f.root }), /source-bound/);
assert.equal(rollbackUnchangedUpgrade(f.context, { appDirectory: workspace }).restored, true);
assert.equal(Object.getPrototypeOf(storage), prototype); assert.equal(f.hub.attempts, attempts); assert.equal(Object.hasOwn(f.hub, 'attempts'), true);
assert.equal(f.hub.ledger, undefined); assert.equal(originalMeta(f.store), original); assert.equal(f.actual.credentials, credentials);
assert.equal(storage.database.prepare('PRAGMA user_version').get().user_version, 1); assert.equal(f.server.listeners('request')[0], f.originalHandler);
installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false });
f.hub.ledger.save(owned('new-post-adoption-result'));
const handler = f.server.listeners('request')[0];
assert.throws(() => rollbackUnchangedUpgrade(f.context, { appDirectory: workspace }), /已有新记录/);
assert.equal(f.server.listeners('request')[0], handler); assert.equal(f.hub.ledger.page().total, 108);
assert.equal(storage.database.prepare('PRAGMA user_version').get().user_version, 2); assert.equal(originalMeta(f.store), original);
});
async function retainedRegisteredLegacy(t) {
const f = await retainedLegacy(t), oldRoot = path.join(f.root, 'previous-program'); fs.mkdirSync(oldRoot);
for (const directory of ['dist-client', 'dist-server']) fs.cpSync(path.join(workspace, directory), path.join(oldRoot, directory), { recursive: true });
fs.copyFileSync(path.join(workspace, 'package.json'), path.join(oldRoot, 'package.json'));
f.context.runtime.appDirectory = oldRoot;
const authority = new HostAuthority({ ...f.context, appDirectory: oldRoot });
f.server.workbenchHostAuthority = authority;
const identity = authority.identity(), infoFile = path.join(f.data, 'service-info.json');
// Legal original formatting must also survive; reserializing is insufficient.
fs.appendFileSync(infoFile, '\n ');
return { ...f, authority, identity, infoFile, info: fs.readFileSync(infoFile),
registration: fs.readFileSync(path.join(f.data, '.secrets/host-authority-v1.json')) };
}
test('untouched adoption restores actual registered authority and exact public index together, retaining original registration and results', async t => {
const f = await retainedRegisteredLegacy(t), results = { original: 'retained runtime results' }; f.context.runtime.results = results;
installUpgrade(f.context, { appDirectory: workspace });
const published = JSON.parse(fs.readFileSync(f.infoFile));
assert.equal(published.runtimeRoot, fs.realpathSync.native(workspace));
assert.notEqual(published.runtimeRoot, f.identity.runtimeRoot);
assert.equal(f.authority.identity().runtimeRoot, published.runtimeRoot);
assert.equal(rollbackUnchangedUpgrade(f.context, { appDirectory: workspace }).restored, true);
assert.equal(f.server.workbenchHostAuthority, f.authority);
assert.deepEqual(f.authority.identity(), f.identity);
assert.ok(fs.readFileSync(f.infoFile).equals(f.info));
assert.ok(fs.readFileSync(path.join(f.data, '.secrets/host-authority-v1.json')).equals(f.registration));
assert.equal(f.context.runtime.results, results);
assert.equal(f.store.storage.database.prepare('PRAGMA user_version').get().user_version, 1);
assert.equal(f.server.listeners('request')[0], f.originalHandler);
});
test('external public index drift refuses untouched rollback before removing the ledger or replacing the current handler', async t => {
const f = await retainedRegisteredLegacy(t);
installUpgrade(f.context, { appDirectory: workspace });
const handler = f.server.listeners('request')[0], published = fs.readFileSync(f.infoFile);
const external = Buffer.from(published.toString('utf8') + '\n '); fs.writeFileSync(f.infoFile, external);
assert.throws(() => rollbackUnchangedUpgrade(f.context, { appDirectory: workspace }), /host index changed outside this adoption/);
assert.ok(fs.readFileSync(f.infoFile).equals(external));
assert.equal(f.server.listeners('request')[0], handler);
assert.equal(f.context.runtime.appDirectory, fs.realpathSync.native(workspace));
assert.equal(f.store.storage.database.prepare('PRAGMA user_version').get().user_version, 2);
assert.equal(f.hub.ledger.page().total, f.rows.length);
assert.ok(fs.readFileSync(path.join(f.data, '.secrets/host-authority-v1.json')).equals(f.registration));
});
test('full export holds a read snapshot while live rows change, keeps all raw fields and ends with complete count and byte checksum', async t => {
const f = fixture(t, { modernDefaults: true }), rows = historicalAttempts(); f.store.storage.setMeta('modelAttempts', rows); const ledger = new ModelRequestLedger(f.store.storage);
const snapshot = ledger.exportSnapshot(), response = new Response(line => { if (JSON.parse(line).type === 'header') { ledger.save({ ...rows[500], reason: 'export-time change' }); ledger.save(owned('owned-during-export')); } });
await streamLedgerExport(response, snapshot); const result = inspectExport(response.chunks.join(''));
assert.equal(result.records.length, 1107); assert.deepEqual(result.records.map(value => value.item), rows); assert.equal(ledger.page().retainedTotal, 1108);
const filtered = new Response(); await streamLedgerExport(filtered, ledger.exportSnapshot({ connectionId: 'owned-beta', status: 'failed' }));
assert.deepEqual(inspectExport(filtered.chunks.join('')).records.map(value => value.item), rows.filter(value => value.connectionId === 'owned-beta' && value.status === 'failed'));
});
test('cancelled export releases its snapshot and partial bytes never acquire a complete footer or cause requests', async t => {
const f = fixture(t, { modernDefaults: true }), ledger = new ModelRequestLedger(f.store.storage); ledger.save(owned('owned-partial-export'));
const response = new Response(() => false), snapshot = ledger.exportSnapshot(); let closed = false; const close = snapshot.close;
snapshot.close = () => { closed = true; close(); }; const exporting = streamLedgerExport(response, snapshot);
response.destroyed = true; response.emit('close'); await assert.rejects(exporting, /被中断/); assert.equal(closed, true); assert.doesNotMatch(response.chunks.join(''), /"complete":true/);
const complete = new Response(); await streamLedgerExport(complete, ledger.exportSnapshot()); assert.equal(inspectExport(complete.chunks.join('')).records.length, 1);
});
for (const [name, sample] of Object.entries(usageSamples)) test(`actual ${name} request uses incremental ledger, retains source-bound usage and original artifact, and restart never dispatches again`, async t => {
const f = fixture(t, { modernDefaults: true }), model = await cacheUsageFixture(t, { ...sample, streaming: true }), actual = new Provider(), hub = actual.modelHub(f.store);
const connection = hub.upsert({ name: 'Owned incremental ' + name, model: usageModelId, protocol: sample.protocol, baseUrl: model.baseUrl, streaming: true, requiresKey: false }); hub.select({ type: 'connection', id: connection.id });
const runtime = new Runtime(f.store, actual); f.onCleanup(() => runtime.stopAll());
runtime.start(f.session.id, '只说明已收到完整回复,不运行工具。'); await until(() => !runtime.isActive(f.session.id), 15000);
assert.equal(model.requests.length, 1); assert.equal(f.store.core.tool.size, 0); assert.equal(hub.compatAttempts, undefined);
const receipt = hub.ledger.record(1); assert.equal(receipt.item.status, 'completed'); assert.deepEqual(receipt.item.usage.raw, sample.raw);
assert.equal(receipt.item.usage.tokenAccounting.metrics.cacheWrite.tokens, name === 'chat' ? 300 : name === 'responses' ? 7000 : 248);
const artifact = f.store.owned('artifact', receipt.item.responseArtifactId, f.session.id); assert.equal(artifact.sha256, hash(model.responses[0]));
assert.equal(f.store.storage.meta('modelAttempts')[0].id, receipt.item.id); await runtime.stopAll(); f.store.close();
const restored = new Store(f.data); f.onCleanup(() => restored.close()); const fresh = provider().modelHub(restored); assert.deepEqual(fresh.ledger.record(1), receipt); assert.equal(model.requests.length, 1);
});
test('actual authenticated local HTTP pages and exports the entire ledger with source details, invalid query/origin and no model execution', async t => {
const f = fixture(t, { modernDefaults: true }), rows = historicalAttempts(), actual = new Provider(); f.store.storage.setMeta('modelAttempts', rows);
const runtime = new Runtime(f.store, actual), token = 'owned-ledger-token', server = http.createServer(); f.onCleanup(() => runtime.stopAll());
server.on('request', createRequestHandler({ appDirectory: workspace, server, store: f.store, provider: actual, runtime, token, clients: new Set(), started: Date.now(), getPort: () => server.address().port }));
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); f.onCleanup(() => new Promise(resolve => { server.closeAllConnections(); server.close(resolve); }));
const base = 'http://127.0.0.1:' + server.address().port, fetchOwned = route => fetch(base + '/api/model-center' + route, { signal: AbortSignal.timeout(8000), headers: { 'X-Workbench-Token': token, Connection: 'close' } });
console.log('[request-ledger-http] reading first page');
const page = await (await fetchOwned('/attempts?limit=65')).json(); assert.equal(page.items.length, 65); assert.equal(page.total, 1107);
console.log('[request-ledger-http] reading first source record');
const record = await (await fetchOwned('/attempts/1')).json(); assert.deepEqual(record.item, rows[0]); assert.equal(record.reference.payloadSha256, hash(JSON.stringify(rows[0])));
console.log('[request-ledger-http] starting complete export');
const response = await fetchOwned('/attempts/export'); assert.equal(response.status, 200); assert.match(response.headers.get('content-type'), /ndjson/);
assert.deepEqual(inspectExport(Buffer.from(await response.arrayBuffer())).records.map(value => value.item), rows);
console.log('[request-ledger-http] complete export received, checking invalid requests');
assert.equal((await fetchOwned('/attempts?limit=0')).status, 400); assert.equal((await fetchOwned('/attempts/999999')).status, 404);
const blocked = await fetch(base + '/api/model-center/attempts', { signal: AbortSignal.timeout(8000), headers: { Origin: 'https://owned-untrusted.example', 'X-Workbench-Token': token, Connection: 'close' } }); assert.equal(blocked.status, 403);
assert.equal(actual.activeRequests ?? 0, 0); assert.equal(runtime.active.size, 0); assert.equal(originalMeta(f.store), JSON.stringify(rows));
});