203 lines
12 KiB
Python
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)
|