Files
canina/infra/hermes-pilot/test_tech_adapter.py
2026-10-23 19:36:56 +00:00

103 lines
5.0 KiB
Python

import datetime, json, pathlib, sys, tempfile, unittest
from unittest.mock import patch
sys.path.insert(0,str(pathlib.Path(__file__).parent))
from test_contract import lease
import tech_adapter as a
class Adapter(unittest.TestCase):
def test_wrong_pilot_never_constructs_inference(self):
calls=[]
class Transport:
def post(self, route, body):
calls.append(route)
return {'lease':dict(lease(),pilotKind='arbitrary')}
with tempfile.TemporaryDirectory() as root:
with self.assertRaises(ValueError):
a.run_once(Transport(),lease()['taskId'],root,{'maxCalls':1,'maxTokens':160,'reservationCents':20,'monetaryCapVerified':False,'acceptUnverifiedMonetaryCap':True},lambda: self.fail('inference constructed'))
self.assertEqual(calls,['tech-claim'])
def test_end_to_end_process_fixture(self):
source='def clamp_quantity(quantity):\n return min(99, max(0, quantity))\n'
d=dict(lease(),pilotKind=a.PILOT_KIND); calls=[]
class Transport:
def post(self,route,body):
calls.append((route,body))
if route=='tech-claim': return {'lease':d}
if route=='heartbeat': return {'leaseUntil':d['leaseUntil']}
return {'taskId':d['taskId'],'runId':d['runId'],'state':'VERIFYING','artifactSha256':'b'*64,'costStatus':'upper-bound-reserved'}
policy={'maxCalls':1,'maxTokens':160,'reservationCents':20,'monetaryCapVerified':False,'acceptUnverifiedMonetaryCap':True}
with tempfile.TemporaryDirectory() as root:
runner=lambda: a.executor.ProcessInference([sys.executable,'-c','print('+repr(json.dumps({'source':source,'tools':0,'model':'Free'}))+')'])
result=a.run_once(Transport(),d['taskId'],root,policy,runner)
self.assertEqual(result['state'],'VERIFYING')
self.assertEqual(calls[-1][0],'tech-complete')
self.assertEqual(calls[-1][1]['source'],source)
self.assertNotIn('leaseToken',result)
class BudgetTests(unittest.TestCase):
def test_second_provider_call_blocked_and_tokens_forced(self):
from inference_budget import SingleCall
seen=[]
gate=SingleCall()
def create(**kwargs): seen.append(kwargs); return 'ok'
self.assertEqual(gate.call(create,{'max_tokens':999,'stream':True}),'ok')
self.assertEqual(seen,[{'max_tokens':160,'stream':False}])
with self.assertRaises(RuntimeError): gate.call(create,{})
self.assertEqual(len(seen),1)
class TransportTests(unittest.TestCase):
def test_invalid_credential_rejected(self):
with self.assertRaises(ValueError): a.Transport('https://stage.invalid','short')
def test_real_http_auth_and_denial(self):
import http.server, threading
seen=[]
class Handler(http.server.BaseHTTPRequestHandler):
def log_message(self,*args): pass
def do_POST(self):
seen.append((self.path,self.headers.get('Authorization'),json.loads(self.rfile.read(int(self.headers['Content-Length'])))))
self.send_response(403 if self.path.endswith('heartbeat') else 200)
self.end_headers(); self.wfile.write(b'{"lease":null}')
server=http.server.ThreadingHTTPServer(('127.0.0.1',0),Handler)
thread=threading.Thread(target=server.serve_forever,daemon=True); thread.start()
try:
t=a.Transport('http://127.0.0.1:'+str(server.server_port),'x'*48,allow_loopback_http=True)
self.assertEqual(t.post('tech-claim',{'taskId':'explicit'}),{'lease':None})
with self.assertRaises(PermissionError): t.post('heartbeat',{})
self.assertEqual(seen[0],('/internal/prepare-worker/tech-claim','Bearer '+'x'*48,{'taskId':'explicit'}))
finally: server.shutdown(); server.server_close(); thread.join()
def test_total_deadline_includes_slow_response_body(self):
import http.server, threading, time
class Handler(http.server.BaseHTTPRequestHandler):
def log_message(self,*args): pass
def do_POST(self):
self.send_response(200); self.end_headers()
try:
for _ in range(30): self.wfile.write(b' '); self.wfile.flush(); time.sleep(.3)
except (BrokenPipeError,ConnectionResetError): pass
server=http.server.ThreadingHTTPServer(('127.0.0.1',0),Handler)
thread=threading.Thread(target=server.serve_forever,daemon=True); thread.start()
try:
t=a.Transport('http://127.0.0.1:'+str(server.server_port),'x'*48,allow_loopback_http=True)
started=time.monotonic()
with self.assertRaises(TimeoutError): t.post('heartbeat',{})
self.assertLess(time.monotonic()-started,5)
finally: server.shutdown(); server.server_close(); thread.join()
def test_secret_mount_rejects_unsafe_files(self):
import os
with tempfile.TemporaryDirectory() as root:
path=pathlib.Path(root,'credential'); path.write_text('x'*48); path.chmod(0o400)
# /tmp may be writable; use descriptor traversal rooted in a private fixture.
with patch.object(a,'SECRET_PATH',str(path)):
with self.assertRaises(ValueError): a.read_credential()
def test_admission_fails_before_network(self):
class Transport:
def post(self,*args): raise AssertionError('network forbidden')
for policy in [{},dict(a.ADMISSION,maxCalls=2),dict(a.ADMISSION,maxTokens=161),dict(a.ADMISSION,monetaryCapVerified=True),dict(a.ADMISSION,maxCalls=True)]:
with self.assertRaises(ValueError): a.run_once(Transport(),lease()['taskId'],'/',policy)
if __name__=='__main__': unittest.main()