204 lines
10 KiB
Python
204 lines
10 KiB
Python
"""Per-design provider selection, credential isolation and runtime immutability."""
|
|
import importlib
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import tempfile
|
|
import unittest
|
|
from unittest.mock import AsyncMock, patch
|
|
|
|
import httpx
|
|
from codex_pcb import config, rpc, storage
|
|
from codex_pcb.models import catalog
|
|
|
|
app = importlib.import_module('codex_pcb.app')
|
|
|
|
|
|
class ProviderSelection(unittest.IsolatedAsyncioTestCase):
|
|
def setUp(self):
|
|
self.temp = tempfile.TemporaryDirectory()
|
|
self.addCleanup(self.temp.cleanup)
|
|
self.root = Path(self.temp.name)
|
|
self.environment = patch.dict(os.environ, {
|
|
'HOME': str(self.root), 'PATH': os.defpath,
|
|
'PCB_SESSION_ROOT': str(self.root/'runtime'), 'PCB_CODEX_AUTH': 'apikey',
|
|
'OPENAI_API_KEY': 'test-openai-only', 'DEEPSEEK_API_KEY': 'test-deepseek-only',
|
|
'ARK_API_KEY': 'test-ark-only', 'DOUBAO_API_KEY': 'test-unused-alias',
|
|
}, clear=True)
|
|
self.environment.start()
|
|
self.reload()
|
|
self.scheduler = patch.object(app, 'schedule')
|
|
self.schedule = self.scheduler.start()
|
|
self.readiness_guard = patch.object(app, 'require_runtime_ready', new=AsyncMock(return_value={'ok': True}))
|
|
self.ready = self.readiness_guard.start()
|
|
self.addCleanup(self.restore)
|
|
|
|
def reload(self):
|
|
for module in (config, storage, rpc, app):
|
|
importlib.reload(module)
|
|
|
|
def restore(self):
|
|
self.readiness_guard.stop()
|
|
self.scheduler.stop()
|
|
self.environment.stop()
|
|
self.reload()
|
|
|
|
async def request(self, method, path, **kwargs):
|
|
async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app.app), base_url='http://test') as client:
|
|
return await client.request(method, path, **kwargs)
|
|
|
|
async def create(self, provider=None):
|
|
body = {'text': 'Publish a proposal only; no production approval.'}
|
|
if provider is not None:
|
|
body['provider'] = provider
|
|
return await self.request('POST', '/api/sessions', json=body)
|
|
|
|
async def test_default_is_openai_at_requested_compatible_endpoint(self):
|
|
response = await self.create()
|
|
self.assertEqual(response.status_code, 201)
|
|
task = response.json()
|
|
self.assertEqual(task['ai_provider'], 'openai')
|
|
self.assertEqual(task['model'], 'gpt-6.1-sol')
|
|
self.assertEqual(task['runtime']['api_base_url'], 'https://api.vip1129.cc')
|
|
self.assertEqual(storage.load(task['id'])['runtime'], task['runtime'])
|
|
self.assertFalse(self.schedule.call_args.args[2])
|
|
|
|
async def test_select_deepseek_and_doubao_for_independent_tasks(self):
|
|
for name, model in (('deepseek','deepseek-flash'), ('doubao','doubao-seed-2-1-pro-260915')):
|
|
with self.subTest(provider=name):
|
|
response = await self.create(name)
|
|
self.assertEqual(response.status_code, 201)
|
|
task = response.json()
|
|
self.assertEqual(task['ai_provider'], name)
|
|
self.assertEqual(task['model'], model)
|
|
self.assertEqual(task['provider'], 'vibemake_'+name)
|
|
self.assertNotIn('test-', json.dumps(task))
|
|
|
|
async def test_unknown_or_unconfigured_provider_creates_no_task(self):
|
|
response = await self.create('unsupported')
|
|
self.assertEqual(response.status_code, 400)
|
|
del os.environ['DEEPSEEK_API_KEY']
|
|
response = await self.create('deepseek')
|
|
self.assertEqual(response.status_code, 503)
|
|
self.assertIn('DEEPSEEK_API_KEY', response.json()['detail'])
|
|
self.assertFalse(storage.TASKS.exists())
|
|
self.schedule.assert_not_called()
|
|
|
|
async def test_unready_environment_rejects_creation_before_allocating_task_or_model(self):
|
|
self.ready.side_effect = app.HTTPException(503, '绘板环境未就绪:BRIDGE_NOT_READY')
|
|
response = await self.create()
|
|
self.assertEqual(response.status_code, 503)
|
|
self.assertIn('BRIDGE_NOT_READY', response.json()['detail'])
|
|
self.assertFalse(storage.TASKS.exists())
|
|
self.schedule.assert_not_called()
|
|
|
|
async def test_unready_environment_does_not_record_approval_or_schedule_production(self):
|
|
task = app.get((await self.create()).json()['id'])
|
|
task.update(state='review', proposal={'revision': 1, 'hash': 'latest', 'markdown': 'Accepted design'})
|
|
self.schedule.reset_mock()
|
|
self.ready.reset_mock()
|
|
self.ready.side_effect = app.HTTPException(503, 'EasyEDA 命令桥接不可用')
|
|
response = await self.request('POST', '/api/sessions/'+task['id']+'/approve', json={'revision': 1, 'hash': 'latest'})
|
|
self.assertEqual(response.status_code, 503)
|
|
self.assertNotIn('approval', task)
|
|
self.assertEqual(task['state'], 'review')
|
|
self.ready.assert_awaited_once_with(force=True)
|
|
self.schedule.assert_not_called()
|
|
|
|
async def test_unready_environment_does_not_resume_or_revise_task(self):
|
|
task = app.get((await self.create()).json()['id'])
|
|
task.update(state='failed')
|
|
self.schedule.reset_mock()
|
|
self.ready.side_effect = app.HTTPException(503, 'EDA unavailable')
|
|
for suffix, body in (('resume', {}), ('comments', {'text': 'Please revise the proposal'})):
|
|
response = await self.request('POST', '/api/sessions/'+task['id']+'/'+suffix, json=body)
|
|
self.assertEqual(response.status_code, 503)
|
|
self.schedule.assert_not_called()
|
|
|
|
async def test_cancel_during_environment_check_cannot_be_overwritten_by_approval(self):
|
|
task = app.get((await self.create()).json()['id'])
|
|
task.update(state='review', proposal={'revision': 1, 'hash': 'latest', 'markdown': 'Accepted design'})
|
|
self.schedule.reset_mock()
|
|
async def cancel_while_checking(**kwargs):
|
|
await app.cancel(task['id'])
|
|
return {'ok': True}
|
|
self.ready.side_effect = cancel_while_checking
|
|
response = await self.request('POST', '/api/sessions/'+task['id']+'/approve', json={'revision': 1, 'hash': 'latest'})
|
|
self.assertEqual(response.status_code, 409)
|
|
self.assertEqual(task['state'], 'cancelled')
|
|
self.assertNotIn('approval', task)
|
|
self.schedule.assert_not_called()
|
|
|
|
async def test_provider_list_reports_readiness_without_credentials(self):
|
|
del os.environ['ARK_API_KEY']
|
|
del os.environ['DOUBAO_API_KEY']
|
|
response = await self.request('GET', '/api/providers')
|
|
result = response.json()
|
|
self.assertEqual(result['default_provider'], 'openai')
|
|
readiness = {p['id']:p['configured'] for p in result['providers']}
|
|
self.assertEqual(readiness, {'claude':False,'openai':True,'deepseek':True,'doubao':False})
|
|
self.assertNotIn('test-', response.text)
|
|
self.assertNotIn('API_KEY', response.text)
|
|
|
|
def test_each_process_receives_only_its_provider_credential(self):
|
|
for name, key, expected in (('openai','OPENAI_API_KEY','test-openai-only'),
|
|
('deepseek','DEEPSEEK_API_KEY','test-deepseek-only'),
|
|
('doubao','ARK_API_KEY','test-ark-only')):
|
|
with self.subTest(provider=name):
|
|
runtime = config.runtime_for(name)
|
|
args, env = rpc.process_config(False, runtime)
|
|
self.assertEqual(env[key], expected)
|
|
self.assertNotIn(expected, ' '.join(args))
|
|
for other in rpc.SECRET_ENV_NAMES:
|
|
if other != key:
|
|
self.assertNotIn(other, env)
|
|
setting = next(args[i+1] for i, arg in enumerate(args) if arg=='-c' and args[i+1].startswith('model_providers.'+runtime.provider+'.wire_api='))
|
|
self.assertTrue(setting.endswith('"responses"'))
|
|
if name == 'deepseek':
|
|
self.assertIn('features.standalone_web_search=true', args)
|
|
self.assertFalse(any('alpha_search' in arg for arg in args))
|
|
|
|
def test_doubao_alias_and_file_secret_do_not_leak_other_keys(self):
|
|
del os.environ['ARK_API_KEY']
|
|
runtime = config.runtime_for('doubao')
|
|
self.assertEqual(rpc.api_key(runtime), 'test-unused-alias')
|
|
del os.environ['DOUBAO_API_KEY']
|
|
secret = self.root/'ark-secret'
|
|
secret.write_text('file-ark-credential\n')
|
|
os.environ['ARK_API_KEY_FILE'] = str(secret)
|
|
args, env = rpc.process_config(False, runtime)
|
|
self.assertEqual(env['ARK_API_KEY'], 'file-ark-credential')
|
|
self.assertNotIn('ARK_API_KEY_FILE', env)
|
|
self.assertNotIn('file-ark-credential', ' '.join(args))
|
|
|
|
async def test_selected_runtime_is_independent_of_default_and_key_rotation(self):
|
|
task = (await self.create('deepseek')).json()
|
|
runtime = app.task_runtime(task)
|
|
before = storage.fingerprint(runtime)
|
|
os.environ.update(PCB_AI_PROVIDER='doubao', DEEPSEEK_API_KEY='rotated-provider-secret')
|
|
importlib.reload(config)
|
|
self.assertEqual(app.task_runtime(task).snapshot(), runtime.snapshot())
|
|
self.assertEqual(storage.fingerprint(app.task_runtime(task)), before)
|
|
|
|
async def test_saved_task_cannot_silently_change_model_or_endpoint(self):
|
|
task = (await self.create('deepseek')).json()
|
|
os.environ['PCB_DEEPSEEK_MODEL'] = 'different-model'
|
|
with self.assertRaisesRegex(RuntimeError, 'cannot switch providers'):
|
|
app.task_runtime(task)
|
|
del os.environ['PCB_DEEPSEEK_MODEL']
|
|
os.environ['PCB_DEEPSEEK_BASE_URL'] = 'https://different.example.test'
|
|
with self.assertRaisesRegex(RuntimeError, 'cannot switch providers'):
|
|
app.task_runtime(task)
|
|
|
|
def test_non_openai_metadata_keeps_requested_model_and_vision(self):
|
|
for name in ('deepseek','doubao'):
|
|
runtime = config.runtime_for(name)
|
|
metadata = catalog(runtime)['models'][0]
|
|
self.assertEqual(metadata['slug'], runtime.model)
|
|
self.assertIn('image', metadata['input_modalities'])
|
|
self.assertNotIn('test-', json.dumps(metadata))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|