Files
Agent-Workbench/tests/change-sets.test.mjs

173 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 { execFileSync } from 'node:child_process';
import { fixture, until } from './helpers.mjs';
import { batchFixture, assertBatchBytes } from './fixtures/change-set-project.mjs';
import { ChangeSetManager } from '../src/core/workspaces/change-sets.mjs';
import { Runtime } from '../src/server/runtime.mjs';
import { Provider } from '../src/server/provider.mjs';
import { CheckRunner } from '../src/core/check-runner.mjs';
import { GitDelivery } from '../src/core/git-delivery.mjs';
import { proposeFile, applyChange } from '../src/server/files.mjs';
import { assertChangeSetsResolved } from '../src/shared/contracts/change-sets.mjs';
test('sealed batches preserve bytes until review, then apply and explicitly restore BOM/CRLF/new files', async t => {
const f = fixture(t), b = batchFixture(f), owner = fs.readFileSync(path.join(f.projectRoot, 'README.md'));
const set = await b.manager.prepare(f.session, b.ids);
assert.equal((await b.manager.prepare(f.session, b.ids)).id, set.id);
assertBatchBytes(assert, f, b.before); assert.equal(fs.existsSync(path.join(f.projectRoot, 'docs')), false);
assert.equal(set.taskId, f.session.taskId); assert.equal(f.store.publicSession(f.session).execution.changeSets.length, 1);
for (let index = 0; index < set.files.length; index++) {
const snapshot = JSON.parse(f.store.artifactStore.read(f.store.owned('artifact', set.files[index].snapshotArtifactId, f.session.id)));
assert.deepEqual(snapshot.before === null ? null : Buffer.from(snapshot.before, 'base64'), b.before[set.files[index].path]);
}
assert.throws(() => applyChange(f.store, f.session, b.ids[0]), /封存/);
const job = await b.manager.start(f.session, set.id, set.fingerprint);
assert.equal((await job.promise).status, 'completed'); assertBatchBytes(assert, f, b.after);
assert.ok(f.session.changes.every(change => change.status === 'applied' && change.changeSetId === set.id));
assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, 'README.md')), owner);
assert.equal((await b.manager.rollback(f.session, set.id, set.fingerprint)).status, 'rolled_back');
assertBatchBytes(assert, f, b.before); assert.ok(f.session.changes.every(change => change.status === 'rolled_back'));
await assert.rejects(b.manager.start(f.session, set.id, set.fingerprint), { status: 409 });
});
test('a conflict in the last file or Git branch prevents writing every file in the batch', async t => {
const f = fixture(t), b = batchFixture(f);
const git = args => execFileSync('git', args, { cwd: f.projectRoot, encoding: 'utf8', windowsHide: true });
git(['init', '-b', 'main']); git(['add', '--', 'README.md', 'src']);
git(['-c', 'user.name=QA', '-c', 'user.email=qa@local.invalid', 'commit', '-m', 'baseline']);
const set = await b.manager.prepare(f.session, b.ids);
fs.mkdirSync(path.join(f.projectRoot, 'docs')); fs.writeFileSync(path.join(f.projectRoot, 'docs/new.md'), 'Owner file');
await assert.rejects(b.manager.start(f.session, set.id, set.fingerprint), /整批/);
assertBatchBytes(assert, f, { ...b.before, 'docs/new.md': Buffer.from('Owner file') }); assert.equal(set.status, 'stale');
b.manager.discard(f.session, set.id, set.fingerprint); fs.unlinkSync(path.join(f.projectRoot, 'docs/new.md'));
const fresh = await b.manager.prepare(f.session, b.ids); git(['switch', '-c', 'owner-branch']);
await assert.rejects(b.manager.start(f.session, fresh.id, fresh.fingerprint), /Git HEAD/); assertBatchBytes(assert, f, b.before);
});
test('duplicate canonical paths, ancestor collisions, links, dependencies and Windows aliases never form a batch', async t => {
const f = fixture(t), b = batchFixture(f);
const alias = proposeFile(f.store, f.session, { path: './src/one.mjs', content: 'alias\n', reason: 'alias' });
await assert.rejects(b.manager.prepare(f.session, [b.ids[0], alias.change_id]), /实际路径/);
const parent = proposeFile(f.store, f.session, { path: 'fresh', content: 'file', reason: 'parent' });
const child = proposeFile(f.store, f.session, { path: 'fresh/nested.md', content: 'child', reason: 'child' });
await assert.rejects(b.manager.prepare(f.session, [parent.change_id, child.change_id]), /子路径/);
fs.symlinkSync(path.join(f.projectRoot, 'src'), path.join(f.projectRoot, 'internal-link'), process.platform === 'win32' ? 'junction' : 'dir');
const linked = proposeFile(f.store, f.session, { path: 'internal-link/one.mjs', content: 'linked', reason: 'link' });
await assert.rejects(b.manager.prepare(f.session, [linked.change_id]), /链接/);
const dependency = proposeFile(f.store, f.session, { path: 'node_modules/owned.txt', content: 'dependency', reason: 'excluded' });
await assert.rejects(b.manager.prepare(f.session, [dependency.change_id]), /普通源码/);
if (process.platform === 'win32') {
assert.throws(() => proposeFile(f.store, f.session, { path: 'src/one.mjs.', content: 'alias', reason: 'windows alias' }), /可读取的项目范围/);
// A proposal retained from an older host must still be refused by batch
// validation even though the current proposal API now rejects it earlier.
const retained = f.session.changes.find(value => value.id === alias.change_id), originalPath = retained.path;
retained.path = 'src/one.mjs.';
try { await assert.rejects(b.manager.prepare(f.session, [retained.id]), /可读取的项目范围/); }
finally { retained.path = originalPath; }
}
assertBatchBytes(assert, f, b.before);
});
test('fingerprints, changed proposals and corrupt snapshot artifacts cannot write or restore any target', async t => {
const f = fixture(t), b = batchFixture(f), set = await b.manager.prepare(f.session, b.ids);
await assert.rejects(b.manager.start(f.session, set.id, '0'.repeat(64)), /指纹/); assertBatchBytes(assert, f, b.before);
f.session.changes[1].content = 'tampered proposal';
await assert.rejects(b.manager.start(f.session, set.id, set.fingerprint), /原提案/); assertBatchBytes(assert, f, b.before);
f.session.changes[1].content = b.after['src/two.mjs'].toString('utf8'); b.manager.discard(f.session, set.id, set.fingerprint);
const fresh = await b.manager.prepare(f.session, b.ids); await (await b.manager.start(f.session, fresh.id, fresh.fingerprint)).promise;
const artifact = f.store.owned('artifact', fresh.files[1].snapshotArtifactId, f.session.id);
fs.writeFileSync(path.join(f.store.artifactStore.root, artifact.relative), 'corrupt snapshot');
await assert.rejects(b.manager.rollback(f.session, fresh.id, fresh.fingerprint), /工件校验/); assertBatchBytes(assert, f, b.after);
});
test('a failure after replacement restores only batch bytes and never retries an old application', async t => {
const f = fixture(t), b = batchFixture(f, { faultInjector: (phase, set, index) => { if (phase === 'replaced' && index === 0) throw new Error('lost result after first replacement'); } });
const set = await b.manager.prepare(f.session, b.ids), result = await (await b.manager.start(f.session, set.id, set.fingerprint)).promise;
assert.equal(result.status, 'rolled_back', result.summary); assertBatchBytes(assert, f, b.before);
await assert.rejects(b.manager.start(f.session, set.id, set.fingerprint), { status: 409 });
});
test('rollback preserves owner edits, blocks other project writers, and explicit acknowledgement releases recovery', async t => {
const f = fixture(t), b = batchFixture(f, { faultInjector: (phase, set, index) => {
if (phase === 'replaced' && index === 1) { fs.writeFileSync(path.join(f.projectRoot, 'src/one.mjs'), 'Owner changed this file\n'); throw new Error('owner edit and lost result'); }
} });
const set = await b.manager.prepare(f.session, b.ids), result = await (await b.manager.start(f.session, set.id, set.fingerprint)).promise;
assert.equal(result.status, 'partial'); assert.equal(result.requiresVerification, true);
assertBatchBytes(assert, f, { ...b.before, 'src/one.mjs': Buffer.from('Owner changed this file\n') });
const runtime = new Runtime(f.store, new Provider()); f.onCleanup(() => runtime.stopAll());
assert.throws(() => runtime.start(f.session.id, '新任务'), /变更集/);
assert.throws(() => proposeFile(f.store, f.session, { path: 'other.md', content: 'no' }), /变更集/);
assert.throws(() => applyChange(f.store, f.session, b.ids[2]), /变更集/);
await assert.rejects(new CheckRunner(f.store).start(f.session, 'unknown'), /变更集/);
await assert.rejects(new GitDelivery(f.store).plan(f.session), /变更集/);
const verified = await b.manager.reconcile(f.session, set.id), oldObservation = verified.observationFingerprint;
fs.writeFileSync(path.join(f.projectRoot, 'src/one.mjs'), 'Owner newer edit\n');
assert.throws(() => b.manager.acknowledge(f.session, set.id, set.fingerprint, oldObservation), /当前文件变化/);
await b.manager.reconcile(f.session, set.id);
const acknowledged = b.manager.acknowledge(f.session, set.id, set.fingerprint, set.observationFingerprint);
assert.equal(acknowledged.status, 'resolved_external'); assert.equal(acknowledged.requiresVerification, false);
assert.doesNotThrow(() => assertChangeSetsResolved(f.store, f.project.id));
assert.equal(f.session.changes[0].status, 'external_preserved'); assert.equal(fs.readFileSync(path.join(f.projectRoot, 'src/one.mjs'), 'utf8'), 'Owner newer edit\n');
});
test('an unattempted owner-created file identical to a suggestion remains external and is never removed', async t => {
const f = fixture(t), b = batchFixture(f, { faultInjector: (phase, set, index) => {
if (phase === 'write_intent' && index === 0) { fs.mkdirSync(path.join(f.projectRoot, 'docs')); fs.writeFileSync(path.join(f.projectRoot, 'docs/new.md'), '# 新文件\n'); throw new Error('not written by this batch'); }
} });
const set = await b.manager.prepare(f.session, b.ids), result = await (await b.manager.start(f.session, set.id, set.fingerprint)).promise;
assert.equal(result.status, 'partial'); assert.equal(result.observations[2].state, 'external');
const restored = await b.manager.rollback(f.session, set.id, set.fingerprint);
assert.equal(restored.status, 'partial'); assertBatchBytes(assert, f, { ...b.before, 'docs/new.md': b.after['docs/new.md'] });
b.manager.acknowledge(f.session, set.id, set.fingerprint, set.observationFingerprint);
assert.equal(fs.readFileSync(path.join(f.projectRoot, 'docs/new.md'), 'utf8'), '# 新文件\n');
});
test('active batch requests are serialized and cancellation leaves a verifiable ended batch', async t => {
const f = fixture(t); let release, entered = false;
const b = batchFixture(f, { faultInjector: async (phase, set, index) => {
if (phase === 'write_intent' && index === 0) { entered = true; await new Promise(resolve => { release = resolve; }); }
} });
const set = await b.manager.prepare(f.session, b.ids), started = await b.manager.start(f.session, set.id, set.fingerprint);
await until(() => entered); await assert.rejects(b.manager.start(f.session, set.id, set.fingerprint), { status: 409 });
await assert.rejects(b.manager.reconcile(f.session, set.id), { status: 409 });
const stopped = b.manager.stop(f.session.id); release(); await stopped;
assert.equal((await started.promise).status, 'rolled_back'); assertBatchBytes(assert, f, b.before); assert.equal(b.manager.projects.size, 0);
});
test('batch application and rollback preserve unrelated Git index and worktree bytes', async t => {
const f = fixture(t), b = batchFixture(f), git = args => execFileSync('git', args, { cwd: f.projectRoot, windowsHide: true, stdio: 'pipe' });
git(['init', '-b', 'main']); git(['add', '--', 'README.md', 'src']); git(['-c', 'user.name=QA', '-c', 'user.email=qa@local.invalid', 'commit', '-m', 'baseline']);
fs.writeFileSync(path.join(f.projectRoot, 'README.md'), 'Owner staged\n'); git(['add', '--', 'README.md']);
fs.writeFileSync(path.join(f.projectRoot, 'README.md'), 'Owner unstaged after staging\n');
const index = fs.readFileSync(path.join(f.projectRoot, '.git/index')), owner = fs.readFileSync(path.join(f.projectRoot, 'README.md'));
const set = await b.manager.prepare(f.session, b.ids); await (await b.manager.start(f.session, set.id, set.fingerprint)).promise;
assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, '.git/index')), index); assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, 'README.md')), owner);
await b.manager.rollback(f.session, set.id, set.fingerprint);
assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, '.git/index')), index); assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, 'README.md')), owner);
assertBatchBytes(assert, f, b.before);
});
test('recovery reuses exact staged bytes but retains a conflicting temporary file for owner inspection', async t => {
const f = fixture(t), b = batchFixture(f), set = await b.manager.prepare(f.session, b.ids);
await (await b.manager.start(f.session, set.id, set.fingerprint)).promise;
const temporary = path.join(f.projectRoot, 'src', '.awb-' + set.id + '-1-rollback.tmp');
fs.writeFileSync(temporary, 'Owner temporary file');
const blocked = await b.manager.rollback(f.session, set.id, set.fingerprint);
assert.equal(blocked.status, 'partial'); assert.equal(fs.readFileSync(temporary, 'utf8'), 'Owner temporary file');
assert.deepEqual(fs.readFileSync(path.join(f.projectRoot, 'src/two.mjs')), b.after['src/two.mjs']);
fs.writeFileSync(temporary, b.before['src/two.mjs']);
const restored = await b.manager.rollback(f.session, set.id, set.fingerprint);
assert.equal(restored.status, 'rolled_back'); assert.equal(fs.existsSync(temporary), false); assertBatchBytes(assert, f, b.before);
});
test('one Task can seal pending proposals from earlier Runs while snapshots retain each source Run', async t => {
const f = fixture(t), b = batchFixture(f), firstRunId = f.session.runId;
const next = f.store.beginRun(f.session, '', true, f.store.config); f.session.status = 'needs_review'; f.store.finishRun(f.session, next);
const set = await b.manager.prepare(f.session, b.ids);
assert.equal(set.runId, next.id); assert.ok(set.files.every(file => file.sourceRunId === firstRunId));
assert.equal((await (await b.manager.start(f.session, set.id, set.fingerprint)).promise).status, 'completed'); assertBatchBytes(assert, f, b.after);
});