Files
Agent-Workbench/tests/workspace-policy.test.mjs
2026-10-30 00:22:05 +08:00

165 lines
12 KiB
JavaScript

import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import path from 'node:path';
import { fixture } from './helpers.mjs';
import { createDeliveryProject, deliveryGit, writeDeliveryFile } from './fixtures/delivery-project.mjs';
import { captureWorkspaceSource, assertWorkspaceSource } from './fixtures/workspace-project.mjs';
import { WorkspaceManager } from '../src/core/workspaces/git-workspaces.mjs';
import { Runtime } from '../src/server/runtime.mjs';
import { Provider } from '../src/server/provider.mjs';
import { CheckRunner } from '../src/core/check-runner.mjs';
import { proposeFile } from '../src/server/files.mjs';
test('worktree checkout disables hooks, fsmonitor and all filter command variants while honoring built-in EOL conversion', { timeout: 60000 }, async t => {
const f = fixture(t); createDeliveryProject(f, { ownerChanges: false });
writeDeliveryFile(f, '.gitattributes', '*.mjs filter=full eol=crlf\n*.txt filter=cleanonly\n*.md filter=processonly\npackage.json filter=smudgeonly\n');
writeDeliveryFile(f, 'src/空 格.mjs', 'export const value = 1;\n');
deliveryGit(f, ['add', '--', '.gitattributes', 'src/空 格.mjs']); deliveryGit(f, ['commit', '-m', 'Attributes fixture before command configuration']);
const marker = path.join(f.root, 'commands-executed.txt'), probe = path.join(f.root, 'probe.mjs');
fs.writeFileSync(probe, `import fs from 'node:fs'; fs.appendFileSync(${JSON.stringify(marker)}, 'executed\\n'); process.exit(2);\n`);
const command = 'node ' + "'" + probe.replaceAll('\\', '/').replaceAll("'", "'\\''") + "'";
for (const [driver, variants] of [['full', ['clean', 'smudge', 'process']], ['cleanonly', ['clean']], ['smudgeonly', ['smudge']], ['processonly', ['process']]]) {
for (const variant of variants) deliveryGit(f, ['config', 'filter.' + driver + '.' + variant, command]);
deliveryGit(f, ['config', 'filter.' + driver + '.required', 'true']);
}
deliveryGit(f, ['config', 'core.fsmonitor', command]);
const hooks = path.join(f.projectRoot, '.git', 'custom-hooks'); fs.mkdirSync(hooks);
fs.writeFileSync(path.join(hooks, 'post-checkout'), '#!/bin/sh\n' + command + '\n', { mode: 0o755 });
deliveryGit(f, ['config', 'core.hooksPath', hooks]);
const before = captureWorkspaceSource(f), manager = new WorkspaceManager(f.store), record = await manager.prepare(f.session, 'filters');
await (await manager.start(f.session, record.id, record.fingerprint)).promise;
assert.equal(record.status, 'ready', record.summary); assert.equal(record.observation.contentsVerified, true);
assert.equal(fs.existsSync(marker), false); assertWorkspaceSource(assert, f, before, record.branch);
assert.equal(fs.readFileSync(path.join(record.root, 'src/空 格.mjs'), 'utf8'), 'export const value = 1;\r\n');
});
test('an ignored external file at checkout is observed and never accepted as pristine creation', async t => {
const f = fixture(t); createDeliveryProject(f, { ownerChanges: false });
const manager = new WorkspaceManager(f.store, { faultInjector: (phase, record) => {
if (phase === 'git_finished') { fs.mkdirSync(path.join(record.root, 'dist')); fs.writeFileSync(path.join(record.root, 'dist/owner.txt'), 'Owner ignored addition\n'); }
} });
const record = await manager.prepare(f.session, 'ignored'); await (await manager.start(f.session, record.id, record.fingerprint)).promise;
assert.equal(record.status, 'unknown'); assert.equal(record.observation.clean, false); assert.equal(record.observation.contentsVerified, true);
const verifier = new WorkspaceManager(f.store); await verifier.reconcile(f.session, record.id, record.fingerprint);
assert.equal(record.status, 'unknown'); assert.equal(f.store.projects.length, 1);
await verifier.acknowledge(f.session, record.id, record.fingerprint, record.observation.fingerprint);
assert.equal(fs.readFileSync(path.join(record.root, 'dist/owner.txt'), 'utf8'), 'Owner ignored addition\n');
});
test('outside content hidden by assume-unchanged cannot pass workspace verification and blocks further source execution', async t => {
const f = fixture(t); createDeliveryProject(f);
const manager = new WorkspaceManager(f.store, { faultInjector: (phase, record) => {
if (phase === 'git_finished') {
deliveryGit({ projectRoot: record.root }, ['update-index', '--assume-unchanged', '--', 'src/add.mjs']);
fs.writeFileSync(path.join(record.root, 'src/add.mjs'), 'Owner hidden change\n');
}
} });
const record = await manager.prepare(f.session, 'flags'); await (await manager.start(f.session, record.id, record.fingerprint)).promise;
assert.equal(record.status, 'unknown'); assert.equal(record.observation.contentsVerified, false);
assert.equal(f.store.projects.length, 1);
const runtime = new Runtime(f.store, new Provider()), checks = new CheckRunner(f.store);
assert.throws(() => runtime.start(f.session.id, 'new source task'), /工作区/);
assert.throws(() => proposeFile(f.store, f.session, { path: 'another.txt', content: 'x', reason: 'x' }), /工作区/);
await assert.rejects(checks.plan(f.session), /工作区/);
record.ownerPid = process.pid; f.store.save(f.session);
await assert.rejects(manager.reconcile(f.session, record.id, record.fingerprint), /进程仍在运行/);
record.ownerPid = null; f.store.save(f.session);
await manager.reconcile(f.session, record.id, record.fingerprint);
assert.equal(record.status, 'unknown'); assert.equal(fs.readFileSync(path.join(record.root, 'src/add.mjs'), 'utf8'), 'Owner hidden change\n');
});
test('workspace preparation refuses known shared-repository activity and preserves archived child sessions', async t => {
const f = fixture(t); createDeliveryProject(f, { ownerChanges: false });
let busyProject = null;
const manager = new WorkspaceManager(f.store, { projectBusy: projectId => projectId === busyProject });
const first = await manager.prepare(f.session, 'first'); await (await manager.start(f.session, first.id, first.fingerprint)).promise;
assert.equal(first.status, 'ready', first.summary);
const child = f.store.session(first.childSessionId); child.archived = true; f.store.save(child);
await manager.reconcile(f.session, first.id, first.fingerprint); assert.equal(child.archived, true);
busyProject = first.childProjectId; await assert.rejects(manager.prepare(f.session, 'while-child-busy'), /同仓库/);
assert.equal(f.store.core.workspace.size, 1);
});
function deepSource(f, bytes) {
const prefix = path.join(f.root, '深', 'repo', '.git');
const padding = Math.max(0, bytes - Buffer.byteLength(prefix, 'utf8'));
const root = path.join(f.root, '深' + 'p'.repeat(padding), 'repo');
assert.ok(path.resolve(root).startsWith(path.resolve(f.root) + path.sep));
fs.mkdirSync(root, { recursive: true });
fs.copyFileSync(path.join(f.projectRoot, 'README.md'), path.join(root, 'README.md'));
f.projectRoot = root; f.project = f.store.addProject(root); f.session = f.store.createSession(f.project.id);
createDeliveryProject(f);
}
test('compact checkout identities create in deep Unicode source directories while retaining the human branch name', async t => {
const f = fixture(t); deepSource(f, 142);
const before = captureWorkspaceSource(f), manager = new WorkspaceManager(f.store);
const label = 'x'.repeat(64), record = await manager.prepare(f.session, label);
assert.equal(record.label, label);
assert.ok(path.basename(record.root).length <= 22);
if (process.platform === 'win32') assert.ok(Buffer.byteLength(path.join(record.source.commonDir, 'worktrees', path.basename(record.root)), 'utf8') <= 200);
assert.ok(record.branch.startsWith('workbench/' + 'x'.repeat(32) + '-'));
await (await manager.start(f.session, record.id, record.fingerprint)).promise;
assert.equal(record.status, 'ready', record.summary);
assertWorkspaceSource(assert, f, before, record.branch);
});
test('Windows Git metadata path limits reject creation before publishing a branch or changing source bytes', async t => {
const f = fixture(t); deepSource(f, 180);
const before = captureWorkspaceSource(f), manager = new WorkspaceManager(f.store);
if (process.platform === 'win32') {
await assert.rejects(manager.prepare(f.session, 'deep metadata'), /Git管理目录过长/);
assert.equal(f.store.core.workspace.size, 0);
assertWorkspaceSource(assert, f, before, 'not-created');
} else {
const record = await manager.prepare(f.session, 'deep metadata');
assert.equal(record.creationAttempted, false);
assertWorkspaceSource(assert, f, before, record.branch);
}
});
test('a pending source snapshot participates in shutdown and completes before storage can close', async t => {
const f = fixture(t); createDeliveryProject(f, { ownerChanges: false });
const runtime = new Runtime(f.store, new Provider()), manager = runtime.workspaceManager();
const snapshot = manager.snapshot.bind(manager); let release;
const gate = new Promise(resolve => { release = resolve; });
manager.snapshot = async project => { await gate; return snapshot(project); };
const prepared = manager.prepare(f.session, 'pending snapshot');
assert.equal(runtime.isActive(f.session.id), true); assert.equal(runtime.hasActivity(), true);
let finished = false; const stopped = runtime.stopAll().then(() => { finished = true; });
await new Promise(resolve => setImmediate(resolve)); assert.equal(finished, false);
release(); const plan = await prepared; await stopped;
assert.equal(plan.status, 'prepared'); assert.equal(fs.existsSync(plan.root), false); assert.equal(runtime.hasActivity(), false);
});
test('source configuration values stay private and a configuration change invalidates a saved review', async t => {
const f = fixture(t); createDeliveryProject(f, { ownerChanges: false });
deliveryGit(f, ['config', 'workbench.syntheticcredential', 'QA-CONFIG-VALUE-MUST-NOT-BE-EXPORTED']);
const manager = new WorkspaceManager(f.store), record = await manager.prepare(f.session, 'config identity');
assert.equal(JSON.stringify(record).includes('QA-CONFIG-VALUE-MUST-NOT-BE-EXPORTED'), false);
assert.match(record.source.configuration.common, /^[a-f0-9]{64}$/);
deliveryGit(f, ['config', 'core.autocrlf', 'true']);
await (await manager.start(f.session, record.id, record.fingerprint)).promise;
assert.equal(record.status, 'prepared'); assert.equal(record.creationAttempted, false); assert.equal(fs.existsSync(record.root), false);
});
for (const kind of ['excluded dependency', 'large committed blob', 'case collision', 'committed symbolic link', 'external config include']) {
test('workspace review rejects ' + kind + ' before any checkout', async t => {
const f = fixture(t); createDeliveryProject(f, { ownerChanges: false });
if (kind === 'excluded dependency') { writeDeliveryFile(f, 'node_modules/probe.txt', 'dependency\n'); deliveryGit(f, ['add', '-f', '--', 'node_modules/probe.txt']); }
if (kind === 'large committed blob') { writeDeliveryFile(f, 'large.txt', Buffer.alloc(1024 * 1024 + 1, 65)); deliveryGit(f, ['add', '--', 'large.txt']); }
if (kind === 'case collision' || kind === 'committed symbolic link') {
const blob = deliveryGit(f, ['hash-object', '-w', '--stdin'], 'README.md\n').trim();
if (kind === 'case collision') for (const name of ['Case.txt', 'case.txt']) deliveryGit(f, ['update-index', '--add', '--cacheinfo', '100644', blob, name]);
else deliveryGit(f, ['update-index', '--add', '--cacheinfo', '120000', blob, 'link.txt']);
}
if (kind !== 'external config include') deliveryGit(f, ['commit', '-m', 'Unsupported source shape fixture']);
else { const include = path.join(f.root, 'external.gitconfig'); fs.writeFileSync(include, '[core]\n\tautocrlf = false\n'); deliveryGit(f, ['config', 'include.path', include]); }
const before = captureWorkspaceSource(f), manager = new WorkspaceManager(f.store);
await assert.rejects(manager.prepare(f.session, 'rejected'), /凭据|依赖|上限|大小写|链接|配置包含/);
assert.equal(f.store.core.workspace.size, 0); assert.equal(fs.readdirSync(manager.outputRoot).length, 0);
assertWorkspaceSource(assert, f, before, 'never-created');
});
}