File size: 10,251 Bytes
caf8059
 
 
5ca3c16
caf8059
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5ca3c16
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
caf8059
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
import concurrent.futures
import time
import unittest
import json
import uuid
from pathlib import Path
from types import SimpleNamespace
from src.apps.workbench.agent_sandboxes import AgentSandboxPool
from src.modules.skill.domain.models import SkillError,digest
from src.tests.runtime.fixtures import workspace


class Session:
    def __init__(self,sandbox,source):
        self.id=uuid.uuid4().hex;self.source=source;self.status='starting';self.error=None;self.receipt=None;self.expires=time.time()+900
    def start(self):self.status='ready';self.receipt={'source_digest':self.source['source_digest']}
    def close(self):self.status='closed'
    def progress(self):return {'events':[]}
    def request(self,method,path,token,**kwargs):
        if self.status!='ready':raise SkillError('PREVIEW_NOT_READY','closed',409)
        return {'source_digest':self.source['source_digest'],'body':kwargs.get('body')}


class AgentSandboxPoolTests(unittest.TestCase):
    def setUp(self):
        self.folder=Path(self.enterContext(workspace()))
        self.revoked=set();self.owner=SimpleNamespace(user_id='owner');self.other=SimpleNamespace(user_id='other')
        def spec(actor,scenario):
            if actor.user_id in self.revoked:raise SkillError('PROJECT_FORBIDDEN','revoked',403)
        def evidence(actor,kind,reference):
            spec(actor,'erp');files={'src/main/java/demo/App.java':reference}
            return 'erp',reference,{'manifest':{'source':{'files':files,'source_digest':digest(files)},'snapshot':{'framework':{}}}}
        self.engine=SimpleNamespace(root=self.folder,evidence=evidence,spec=spec,
            runtimes={'erp':SimpleNamespace(sandbox=None,harness=SimpleNamespace(files=lambda *args:None))})
        self.pool=AgentSandboxPool(self.engine,3,Session)
        self.addCleanup(self.pool.shutdown)
    def ready(self,actor,reference):
        state=self.pool.start(actor,'run',reference)
        for _ in range(100):
            state=self.pool.state(actor,state['id'])
            if state['status']=='ready':return state
            time.sleep(.005)
        self.fail('did not start')
    def test_three_artifacts_coexist_and_duplicate_requests_reuse_only_the_same_unit(self):
        states=[self.ready(self.owner,str(i)) for i in range(3)]
        self.assertEqual(len({s['id'] for s in states}),3)
        self.assertEqual(self.pool.start(self.owner,'run','0')['id'],states[0]['id'])
        for s in states:self.assertEqual(self.pool.state(self.owner,s['id'])['status'],'ready')
        with self.assertRaises(SkillError):self.pool.start(self.owner,'run','fourth')
        self.assertEqual(self.pool.list(self.owner)['active_total'],3)
    def test_other_owners_never_share_or_discover_a_unit(self):
        a=self.ready(self.owner,'same');b=self.ready(self.other,'same')
        self.assertNotEqual(a['id'],b['id'])
        with self.assertRaises(SkillError):self.pool.state(self.other,a['id'])
        with self.assertRaises(SkillError):self.pool.request(self.other,a['id'],'GET','/health','token')
        self.assertEqual([x['id'] for x in self.pool.list(self.other)['items']],[b['id']])
    def test_requests_keep_their_source_after_another_application_is_selected(self):
        first=self.ready(self.owner,'first');second=self.ready(self.owner,'second')
        self.assertEqual(self.pool.request(self.owner,first['id'],'GET','/health','token')['source_digest'],first['receipt']['source_digest'])
        self.assertNotEqual(first['receipt']['source_digest'],second['receipt']['source_digest'])
    def test_closing_one_application_does_not_close_the_others(self):
        a=self.ready(self.owner,'one');b=self.ready(self.owner,'two')
        self.pool.close(self.owner,a['id'])
        self.assertEqual(self.pool.state(self.owner,b['id'])['status'],'ready')
        self.assertEqual(self.pool.find(self.owner,'run','two')['id'],b['id'])
        self.assertEqual(self.pool.list(self.owner)['active_total'],1)
        with self.assertRaises(SkillError):self.pool.request(self.owner,a['id'],'GET','/health','token')
    def test_revocation_is_rechecked_for_existing_units(self):
        a=self.ready(self.owner,'one');self.revoked.add(self.owner.user_id)
        with self.assertRaises(SkillError):self.pool.state(self.owner,a['id'])
        with self.assertRaises(SkillError):self.pool.request(self.owner,a['id'],'GET','/health','token')
        self.assertEqual(self.pool.list(self.owner)['items'],[])
    def test_concurrent_clicks_create_one_unit_and_shutdown_releases_all(self):
        with concurrent.futures.ThreadPoolExecutor(8) as executor:
            states=list(executor.map(lambda _:self.pool.start(self.owner,'run','one'),range(12)))
        self.assertEqual(len({s['id'] for s in states}),1)
        self.pool.shutdown();self.assertEqual(self.pool.list(self.owner)['active_total'],0)

    def test_user_claims_prewarmed_preview_and_active_units_are_never_evicted(self):
        warm=self.pool.start(self.owner,'run','warm',prewarm=True)
        self.assertEqual(self.pool.list(self.owner)['items'],[])
        claimed=self.pool.start(self.owner,'run','warm')
        self.assertEqual(claimed['id'],warm['id'])
        self.assertGreater(claimed['expires_at'],time.time()+800)
        self.ready(self.owner,'two');self.ready(self.owner,'three')
        with self.assertRaises(SkillError):self.pool.start(self.owner,'run','four')
        self.assertIn(self.pool.state(self.owner,claimed['id'])['status'],{'starting','ready'})

    def test_unclaimed_prewarm_is_released_only_when_capacity_is_needed(self):
        first=self.ready(self.owner,'one');second=self.ready(self.owner,'two')
        warm=self.pool.start(self.other,'run','warm',prewarm=True)
        third=self.ready(self.owner,'three')
        self.assertEqual(self.pool.state(self.other,warm['id'])['status'],'closed')
        self.assertEqual(self.pool.state(self.owner,first['id'])['status'],'ready')
        self.assertEqual(self.pool.state(self.owner,second['id'])['status'],'ready')
        self.assertEqual(self.pool.state(self.owner,third['id'])['status'],'ready')

    def browser_clock(self):
        self.now=100.;self.pool.clock=lambda:self.now

    def test_last_window_releases_capacity_after_grace(self):
        self.browser_clock()
        states=[self.ready(self.owner,str(i)) for i in range(3)]
        a=states[0]['id'];self.pool.browser_client(self.owner,a,'a'*32,'attach')
        self.pool.browser_client(self.owner,a,'a'*32,'release')
        self.assertEqual(self.pool.state(self.owner,a)['status'],'ready')
        self.now+=self.pool.BROWSER_GRACE+1
        self.assertEqual(self.pool.state(self.owner,a)['status'],'closed')
        self.assertEqual(self.ready(self.owner,'replacement')['status'],'ready')
        self.assertEqual(self.pool.state(self.owner,states[1]['id'])['status'],'ready')

    def test_reload_and_other_windows_keep_same_session_alive(self):
        self.browser_clock();a=self.ready(self.owner,'same')['id']
        self.pool.browser_client(self.owner,a,'a'*32,'attach')
        self.pool.browser_client(self.owner,a,'b'*32,'attach')
        self.pool.browser_client(self.owner,a,'a'*32,'release')
        self.now+=10
        self.assertEqual(self.pool.state(self.owner,a)['status'],'ready')
        self.pool.browser_client(self.owner,a,'b'*32,'release')
        self.now+=3;self.pool.browser_client(self.owner,a,'c'*32,'attach')
        self.now+=10
        self.assertEqual(self.pool.find(self.owner,'run','same')['id'],a)
        with self.assertRaises(SkillError):self.pool.browser_client(self.owner,a,'b'*32,'heartbeat')

    def test_missing_close_notification_expires_without_closing_live_window(self):
        self.browser_clock();a=self.ready(self.owner,'one')['id'];b=self.ready(self.owner,'two')['id']
        self.pool.browser_client(self.owner,a,'a'*32,'attach');self.pool.browser_client(self.owner,b,'b'*32,'attach')
        self.now+=self.pool.BROWSER_TIMEOUT-1
        self.pool.browser_client(self.owner,b,'b'*32,'heartbeat')
        self.now+=2;self.pool.list(self.owner)
        self.now+=self.pool.BROWSER_GRACE+1
        self.assertEqual(self.pool.state(self.owner,a)['status'],'closed')
        self.assertEqual(self.pool.state(self.owner,b)['status'],'ready')

    def test_client_registration_cannot_cross_owner_or_revoked_acl(self):
        self.browser_clock();a=self.ready(self.owner,'one')['id']
        with self.assertRaises(SkillError):self.pool.browser_client(self.other,a,'a'*32,'release')
        self.pool.browser_client(self.owner,a,'a'*32,'attach');self.revoked.add(self.owner.user_id)
        with self.assertRaises(SkillError):self.pool.browser_client(self.owner,a,'a'*32,'release')

    def test_window_that_never_attached_is_reclaimed(self):
        self.browser_clock();a=self.ready(self.owner,'one')['id']
        self.now+=self.pool.BROWSER_TIMEOUT+1
        self.assertEqual(self.pool.state(self.owner,a)['status'],'closed')



