173 lines
14 KiB
JavaScript
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);
|
|
});
|