114 lines
8.3 KiB
JavaScript
114 lines
8.3 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import http from 'node:http';
|
|
import { randomUUID } from 'node:crypto';
|
|
import { spawnSync } from 'node:child_process';
|
|
import { fixture, workspace } from './helpers.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { installUpgrade } from '../src/server/hot-upgrade.mjs';
|
|
|
|
function databaseRows(store) {
|
|
const database = store.storage.database;
|
|
return Object.fromEntries(database.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name").all()
|
|
.map(({ name }) => [name, database.prepare('SELECT * FROM "' + name.replaceAll('"', '""') + '" ORDER BY rowid').all()]));
|
|
}
|
|
async function context(t) {
|
|
const f = fixture(t), provider = new Provider(), runtime = new Runtime(f.store, provider, { appDirectory: workspace });
|
|
provider.setKey('owned-controlled-upgrade-fixture'); f.store.claimRuntime();
|
|
const server = http.createServer((_request, response) => response.end('original-owned-handler'));
|
|
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
|
|
f.onCleanup(() => new Promise(resolve => { server.closeAllConnections(); server.close(resolve); }));
|
|
return { ...f, provider, runtime, server, context: { server, store: f.store, provider, runtime,
|
|
clients: new Set(), token: 'owned-controlled-upgrade-token', started: Date.now(), exampleProject: f.project, shutdown: () => {} } };
|
|
}
|
|
function retainedEngineRecord(f, session) {
|
|
// A declared persisted record for migration/read ownership; no native execution is claimed.
|
|
return { id: randomUUID(), schemaVersion: 1, sessionId: session.id, projectId: session.projectId,
|
|
taskId: session.taskId ?? null, runId: session.runId ?? null, status: 'unknown', requiresVerification: true,
|
|
native: null, requests: [], calls: [], startedAt: '2026-01-01T00:00:00.000Z' };
|
|
}
|
|
|
|
test('claiming the same runtime owner twice preserves its original metadata and every database row', t => {
|
|
const f = fixture(t); f.store.claimRuntime();
|
|
const original = f.store.storage.meta('runtimeOwner'); original.startedAt = '2026-01-01T00:00:00.000Z';
|
|
f.store.storage.transaction(() => f.store.storage.setMeta('runtimeOwner', original));
|
|
const before = databaseRows(f.store);
|
|
f.store.claimRuntime(); f.store.claimRuntime();
|
|
assert.deepEqual(f.store.storage.meta('runtimeOwner'), original); assert.deepEqual(databaseRows(f.store), before);
|
|
});
|
|
|
|
test('sessions without controlled-engine history retain their prior export shape and never expose another session record', t => {
|
|
const f = fixture(t), other = f.store.createSession(f.project.id), record = retainedEngineRecord(f, other);
|
|
assert.equal(Object.hasOwn(f.store.executionSnapshot(f.session), 'engineRuns'), false);
|
|
f.store.putRecord('engine_run', other, record, 'fixture.persisted-engine');
|
|
assert.equal(Object.hasOwn(f.store.executionSnapshot(f.session), 'engineRuns'), false);
|
|
assert.deepEqual(f.store.executionSnapshot(other).engineRuns.map(value => value.id), [record.id]);
|
|
});
|
|
|
|
test('live workers, controlled drivers, or MCP operations refuse an upgrade before changing handlers, managers or database rows', async t => {
|
|
const f = await context(t), handlers = f.server.listeners('request'), before = databaseRows(f.store);
|
|
for (const [name, manager] of [['workers', { active: new Map([[f.session.id, {}]]) }],
|
|
['controlledEngines', { drivers: new Map([[f.session.runId, { session: f.session }]]) }],
|
|
['mcp', { active: new Map([[randomUUID(), {}]]) }]]) {
|
|
f.runtime[name] = manager;
|
|
assert.throws(() => installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false }), /active|finish|upgrading/);
|
|
assert.equal(f.runtime[name], manager); assert.deepEqual(f.server.listeners('request'), handlers);
|
|
assert.deepEqual(databaseRows(f.store), before); delete f.runtime[name];
|
|
}
|
|
});
|
|
|
|
test('an idle upgrade loads the newly introduced engine record map, resets obsolete managers and preserves original rows, sessions and provider objects', async t => {
|
|
const f = await context(t), other = f.store.createSession(f.project.id), record = retainedEngineRecord(f, other);
|
|
f.store.putRecord('engine_run', other, record, 'fixture.persisted-engine');
|
|
const before = databaseRows(f.store), exported = f.store.publicSession(f.session), tasks = f.store.core.task,
|
|
provider = f.provider, credentials = provider.credentials;
|
|
delete f.store.core.engine_run;
|
|
f.runtime.workers = { active: new Map() }; f.runtime.controlledEngines = { drivers: new Map() };
|
|
installUpgrade(f.context, { appDirectory: workspace, updateServiceInfo: false });
|
|
assert.equal(f.runtime.workers, null); assert.equal(f.runtime.controlledEngines, null);
|
|
assert.equal(f.store.core.task, tasks); assert.equal(f.store.core.engine_run.size, 1);
|
|
assert.deepEqual(f.store.core.engine_run.get(record.id), record);
|
|
assert.equal(f.context.provider, provider); assert.equal(f.provider.credentials, credentials);
|
|
assert.equal(f.provider.hasKey(), true); assert.deepEqual(f.store.publicSession(f.session), exported);
|
|
assert.deepEqual(databaseRows(f.store), before);
|
|
});
|
|
|
|
test('an installation failure restores old managers, original record maps, handlers and all existing database rows', async t => {
|
|
const f = await context(t), workers = { active: new Map() }, engines = { drivers: new Map() };
|
|
f.runtime.workers = workers; f.runtime.controlledEngines = engines; delete f.store.core.engine_run;
|
|
const core = f.store.core, handlers = f.server.listeners('request'), before = databaseRows(f.store), provider = f.provider;
|
|
fs.mkdirSync(path.join(f.data, 'service-info.json'));
|
|
assert.throws(() => installUpgrade(f.context, { appDirectory: workspace }));
|
|
assert.equal(f.runtime.workers, workers); assert.equal(f.runtime.controlledEngines, engines);
|
|
assert.equal(f.store.core, core); assert.equal(Object.hasOwn(core, 'engine_run'), false);
|
|
assert.equal(f.context.provider, provider); assert.equal(provider.hasKey(), true);
|
|
assert.deepEqual(f.server.listeners('request'), handlers); assert.deepEqual(databaseRows(f.store), before);
|
|
});
|
|
|
|
test('the owned controlled driver remains an active session and project even after outer task activity has ended', t => {
|
|
const f = fixture(t), provider = new Provider(), runtime = new Runtime(f.store, provider), runner = runtime.engineRunner();
|
|
assert.equal(runtime.hasActivity(), false); runner.drivers.set(f.session.runId, { session: f.session });
|
|
assert.equal(runtime.active.size, 0); assert.equal(runtime.hasActivity(), true);
|
|
assert.equal(runtime.isActive(f.session.id), true); assert.equal(runtime.projectHasActivity(f.project.id), true);
|
|
const parentRoot = path.join(f.root, 'parent-project'); fs.mkdirSync(parentRoot);
|
|
const parentProject = f.store.addProject(parentRoot), parent = f.store.createSession(parentProject.id), manager = runtime.workerManager();
|
|
const id = randomUUID(); f.store.core.collaboration.set(id, { id, sessionId: parent.id, projectId: parentProject.id, status: 'paused', children: [{ sessionId: f.session.id }] });
|
|
assert.equal(manager.childActive(f.session.id), true); assert.equal(runtime.isActive(parent.id), true); assert.equal(runtime.projectHasActivity(parentProject.id), true);
|
|
runner.drivers.clear(); assert.equal(runtime.hasActivity(), false); assert.equal(runtime.isActive(f.session.id), false);
|
|
assert.equal(runtime.isActive(parent.id), false); assert.equal(runtime.projectHasActivity(parentProject.id), false);
|
|
});
|
|
|
|
test('release and upgrade help or invalid arguments have no file or network setup side effects in an independent directory', t => {
|
|
const f = fixture(t), before = fs.readdirSync(f.root).sort();
|
|
for (const script of ['package.mjs', 'upgrade-running.mjs']) {
|
|
const help = spawnSync(process.execPath, [path.join(workspace, 'scripts', script), '--help'], { cwd: f.root, encoding: 'utf8', windowsHide: true, timeout: 10000 });
|
|
assert.equal(help.status, 0, help.stderr); assert.match(help.stdout, /node scripts/);
|
|
const invalid = spawnSync(process.execPath, [path.join(workspace, 'scripts', script), '--unknown-owned-argument'], { cwd: f.root, encoding: 'utf8', windowsHide: true, timeout: 10000 });
|
|
assert.notEqual(invalid.status, 0); assert.match(invalid.stderr, /argument|option|Unsupported|Unknown/);
|
|
assert.deepEqual(fs.readdirSync(f.root).sort(), before);
|
|
}
|
|
});
|