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