193 lines
21 KiB
JavaScript
193 lines
21 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import http from 'node:http';
|
|
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 } from '../src/server/hot-upgrade.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('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));
|
|
});
|