77 lines
6.1 KiB
JavaScript
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 });
|
|
});
|