Files
Neutron/tests/test_codex_quota_guard.py
T

237 lines
10 KiB
Python

"""Quota policy and recovery tests; no model calls or quota consumption."""
import contextlib
import io
import json
from pathlib import Path
import struct
import tempfile
import unittest
from unittest.mock import patch
from tools.workflow import codex_quota_guard as guard
def limits(used=79, duration=300, reset=2000):
return {'rateLimits': {'primary': {'usedPercent': used, 'windowDurationMins': duration,
'resetsAt': reset}}}
class QuotaTests(unittest.TestCase):
def test_boundary_thresholds(self):
for used, expected in [(0, 'ready'), (79, 'ready'), (80, 'drain'), (84, 'drain'),
(85, 'pause'), (100, 'pause')]:
with self.subTest(used=used):
self.assertEqual(guard.stage(guard.quota(limits(used), 1000), 1000), expected)
def test_actual_window_secondary(self):
data = limits(99, 10080)
data['rateLimits']['secondary'] = limits(40)['rateLimits']['primary']
self.assertEqual(guard.quota(data, 1000)['remaining'], 60)
def test_general_bucket_preferred(self):
data = limits(99)
data['rateLimitsByLimitId'] = {'codex': limits(10)['rateLimits'],
'specialty': limits(100)['rateLimits']}
self.assertEqual(guard.quota(data, 1000)['remaining'], 90)
def test_invalid_windows_never_look_healthy(self):
for data in [limits(50, 10080), limits(50, reset=999), limits(float('nan')),
limits(-1), limits(101), limits(True), {}, {'rateLimits': None}]:
with self.subTest(data=data), self.assertRaises(ValueError):
guard.quota(data, 1000)
def test_stale_and_expired_unknown(self):
sample = guard.quota(limits(), 1000)
self.assertEqual(guard.stage(sample, 1181), 'unknown')
self.assertEqual(guard.stage(dict(sample, checkedAt=1999), 2000), 'unknown')
self.assertEqual(guard.stage(None, 1000), 'unknown')
def test_reset_clears_pause_only_after_fresh_quota(self):
sample = guard.quota(limits(99), 1000)
self.assertEqual(guard.stage(sample, 2000), 'unknown')
fresh = guard.quota(limits(1, reset=20000), 2001)
self.assertEqual(guard.stage(fresh, 2001), 'ready')
def test_worker_denials_leave_checkpoint_tools_available(self):
for used in (80, 85, 100):
sample = guard.quota(limits(used), 1000)
for tool in ('Agent', 'spawn_agent', 'followup_task', 'mcp__local__spawn_agent',
'collaboration.spawn_agent'):
answer = guard.hook_response('PreToolUse', tool, sample, 1000)
self.assertEqual(answer['hookSpecificOutput']['permissionDecision'], 'deny')
for tool in ('Bash', 'apply_patch', 'send_message', 'interrupt_agent'):
answer = guard.hook_response('PreToolUse', tool, sample, 1000)
self.assertNotIn('permissionDecision', answer.get('hookSpecificOutput', {}))
def test_unknown_denies_new_workers(self):
answer = guard.hook_response('PreToolUse', 'spawn_agent', None, 1000)
self.assertEqual(answer['hookSpecificOutput']['permissionDecision'], 'deny')
def test_ready_allows_dispatch(self):
self.assertEqual(guard.hook_response('PreToolUse', 'spawn_agent',
guard.quota(limits(), 1000), 1000), {})
def test_diagnostic_event_does_not_return_context(self):
self.assertEqual(guard.hook_response('PreModelRequest', '',
guard.quota(limits(90), 1000), 1000), {})
class StateTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.state = Path(self.temp.name) / 'state'
self.patcher = patch.object(guard, 'STATE', self.state)
self.patcher.start()
self.addCleanup(self.patcher.stop)
def test_atomic_is_private_and_replaces(self):
path = self.state / 'value.json'
guard.atomic(path, {'one': 1})
guard.atomic(path, {'two': 2})
self.assertEqual(guard.read(path), {'two': 2})
self.assertEqual(path.stat().st_mode & 0o777, 0o600)
def test_thread_registration_uses_agent_id(self):
guard.register({'session_id': 'root', 'agent_id': 'child', 'turn_id': 'turn'})
entries = list((self.state / 'threads').glob('*.json'))
self.assertEqual(guard.read(entries[0])['threadId'], 'child')
def test_missing_turn_never_guessed(self):
guard.register({'session_id': 'root'})
self.assertFalse((self.state / 'threads').exists())
def test_context_only_once_per_turn(self):
guard.atomic(self.state / 'quota.json', guard.quota(limits(90), 1000))
payload = {'hook_event_name': 'PostToolUse', 'turn_id': 'turn'}
with patch.object(guard.time, 'time', return_value=1000):
self.assertIn('hookSpecificOutput', guard.handle_hook(payload))
self.assertEqual(guard.handle_hook(payload), {})
payload['turn_id'] = 'next'
self.assertIn('hookSpecificOutput', guard.handle_hook(payload))
def test_only_unambiguous_events_register_thread(self):
with patch.object(guard, 'register') as register:
guard.handle_hook({'hook_event_name': 'PreToolUse', 'session_id': 'root', 'turn_id': 'child'})
register.assert_not_called()
guard.handle_hook({'hook_event_name': 'PreModelRequest', 'session_id': 'root', 'turn_id': 'root-turn'})
register.assert_called_once()
def test_pause_saves_snapshot_and_steers_once(self):
class FakeRPC:
calls = []
def call(self, method, params):
self.calls.append((method, params))
return limits(90)
def close(self):
pass
guard.register({'session_id': 'root', 'turn_id': 'turn'})
with patch.object(guard, 'RPC', FakeRPC), patch.object(guard, 'snapshot') as snapshot, \
patch.object(guard.time, 'time', return_value=1000):
guard.tick()
guard.tick()
self.assertEqual(snapshot.call_count, 2)
steers = [p for m, p in FakeRPC.calls if m == 'turn/steer']
self.assertEqual(len(steers), 1)
self.assertEqual(steers[0]['expectedTurnId'], 'turn')
self.assertEqual(steers[0]['threadId'], 'root')
self.assertFalse(any(m == 'turn/start' for m, _ in FakeRPC.calls))
def test_inactive_turn_is_not_restarted(self):
class FakeRPC:
calls = []
def call(self, method, params):
self.calls.append(method)
if method == 'turn/steer':
raise RuntimeError('inactive')
return limits(90)
def close(self):
pass
guard.register({'session_id': 'root', 'turn_id': 'turn'})
with patch.object(guard, 'RPC', FakeRPC), patch.object(guard, 'snapshot'), \
patch.object(guard.time, 'time', return_value=1000):
guard.tick()
guard.tick()
self.assertEqual(FakeRPC.calls.count('turn/steer'), 1)
self.assertNotIn('turn/start', FakeRPC.calls)
def test_reset_timestamp_jitter_does_not_repeat_pause(self):
class FakeRPC:
steers = 0
reads = 0
def call(self, method, params):
if method == 'turn/steer':
self.steers += 1
return {}
self.reads += 1
return limits(90, reset=2000 + self.reads)
def close(self):
pass
rpc = FakeRPC()
guard.register({'session_id': 'root', 'turn_id': 'turn'})
with patch.object(guard, 'RPC', return_value=rpc), patch.object(guard, 'snapshot'), \
patch.object(guard.time, 'time', return_value=1000):
guard.tick()
guard.tick()
self.assertEqual(rpc.steers, 1)
def test_recovery_preserves_canonical_handoff(self):
project = Path(self.temp.name) / 'project'
(project / '.planning').mkdir(parents=True)
handoff = project / '.planning/HANDOFF.json'
handoff.write_text('{"precise": "continuation"}')
process = unittest.mock.MagicMock()
process.__enter__.return_value = process
process.stdout.read.return_value = b'test git output'
with patch.object(guard, 'ROOT', project), patch.object(guard.subprocess, 'Popen', return_value=process):
guard.snapshot(guard.quota(limits(90), 1000))
guard.snapshot(guard.quota(limits(90, reset=2001), 1000))
self.assertEqual(handoff.read_text(), '{"precise": "continuation"}')
self.assertFalse((self.state / 'recovery-2001').exists())
record = guard.read(self.state / 'recovery-2000/record.json')
self.assertIn('continuation', record['gsd']['.planning/HANDOFF.json'])
class FrameTests(unittest.TestCase):
def rpc(self, data=b''):
rpc = guard.RPC.__new__(guard.RPC)
rpc.sock = unittest.mock.Mock()
rpc.buffer = data
rpc.sequence = 0
return rpc
def test_eof_terminates_instead_of_spinning(self):
rpc = self.rpc()
rpc.sock.recv.return_value = b''
with self.assertRaises(EOFError):
rpc.take(1)
def test_oversize_rejected_before_payload_read(self):
rpc = self.rpc(b'\x81\x7f' + struct.pack('!Q', 2**21))
with self.assertRaises(ValueError):
rpc.message()
rpc.sock.recv.assert_not_called()
def test_ping_and_fragmented_text(self):
rpc = self.rpc(b'\x89\x01x' + b'\x01\x05{"a":' + b'\x80\x021}')
self.assertEqual(rpc.message(), {'a': 1})
rpc.sock.sendall.assert_called_once()
def test_client_masks_outgoing_frames(self):
rpc = self.rpc()
rpc.send({'test': 'value'})
wire = rpc.sock.sendall.call_args.args[0]
self.assertTrue(wire[1] & 128)
mask = wire[2:6]
raw = bytes(c ^ mask[i % 4] for i, c in enumerate(wire[6:]))
self.assertEqual(json.loads(raw), {'test': 'value'})
def test_notifications_skipped_until_matching_response(self):
rpc = self.rpc()
with patch.object(rpc, 'message', side_effect=[{'method': 'notify'}, {'id': 1, 'result': {'ok': True}}]):
self.assertEqual(rpc.call('test', {}), {'ok': True})
if __name__ == '__main__':
unittest.main()