Files
likang 7ddc3c22c5
CI / typecheck + test + build (push) Has been cancelled
commit
2026-11-16 17:50:15 +08:00

219 lines
10 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_AI_PROVIDER': 'openai',
'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.vip1129.cc')
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_explicit_api_endpoint_and_approval_fingerprint(self):
os.environ['OPENAI_API_KEY'] = FAKE_KEY
before = storage.fingerprint()
os.environ['PCB_OPENAI_BASE_URL'] = 'https://gateway.example.test/v1/'
self.reload()
args, _ = rpc.process_config(False)
provider = command_settings(args)['model_providers'][config.PROVIDER]
self.assertEqual(provider['base_url'], 'https://gateway.example.test/v1')
self.assertNotEqual(before, storage.fingerprint())
os.environ['OPENAI_API_KEY'] = 'rotated-unit-test-credential'
self.assertEqual(provider['base_url'], config.MODEL_API_BASE_URL)
def test_api_endpoint_rejects_embedded_secrets_and_invalid_urls(self):
for value in ('file:///tmp/socket', 'https://user:secret@example.test/v1',
'https://example.test/v1?key=secret', 'https://example.test/#secret',
'https://', 'https://example.test:invalid', 'https://example.test:0'):
with self.subTest(value=value):
os.environ['PCB_OPENAI_BASE_URL'] = value
with self.assertRaisesRegex(ValueError, 'PCB_OPENAI_BASE_URL'):
config.model_api_base_url()
def test_idle_timeout_is_part_of_frozen_runtime(self):
before = storage.fingerprint()
os.environ['PCB_CODEX_IDLE_TIMEOUT'] = '60'
self.reload()
self.assertEqual(config.CODEX_IDLE_TIMEOUT, 60)
self.assertNotEqual(before, storage.fingerprint())
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=(None, None))
async def start(*args, **kwargs):
kwargs['stdout'].write(b'{"ok":true,"value":{"alive":true}}')
return process
with patch.object(asyncio, 'create_subprocess_exec', new=AsyncMock(side_effect=start)) 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()