168 lines
17 KiB
JavaScript
168 lines
17 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, until, launchWorkbench, compatibleFixture,completion,call,assertToolPairs } from './helpers.mjs';
|
|
import { environmentProject } from './fixtures/environment-project.mjs';
|
|
import { EnvironmentManager } from '../src/core/environment/environment-manager.mjs';
|
|
import { diagnoseEnvironment,inspectNodeEnvironment,dependencyTree,nodeEnvironmentBinding,verifyNodeBinding } from '../src/core/environment/environment-inspector.mjs';
|
|
import { CheckRunner } from '../src/core/check-runner.mjs';
|
|
import { verifiedCheck } from '../src/core/delivery-report.mjs';
|
|
import { inspectProject } from '../src/core/project-inspector.mjs';
|
|
import { Store } from '../src/server/store.mjs';
|
|
import { Runtime } from '../src/server/runtime.mjs';
|
|
import { Provider } from '../src/server/provider.mjs';
|
|
import { assertEnvironmentsResolved } from '../src/shared/contracts/environment.mjs';
|
|
import { installUpgrade } from '../src/server/hot-upgrade.mjs';
|
|
|
|
function manager(f,options={}){const value=new EnvironmentManager(f.store,{allowHttpLoopback:true,...options});f.onCleanup(()=>value.stopAll());return value;}
|
|
const write=(project,name,value)=>fs.writeFileSync(path.join(project.root,name),value);
|
|
const read=(project,name)=>fs.readFileSync(path.join(project.root,name),'utf8');
|
|
|
|
test('unfixed dependency URLs and invalid integrity are reported without exposing URL credentials or allowing a plan',t=>{
|
|
const f=fixture(t);write(f.project,'package.json',JSON.stringify({dependencies:{a:'1.0.0'}}));
|
|
write(f.project,'package-lock.json',JSON.stringify({lockfileVersion:3,packages:{'':{dependencies:{a:'1.0.0'}},'node_modules/a':{version:'1.0.0',resolved:'https://private-token@example.invalid/a.tgz',integrity:'sha1-invalid'}}}));
|
|
const node=inspectNodeEnvironment(f.project);assert.equal(node.preparable,false);assert.match(node.issues.join(),/来源/);assert.match(node.issues.join(),/sha512/);assert.ok(!JSON.stringify(node).includes('private-token'));
|
|
});
|
|
test('hot upgrade refuses an active dependency operation or evaluation before changing runtime objects',()=>{
|
|
for(const name of ['environments','evaluations']){const runtime={[name]:{active:new Map([['owned',{}]])}},context={server:{listening:true},store:{},provider:{},runtime,token:'owned-token',clients:new Set()};
|
|
assert.throws(()=>installUpgrade(context,{appDirectory:process.cwd()}),/Wait for active/);assert.ok(runtime[name].active.has('owned'));}
|
|
});
|
|
|
|
test('read-only environment diagnosis identifies actual runtime, missing dependencies and sealed inputs without installing or running scripts',async t=>{
|
|
const f=fixture(t),p=await environmentProject(f),m=manager(f),before=read(p.project,'package-lock.json');
|
|
const diagnostic=await m.diagnose(p.session);
|
|
assert.equal(diagnostic.node.status,'needs_preparation');assert.deepEqual(diagnostic.node.missing,['awb-env-fixture']);
|
|
assert.match(diagnostic.node.runtime.node.sha256,/^[a-f0-9]{64}$/);assert.ok(diagnostic.node.runtime.npm.version);
|
|
assert.equal(diagnostic.node.lifecycle[0].name,'postinstall');assert.equal(p.requests(),0);
|
|
assert.equal(fs.existsSync(path.join(p.root,'node_modules')),false);assert.equal(read(p.project,'package-lock.json'),before);
|
|
assert.equal(f.store.artifactStore.read(f.store.owned('artifact',diagnostic.artifactId,p.session.id)),JSON.stringify((({artifactId,artifactSha256,...data})=>data)(diagnostic)));
|
|
});
|
|
test('diagnosis rejects unsupported managers, lock integrity and credential configuration without reading config content',async t=>{
|
|
const f=fixture(t),p=await environmentProject(f,{dependency:false});
|
|
write(p.project,'.npmrc','_authToken=diagnostic-must-not-read-this');
|
|
let node=inspectNodeEnvironment(p.project);assert.equal(node.preparable,false);assert.match(node.issues.join(),/npmrc/);assert.ok(!JSON.stringify(node).includes('diagnostic-must-not-read-this'));
|
|
fs.unlinkSync(path.join(p.root,'.npmrc'));
|
|
const manifest=JSON.parse(read(p.project,'package.json'));manifest.packageManager='pnpm@10.0.0';write(p.project,'package.json',JSON.stringify(manifest));
|
|
node=inspectNodeEnvironment(p.project);assert.equal(node.status,'unsupported');assert.equal(node.preparable,false);
|
|
});
|
|
test('approved real npm ci runs only in owned worktree, skips scripts, retains logs and binds later actual tests', {timeout:60000},async t=>{
|
|
const f=fixture(t),p=await environmentProject(f),m=manager(f);
|
|
await assert.rejects(m.plan(f.session,{}),/独立工作区/);
|
|
const plan=await m.plan(p.session,{registry:p.registry});assert.equal(plan.scripts,'skip');
|
|
await assert.rejects(m.start(p.session,plan.id,plan.fingerprint),/批准/);
|
|
const started=await m.start(p.session,plan.id,plan.fingerprint,{approved:true}),job=await started.promise;
|
|
assert.equal(job.status,'prepared',job.summary+'\n'+job.logExcerpt);assert.equal(job.result.exitCode,0);assert.ok(job.process.pid);assert.equal(job.process.rootExited,true);
|
|
assert.equal(fs.existsSync(path.join(p.root,'node_modules/lifecycle.txt')),false);assert.equal(fs.existsSync(path.join(p.sourceRoot,'node_modules')),false);
|
|
assert.equal(f.store.core.task.get(p.session.taskId).verification.status,'not_configured');assert.ok(p.requests()>0);
|
|
assert.match(f.store.artifactStore.read(f.store.owned('artifact',job.logArtifactId,p.session.id)),/added 1 package/);
|
|
await assert.rejects(m.start(p.session,plan.id,plan.fingerprint,{approved:true}),/已经使用/);
|
|
const checks=new CheckRunner(f.store);const checkPlan=await checks.plan(p.session,['test']);const check=await(await checks.start(p.session,checkPlan.id)).promise;
|
|
assert.equal(check.status,'passed',check.summary);assert.equal(check.results[0].tests.passed,1);assert.equal(check.environment.identity,job.after.identity);
|
|
assert.ok(verifiedCheck(f.store,p.session,await inspectProject(p.project)));
|
|
fs.appendFileSync(path.join(p.root,'node_modules/awb-env-fixture/index.cjs'),'\n// external change');
|
|
assert.equal(verifiedCheck(f.store,p.session,await inspectProject(p.project)),null);
|
|
const stale=await(await checks.start(p.session,checkPlan.id)).promise;assert.equal(stale.status,'stale');assert.equal(stale.results.length,0);
|
|
});
|
|
test('explicitly allowing lifecycle scripts executes sealed root script and preserves the separate preparation result', {timeout:60000},async t=>{
|
|
const f=fixture(t),p=await environmentProject(f),m=manager(f),plan=await m.plan(p.session,{registry:p.registry,scripts:'allow'});
|
|
const job=await(await m.start(p.session,plan.id,plan.fingerprint,{approved:true})).promise;
|
|
assert.equal(job.status,'prepared',job.logExcerpt);assert.equal(read(p.project,'node_modules/lifecycle.txt'),'approved');
|
|
assert.equal(f.store.core.task.get(p.session.taskId).verification.status,'not_configured');
|
|
});
|
|
test('stale lockfile, tampered plan/config, cross-session identities and mismatched download sources never dispatch npm',async t=>{
|
|
const f=fixture(t),p=await environmentProject(f),m=manager(f);
|
|
await assert.rejects(m.plan(p.session,{}),/来源/);
|
|
const plan=await m.plan(p.session,{registry:p.registry}),original=read(p.project,'package-lock.json');
|
|
await assert.rejects(m.start(f.session,plan.id,plan.fingerprint,{approved:true}),/不属于/);
|
|
write(p.project,'package-lock.json',original+'\n');await assert.rejects(m.start(p.session,plan.id,plan.fingerprint,{approved:true}),/变化/);
|
|
write(p.project,'package-lock.json',original);fs.writeFileSync(plan.configFiles[0].path,'ignore-scripts=false');await assert.rejects(m.start(p.session,plan.id,plan.fingerprint,{approved:true}),/配置/);
|
|
fs.writeFileSync(plan.configFiles[0].path,'');plan.invocation.args.push('--ignore-scripts=false');await assert.rejects(m.start(p.session,plan.id,plan.fingerprint,{approved:true}),/范围/);
|
|
assert.equal(p.requests(),0);assert.equal(f.store.core.environment_job.size,0);
|
|
});
|
|
test('registry failure keeps original npm exit/log and performs no automatic fallback or replay', {timeout:60000},async t=>{
|
|
const f=fixture(t),p=await environmentProject(f,{response:'error'}),m=manager(f),plan=await m.plan(p.session,{registry:p.registry});
|
|
const job=await(await m.start(p.session,plan.id,plan.fingerprint,{approved:true})).promise;
|
|
assert.equal(job.status,'failed',job.summary);assert.notEqual(job.result.exitCode,0);assert.match(job.logExcerpt,/503|E503/);assert.equal(p.requests(),1);
|
|
assert.equal(fs.existsSync(path.join(p.sourceRoot,'node_modules')),false);
|
|
});
|
|
test('stopping a hanging dependency download records only its owned process and preserves stopped logs', {timeout:60000},async t=>{
|
|
const f=fixture(t),p=await environmentProject(f,{response:'hang'}),m=manager(f),plan=await m.plan(p.session,{registry:p.registry});
|
|
const {job,promise}=await m.start(p.session,plan.id,plan.fingerprint,{approved:true});await until(()=>p.requests()>0);
|
|
assert.equal(m.projectActive(p.project.id),true);assert.throws(()=>assertEnvironmentsResolved(f.store,p.project.id),/准备/);
|
|
await m.stop(p.session.id,job.id);await promise;assert.ok(['cancelled','unknown'].includes(job.status),job.summary);
|
|
assert.ok(job.logArtifactId);assert.equal(job.result.process.treeTermination,job.status==='unknown'?'unknown':'confirmed');assert.equal(m.active.size,0);
|
|
});
|
|
test('restart retains unknown preparation, blocks writes and checks, and requires explicit read-only reconciliation',async t=>{
|
|
const f=fixture(t),p=await environmentProject(f,{dependency:false}),m=manager(f),plan=await m.plan(p.session,{offline:true});
|
|
const job={id:crypto.randomUUID(),sessionId:p.session.id,projectId:p.project.id,taskId:p.session.taskId,runId:p.session.runId,planId:plan.id,planFingerprint:plan.fingerprint,status:'queued',process:null};
|
|
f.store.putRecord('environment_job',p.session,job,'environment.queued');f.store.close();
|
|
const recovered=new Store(f.data);f.onCleanup(()=>recovered.close());const session=recovered.session(p.session.id),original=recovered.core.environment_job.get(job.id);
|
|
assert.equal(original.status,'unknown');assert.equal(original.requiresVerification,true);
|
|
const runtime=new Runtime(recovered,new Provider());assert.throws(()=>runtime.start(session.id,'new task'),/环境|依赖/);
|
|
await assert.rejects(new CheckRunner(recovered).plan(session),/依赖/);
|
|
const resumedManager=new EnvironmentManager(recovered);await resumedManager.reconcile(session,job.id,plan.fingerprint);
|
|
assert.equal(original.status,'unknown');assert.equal(original.requiresVerification,false);assert.ok(original.reconciliation.sha256);assert.doesNotThrow(()=>assertEnvironmentsResolved(recovered,p.project.id));
|
|
});
|
|
test('HTTP environment flow survives refresh, requires explicit approval and preserves task and artifact ownership', {timeout:60000},async t=>{
|
|
const f=fixture(t),p=await environmentProject(f,{dependency:false}),id=p.session.id;f.store.close();const host=await launchWorkbench(t,f.data),base='/sessions/'+id;
|
|
let session=await host.api(base+'/environment-diagnostics',{});assert.equal(session.execution.environmentDiagnostics.at(-1).node.status,'ready');
|
|
session=await host.api(base+'/environment-plans',{offline:true});const plan=session.execution.environmentPlans.at(-1);
|
|
await assert.rejects(host.api(base+'/environment-jobs',{planId:plan.id,fingerprint:plan.fingerprint}),/批准/);
|
|
await host.api(base+'/environment-jobs',{planId:plan.id,fingerprint:plan.fingerprint,approved:true});
|
|
await until(async()=>{session=await host.api(base);return session.execution.environmentJobs.at(-1)?.finishedAt;},30000);
|
|
assert.equal(session.execution.environmentJobs.at(-1).status,'prepared',session.execution.environmentJobs.at(-1).logExcerpt);
|
|
assert.equal(session.execution.task.id,p.session.taskId);assert.equal(session.approvals.at(-1).environmentPlanId,plan.id);
|
|
await host.close();const next=await launchWorkbench(t,f.data),again=await next.api(base);assert.equal(again.execution.environmentJobs.at(-1).status,'prepared');
|
|
});
|
|
test('Python environment diagnosis reads declarations and runtime identity without executing project code or installing packages',async t=>{
|
|
const f=fixture(t);write(f.project,'pyproject.toml','[tool.pytest.ini_options]\ntestpaths=["tests"]\n');
|
|
write(f.project,'conftest.py',"raise RuntimeError('must never import during diagnosis')");
|
|
const diagnostic=await diagnoseEnvironment(f.project,{pythonExecutable:process.env.AGENT_WORKBENCH_TEST_PYTHON});
|
|
assert.equal(diagnostic.node,null);assert.ok(diagnostic.python);assert.equal(diagnostic.python.preparation,'manual');assert.match(diagnostic.python.runtime.sha256,/^[a-f0-9]{64}$/);
|
|
assert.equal(fs.existsSync(path.join(f.projectRoot,'__pycache__')),false);
|
|
});
|
|
test('empty build cache directories keep dependency identity while added executable files invalidate it',t=>{
|
|
const f=fixture(t);write(f.project,'package.json','{"name":"dependency-identity","private":true}');
|
|
fs.mkdirSync(path.join(f.projectRoot,'node_modules/a'),{recursive:true});write(f.project,'node_modules/a/package.json','{"name":"a","version":"1.0.0"}');
|
|
const before=nodeEnvironmentBinding(f.project);
|
|
fs.mkdirSync(path.join(f.projectRoot,'node_modules/.vite-temp'));
|
|
fs.mkdirSync(path.join(f.projectRoot,'node_modules/.cache/empty'),{recursive:true});
|
|
assert.deepEqual(nodeEnvironmentBinding(f.project),before);verifyNodeBinding(f.project,before);
|
|
write(f.project,'node_modules/.vite-temp/config.mjs','export default {plugins:[]}');
|
|
assert.throws(()=>verifyNodeBinding(f.project,before),/依赖已变化/);
|
|
fs.unlinkSync(path.join(f.projectRoot,'node_modules/.vite-temp/config.mjs'));verifyNodeBinding(f.project,before);
|
|
write(f.project,'node_modules/a/package.json','{"name":"a","version":"2.0.0"}');
|
|
assert.throws(()=>verifyNodeBinding(f.project,before),/依赖已变化/);
|
|
});
|
|
|
|
test('dependency snapshots reject external links and incomplete budgets instead of claiming environment equivalence',async t=>{
|
|
const f=fixture(t);fs.mkdirSync(path.join(f.projectRoot,'node_modules/a'),{recursive:true});write(f.project,'node_modules/a/package.json','{}');
|
|
assert.equal(dependencyTree(f.project,{maximumFiles:1}).status,'unverified');const before=nodeEnvironmentBinding(f.project);assert.equal(before,null);
|
|
const external=path.join(f.root,'external');fs.mkdirSync(external);fs.symlinkSync(external,path.join(f.projectRoot,'node_modules/external'),process.platform==='win32'?'junction':'dir');
|
|
assert.equal(dependencyTree(f.project).status,'unverified');
|
|
});
|
|
test('model-requested environment preparation uses the original approval boundary and never treats preparation as passed engineering checks',{timeout:60000},async t=>{
|
|
const f=fixture(t),p=await environmentProject(f,{dependency:false}),upstream=await compatibleFixture(t,(route,input,requests)=>{
|
|
if(requests.length===1)return completion([call('env-diagnose','diagnose_environment',{})]);
|
|
if(requests.length===2)return completion([call('env-plan','plan_environment',{offline:true})]);
|
|
if(requests.length===3){const plan=JSON.parse(input.messages.findLast(value=>value.tool_call_id==='env-plan').content);return completion([call('env-run','prepare_environment',{plan_id:plan.id,fingerprint:plan.fingerprint})]);}
|
|
return completion([],'依赖准备已完成,工程检查尚未执行。');
|
|
});
|
|
f.store.config={...f.store.config,mode:'compatible',baseUrl:upstream.baseUrl,model:'owned-environment-fixture'};
|
|
const runtime=new Runtime(f.store,new Provider());f.onCleanup(()=>runtime.stopAll());runtime.start(p.session.id,'仅准备这个独立工作区的依赖,保留原记录,不需要测试');const running=runtime.active.get(p.session.id).promise;
|
|
await until(()=>p.session.approvals.some(row=>row.environmentPlanId&&row.status==='pending'),30000);
|
|
const approval=p.session.approvals.find(row=>row.environmentPlanId&&row.status==='pending');assert.equal(f.store.core.environment_job.size,0);assert.equal(approval.environmentSummary.scripts,'skip');
|
|
runtime.decide(p.session.id,approval.id,true);await running;
|
|
const snapshot=f.store.executionSnapshot(p.session),job=snapshot.environmentJobs.at(-1);assert.equal(job.status,'prepared',job.summary);assert.equal(f.store.core.task.get(p.session.taskId).verification.status,'not_configured');
|
|
assert.equal(snapshot.environmentDiagnostics.at(-1).node.status,'ready');assert.equal(snapshot.environmentDiagnostics.at(-1).runId,job.runId);
|
|
assert.equal(f.store.core.environment_job.get(job.id).approvalId,approval.id);assertToolPairs(p.session.providerMessages);
|
|
});
|
|
test('timeout and offline cache miss retain actual failures and new attempts require newly sealed plans',{timeout:60000},async t=>{
|
|
const f=fixture(t),p=await environmentProject(f,{response:'hang'}),m=manager(f,{timeoutMs:1200});
|
|
const offline=await m.plan(p.session,{registry:p.registry,offline:true}),missing=await(await m.start(p.session,offline.id,offline.fingerprint,{approved:true})).promise;
|
|
assert.equal(missing.status,'failed');assert.match(missing.logExcerpt,/ENOTCACHED|cache/i);assert.equal(p.requests(),0);
|
|
const plan=await m.plan(p.session,{registry:p.registry}),job=await(await m.start(p.session,plan.id,plan.fingerprint,{approved:true})).promise;
|
|
assert.equal(job.result.timedOut,true);assert.ok(['failed','unknown'].includes(job.status));assert.ok(job.logArtifactId);assert.notEqual(job.id,missing.id);
|
|
});
|