class PreviewDiagnosticsTests(unittest.TestCase):
    def test_new_pinned_controller_reaches_evidence_check_without_bypassing_it(self):
        from src.adapters.sandbox.preview import PreviewSession
        from src.modules.skill.domain.models import digest
        sandbox=SimpleNamespace(preflight=lambda:None,worker=Path('vm_worker_v6.py'))
        session=PreviewSession(sandbox,{'files':{},'source_digest':digest({})})
        session.tested_candidate={'source_digest':'wrong'}
        session.tested_evidence={'passed':True}
        session.start()
        self.assertEqual(session.error,'EVIDENCE_BINDING_MISMATCH')
        self.assertIsNone(session.process)

    def test_preview_diagnostics_omit_exception_message_and_request_data(self):
        from src.adapters.sandbox.preview import PreviewSession
        session=PreviewSession(None,{'files':{},'source_digest':'a'*64})
        try:
            raise RuntimeError('synthetic-secret-prompt-and-url')
        except RuntimeError as exc:
            session.record_diagnostic('rpc','transport_error',exc)
        encoded=json.dumps(session.diagnostics)
        self.assertIn('RuntimeError',encoded)
        self.assertIn('transport_error',encoded)
        self.assertNotIn('synthetic-secret',encoded)

if __name__=='__main__':unittest.main()