Files
Agent-Workbench/docs/messages-m-evidence/source-bytes/tests/desktop-install.test.mjs
T

91 lines
8.2 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import net from 'node:net';
import { createHash } from 'node:crypto';
import { fixture, workspace } from './helpers.mjs';
import { InstallationManager, validateInstalledVersion, snapshotPersistentData } from '../src/core/desktop/install-manager.mjs';
import { inspectHostInstallation } from '../src/core/desktop/app-installation.mjs';
const hash = value => createHash('sha256').update(value).digest('hex');
function candidate(f, name = 'owned-a', bootstrapBytes = 'declared-static-unit-fixture') {
const root = path.join(f.root, 'install', 'versions', name); fs.mkdirSync(root, { recursive: true });
for (const directory of ['dist-client', 'dist-server', 'dist-desktop']) fs.cpSync(path.join(workspace, directory), path.join(root, directory), { recursive: true });
for (const file of ['AgentWorkbench.exe', 'runtime/node.exe', 'desktop/AgentWorkbench.exe', 'desktop/resources/app/main.cjs', 'desktop/resources/app/package.json']) { fs.mkdirSync(path.dirname(path.join(root, file)), { recursive: true }); fs.writeFileSync(path.join(root, file), 'declared-static-unit-fixture'); }
fs.writeFileSync(path.join(root, 'AgentWorkbench.exe'), bootstrapBytes);
const walk = (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() ? walk(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: JSON.parse(fs.readFileSync(path.join(workspace, 'package.json'))).version, platform: 'win32-x64', files: walk(root) }));
return root;
}
const manager = (f, root) => new InstallationManager({ installRoot: path.join(f.root, 'install'), dataRoot: f.data, candidateRoot: root, port: 49999 });
test('full candidate validation returns the exact loaded-input host identity and rejects undeclared or altered files', t => {
const f = fixture(t), root = candidate(f);
assert.deepEqual(validateInstalledVersion(root), inspectHostInstallation(root));
fs.writeFileSync(path.join(root, 'extra.txt'), 'unknown'); assert.throws(() => validateInstalledVersion(root)); fs.unlinkSync(path.join(root, 'extra.txt'));
fs.appendFileSync(path.join(root, 'dist-server/server.mjs'), '\nchanged'); assert.throws(() => validateInstalledVersion(root));
});
test('installation requires separate absolute program/data directories and a candidate in its own versions namespace', t => {
const f = fixture(t), root = candidate(f);
assert.throws(() => new InstallationManager({ installRoot: f.root, dataRoot: f.data }));
assert.throws(() => new InstallationManager({ installRoot: 'relative', dataRoot: f.data }));
const m = manager(f, root); m.candidateRoot = f.projectRoot; assert.throws(() => m.candidate());
});
test('staging retains the original data and pointer without querying or restarting a host', async t => {
const f = fixture(t), root = candidate(f), m = manager(f, root), before = snapshotPersistentData(f.data);
m.host = () => { throw Error('Staging must not contact the host'); };
const result = await m.activate({ stageOnly: true }); assert.equal(result.activated, false); assert.equal(m.current(), null); assert.deepEqual(snapshotPersistentData(f.data), before);
});
test('a post-pointer failure restores every original pointer byte and persistent row; a first-install failure removes only its published pointer', async t => {
const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null;
await assert.rejects(m.activate({ afterPointer: () => { throw Error('owned-first-failure'); } }), /owned-first-failure/); assert.equal(m.current(), null);
await m.activate(); const pointer = fs.readFileSync(m.recordFile), before = snapshotPersistentData(f.data);
m.candidateRoot = candidate(f, 'owned-b');
await assert.rejects(m.activate({ afterPointer: () => { throw Error('owned-post-pointer-failure'); } }), /owned-post-pointer-failure/);
assert.deepEqual(fs.readFileSync(m.recordFile), pointer); assert.deepEqual(snapshotPersistentData(f.data), before);
});
test('changed active manifest and concurrent pointer changes are rejected without overwriting the unknown record', async t => {
const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null; await m.activate();
fs.appendFileSync(path.join(root, 'MANIFEST.json'), ' '); assert.throws(() => m.current());
});
test('an unregistered non-HTTP listener blocks preflight even when service-info is absent', async t => {
const f = fixture(t), root = candidate(f), server = net.createServer(socket => socket.on('error', () => {}));
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)); f.onCleanup(() => new Promise(resolve => server.close(resolve)));
const m = new InstallationManager({ installRoot: path.join(f.root, 'install'), dataRoot: f.data, candidateRoot: root, port: server.address().port });
await assert.rejects(m.preflight(), /端口/); assert.equal(m.current(), null);
});
test('uninstall archives its original pointer and preserves every data row/artifact instead of recursively deleting data', async t => {
const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null;
await m.activate(); const before = snapshotPersistentData(f.data), pointer = fs.readFileSync(m.recordFile);
const result = await m.prepareUninstall(); assert.equal(result.dataPolicy, 'preserve-original-data'); assert.equal(m.current(), null); assert.deepEqual(snapshotPersistentData(f.data), before);
const archive = fs.readdirSync(m.stateRoot).find(name => name.startsWith('uninstalled-')); assert.deepEqual(fs.readFileSync(path.join(m.stateRoot, archive)), pointer);
});
test('preflight rejects an unrelated program root or changed native bootstrap while preserving its original bytes', async t => {
const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null;
const unknown = path.join(m.installRoot, 'unrelated.exe'); fs.writeFileSync(unknown, 'owned-unknown-original');
await assert.rejects(m.preflight(), /未登记/); assert.equal(fs.readFileSync(unknown, 'utf8'), 'owned-unknown-original'); fs.unlinkSync(unknown);
const launcher = path.join(m.installRoot, 'AgentWorkbench.exe'); fs.writeFileSync(launcher, 'owned-altered-bootstrap');
await assert.rejects(m.preflight(), /启动器/); assert.equal(fs.readFileSync(launcher, 'utf8'), 'owned-altered-bootstrap');
});
test('a changed owned bootstrap follows its candidate and a post-pointer fault restores both original bytes', async t => {
const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null;
await m.activate(); const launcher = path.join(m.installRoot, 'AgentWorkbench.exe'), original = fs.readFileSync(launcher), pointer = fs.readFileSync(m.recordFile);
m.candidateRoot = candidate(f, 'owned-bootstrap-b', 'owned-new-native-bootstrap');
await assert.rejects(m.activate({ afterPointer: () => { assert.equal(fs.readFileSync(launcher, 'utf8'), 'owned-new-native-bootstrap'); throw Error('owned-bootstrap-published-fault'); } }), /owned-bootstrap-published-fault/);
assert.deepEqual(fs.readFileSync(launcher), original); assert.deepEqual(fs.readFileSync(m.recordFile), pointer); await m.preflight();
await m.activate(); assert.equal(fs.readFileSync(launcher, 'utf8'), 'owned-new-native-bootstrap'); await m.preflight();
});
test('an external bootstrap change after preflight is preserved and never overwritten as an update or rollback', async t => {
const f = fixture(t), root = candidate(f), m = manager(f, root); m.host = async () => null; await m.activate();
const launcher = path.join(m.installRoot, 'AgentWorkbench.exe'), pointer = fs.readFileSync(m.recordFile);
m.candidateRoot = candidate(f, 'owned-bootstrap-b', 'owned-new-native-bootstrap');
await assert.rejects(m.activate({ beforePointer: () => fs.writeFileSync(launcher, 'owned-external-bootstrap') }), /回退尚待核对/);
assert.equal(fs.readFileSync(launcher, 'utf8'), 'owned-external-bootstrap'); assert.deepEqual(fs.readFileSync(m.recordFile), pointer);
});