112 lines
9.3 KiB
JavaScript
112 lines
9.3 KiB
JavaScript
import test from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { fixture, call, compatibleFixture, completion, until } from './helpers.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { prepareWorkerFixture, ownerBytes } from './fixtures/workers-project.mjs';
|
|
import { workerForSession, workerSeal } from '../src/shared/contracts/workers.mjs';
|
|
|
|
test('each engineering assignment freezes its role, native settings and independent route without changing the default', { timeout: 120000 }, async t => {
|
|
const f = fixture(t, { modernDefaults: true });
|
|
const { manager, provider, requests } = prepareWorkerFixture(f);
|
|
const hub = provider.modelHub(f.store);
|
|
const a = hub.upsert({ name: 'A', model: 'owned-a', baseUrl: 'http://127.0.0.1:1/v1', requiresKey: false, nativeParameters: { reasoning_effort: 'high' } });
|
|
const b = hub.upsert({ name: 'B', model: 'owned-b', baseUrl: 'http://127.0.0.1:2/v1', requiresKey: false, nativeParameters: { reasoning_effort: 'low' } });
|
|
hub.select({ type: 'connection', id: a.id });
|
|
const original = ownerBytes(f), selected = structuredClone(hub.state.selected);
|
|
const pool = hub.pool({ name: 'B pool', members: [{ connectionId: b.id, weight: 1 }], maxAttempts: 1 });
|
|
const group = await manager.plan(f.session, { goal: 'Owned independent assignments', children: [
|
|
{ label: 'implementation', role: '工程实现', goal: 'Implement A', paths: ['src/a.mjs'], requirements: ['Keep A compatible'] },
|
|
{ label: 'tests', role: '测试完善', goal: 'Improve B', paths: ['src/b.mjs'], modelSelection: { type: 'pool', id: pool.id } },
|
|
] });
|
|
assert.deepEqual(hub.state.selected, selected); assert.equal(requests.length, 0);
|
|
assert.equal(group.children[0].assignment.model.model, a.model); assert.equal(group.children[1].assignment.model.model, b.model);
|
|
assert.equal(group.children[1].assignment.config.nativeParameters.reasoning_effort, 'low');
|
|
await (await manager.prepare(f.session, group.id, group.fingerprint)).promise;
|
|
assert.equal(group.status, 'ready', group.summary);
|
|
hub.select({ type: 'connection', id: b.id });
|
|
for (const child of group.children) {
|
|
const worker = workerForSession(f.store, f.store.session(child.sessionId));
|
|
assert.equal(manager.configFor(group, worker).model, child.assignment.model.model);
|
|
assert.deepEqual(workerSeal(worker).assignment, child.assignment);
|
|
}
|
|
hub.upsert({ ...a, revision: a.revision, nativeParameters: { reasoning_effort: 'medium' } });
|
|
assert.throws(() => manager.configFor(group, f.store.core.worker.get(group.children[0].id)), /修订/);
|
|
assert.equal(manager.configFor(group, f.store.core.worker.get(group.children[1].id)).model, b.model);
|
|
assert.deepEqual(ownerBytes(f), original); assert.equal(requests.length, 0);
|
|
});
|
|
|
|
test('a frozen pool preserves actual HTTP 429, Retry-After and unknown consumption without a hidden replacement', { timeout: 120000 }, async t => {
|
|
const bad = await compatibleFixture(t, () => ({ status: 429, headers: { 'retry-after': '17' }, body: { error: { message: 'owned rate limit', type: 'rate_limit_error' } } }));
|
|
const good = await compatibleFixture(t, () => completion([], 'Must not be used to mask the failed request.'));
|
|
const f = fixture(t, { modernDefaults: true }); f.store.saveConfig({ approvalMode: 'full' });
|
|
const { manager, provider } = prepareWorkerFixture(f); provider.complete = Provider.prototype.complete.bind(provider);
|
|
const hub = provider.modelHub(f.store);
|
|
const a = hub.upsert({ name: 'Rate limited', model: 'owned-a', baseUrl: bad.baseUrl, requiresKey: false });
|
|
const b = hub.upsert({ name: 'Other', model: 'owned-b', baseUrl: good.baseUrl, requiresKey: false });
|
|
const pool = hub.pool({ name: 'Frozen pool', members: [{ connectionId: a.id }, { connectionId: b.id }], maxAttempts: 2 });
|
|
const group = await manager.plan(f.session, { goal: 'Keep failure facts', children: [{ label: 'owned', goal: 'Read A', paths: ['src/a.mjs'], modelSelection: { type: 'pool', id: pool.id } }] });
|
|
await (await manager.prepare(f.session, group.id, group.fingerprint)).promise;
|
|
await (await manager.start(f.session, group.id, group.fingerprint)).promise;
|
|
assert.equal(bad.requests.length, 1); assert.equal(good.requests.length, 0);
|
|
const worker = f.store.core.worker.get(group.children[0].id), session = f.store.session(worker.sessionId);
|
|
assert.equal(worker.result, null); assert.equal(session.status, 'failed');
|
|
assert.match(JSON.stringify(session.failure), /owned rate limit/); assert.match(JSON.stringify(session.failure), /17/);
|
|
const run = f.store.core.run.get(worker.currentRunId);
|
|
assert.equal(run.consumption.length, 1); assert.equal(run.consumption[0].usageStatus, 'unknown');
|
|
assert.equal(run.usage.totalTokens, 0); assert.equal(run.usage.unknownRequests, 1);
|
|
const plan = [...f.store.core.context_plan.values()].find(row => row.taskId === worker.taskId);
|
|
assert.ok(plan.workerDispatch); assert.equal(plan.status, 'failed');
|
|
});
|
|
|
|
test('stopping a routed worker keeps its prepared evidence and a late HTTP tool proposal cannot write files', { timeout: 120000 }, async t => {
|
|
let release; const held = new Promise(resolve => { release = resolve; });
|
|
const upstream = await compatibleFixture(t, async () => { await held; return completion([call('late', 'propose_file', { path: 'src/a.mjs', content: 'late', reason: 'late' })]); });
|
|
t.after(() => release());
|
|
const f = fixture(t, { modernDefaults: true }); f.store.saveConfig({ approvalMode: 'full' });
|
|
const { manager, provider } = prepareWorkerFixture(f); provider.complete = Provider.prototype.complete.bind(provider);
|
|
const hub = provider.modelHub(f.store), connection = hub.upsert({ name: 'Held', model: 'held', baseUrl: upstream.baseUrl, requiresKey: false });
|
|
const group = await manager.plan(f.session, { goal: 'Stop once', children: [{ label: 'held', goal: 'Read A', paths: ['src/a.mjs'], modelSelection: { type: 'connection', id: connection.id } }] });
|
|
await (await manager.prepare(f.session, group.id, group.fingerprint)).promise;
|
|
const started = manager.start(f.session, group.id, group.fingerprint);
|
|
await until(() => upstream.requests.length === 1, 20000);
|
|
await manager.stopParent(f.session.id); await started.promise;
|
|
const session = f.store.session(group.children[0].sessionId), count = session.changes.length;
|
|
release(); await new Promise(resolve => setTimeout(resolve, 80));
|
|
assert.equal(session.changes.length, count); assert.equal(count, 0);
|
|
assert.equal(upstream.requests.length, 1);
|
|
const plan = [...f.store.core.context_plan.values()].find(row => row.taskId === session.taskId);
|
|
assert.ok(plan.workerDispatch); assert.equal(plan.status, 'interrupted');
|
|
});
|
|
|
|
test('parent collection verifies dispatch/tool generation and real bytes, preserving absent checks and unassessed requirements', { timeout: 180000 }, async t => {
|
|
const f = fixture(t, { modernDefaults: true }); f.store.saveConfig({ approvalMode: 'full' });
|
|
const { manager } = prepareWorkerFixture(f, { respond: async ({ project }) => {
|
|
const session = [...f.store.sessions.values()].find(value => value.projectId === project.id);
|
|
return { message: { role: 'assistant', content: session.changes.length ? 'All requirements passed!' : '',
|
|
...(!session.changes.length ? { tool_calls: [call('owned-file', 'propose_file', { path: 'src/a.mjs', content: 'export const value = 7;\n', reason: 'owned fixture' })] } : {}) }, usage: null };
|
|
} });
|
|
const original = ownerBytes(f);
|
|
const group = await manager.plan(f.session, { goal: 'Collect only facts', children: [{ label: 'worker', role: '工程实现', goal: 'Change A', requirements: ['Improve performance'], paths: ['src/a.mjs'] }] });
|
|
await (await manager.prepare(f.session, group.id, group.fingerprint)).promise;
|
|
await (await manager.start(f.session, group.id, group.fingerprint)).promise;
|
|
assert.equal(group.status, 'ready_to_collect', group.summary);
|
|
const child = group.children[0], worker = f.store.core.worker.get(child.id), session = f.store.session(child.sessionId);
|
|
const output = await manager.output(session, worker), quality = output.quality;
|
|
assert.equal(output.check, null); assert.equal(quality.checks.status, 'not_verified');
|
|
assert.ok(quality.requirements.every(row => row.status === 'not_evaluated'));
|
|
assert.equal(quality.usage.unknownRequests, 2); assert.equal(quality.usage.totalTokens, 0);
|
|
assert.equal(quality.requests.length, 2); assert.ok(quality.requests.every(row => row.phase === 'prepared' && row.toolSurfaceGeneration));
|
|
await (await manager.collect(f.session, group.id, group.fingerprint)).promise;
|
|
assert.equal(group.status, 'collected', group.summary);
|
|
const collected = await manager.readCollection(f.session, group);
|
|
assert.deepEqual(collected.workers[0].quality, quality);
|
|
const plan = [...f.store.core.context_plan.values()].find(row => row.taskId === worker.taskId);
|
|
const ref = plan.workerDispatch; plan.workerDispatch = { ...ref, sha256: '0'.repeat(64) };
|
|
await assert.rejects(manager.output(session, worker), /派发/); plan.workerDispatch = ref;
|
|
f.store.core.task.get(worker.taskId).acceptance.push('Later requirement');
|
|
assert.throws(() => workerForSession(f.store, session), /原要求/);
|
|
f.store.core.task.get(worker.taskId).acceptance.pop();
|
|
await (await manager.prepareMerge(f.session, group.id, group.fingerprint)).promise;
|
|
assert.equal(group.merge.status, 'applied', group.summary); assert.deepEqual(ownerBytes(f), original);
|
|
});
|