Files
Agent-Workbench/tests/upgrade-artifacts.test.mjs
2026-10-30 18:58:55 +08:00

77 lines
6.1 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 { createHash } from 'node:crypto';
import { fixture, workspace } from './helpers.mjs';
import { createBrowserProject, browserSteps } from './fixtures/browser-project.mjs';
import { ArtifactStore as LegacyArtifacts } from './fixtures/legacy-artifacts-1.9/artifact-store.mjs';
import { Provider } from '../src/server/provider.mjs';
import { Runtime } from '../src/server/runtime.mjs';
import { createRequestHandler } from '../src/server/app.mjs';
import { installUpgrade } from '../src/server/hot-upgrade.mjs';
import { verifyBrowserJob } from '../src/core/browser/browser-manager.mjs';
async function legacyContext(t) {
const f = createBrowserProject(fixture(t));
const provider = new Provider(); provider.setKey('owned-upgrade-fixture-key');
const runtime = new Runtime(f.store, provider, { appDirectory: workspace });
f.store.artifactStore = new LegacyArtifacts(f.data);
const context = { store: f.store, provider, runtime, server: http.createServer(), token: 'owned-upgrade-token',
clients: new Set(), started: Date.now(), exampleProject: null, shutdown: async () => {}, getPort: () => context.server.address().port };
context.server.on('request', createRequestHandler({ ...context, appDirectory: workspace }));
await new Promise(resolve => context.server.listen(0, '127.0.0.1', resolve));
f.onCleanup(async () => { context.server.closeAllConnections(); await new Promise(resolve => context.server.close(resolve)); });
return { f, context };
}
test('a live SQLite host with the actual 1.9 artifact object upgrades, keeps its original blobs and verifies real browser PNG bytes', { timeout: 30000 }, async t => {
const { f, context } = await legacyContext(t), original = context.store.artifactStore;
const run = f.store.core.run.get(f.session.runId), value = { original: '旧版实际 UTF-8 工件', n: 19 };
const artifact = original.write(f.session, run, value); f.store.core.artifact.set(artifact.id, artifact); f.store.save(f.session);
const bytes = fs.readFileSync(path.join(original.root, artifact.relative));
const beforeSession = structuredClone(f.store.publicSession(f.session));
context.runtime.projectMemories = { context: () => { throw new Error('Old memory context must not survive an upgrade.'); } };
context.runtime.taskCheckpoints = { list: () => { throw new Error('Old checkpoint verifier must not survive an upgrade.'); } };
context.runtime.skills = { view: () => { throw new Error('Old skill registry must not survive an upgrade.'); } };
assert.equal(typeof original.readBytes, 'undefined');
const upgraded = installUpgrade(context, { appDirectory: workspace, updateServiceInfo: false });
assert.equal(upgraded.hasKey, true); assert.equal(context.provider, context.runtime.provider);
assert.deepEqual(f.store.publicSession(f.session), beforeSession);
assert.deepEqual(f.store.artifactStore.readBytes(artifact), bytes);
assert.deepEqual(JSON.parse(f.store.artifactStore.read(artifact)), value);
assert.equal(await context.runtime.memoryManager().context(f.session), null);
const checkpoints = await fetch('http://127.0.0.1:' + context.server.address().port + '/api/sessions/' + f.session.id + '/task-checkpoints',
{ headers: { 'X-Workbench-Token': context.token, Connection: 'close' } });
assert.equal(checkpoints.status, 200); assert.deepEqual(await checkpoints.json(), []);
assert.deepEqual(context.runtime.skillRegistry().view(f.project.id).skills, []);
const planned = await context.runtime.browserManager().plan(f.session, { steps: browserSteps });
const active = await context.runtime.browserManager().start(f.session, planned.id); await active.promise;
assert.equal(active.job.status, 'passed'); assert.equal(active.job.cleanup.exited, true);
const record = verifyBrowserJob(f.store, f.session, active.job); assert.equal(record.assertions.passed, record.assertions.total);
const image = active.job.screenshots[0], stored = f.store.owned('artifact', image.artifactId, f.session.id);
const response = await fetch('http://127.0.0.1:' + context.server.address().port + '/api/sessions/' + f.session.id + '/browser-jobs/' + active.job.id + '/images/' + image.artifactId,
{ headers: { 'X-Workbench-Token': context.token, Connection: 'close' } });
assert.equal(response.status, 200); assert.equal(response.headers.get('content-type'), 'image/png');
const actual = Buffer.from(await response.arrayBuffer());
assert.ok(actual.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])));
assert.equal(createHash('sha256').update(actual).digest('hex'), stored.sha256);
assert.equal(fs.readFileSync(path.join(original.root, artifact.relative)).equals(bytes), true);
});
test('failed upgrade restores the original artifact object, provider and request handler', async t => {
const { f, context } = await legacyContext(t), original = f.store.artifactStore, handlers = context.server.listeners('request');
const runtimeProperties = { appDirectory: context.runtime.appDirectory, browser: context.runtime.browser,
projectMemories: context.runtime.memoryManager(), taskCheckpoints: context.runtime.checkpointManager(), skills: context.runtime.skillRegistry() };
fs.mkdirSync(path.join(f.data, 'service-info.json'));
assert.throws(() => installUpgrade(context, { appDirectory: workspace }));
assert.equal(f.store.artifactStore, original); assert.equal(typeof f.store.artifactStore.readBytes, 'undefined');
assert.deepEqual(context.server.listeners('request'), handlers); assert.equal(context.provider.hasKey(), true);
assert.equal(context.runtime.appDirectory, runtimeProperties.appDirectory); assert.equal(context.runtime.browser, runtimeProperties.browser);
assert.equal(context.runtime.projectMemories, runtimeProperties.projectMemories); assert.equal(context.runtime.taskCheckpoints, runtimeProperties.taskCheckpoints);
assert.equal(context.runtime.skills, runtimeProperties.skills);
const artifact = original.write(f.session, f.store.core.run.get(f.session.runId), { rollback: true });
assert.deepEqual(JSON.parse(original.read(artifact)), { rollback: true });
});