File size: 9,133 Bytes
5ca3c16
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Targeted editor tests; fixtures are synthetic, browser evidence is separate."""
import base64
import json
import unittest
from types import SimpleNamespace

from src.apps.workbench.workflow_edit import InputFile, Trial, WorkflowEdit
from src.modules.orchestrator.profile import supported_graph
from src.modules.skill.domain.models import Actor, Draft, SkillError
from src.tests.runtime.fixtures import AUTHOR, REVIEWER, USER, setup, through_execution, workspace


class WorkflowEditTests(unittest.TestCase):
    def setUp(self):
        self.runtime, self.request, self.model, self.sandbox = setup(self.enterContext(workspace()))
        self.skills = self.runtime.skills
        self.sent = []
        def submit(*args, **kwargs):
            self.sent.append((args, kwargs))
            return {'id': 'synthetic-unit-dispatch'}
        self.engine = SimpleNamespace(skills=self.skills, submit=submit)
        self.edit = WorkflowEdit(self.engine)
        self.base = self.request['release_ref'].split('@')[0]
        self.clone = self.edit.clone(AUTHOR, self.base)
        body = {k: v for k, v in self.clone['body'].items() if k not in {'owner_id', 'last_editor_id'}}
        body['project_id'] = 'fixture-project'
        body['graph']['nodes'][0]['inputs'] = {'requirement': 'Build the requested fixture application', 'query': 'fixture-query'}
        self.clone = self.skills.save_draft(AUTHOR, Draft.model_validate(body), 1)

    def update(self, fn):
        body = {k: v for k, v in self.clone['body'].items() if k not in {'owner_id', 'last_editor_id'}}
        body = json.loads(json.dumps(body))
        fn(body)
        self.clone = self.skills.save_draft(AUTHOR, Draft.model_validate(body), self.clone['revision'])
        return self.clone

    def file(self, name='requirements.txt', content='附件中的需求资料'):
        return self.edit.upload(AUTHOR, InputFile(workflow_id=self.clone['key'], name=name,
                                content_base64=base64.b64encode(content.encode()).decode()))

    def test_clone_keeps_pinned_versions_and_original_is_unchanged(self):
        original = self.skills.read_draft(AUTHOR, self.base)
        self.assertEqual(original['revision'], 1)
        self.assertNotEqual(self.clone['key'], self.base)
        self.assertEqual(self.clone['body']['execution_profile_ref'], self.base)
        self.assertEqual(self.clone['body']['graph']['nodes'][1]['operation_ref'], 'AO01@0.1.0')
        self.assertEqual(original['body']['graph']['nodes'][0]['inputs'], {})

    def test_input_prompt_and_upload_are_saved_reopened_and_dispatched(self):
        file = self.file()
        self.update(lambda b: b['graph']['nodes'][0]['inputs'].update(attachments=[file['id']]))
        self.assertTrue(self.skills.validate(AUTHOR, self.clone['key']).valid)
        reopened = self.skills.read_draft(AUTHOR, self.clone['key'])
        self.assertEqual(reopened['body'], self.clone['body'])
        self.edit.trial(AUTHOR, self.clone['key'], Trial(expected_revision=self.clone['revision'], request_key='canvas-input-test'))
        args, kwargs = self.sent[0]
        self.assertIn('附件中的需求资料', args[2])
        self.assertEqual(kwargs['workflow_id'], self.clone['key'])
        self.assertEqual(kwargs['workflow_revision'], self.clone['revision'])
        self.assertEqual(kwargs['workflow_inputs']['attachments'][0]['sha256'], file['sha256'])
        self.assertNotIn('text', file)

    def test_prompt_and_attachment_limit_never_silently_truncates(self):
        file = self.file(content='x'*6001)
        self.update(lambda b: b['graph']['nodes'][0]['inputs'].update(attachments=[file['id']]))
        with self.assertRaises(SkillError) as denied:
            self.edit.trial(AUTHOR, self.clone['key'], Trial(expected_revision=self.clone['revision'], request_key='canvas-limit-test'))
        self.assertEqual(denied.exception.code, 'REQUIREMENT_LIMIT')
        self.assertEqual(self.sent, [])

    def test_upload_checks_role_owner_tenant_project_and_format(self):
        uploaded = self.file()
        other = Actor(tenant_id=AUTHOR.tenant_id, user_id='other-manager', roles=['admin'])
        for actor in (other, REVIEWER, USER):
            with self.assertRaises(SkillError): self.edit.file(actor, self.clone['key'], uploaded['id'])
        for name in ('../evil.txt', 'C:secret.txt', 'payload.exe', 'requirements.pdf'):
            with self.assertRaises(SkillError): self.file(name=name)
        with self.assertRaises(SkillError): self.file(content='bad\x00binary')
        with self.assertRaises(SkillError): self.file(content='x'*65537)

    def test_invalid_graph_and_conflicting_revision_do_not_submit(self):
        with self.assertRaises(SkillError) as conflict:
            self.edit.trial(AUTHOR, self.clone['key'], Trial(expected_revision=1, request_key='canvas-conflict-test'))
        self.assertEqual(conflict.exception.code, 'REVISION_CONFLICT')
        self.update(lambda b: b['graph']['control_edges'].append({'source': 'end', 'target': 'start'}))
        with self.assertRaises(SkillError) as invalid:
            self.edit.trial(AUTHOR, self.clone['key'], Trial(expected_revision=self.clone['revision'], request_key='canvas-graph-test'))
        self.assertEqual(invalid.exception.code, 'GRAPH_INVALID')
        self.assertEqual(self.sent, [])

    def test_added_independent_atom_and_its_mapping_execute_in_real_interpreter(self):
        def add(body):
            g = body['graph']
            g['nodes'].append({'id': 'extra-requirements', 'kind': 'operation', 'operation_ref': 'AO01@0.1.0',
                               'inputs': {'requirement': 'Distinct node literal from canvas'}, 'label': 'Independent requirements'})
            g['control_edges'].remove({'source': 'requirements', 'target': 'knowledge'})
            g['control_edges'].extend([{'source': 'requirements', 'target': 'extra-requirements'}, {'source': 'extra-requirements', 'target': 'knowledge'}])
            for edge in g['data_edges']:
                if edge['target'] == 'context' and edge['target_port'] == 'document': edge['source'] = 'extra-requirements'
            body['editor_positions']['extra-requirements'] = {'x': 321.0, 'y': 432.0}
        self.update(add)
        self.assertTrue(self.skills.validate(AUTHOR, self.clone['key']).valid)
        self.assertTrue(supported_graph(self.clone['body']['graph']))
        release = self.skills.stage_local_validation(AUTHOR, self.clone['key'], 'unit-test-delegation', validation_owner=USER.user_id)
        request = {**self.request, 'release_ref': release['key']}
        run = through_execution(self.runtime, request)
        self.assertEqual(run['status'], 'waiting_approval')
        self.assertEqual(run['outputs']['extra-requirements']['document']['requirement'], 'Distinct node literal from canvas')
        self.assertEqual(run['release']['draft']['editor_positions']['extra-requirements'], {'x': 321.0, 'y': 432.0})
        self.assertTrue(self.runtime.validation_evidence(USER, run['id'])['manifest']['test']['passed'])
        old = run['release']['draft']
        self.update(lambda b: b['graph']['nodes'][0]['inputs'].update(requirement='Draft changed while old run exists'))
        self.assertEqual(self.runtime.get(USER, run['id'])['release']['draft'], old)

    def test_artifact_and_model_stages_cannot_be_ambiguously_duplicated(self):
        for atom in ('AO04', 'AO05', 'AO06', 'AO08', 'AO09', 'AO10', 'AO11'):
            g = json.loads(json.dumps(self.clone['body']['graph']))
            node = next(n for n in g['nodes'] if (n.get('operation_ref') or '').startswith(atom+'@'))
            g['nodes'].append({**node, 'id': 'second-'+atom})
            self.assertFalse(supported_graph(g))

    def test_replaced_atomic_nodes_have_independent_ids_and_still_deliver(self):
        def rename(body):
            ids = {'design': 'canvas-design-instance', 'code': 'canvas-code-instance', 'patch': 'canvas-patch-instance'}
            g = body['graph']
            for node in g['nodes']: node['id'] = ids.get(node['id'], node['id'])
            for edge in [*g['control_edges'], *g['data_edges']]:
                for field in ('source', 'target'): edge[field] = ids.get(edge[field], edge[field])
            for edge in g['resource_edges']: edge['node'] = ids.get(edge['node'], edge['node'])
        self.update(rename)
        self.assertTrue(self.skills.validate(AUTHOR, self.clone['key']).valid)
        release = self.skills.stage_local_validation(AUTHOR, self.clone['key'], 'unit-replaced-instances', validation_owner=USER.user_id)
        run = through_execution(self.runtime, {**self.request, 'release_ref': release['key']})
        self.assertIn('canvas-patch-instance', run['outputs'])
        self.assertNotIn('patch', run['outputs'])
        evidence = self.runtime.validation_evidence(USER, run['id'])['manifest']
        self.assertEqual(evidence['source'], run['outputs']['canvas-patch-instance']['source'])
        self.assertEqual(evidence['development']['design'], run['outputs']['canvas-design-instance']['design'])


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