Files
Agent-Workbench/tests/desktop-data-retention.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

175 lines
14 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { createHash, randomUUID } from 'node:crypto';
import { DatabaseSync } from 'node:sqlite';
import { fixture, workspace } from './helpers.mjs';
import { ModelRequestLedger } from '../src/core/models/request-ledger.mjs';
import { StateDatabase } from '../src/core/storage/state-database.mjs';
import { REQUEST_LEDGER_MIGRATION } from '../src/core/storage/request-ledger-schema.mjs';
import { readDataCompatibility, assertDataCompatibility, snapshotPersistentData, verifyPersistentDataTransition } from '../src/core/desktop/data-retention.mjs';
import { InstallationManager } from '../src/core/desktop/install-manager.mjs';
import { writeDataCompatibility } from '../scripts/build-data-compatibility.mjs';
const hash = value => createHash('sha256').update(value).digest('hex');
const compatible = { readWriteSchemas: [1, 2], ledgerMigration: REQUEST_LEDGER_MIGRATION };
const seed = (f, count = 7) => {
const values = Array.from({ length: count }, (_, index) => ({ id: index < 2 ? 'duplicate-legacy-id' : 'legacy-' + index,
connectionId: 'synthetic-connection', sessionId: f.session.id, projectId: f.project.id, taskId: 'synthetic-task', runId: 'synthetic-run',
model: 'synthetic-model', protocol: 'chat-completions', status: ['succeeded', 'failed', 'unknown'][index % 3],
opaqueSource: { index, text: '原文 / 😀' } }));
const raw = JSON.stringify(values, null, 2) + '\n';
f.store.storage.database.prepare('INSERT INTO metadata(key,value) VALUES(?,?)').run('modelAttempts', raw);
return { values, raw };
};
const candidate = (f, name, { legacy = false } = {}) => {
const root = path.join(f.root, 'install/versions', name); fs.mkdirSync(root, { recursive: true });
for (const name of ['dist-client', 'dist-server', 'dist-desktop']) fs.cpSync(path.join(workspace, name), path.join(root, name), { recursive: true });
if (legacy) fs.unlinkSync(path.join(root, 'dist-server/data-compatibility.json'));
for (const name of ['AgentWorkbench.exe', 'runtime/node.exe', 'desktop/AgentWorkbench.exe', 'desktop/resources/app/main.cjs', 'desktop/resources/app/package.json']) {
const file = path.join(root, name); fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, 'declared-static-unit-fixture');
}
const inventory = (directory, prefix = '') => fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
const relative = path.posix.join(prefix, entry.name), file = path.join(directory, entry.name);
return entry.isDirectory() ? inventory(file, relative) : [{ path: relative, bytes: fs.statSync(file).size, sha256: hash(fs.readFileSync(file)) }];
});
fs.writeFileSync(path.join(root, 'MANIFEST.json'), JSON.stringify({ app: 'agent-workbench', kind: 'portable', version: '1.25.12', platform: 'win32-x64', files: inventory(root) }));
return root;
};
const manager = (f, candidateRoot) => {
const instance = new InstallationManager({ installRoot: path.join(f.root, 'install'), dataRoot: f.data, candidateRoot, port: 49996 });
instance.host = async () => null; return instance;
};
for (const count of [0, 7, 107]) test(`exact schema1 migration preserves ${count} ordered legacy entries, original metadata and each artifact/config byte`, t => {
const f = fixture(t, { modernDefaults: true }), { raw } = seed(f, count), before = snapshotPersistentData(f.data);
const ledger = new ModelRequestLedger(f.store.storage), after = snapshotPersistentData(f.data);
const result = verifyPersistentDataTransition(before, after, compatible);
assert.equal(result.kind, 'model-attempt-ledger-v1'); assert.equal(result.legacyEntries, count);
assert.equal(result.originalMetadata.sha256, hash(raw));
assert.equal(f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get().value, raw);
assert.equal(ledger.page().total, count); assert.equal(after.database.userVersion, 2);
assert.deepEqual(after.database.expectedLegacyRows.map(row => row.legacyPosition), Array.from({ length: count }, (_, i) => i));
});
test('fresh empty legacy metadata is not fabricated and absent row migrates without adding a modelAttempts row', t => {
const f = fixture(t, { modernDefaults: true }), before = snapshotPersistentData(f.data);
new ModelRequestLedger(f.store.storage);
const after = snapshotPersistentData(f.data), result = verifyPersistentDataTransition(before, after, compatible);
assert.equal(result.legacyEntries, 0); assert.equal(result.originalMetadata, null);
assert.equal(f.store.storage.database.prepare("SELECT value FROM metadata WHERE key='modelAttempts'").get(), undefined);
});
const corruptions = {
'missing legacy row': db => db.exec('DELETE FROM model_attempts WHERE seq=2'),
'reassigned legacy position': db => db.exec('UPDATE model_attempts SET legacy_position=50 WHERE seq=2'),
'same-length payload edit': db => db.exec("UPDATE model_attempts SET payload=replace(payload,'原文','改文') WHERE seq=2"),
'edited initial bytes with recomputed hash': db => { const raw = db.prepare('SELECT initial_payload FROM model_attempts WHERE seq=2').get().initial_payload.replace('原文', '改文'); db.prepare('UPDATE model_attempts SET initial_payload=?,initial_sha256=? WHERE seq=2').run(raw, hash(raw)); },
'search ownership altered': db => db.exec("UPDATE model_attempts SET task_id='other-owner' WHERE seq=2"),
'new request after migration': db => db.exec("INSERT INTO model_attempts(id,payload,payload_sha256,initial_payload,initial_sha256) VALUES('new','{}','x','{}','x')"),
'unknown marker field': db => db.exec("UPDATE metadata SET value=json_set(value,'$.unknown',true) WHERE key='modelAttemptLedger'"),
'wrong marker original digest': db => db.exec("UPDATE metadata SET value=json_set(value,'$.legacyMetadataSha256','bad') WHERE key='modelAttemptLedger'"),
'extra table': db => db.exec('CREATE TABLE foreign_rows(id TEXT)'),
'extra trigger': db => db.exec('CREATE TRIGGER foreign_trigger AFTER INSERT ON model_attempts BEGIN SELECT 1; END'),
'extra view': db => db.exec('CREATE VIEW foreign_view AS SELECT id FROM model_attempts'),
'changed index definition': db => db.exec('DROP INDEX model_attempts_status; CREATE INDEX model_attempts_status ON model_attempts(model,seq)'),
'wrong schema version': db => db.exec('PRAGMA user_version=3'),
'same-length original metadata edit': db => db.exec("UPDATE metadata SET value=replace(value,'原文','改文') WHERE key='modelAttempts'"),
'old project payload altered': db => db.exec("UPDATE projects SET payload=json_set(payload,'$.name','other-project')"),
'original sequence altered': db => db.exec("UPDATE sqlite_sequence SET seq=seq+1 WHERE name='events'"),
};
for (const [name, corrupt] of Object.entries(corruptions)) test(`exact migration rejects ${name} and never rewrites the conflicting source`, t => {
const f = fixture(t, { modernDefaults: true }); seed(f); const before = snapshotPersistentData(f.data);
new ModelRequestLedger(f.store.storage); corrupt(f.store.storage.database);
const after = snapshotPersistentData(f.data);
assert.throws(() => verifyPersistentDataTransition(before, after, compatible), /迁移|原|schema/);
assert.deepEqual(snapshotPersistentData(f.data), after);
});
test('ledger initializer rollback remains source-bound and a new current outcome cannot be removed', t => {
const f = fixture(t, { modernDefaults: true }); seed(f); const before = snapshotPersistentData(f.data);
const first = new ModelRequestLedger(f.store.storage); assert.equal(first.rollbackInitialization(), true);
assert.deepEqual(snapshotPersistentData(f.data), before);
const ledger = new ModelRequestLedger(f.store.storage), old = ledger.all()[2]; old.status = 'succeeded'; ledger.save(old);
const after = snapshotPersistentData(f.data);
assert.throws(() => ledger.rollbackInitialization(), /已有新记录/); assert.deepEqual(snapshotPersistentData(f.data), after);
});
test('consistent read transaction prevents a second SQLite writer from mixing original rows with later schema/metadata state', t => {
const f = fixture(t, { modernDefaults: true }); seed(f); const before = snapshotPersistentData(f.data);
const writer = new DatabaseSync(path.join(f.data, 'workbench.sqlite'));
const original = DatabaseSync.prototype.prepare; let changed = false;
DatabaseSync.prototype.prepare = function(sql) {
const statement = original.call(this, sql);
if (this !== writer && sql === 'SELECT * FROM "metadata"') {
const read = statement.all.bind(statement);
statement.all = (...args) => {
const rows = read(...args);
writer.exec("UPDATE projects SET payload=json_set(payload,'$.name','concurrent-write')"); changed = true;
return rows;
};
}
return statement;
};
try {
const snapshot = snapshotPersistentData(f.data); assert.equal(changed, true); assert.deepEqual(snapshot, before);
} finally { DatabaseSync.prototype.prepare = original; writer.close(); }
assert.notDeepEqual(snapshotPersistentData(f.data), before);
});
test('candidate compatibility binds actual server/hot-upgrade bytes and unknown/changed declarations are rejected', t => {
const f = fixture(t, { modernDefaults: true }), root = path.join(f.root, 'declaration'); fs.mkdirSync(path.join(root, 'dist-server'), { recursive: true });
assert.deepEqual(readDataCompatibility(root).readWriteSchemas, [1]);
for (const name of ['src/core/models/request-ledger.mjs', 'src/core/storage/state-database.mjs', 'src/core/storage/request-ledger-schema.mjs', 'dist-server/server.mjs', 'dist-server/hot-upgrade.mjs']) {
fs.mkdirSync(path.dirname(path.join(root, name)), { recursive: true }); fs.copyFileSync(path.join(workspace, name), path.join(root, name));
}
const declaration = writeDataCompatibility(root), file = path.join(root, 'dist-server/data-compatibility.json');
assert.deepEqual(readDataCompatibility(root).readWriteSchemas, [1, 2]);
const changed = structuredClone(declaration); changed.ledgerMigration.id = 'unreviewed'; fs.writeFileSync(file, JSON.stringify(changed));
assert.throws(() => readDataCompatibility(root), /迁移身份/);
fs.writeFileSync(file, JSON.stringify(declaration)); fs.appendFileSync(path.join(root, 'dist-server/hot-upgrade.mjs'), '\nchanged');
assert.throws(() => readDataCompatibility(root), /实际处理器/);
const before = snapshotPersistentData(f.data); new ModelRequestLedger(f.store.storage);
assert.doesNotThrow(() => assertDataCompatibility(before, { readWriteSchemas: [1] }));
assert.throws(() => assertDataCompatibility(snapshotPersistentData(f.data), { readWriteSchemas: [1] }), /schema2/);
});
test('actual installer path accepts only the declared exact migration and archives per-legacy hashes in its receipt', async t => {
const f = fixture(t, { modernDefaults: true }); seed(f); const root = candidate(f, 'declared-migration'), m = manager(f, root);
let migrated = false; const phase = m.phase.bind(m);
m.phase = (name, detail) => { phase(name, detail); if (name === 'verify-data' && !migrated) { new ModelRequestLedger(f.store.storage); migrated = true; } };
const result = await m.activate(), receipt = JSON.parse(fs.readFileSync(result.receiptFile));
assert.equal(result.dataVerification.kind, 'model-attempt-ledger-v1'); assert.equal(receipt.dataVerification.legacyRows.length, 7);
assert.equal(receipt.compatibility.declarationSha256, readDataCompatibility(root).declarationSha256);
assert.equal(receipt.state, 'activated');
});
test('installer catches data drift between verification and pointer publication, keeps the original pointer and does not erase the conflicting change', async t => {
const f = fixture(t, { modernDefaults: true }), m = manager(f, candidate(f, 'first'));
await m.activate(); const pointer = fs.readFileSync(m.recordFile); m.candidateRoot = candidate(f, 'second');
await assert.rejects(m.activate({ beforePointer: () => f.store.storage.setMeta('concurrent-change', { id: randomUUID() }) }), /回退尚待核对/);
assert.ok(fs.readFileSync(m.recordFile).equals(pointer)); assert.ok(f.store.storage.meta('concurrent-change'));
assert.equal(JSON.parse(fs.readFileSync(m.receiptFile)).state, 'rollback-unverified');
});
test('schema2 rollback rejects an undeclared schema1 previous payload before pointer changes and a declared recovery payload keeps all new outcomes through fresh open', async t => {
const f = fixture(t, { modernDefaults: true }); seed(f);
const old = candidate(f, 'old-schema1', { legacy: true }), active = candidate(f, 'new-schema2'), recovery = candidate(f, 'schema2-recovery'), m = manager(f, old);
await m.activate(); m.candidateRoot = active;
let migrated = false; const phase = m.phase.bind(m);
m.phase = (name, detail) => { phase(name, detail); if (name === 'verify-data' && !migrated) { new ModelRequestLedger(f.store.storage); migrated = true; } };
await m.activate();
const ledger = new ModelRequestLedger(f.store.storage);
for (const status of ['succeeded', 'failed', 'unknown']) ledger.save({ id: 'post-migration-' + status, model: 'synthetic-model', status, opaque: { status } });
const before = snapshotPersistentData(f.data), pointer = fs.readFileSync(m.recordFile);
await assert.rejects(m.rollback(), /schema2/); assert.ok(fs.readFileSync(m.recordFile).equals(pointer));
assert.deepEqual(snapshotPersistentData(f.data), before);
const result = await m.rollback({ recoveryRoot: recovery }); assert.equal(result.operation, 'rollback');
assert.equal(result.dataVerification.kind, 'unchanged'); assert.deepEqual(snapshotPersistentData(f.data), before);
f.store.storage.close(); f.store.storage = new StateDatabase(f.data);
const reopened = new ModelRequestLedger(f.store.storage); assert.equal(reopened.page().total, 10);
reopened.save({ id: 'post-restart-request', model: 'synthetic-model', status: 'succeeded' });
assert.equal(reopened.page().total, 11); assert.equal(f.store.storage.database.prepare('PRAGMA user_version').get().user_version, 2);
});