File size: 5,359 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
"""Explicit synthetic doubles. Never used by the production composition root."""
from pathlib import Path
from contextlib import contextmanager
import uuid
from src.adapters.persistence.runtime_sqlite import RuntimeStore
from src.adapters.persistence.skill_sqlite import SqliteSkillRepository
from src.modules.skill.application.service import SkillService
from src.modules.skill.domain.models import Actor, SkillError, digest
from src.modules.skill.packs.examples import all_examples, framework_candidate
from src.modules.harness.policy import Harness
from src.modules.llm_gateway.service import LLMGateway, ModelReply
from src.modules.orchestrator.service import AgentRuntime

AUTHOR = Actor(tenant_id='test-tenant', user_id='author', roles=['admin'])
REVIEWER = Actor(tenant_id='test-tenant', user_id='reviewer', roles=['reviewer'])
USER = Actor(tenant_id='test-tenant', user_id='developer', roles=[])
OTHER = Actor(tenant_id='other', user_id='developer', roles=['admin'])
COLLECTIONS = ['java-basics', 'java-patterns', 'erp', 'wms', 'equipment-ops', 'java-frameworks',
               'web-development', 'java-persistence', 'java-testing', 'java-integration']
SOURCE = {'src/main/java/demo/App.java': 'package demo; public class App { public static void main(String[] args) {} }'}


@contextmanager
def workspace():
    # Keep test evidence under the ignored workspace; Windows system TEMP may have different ACLs.
    folder = Path(__file__).resolve().parents[3] / '.local/test-runs/runtime' / uuid.uuid4().hex
    folder.mkdir(parents=True)
    yield str(folder)


class KnowledgeFixture:
    allowed = True

    def resolve(self, actor, binding):
        if not self.allowed:
            raise SkillError('KNOWLEDGE_NOT_FOUND', 'fixture revoked', 404)
        return {'collection_id': binding.collection_id, 'revision': binding.revision, 'digest': 'a' * 64}

    def search(self, actor, query, ids, limit):
        return [{'citation_id': 'fixture-citation', 'snippet': 'Synthetic test reference only', 'source_url': 'fixture://source'}]


class ModelFixture:
    name = 'test-only-model'
    count = 0
    hook = None

    def complete(self, messages, max_tokens, cancelled):
        self.count += 1
        if self.hook:
            self.hook()
        import json
        kind = json.loads(messages[-1]['content'])['task']
        return ModelReply({'summary': 'Synthetic Java design'} if kind == 'design' else {'files': SOURCE}, 80, 80, self.name)


class SandboxFixture:
    execution_mode = 'simulated'
    runtime_contract = {'main_class': 'demo.App', 'port': 8080}
    skill_ids = ['erp-java-development', 'wms-java-development', 'equipment-ops-java-development']
    fail = None
    cleaned = True

    def __init__(self):
        self.calls = []

    def build(self, run_id, source, cancelled):
        self.calls.append('build')
        if self.fail == 'build':
            raise SkillError('JAVA_BUILD_FAILED', 'synthetic failure')
        return {'source_digest': source['source_digest'], 'image': 'fixture@sha256:' + '1' * 64,
                'classes_digest': '2' * 64, 'suite_digest': '3' * 64, 'config_digest': '4' * 64,
                'execution_mode': 'simulated', 'stage': 'build', 'passed': True, 'container': 'fixture'}

    def probe(self, run_id, candidate, stage, cancelled):
        self.calls.append(stage)
        if self.fail == stage:
            raise SkillError('JAVA_TEST_FAILED' if stage == 'test' else 'JAVA_PREVIEW_FAILED', 'synthetic failure')
        return dict(candidate, stage=stage, cases=3, passed_cases=3)

    def cleanup(self, run_id):
        self.calls.append('cleanup')
        return self.cleaned


def setup(folder, scenario=0, *, clock=None):
    folder = Path(folder)
    knowledge = KnowledgeFixture()
    skills = SkillService(SqliteSkillRepository(folder / 'skills.sqlite'), knowledge.resolve, lambda actor, project: None)
    skills.bootstrap(AUTHOR)
    framework = framework_candidate().model_copy(update={'state': 'approved', 'evidence_refs': ['synthetic-unit-test-only']})
    skills.add_framework(AUTHOR, framework)
    draft = all_examples({c: 'fixture-v1' for c in COLLECTIONS})[scenario]
    skills.save_draft(AUTHOR, draft)
    report = skills.validate(AUTHOR, draft.skill_id)
    approval = skills.approve(REVIEWER, draft.skill_id, 1, report.digest, ['synthetic-unit-test-only'])
    release = skills.publish(AUTHOR, draft.skill_id, '0.1.0', 1, approval['key'])
    store = RuntimeStore(folder / 'runtime.sqlite')
    model, sandbox = ModelFixture(), SandboxFixture()
    runtime = AgentRuntime(store, skills, knowledge, LLMGateway(store, [model]), Harness(enabled=True, allow_simulated=True), sandbox,
                           **({'clock': clock} if clock else {}))
    request = {'release_ref': release['key'], 'project_id': 'fixture-project', 'source_digest': digest({}),
               'requirement': 'Synthetic Java HTTP test requirement', 'query': 'inventory'}
    return runtime, request, model, sandbox


def through_execution(runtime, request):
    run = runtime.create(USER, request, 'request-0001')
    run = runtime.advance(USER, run['id'])
    runtime.approve(USER, run['id'], run['pending_approval']['digest'])
    run = runtime.advance(USER, run['id'])
    runtime.approve(USER, run['id'], run['pending_approval']['digest'])
    return runtime.advance(USER, run['id'])