Files
vibemake-pcb-studio/codex_pcb/tests/test_recovery_review.py
T

203 lines
12 KiB
Python

"""Paused production can converse/revise without reusing old production consent."""
import asyncio
import copy
import json
import tempfile
import unittest
from pathlib import Path
from unittest.mock import AsyncMock, patch
from fastapi import HTTPException
from codex_pcb import app as service
class RecoveryReviewTest(unittest.IsolatedAsyncioTestCase):
def setUp(self):
self.tmp=tempfile.TemporaryDirectory(dir=Path(__file__).parent)
self.addCleanup(self.tmp.cleanup)
self.folder=Path(self.tmp.name)
(self.folder/'evidence').mkdir()
(self.folder/'evidence/blocker.md').write_text('manufacturer evidence')
self.task={'id':'test-recovery','state':'blocked','busy':False,'cursor':5,
'request':'test board','thread_id':'original-thread','eda_session':'original-eda',
'error':'Power constraint conflict','blocker_evidence':'evidence/blocker.md',
'proposal':{'revision':1,'title':'Original','markdown':'original approved circuit '*10,'hash':'v1'},
'approval':{'revision':1,'hash':'v1','at':1},'frozen_source':service.fingerprint()}
for name,kwargs in [('get',{'return_value':self.task}),('event',{}),('save',{}),
('workspace',{'return_value':self.folder}),
('provider_status',{'return_value':{'configured':True}})]:
p=patch.object(service,name,**kwargs);p.start();self.addCleanup(p.stop)
self.ready=patch.object(service,'require_runtime_ready',new_callable=AsyncMock).start()
self.addCleanup(patch.stopall)
def feedback_request(self,intent='discuss',text='What can we change?'):
p=self.task['proposal']
return service.Feedback(text=text,intent=intent,revision=p['revision'],hash=p['hash'])
async def start_feedback(self,intent='discuss'):
with patch.object(service,'schedule') as schedule:
await service.feedback(self.task['id'],self.feedback_request(intent))
self.assertFalse(schedule.call_args.args[2])
return schedule.call_args.args[1]
async def tool(self,name,args):
return await service.handle(self.task,'item/tool/call',{'tool':name,'arguments':args,'callId':'test'})
async def publish(self):
return await self.tool('pcb_proposal',{'title':'Revised','markdown':'## 本次变更\nUse external supply; retain interfaces and repeat power checks.\n'+('Complete revised proposal. '*12)})
async def test_discussion_needs_no_eda_and_cannot_publish_or_mutate(self):
before=copy.deepcopy(self.task)
prompt=await self.start_feedback()
self.ready.assert_not_awaited()
self.assertIn('PRODUCTION PAUSED',prompt)
with patch.object(service,'execute',new_callable=AsyncMock) as execute,patch.object(service,'verify_native',new_callable=AsyncMock) as check,patch.object(service,'prepare_delivery',new_callable=AsyncMock) as prepare,patch.object(service,'deliver',new_callable=AsyncMock) as deliver:
for name in ('pcb_eda','pcb_check','pcb_prepare_delivery','pcb_deliver','pcb_blocked','pcb_proposal'):
result=await self.tool(name,{})
self.assertFalse(result['success'],name)
for mock in (execute,check,prepare,deliver):mock.assert_not_awaited()
for key in ('approval','proposal','thread_id','eda_session'):
self.assertEqual(self.task[key],before[key])
with patch.object(service,'run_turn',new_callable=AsyncMock):
await service.work(self.task,prompt,False)
self.assertEqual(self.task['state'],'blocked')
self.assertFalse(self.task['busy'])
async def test_revision_requires_new_approval_and_keeps_original_sessions(self):
before=copy.deepcopy(self.task)
await self.start_feedback('revise')
with self.assertRaises(HTTPException):await service.resume(self.task['id'])
self.assertTrue((await self.publish())['success'])
self.assertEqual(self.task['proposal']['revision'],2)
self.assertEqual(self.task['proposal_history'][0],{'proposal':before['proposal'],'approval':before['approval']})
self.assertEqual(self.task['approval'],before['approval'])
self.task['state']='review'
with self.assertRaises(HTTPException):
await service.approve(self.task['id'],service.Approval(revision=1,hash='v1'))
with self.assertRaises(HTTPException):
await service.approve(self.task['id'],service.Approval(revision=2,hash='stale'))
with patch.object(service,'schedule') as schedule:
await service.approve(self.task['id'],service.Approval(revision=2,hash=self.task['proposal']['hash']))
self.assertTrue(schedule.call_args.args[2])
self.assertIn('Preserve existing native project',schedule.call_args.args[1])
self.assertNotIn('recovery',self.task)
self.assertEqual(self.task['approval']['revision'],2)
self.assertEqual(self.task['approval_history'],[before['approval']])
self.assertEqual(self.task['thread_id'],before['thread_id'])
self.assertEqual(self.task['eda_session'],before['eda_session'])
self.assertTrue(self.task['check_eda_session'])
async def test_missing_decision_does_not_make_old_proposal_approvable(self):
await self.start_feedback('revise')
with patch.object(service,'run_turn',new_callable=AsyncMock):
await service.work(self.task,'Ask user to choose supply',False)
self.assertEqual(self.task['state'],'needs_input')
with self.assertRaises(HTTPException):
await service.approve(self.task['id'],service.Approval(revision=1,hash='v1'))
with self.assertRaises(HTTPException):await service.resume(self.task['id'])
await self.start_feedback('discuss')
self.assertTrue(self.task['recovery']['requires_approval'])
with self.assertRaises(HTTPException):await service.resume(self.task['id'])
async def test_discussion_of_pending_revision_preserves_review_gate(self):
await self.start_feedback('revise');await self.publish()
self.task['state']='review'
await self.start_feedback('discuss')
with patch.object(service,'run_turn',new_callable=AsyncMock):
await service.work(self.task,'Explain revision',False)
self.assertEqual(self.task['state'],'review')
self.assertFalse((await self.publish())['success'])
self.task['state']='failed'
with self.assertRaises(HTTPException):await service.resume(self.task['id'])
async def test_original_plan_retry_after_discussion_is_explicit(self):
await self.start_feedback()
with patch.object(service,'schedule') as schedule:
await service.resume(self.task['id'])
self.assertTrue(schedule.call_args.args[2])
self.assertNotIn('recovery',self.task)
self.assertEqual(self.task['approval']['revision'],1)
self.assertEqual(self.task['thread_id'],'original-thread')
async def test_unanswered_followup_revision_cannot_approve_previous_draft(self):
await self.start_feedback('revise');await self.publish()
self.task['state']='review'
previous=copy.deepcopy(self.task['proposal'])
await self.start_feedback('revise')
with patch.object(service,'run_turn',new_callable=AsyncMock):
await service.work(self.task,'Ask user about additional changes',False)
self.assertEqual(self.task['state'],'needs_input')
await self.start_feedback('discuss')
with patch.object(service,'run_turn',new_callable=AsyncMock):
await service.work(self.task,'Explain missing decision',False)
self.assertEqual(self.task['state'],'needs_input')
with self.assertRaises(HTTPException):
await service.approve(self.task['id'],service.Approval(revision=previous['revision'],hash=previous['hash']))
async def test_stale_feedback_busy_and_completed_rejected(self):
req=self.feedback_request()
self.task['proposal']['revision']=2
with self.assertRaises(HTTPException):await service.feedback(self.task['id'],req)
self.assertNotIn('recovery',self.task)
for state,busy in [('running',True),('completed',False)]:
self.task.update(state=state,busy=busy)
with self.assertRaises(HTTPException):await service.feedback(self.task['id'],self.feedback_request())
async def test_read_only_evidence_blocks_escape_and_nontext(self):
await self.start_feedback()
result=await self.tool('pcb_read_reference',{'path':'workspace/evidence/blocker.md','offset':0,'limit':100})
self.assertTrue(result['success'])
self.assertIn('manufacturer evidence',result['contentItems'][0]['text'])
(self.folder/'evidence/model.step').write_text('geometry')
(self.folder/'evidence/escape.md').symlink_to(self.folder.parent/'secret.md')
for path in ('workspace/../secret.md','workspace/evidence/model.step','workspace/evidence/escape.md'):
self.assertFalse((await self.tool('pcb_read_reference',{'path':path}))['success'])
async def test_restart_keeps_pending_review_read_only(self):
await self.start_feedback('revise')
self.task.update(state='planning',busy=True,pending_prompt='PRODUCTION PAUSED: revise safely')
taskdir=self.folder/'tasks'/self.task['id'];taskdir.mkdir(parents=True)
(taskdir/'state.json').write_text(json.dumps(self.task))
with patch.object(service,'TASKS',self.folder/'tasks'),patch.object(service,'CACHE',{}),patch.object(service,'JOBS',{}),patch.object(service,'schedule') as schedule,patch.object(service.readiness,'start'),patch.object(service.readiness,'close',new_callable=AsyncMock),patch.object(service.aftercare,'recover'),patch.object(service.aftercare,'close',new_callable=AsyncMock):
async with service.lifespan(service.app):pass
self.assertFalse(schedule.call_args.args[2])
self.assertEqual(schedule.call_args.args[1],self.task['pending_prompt'])
async def test_review_turn_resumes_same_thread_with_tools_locked(self):
await self.start_feedback('revise')
calls=[];options=[]
class Server:
def __init__(self,*args,**kwargs):
options.append((args,kwargs));self.events=asyncio.Queue();self.requests=set()
async def __aenter__(self):return self
async def __aexit__(self,*args):pass
async def call(self,method,args):
calls.append((method,args))
if method=='thread/resume':return {'thread':{'id':'original-thread'}}
if method=='turn/start':
await self.events.put({'method':'turn/completed','params':{'turn':{'id':'review-turn','status':'completed'}}})
return {'turn':{'id':'review-turn'}}
raise AssertionError(method)
with patch.object(service,'AppServer',Server):
await service.run_turn(self.task,'PRODUCTION PAUSED',False)
service.CLIENTS.pop(self.task['id'],None)
self.assertFalse(options[0][0][1]);self.assertTrue(options[0][1]['read_only_tools'])
self.assertTrue(options[0][1]['allow_web'])
self.assertEqual(calls[0][1]['threadId'],'original-thread')
self.assertEqual(calls[1][1]['sandboxPolicy'],{'type':'readOnly','networkAccess':False})
async def test_schedule_cannot_bypass_review(self):
await self.start_feedback('revise')
with self.assertRaises(HTTPException):service.schedule(self.task,'produce',True)
def test_recovery_search_preserves_read_only_tool_lock(self):
from codex_pcb import rpc
with patch.object(rpc,'CODEX_HOME',self.folder):
(self.folder/'config.toml').write_text('[mcp_servers.eda]\ncommand="unused"\n')
runtime=service.runtime_for('openai')
args,_=rpc.process_config(False,runtime,read_only_tools=True,allow_web=True)
strict,_=rpc.process_config(False,runtime,read_only_tools=True)
self.assertIn('web_search="live"',args)
self.assertIn('web_search="disabled"',strict)
for item in ('features.shell_tool=false','mcp_servers.eda.enabled=false','sandbox_mode="read-only"'):
self.assertIn(item,args)