File size: 7,881 Bytes
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
import io
import json
import threading
import time
import unittest
import zipfile
from pathlib import Path
from src.adapters.persistence.local_identity import LocalIdentity
from src.apps.workbench.conversation import Conversations
from src.apps.workbench.java_skills import JavaSkills
from src.modules.llm_gateway.service import ModelReply, ProviderFailure
from src.modules.skill.domain.models import SkillError, digest
from src.tests.runtime.fixtures import workspace, USER, REVIEWER
from src.tests.runtime import test_local_web as queue_tests


class ChatTests(unittest.TestCase):
    def setUp(self):
        self.identity=LocalIdentity(Path(self.enterContext(workspace()))/'identity.sqlite')
        self.identity.seed_projects();self.identity.seed_demo_users()
        def actor(name):
            token,_=self.identity.login(name,'VibeCoding@2026');return self.identity.session(token)[0]
        self.actor,self.other,self.admin=actor('programmer'),actor('tester'),actor('manager')

    def wait(self, service, key):
        for _ in range(100):
            result=service.get(self.actor,key)
            if result['state']!='running':return result
            time.sleep(.01)
        self.fail('chat worker did not finish')

    def test_idempotency_owner_isolation_usage_and_no_tools(self):
        calls=[]
        class Provider:
            def complete(_,messages,limit,cancelled):
                calls.append(messages);return ModelReply({'answer':'Test response'},20,10,'fixture')
        s=Conversations(self.identity,[Provider()])
        r=s.submit(self.actor,'conversation','hello','request-key')
        r=self.wait(s,r['id']);self.assertEqual(r['charged'],30)
        self.assertEqual(s.submit(self.actor,'conversation','hello','request-key')['id'],r['id'])
        self.assertEqual(len(calls),1);self.assertEqual(s.usage(self.admin)['charged_tokens'],30)
        with self.assertRaises(SkillError):s.get(self.other,r['id'])
        with self.assertRaises(SkillError):s.submit(self.actor,'conversation','changed','request-key')

    def test_unknown_is_not_replayed_and_reservation_is_retained(self):
        class Provider:
            def complete(*args):raise ProviderFailure()
        s=Conversations(self.identity,[Provider()]);r=s.submit(self.actor,'conversation','hello','request-key')
        r=self.wait(s,r['id']);self.assertEqual(r['state'],'unknown');self.assertIsNone(r['charged'])
        restarted=Conversations(self.identity,[])
        self.assertEqual(restarted.submit(self.actor,'conversation','hello','request-key')['id'],r['id'])
        self.assertGreater(restarted.usage(self.admin)['unsettled_tokens'],0)

    def test_operator_open_does_not_recover_a_running_chat(self):
        release=threading.Event();self.addCleanup(release.set)
        class Provider:
            def complete(*args):
                release.wait(5);return ModelReply({'answer':'completed after inspection'},20,10,'fixture')
        service=Conversations(self.identity,[Provider()])
        row=service.submit(self.actor,'inspection','hello','operator-chat-key')
        inspection=Conversations(self.identity,[],recover_incomplete=False)
        self.assertEqual(inspection.get(self.actor,row['id'])['state'],'running')
        release.set();self.assertEqual(self.wait(service,row['id'])['state'],'completed')

    def test_known_truncated_chat_response_keeps_actual_charge_without_replay(self):
        seen=[]
        class Provider:
            def complete(*args):
                seen.append(True)
                raise ProviderFailure('MODEL_OUTPUT_TRUNCATED',input_tokens=10,output_tokens=20)
        service=Conversations(self.identity,[Provider()])
        row=service.submit(self.actor,'truncated','hello','known-truncation-chat')
        result=self.wait(service,row['id'])
        self.assertEqual(result['state'],'failed');self.assertEqual(result['charged'],30)
        self.assertEqual(len(seen),1);self.assertIsNone(result['answer'])

    def test_project_revocation_hides_answer_and_seed_does_not_regrant(self):
        class Provider:
            def complete(*args):return ModelReply({'answer':'scoped'},10,10,'fixture')
        s=Conversations(self.identity,[Provider()]);r=s.submit(self.actor,'conversation','hello','request-key','erp-demo')
        self.wait(s,r['id'])
        self.identity.set_member(self.admin,'erp-demo',self.actor.user_id,False)
        self.identity.seed_demo_users()
        with self.assertRaises(SkillError):s.get(self.actor,r['id'])
        with self.assertRaises(SkillError):s.submit(self.actor,'conversation','hello','request-new','erp-demo')


