173 lines
15 KiB
JavaScript
173 lines
15 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { randomUUID } from 'node:crypto';
|
|
import { fixture, compatibleFixture, call, completion, assertToolPairs } from './helpers.mjs';
|
|
import { beginPlanTask, completeRead } from './fixtures/task-plan-fixture.mjs';
|
|
import { RequirementReview } from '../src/core/tasks/requirement-review.mjs';
|
|
import { TaskPlanManager } from '../src/core/tasks/task-plan-manager.mjs';
|
|
import { FileResults } from '../src/core/tasks/file-results.mjs';
|
|
import { DeliveryReporter, renderDeliveryMarkdown } from '../src/core/delivery-report.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { readText, proposeFile, applyChange } from '../src/server/files.mjs';
|
|
import { createDeliveryProject, applyDeliveryFix, deliveryGit } from './fixtures/delivery-project.mjs';
|
|
import { CheckRunner } from '../src/core/check-runner.mjs';
|
|
import { GitDelivery } from '../src/core/git-delivery.mjs';
|
|
|
|
const item = (f, fields = {}) => ({ key: 'review', title: '解释原工程', criterion: '有原读取与结论可供核对', kind: 'analysis', tools: ['read_file'], method: 'evidence',
|
|
source: { kind: 'goal', id: f.session.taskId, start: 0, end: f.store.core.task.get(f.session.taskId).goal.length }, ...fields });
|
|
const create = async (f, rows = [item(f)]) => { const manager = new RequirementReview(f.store); await manager.save(f.session, { expected_revision: 0, requirements: rows }); return manager; };
|
|
const verify = (f, manager, id, key = 'review', revision = 1) => manager.verify(f.session, { expected_revision: revision, key, evidence_id: id });
|
|
|
|
test('research evidence binds actual original bytes; model completion is not user acceptance', async t => {
|
|
const f = fixture(t); beginPlanTask(f, '只研究README.md,不修改参考文件。'); const read = completeRead(f);
|
|
const manager = await create(f); assert.equal((await manager.inspect(f.session)).items[0].status, 'pending');
|
|
assert.equal((await verify(f, manager, read.id)).status, 'completed');
|
|
const view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'evidence_verified'); assert.equal(view.all_resolved, true);
|
|
assert.equal(f.session.changes.length, 0); assert.equal(f.store.core.check_job.size, 0);
|
|
assert.equal(view.items[0].source.quote, '只研究README.md,不修改参考文件。');
|
|
const report = await new DeliveryReporter(f.store).create(f.session);
|
|
assert.equal(report.report.requirements.items[0].status, 'evidence_verified');
|
|
assert.match(renderDeliveryMarkdown(report.report), /原目标|goal:/); assert.match(report.report.task.note, /不代替/);
|
|
});
|
|
|
|
test('same text with distinct user source instances stays distinct; an appended requirement only invalidates its own revision', async t => {
|
|
const f = fixture(t); beginPlanTask(f, '读取当前依据'); const read = completeRead(f), task = f.store.core.task.get(f.session.taskId);
|
|
task.instructions.push({ id: randomUUID(), source: 'user', content: '读取当前依据', createdAt: new Date().toISOString() });
|
|
const first = item(f), second = item(f, { key: 'second', source: { kind: 'instruction', id: task.instructions[0].id, start: 0, end: 6 } });
|
|
const manager = await create(f, [first, second]); await verify(f, manager, read.id); await verify(f, manager, read.id, 'second');
|
|
let view = await manager.inspect(f.session); assert.notEqual(view.items[0].source.sourceSha256, view.items[1].source.sourceSha256);
|
|
task.instructions.push({ id: randomUUID(), source: 'user', content: '新增要求', createdAt: new Date().toISOString() });
|
|
view = await manager.inspect(f.session); assert.equal(view.all_resolved, false); assert.equal(view.unreviewed_sources.length, 1);
|
|
assert.equal(view.items[0].status, 'evidence_verified');
|
|
await manager.save(f.session, { expected_revision: 1, requirements: [first, { ...second, criterion: '新增明确条件' }] });
|
|
view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'evidence_verified'); assert.equal(view.items[0].revision, 1);
|
|
assert.equal(view.items[1].status, 'pending'); assert.equal(view.items[1].revision, 2); assert.equal(task.requirementProofs.length, 2);
|
|
});
|
|
|
|
test('foreign project, old Task and fabricated evidence strings are rejected with preserved failed proofs', async t => {
|
|
const f = fixture(t); beginPlanTask(f); const old = completeRead(f);
|
|
f.store.core.task.get(f.session.taskId).status = 'completed';
|
|
beginPlanTask(f, '另一个任务的原目标'); const manager = await create(f);
|
|
assert.equal((await verify(f, manager, old.id)).status, 'error');
|
|
assert.equal((await verify(f, manager, 'a nonempty fabricated evidence')).status, 'error');
|
|
const foreign = fixture(t); beginPlanTask(foreign); const foreignRead = completeRead(foreign);
|
|
assert.equal((await verify(f, manager, foreignRead.id)).status, 'error');
|
|
const view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'failed'); assert.equal(view.history.length, 3);
|
|
assert.ok(view.history.every(row => row.status === 'rejected'));
|
|
});
|
|
|
|
test('source changes invalidate prior proofs and cannot certify a read that was already stale at binding', async t => {
|
|
const f = fixture(t); beginPlanTask(f); const read = completeRead(f), manager = await create(f);
|
|
await verify(f, manager, read.id);
|
|
fs.appendFileSync(path.join(f.projectRoot, 'README.md'), '\nnew user content\n');
|
|
assert.equal((await manager.inspect(f.session)).items[0].status, 'stale');
|
|
assert.equal((await verify(f, manager, read.id)).status, 'error');
|
|
const current = completeRead(f); assert.equal((await verify(f, manager, current.id)).status, 'completed');
|
|
const view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'evidence_verified'); assert.equal(view.history.length, 3);
|
|
});
|
|
|
|
test('missing or tampered artifacts never become evidence and original failures remain after recovery', async t => {
|
|
const f = fixture(t); beginPlanTask(f); const read = completeRead(f), manager = await create(f);
|
|
await verify(f, manager, read.id); const artifact = f.store.owned('artifact', read.resultArtifactId, f.session.id), original = artifact.sha256;
|
|
artifact.sha256 = '0'.repeat(64);
|
|
assert.equal((await manager.inspect(f.session)).items[0].status, 'unverified');
|
|
assert.equal((await verify(f, manager, read.id)).status, 'error');
|
|
artifact.sha256 = original;
|
|
const view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'evidence_verified'); assert.equal(view.history[1].status, 'rejected');
|
|
const proof = f.store.core.task.get(f.session.taskId).requirementProofs[0]; proof.requirementRevision++;
|
|
assert.equal((await manager.inspect(f.session)).items[0].status, 'unverified');
|
|
});
|
|
|
|
test('checks omitted by explicit agreement are reported as not executed and never passed', async t => {
|
|
const f = fixture(t); beginPlanTask(f, '只研究现有文件,无需测试。');
|
|
const manager = await create(f, [item(f, { kind: 'checks', tools: undefined, checks: ['test'], method: 'not_requested' })]);
|
|
let view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'not_requested'); assert.equal(view.items[0].proof_id, null);
|
|
assert.equal(f.store.core.check_job.size, 0);
|
|
f.store.core.task.get(f.session.taskId).contract.checks = 'required';
|
|
view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'stale'); assert.equal(view.all_resolved, false);
|
|
});
|
|
|
|
test('user confirmation stays separate from engineering evidence, is bounded to current inputs and cannot be silently converted', async t => {
|
|
const f = fixture(t); beginPlanTask(f); const manager = await create(f, [item(f, { method: 'user' })]);
|
|
await assert.rejects(verify(f, manager, randomUUID()), /不能混用/);
|
|
await manager.verify(f.session, { expected_revision: 1, key: 'review', note: '实际打开页面,确认中文说明与当前要求一致。' });
|
|
let view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'user_confirmed'); assert.equal(view.items[0].evidence, null);
|
|
fs.appendFileSync(path.join(f.projectRoot, 'README.md'), 'new input');
|
|
view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'stale');
|
|
});
|
|
|
|
test('existing multi-file results keep provenance and invalidate only evidence whose files changed', async t => {
|
|
const f = fixture(t); beginPlanTask(f, '核对README.md已有成果,不修改,无需测试。');
|
|
fs.writeFileSync(path.join(f.projectRoot, 'notes.md'), 'existing notes');
|
|
const results = new FileResults(f.store);
|
|
const a = results.record(f.session, { files: [{ path: 'README.md', sha256: readText(f.project, 'README.md').sha256 }], reason: '核对现有说明' }, { source: 'user' });
|
|
const b = results.record(f.session, { files: [{ path: 'notes.md', sha256: readText(f.project, 'notes.md').sha256 }], reason: '核对现有笔记' }, { source: 'user' });
|
|
const manager = await create(f, [item(f, { kind: 'results', tools: undefined, paths: ['README.md'] }), item(f, { key: 'notes', kind: 'results', tools: undefined, paths: ['notes.md'] })]);
|
|
assert.equal((await verify(f, manager, a.result_id)).status, 'completed'); assert.equal((await verify(f, manager, b.result_id, 'notes')).status, 'completed');
|
|
fs.appendFileSync(path.join(f.projectRoot, 'notes.md'), ' changed');
|
|
const view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'evidence_verified'); assert.equal(view.items[1].status, 'stale');
|
|
assert.equal(f.session.changes.length, 0);
|
|
});
|
|
|
|
test('unrelated additions preserve the checked file facts but remain visible as unreviewed user sources', async t => {
|
|
const f = fixture(t); beginPlanTask(f, '解释README.md'); const read = completeRead(f);
|
|
const manager = await create(f); await verify(f, manager, read.id);
|
|
fs.writeFileSync(path.join(f.projectRoot, 'unrelated.txt'), 'new unrelated input');
|
|
f.store.core.task.get(f.session.taskId).instructions.push({ id: randomUUID(), source: 'user', content: '还要研究另一文件。', createdAt: new Date().toISOString() });
|
|
const view = await manager.inspect(f.session); assert.equal(view.items[0].status, 'evidence_verified'); assert.equal(view.all_resolved, false);
|
|
assert.equal(view.unreviewed_sources.length, 1);
|
|
});
|
|
|
|
test('actual Git preview and publication recheck changed requirement bindings without touching HEAD or the owner index', async t => {
|
|
const f = fixture(t); createDeliveryProject(f); applyDeliveryFix(f); f.session.status = 'paused';
|
|
const runner = new CheckRunner(f.store), delivery = new GitDelivery(f.store); f.onCleanup(() => runner.stopAll()); f.onCleanup(() => delivery.stopAll());
|
|
const checkPlan = await runner.plan(f.session), check = await (await runner.start(f.session, checkPlan.id)).promise; assert.equal(check.status, 'passed');
|
|
const requirement = item(f, { kind: 'checks', tools: undefined, checks: ['test', 'build'] }), manager = await create(f, [requirement]);
|
|
await assert.rejects(delivery.plan(f.session), /用户要求/);
|
|
await verify(f, manager, check.id); const preview = await delivery.plan(f.session); assert.match(preview.requirementBindingSha256, /^[a-f0-9]{64}$/);
|
|
const head = deliveryGit(f, ['rev-parse', 'HEAD']), indexFile = path.join(deliveryGit(f, ['rev-parse', '--absolute-git-dir']).trim(), 'index'), index = fs.readFileSync(indexFile);
|
|
await manager.save(f.session, { expected_revision: 1, requirements: [{ ...requirement, criterion: '新条件必须重新核对当前检查' }] });
|
|
const result = await (await delivery.start(f.session, preview.id)).promise;
|
|
assert.equal(result.status, 'stale'); assert.equal(deliveryGit(f, ['rev-parse', 'HEAD']), head); assert.deepEqual(fs.readFileSync(indexFile), index);
|
|
});
|
|
|
|
test('no-test file application and manual completion keep pending user requirements for explicit review', async t => {
|
|
const f = fixture(t); beginPlanTask(f, '修改README.md,无需测试。'); const read = completeRead(f), manager = await create(f);
|
|
const change = proposeFile(f.store, f.session, { path: 'README.md', content: '# new reviewed file\n', reason: '明确修改' });
|
|
applyChange(f.store, f.session, change.change_id); assert.equal(f.session.status, 'paused');
|
|
const runtime = new Runtime(f.store, new Provider());
|
|
await assert.rejects(runtime.completeFileResults(f.session), /用户要求/);
|
|
const currentRead = completeRead(f); assert.equal((await verify(f, manager, currentRead.id)).status, 'completed');
|
|
await runtime.completeFileResults(f.session); assert.equal(f.session.status, 'completed'); assert.equal(f.store.core.check_job.size, 0);
|
|
assert.notEqual(read.id, currentRead.id);
|
|
});
|
|
|
|
test('revision races, forged source ranges, evidence fields and deletion cannot overwrite sealed requirements', async t => {
|
|
const f = fixture(t); beginPlanTask(f); const manager = await create(f);
|
|
await assert.rejects(manager.save(f.session, { expected_revision: 1, requirements: [item(f, { source: { kind: 'goal', id: randomUUID(), start: 0, end: 1 } })] }), /来源/);
|
|
await assert.rejects(manager.save(f.session, { expected_revision: 1, requirements: [item(f, { status: 'verified' })] }), /未声明/);
|
|
await assert.rejects(manager.save(f.session, { expected_revision: 1, requirements: [item(f, { key: 'different' })] }), /不能删除/);
|
|
const race = await Promise.allSettled(['first', 'second'].map(criterion => manager.save(f.session, { expected_revision: 1, requirements: [item(f, { criterion })] })));
|
|
assert.equal(race.filter(row => row.status === 'fulfilled').length, 1);
|
|
assert.equal(f.store.core.task.get(f.session.taskId).requirementRevisions.length, 2);
|
|
});
|
|
|
|
test('requirement binding prevents completion and Git acceptance after a review changes; legacy tasks stay explicit', async t => {
|
|
const f = fixture(t); beginPlanTask(f); const read = completeRead(f), manager = new RequirementReview(f.store);
|
|
assert.equal((await manager.assertReady(f.session)).configured, false);
|
|
await manager.save(f.session, { expected_revision: 0, requirements: [item(f)] });
|
|
await assert.rejects(manager.assertReady(f.session), /待复核/);
|
|
await verify(f, manager, read.id); const accepted = await manager.assertReady(f.session);
|
|
await manager.save(f.session, { expected_revision: 1, requirements: [item(f, { criterion: '新的业务要求' })] });
|
|
await assert.rejects(manager.assertReady(f.session, { expectedBinding: accepted.binding_sha256 }), /待复核|变化/);
|
|
const model = await compatibleFixture(t, () => ({ body: completion([], '所有要求均已完成。') }));
|
|
f.store.saveConfig({ mode: 'compatible', model: 'owned-claim', baseUrl: model.baseUrl });
|
|
const runtime = new Runtime(f.store, new Provider()); f.onCleanup(() => runtime.stopAll());
|
|
runtime.start(f.session.id, '', true); await runtime.active.get(f.session.id).promise;
|
|
assert.equal(f.store.core.run.get(f.session.runId).stopReason, 'requirements_incomplete'); assert.equal(f.session.status, 'paused');
|
|
assertToolPairs(f.session.providerMessages);
|
|
});
|