Files
vibemake-pcb-studio/codex_pcb/tests/test_runtime_config.py
T
admin e7f19ff493
CI / typecheck + test + build (push) Has been cancelled
部署更改
2026-11-13 17:20:03 +08:00

187 lines
8.4 KiB
Python

"""Deployment/authentication boundaries; no real credentials or model calls."""
import asyncio
import importlib
import json
import os
from pathlib import Path
import sys
import tempfile
import tomllib
import unittest
from unittest.mock import AsyncMock, patch
from codex_pcb import config, eda, rpc, storage
FAKE_KEY = 'unit-test-api-credential'
def command_settings(args):
return tomllib.loads('\n'.join(args[i + 1] for i, value in enumerate(args) if value == '-c'))
class RuntimeConfig(unittest.IsolatedAsyncioTestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name).resolve()
environment = {
'HOME': str(self.root), 'PATH': os.defpath,
'PCB_CODEX_AUTH': 'apikey',
'PCB_SESSION_ROOT': str(self.root / 'runtime'),
'PCB_CODEX_BIN': str(self.root / 'codex'),
'PCB_EDA_BIN': str(self.root / 'native eda'),
'PCB_BLENDER_BIN': str(self.root / 'native blender'),
}
self.environment = patch.dict(os.environ, environment, clear=True)
self.environment.start()
self.addCleanup(self.restore_environment)
self.reload()
def reload(self):
for module in (config, storage, rpc, eda):
importlib.reload(module)
def restore_environment(self):
self.environment.stop()
self.reload()
def test_api_key_provider_does_not_put_credentials_in_arguments(self):
os.environ.update(OPENAI_API_KEY=FAKE_KEY, CODEX_API_KEY='unrelated',
DEEPSEEK_API_KEY='unrelated', OPENAI_BASE_URL='https://unused.invalid')
args, env = rpc.process_config(True)
settings = command_settings(args)
provider = settings['model_providers'][config.PROVIDER]
self.assertEqual(provider['base_url'], 'https://api.openai.com/v1')
self.assertEqual(provider['env_key'], 'OPENAI_API_KEY')
self.assertEqual(provider['wire_api'], 'responses')
self.assertFalse(provider['requires_openai_auth'])
self.assertEqual(settings['model_provider'], config.PROVIDER)
self.assertFalse(settings['shell_environment_policy']['ignore_default_excludes'])
self.assertEqual(env['OPENAI_API_KEY'], FAKE_KEY)
self.assertNotIn(FAKE_KEY, ' '.join(args))
for name in ('CODEX_API_KEY', 'DEEPSEEK_API_KEY', 'OPENAI_BASE_URL'):
self.assertNotIn(name, env)
def test_file_secret_does_not_create_login_file(self):
secret = self.root / 'api-key'
secret.write_text(FAKE_KEY + '\n')
os.environ['OPENAI_API_KEY_FILE'] = str(secret)
args, env = rpc.process_config(False)
self.assertEqual(env['OPENAI_API_KEY'], FAKE_KEY)
self.assertNotIn('OPENAI_API_KEY_FILE', env)
self.assertNotIn(FAKE_KEY, ' '.join(args))
self.assertFalse(config.CODEX_HOME.exists())
def test_environment_key_takes_precedence_over_file(self):
os.environ.update(OPENAI_API_KEY=FAKE_KEY, OPENAI_API_KEY_FILE='/missing/file')
self.assertEqual(rpc.api_key(), FAKE_KEY)
def test_missing_and_invalid_secrets_fail_without_login_fallback(self):
with self.assertRaisesRegex(ValueError, 'requires OPENAI_API_KEY'):
rpc.process_config(False)
os.environ['OPENAI_API_KEY_FILE'] = str(self.root / 'missing')
with self.assertRaisesRegex(ValueError, 'Cannot read OPENAI_API_KEY_FILE'):
rpc.process_config(False)
for value in ('two values', 'x' * 16385):
os.environ['OPENAI_API_KEY'] = value
with self.assertRaisesRegex(ValueError, 'single non-empty value'):
rpc.process_config(False)
def test_chatgpt_mode_removes_api_credentials(self):
os.environ.update(PCB_CODEX_AUTH='chatgpt', OPENAI_API_KEY=FAKE_KEY,
OPENAI_API_KEY_FILE='/missing/file')
self.reload()
args, env = rpc.process_config(False)
settings = command_settings(args)
self.assertEqual(settings['model_provider'], 'openai')
self.assertNotIn('model_providers', settings)
self.assertNotIn('OPENAI_API_KEY', env)
self.assertNotIn('OPENAI_API_KEY_FILE', env)
self.assertEqual(env['CODEX_HOME'], str(config.ROOT / 'codex-home'))
def test_invalid_auth_mode_is_rejected(self):
os.environ['PCB_CODEX_AUTH'] = 'typo'
self.reload()
with self.assertRaisesRegex(ValueError, 'must be apikey or chatgpt'):
rpc.process_config(False)
def test_portable_defaults_and_explicit_model_paths(self):
for name in ('PCB_SESSION_ROOT', 'PCB_CODEX_AUTH'):
del os.environ[name]
self.reload()
self.assertEqual(config.ROOT, self.root / '.local/share/vibemake-pcb')
self.assertEqual(config.AUTH_MODE, 'chatgpt')
os.environ.update(PCB_SESSION_ROOT='~/data', PCB_CODEX_HOME='~/history',
PCB_MODEL='project-model', PCB_REASONING_EFFORT='medium',
PCB_FREEROUTING_JAR='~/router.jar')
self.reload()
self.assertEqual(config.ROOT, self.root / 'data')
self.assertEqual(config.CODEX_HOME, self.root / 'history')
self.assertEqual(config.FREEROUTING_JAR, self.root / 'router.jar')
self.assertEqual(storage.MODEL, 'project-model')
self.assertEqual(storage.EFFORT, 'medium')
def test_approval_hash_tracks_runtime_but_allows_key_rotation(self):
before = storage.fingerprint()
os.environ['OPENAI_API_KEY'] = FAKE_KEY
self.assertEqual(before, storage.fingerprint())
os.environ['OPENAI_API_KEY'] = 'rotated-unit-test-credential'
self.assertEqual(before, storage.fingerprint())
os.environ['PCB_MODEL'] = 'different-model'
self.reload()
self.assertNotEqual(before, storage.fingerprint())
async def test_eda_preserves_display_settings_without_api_credentials(self):
os.environ.update(OPENAI_API_KEY=FAKE_KEY, OPENAI_API_KEY_FILE='/secret',
DISPLAY=':99', XDG_RUNTIME_DIR=str(self.root / 'xdg'))
process = unittest.mock.Mock(returncode=0)
process.communicate = AsyncMock(return_value=(b'{"ok":true,"value":{"alive":true}}', b''))
with patch.object(asyncio, 'create_subprocess_exec', new=AsyncMock(return_value=process)) as spawn:
self.assertEqual(await eda.cli(['session', 'list']), {'alive': True})
args, kwargs = spawn.call_args
self.assertEqual(args[0], str(self.root / 'native eda'))
self.assertEqual(kwargs['env']['DISPLAY'], ':99')
self.assertEqual(kwargs['env']['XDG_RUNTIME_DIR'], str(self.root / 'xdg'))
self.assertNotIn('OPENAI_API_KEY', kwargs['env'])
self.assertNotIn('OPENAI_API_KEY_FILE', kwargs['env'])
async def test_rpc_starts_with_environment_auth_and_persistent_home(self):
os.environ['OPENAI_API_KEY'] = FAKE_KEY
binary = Path(config.CODEX_BIN)
binary.write_text(f'#!{sys.executable}\n' + '''import json,os,sys
assert os.environ.get('OPENAI_API_KEY') == 'unit-test-api-credential'
assert 'unit-test-api-credential' not in ' '.join(sys.argv)
for line in sys.stdin:
message=json.loads(line)
if 'id' in message:
result={'home':os.environ['CODEX_HOME']} if message['method']=='probe' else {}
print(json.dumps({'id':message['id'],'result':result}),flush=True)
''')
binary.chmod(0o755)
async with rpc.AppServer(self.root, False, AsyncMock()) as client:
reply = await client.call('probe', {}, timeout=5)
self.assertEqual(reply['home'], str(config.CODEX_HOME))
self.assertIsNotNone(client.proc.returncode)
self.assertTrue(client.err.closed)
self.assertFalse((config.CODEX_HOME / 'auth.json').exists())
async def test_failed_initialize_closes_process_and_log(self):
os.environ['OPENAI_API_KEY'] = FAKE_KEY
binary = Path(config.CODEX_BIN)
binary.write_text(f'#!{sys.executable}\n' + '''import json,sys
for line in sys.stdin:
message=json.loads(line)
print(json.dumps({'id':message['id'],'error':{'message':'invalid configuration'}}),flush=True)
''')
binary.chmod(0o755)
client = rpc.AppServer(self.root, False, AsyncMock())
with self.assertRaisesRegex(RuntimeError, 'invalid configuration'):
await client.__aenter__()
self.assertIsNotNone(client.proc.returncode)
self.assertTrue(client.err.closed)
if __name__ == '__main__':
unittest.main()