class SkillReuseTests(unittest.TestCase):
    def setUp(self):
        queue_tests.WorkQueueTests.setUp(self)

    def test_generated_skill_reuses_verified_baseline_in_shared_engine(self):
        e=self.engine;e.java_skills=JavaSkills(e)
        r=e.submit(USER,'erp','Test requirement','first-request');e.process(e.queue.get_nowait())
        skill=e.java_skills.create(USER,'run',r['id'])
        with self.assertRaises(SkillError):e.java_skills.get(REVIEWER,skill['id'])
        with zipfile.ZipFile(io.BytesIO(e.java_skills.export(USER,skill['id']))) as z:
            self.assertIn('SKILL.md',z.namelist())
            self.assertEqual(json.loads(z.read('references/evidence.json'))['manifest']['source']['source_digest'],skill['source_digest'])
        calls=[];complete=self.model.complete
        def capture(messages,*args):calls.append(messages);return complete(messages,*args)
        self.model.complete=capture
        new=e.submit(USER,'erp','Extend within the contract','reuse-request',skill['id'])
        e.process(e.queue.get_nowait())
        self.assertEqual(e.job(USER,new['id'])['status'],'verified')
        self.assertEqual(e.store.get(new['id'])['request']['source_digest'],skill['source_digest'])
        self.assertNotIn('files',json.loads(calls[0][-1]['content'])['data']['source_baseline'])
        self.assertEqual(json.loads(calls[1][-1]['content'])['data']['source_baseline']['files'],skill['evidence']['manifest']['source']['files'])
        with e.store.connect() as db:
            body=skill.copy();body.pop('id');body['name']='tampered'
            db.execute('UPDATE web_java_skills SET body=? WHERE id=?',(json.dumps(body),skill['id']))
        with self.assertRaises(SkillError):e.java_skills.get(USER,skill['id'])

    def test_waiting_job_cancellation_does_not_close_preview(self):
        from types import SimpleNamespace
        e=self.engine;r=e.submit(USER,'erp','Test requirement','queued-request')
        e.preview=SimpleNamespace(status='ready')
        worker=threading.Thread(target=e.process,args=(e.queue.get_nowait(),));worker.start()
        e.runtimes['erp'].cancel(USER,r['id']);worker.join(3)
        self.assertFalse(worker.is_alive());self.assertEqual(e.preview.status,'ready')
        self.assertEqual(self.model.count,0);self.assertEqual(e.job(USER,r['id'])['status'],'cancelled')

    def test_new_coding_task_and_idempotent_read_preserve_existing_previews(self):
        from types import SimpleNamespace
        e=self.engine
        preview=SimpleNamespace(status='ready')
        preview.close=lambda:setattr(preview,'status','closed')
        e.preview=preview;e.preview_owner=USER.user_id
        r=e.submit(USER,'erp','Test requirement','release-own-preview')
        self.assertEqual(preview.status,'ready')
        self.assertEqual(self.model.count,0)
        preview.status='ready'
        self.assertEqual(e.submit(USER,'erp','Test requirement','release-own-preview')['id'],r['id'])
        self.assertEqual(preview.status,'ready','idempotent reads must not evict a newer preview')
        e.queue.get_nowait();e.queue.task_done()
        e.preview_owner=REVIEWER.user_id
        e.submit(USER,'erp','Another task','preserve-other-preview')
        self.assertEqual(preview.status,'ready')