103 lines
5.0 KiB
Python
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()
|