219 lines
10 KiB
Python
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()
|