File size: 9,541 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
144
145
146
147
148
149
"""Targeted tests of the read adapter; synthetic fixtures are not browser evidence."""
import json
import unittest
from types import SimpleNamespace

from fastapi import FastAPI
from fastapi.responses import JSONResponse
from fastapi.testclient import TestClient

from src.apps.workbench.workflow_read import WorkflowRead, build_router, safe
from src.modules.skill.domain.models import Actor, Draft, SkillError
from src.tests.runtime.fixtures import AUTHOR, REVIEWER, USER, OTHER, setup, through_execution, workspace


class WorkflowReadTests(unittest.TestCase):
    def setUp(self):
        folder = self.enterContext(workspace())
        self.runtime, self.request, self.model, self.sandbox = setup(folder)
        self.skills = self.runtime.skills
        self.read = WorkflowRead(SimpleNamespace(skills=self.skills, store=self.runtime.store, runtimes={'erp': self.runtime}))
        self.id = self.request['release_ref'].split('@')[0]

    def test_graph_comes_from_real_saved_definition(self):
        doc = self.skills.read_draft(AUTHOR, self.id)
        result = self.read.definition(AUTHOR, self.id)
        self.assertEqual(result['definition']['graph'], doc['body']['graph'])
        self.assertEqual(result['source']['digest'], doc['digest'])
        self.assertEqual(len(result['nodes']), 16)
        self.assertEqual(result['issues'], [])
        for node in result['nodes']:
            if node['definition']['kind'] == 'operation':
                self.assertEqual(node['definition']['operation_ref'], node['atom']['operation_id']+'@'+node['atom']['version'])
            else:
                self.assertIsNone(node['atom']['version'])

    def test_historical_run_does_not_use_changed_draft_or_current_registry(self):
        run = self.runtime.create(USER, self.request, 'readonly-history-0001')
        doc = self.skills.read_draft(AUTHOR, self.id)
        body = {k: v for k, v in doc['body'].items() if k not in {'owner_id', 'last_editor_id'}}
        body['graph']['nodes'][1]['label'] = 'Changed current draft'
        self.skills.save_draft(AUTHOR, Draft.model_validate(body), doc['revision'])
        with self.skills.repository.transaction(write=True) as tx:
            tx.db.execute("UPDATE skill_documents SET body=replace(body,'parse_requirements','changed_registry') WHERE kind='operation'")
        historical = self.read.definition(AUTHOR, self.id, run_id=run['id'])
        self.assertEqual(historical['definition']['graph'], run['release']['draft']['graph'])
        self.assertNotEqual(historical['definition']['graph'], self.read.definition(AUTHOR, self.id)['definition']['graph'])
        atom = next(n['atom'] for n in historical['nodes'] if n['definition'].get('operation_ref') == 'AO01@0.1.0')
        self.assertEqual(atom['handler_ref'], 'parse_requirements')

    def test_waiting_acceptance_is_not_success_and_output_without_events_is_recorded(self):
        run = through_execution(self.runtime, self.request)
        trace = self.read.trace(AUTHOR, run['id'])
        self.assertEqual(trace['status'], 'waiting_approval')
        self.assertEqual(trace['nodes']['acceptance']['status'], 'waiting')
        self.assertEqual(trace['nodes']['evidence']['status'], 'not_started')
        self.assertEqual(trace['nodes']['end']['status'], 'not_started')
        self.runtime.store.mutate(run['id'], lambda r: r['outputs'].update({'end': {'manifest': 'synthetic'}}))
        self.assertEqual(self.read.trace(AUTHOR, run['id'])['nodes']['end']['status'], 'recorded')

    def test_unknown_fields_and_unmappable_atoms_are_visible_not_dropped(self):
        with self.skills.repository.transaction(write=True) as tx:
            doc = tx.get(AUTHOR.tenant_id, 'draft', self.id)
            body = doc['body']
            body['graph']['nodes'][1]['operation_ref'] = 'AO99@9.0.0'
            body['graph']['nodes'][1]['future_condition'] = {'branch': 'unsupported', 'api_key': 'DO_NOT_EXPOSE'}
            tx.update(AUTHOR.tenant_id, 'draft', self.id, body, doc['revision'])
        result = self.read.definition(AUTHOR, self.id)
        self.assertTrue(result['issues'])
        self.assertIn('future_condition', result['definition']['graph']['nodes'][1])
        self.assertEqual(result['definition']['graph']['nodes'][1]['future_condition']['api_key'], '[已隐藏]')
        self.assertTrue(result['nodes'][1]['missing'])

    def test_permissions_and_project_access_apply_to_every_read(self):
        for call in (lambda: self.read.workflows(USER), lambda: self.read.atoms(USER), lambda: self.read.runs(USER), lambda: self.read.definition(USER, self.id)):
            with self.assertRaises(SkillError) as denied: call()
            self.assertEqual(denied.exception.status, 403)
        run = self.runtime.create(USER, self.request, 'readonly-acl-0001')
        with self.assertRaises(SkillError): self.read.trace(OTHER, run['id'])
        with self.skills.repository.transaction(write=True) as tx:
            doc = tx.get(AUTHOR.tenant_id, 'draft', self.id)
            tx.update(AUTHOR.tenant_id, 'draft', self.id, {**doc['body'], 'project_id': 'denied'}, doc['revision'])
        def deny(actor, project): raise SkillError('PROJECT_DENIED', 'denied', 403)
        self.skills.project_access = deny
        self.assertEqual(self.read.workflows(AUTHOR), [])
        self.assertEqual(self.read.runs(AUTHOR)['items'], [])
        with self.assertRaises(SkillError): self.read.definition(AUTHOR, self.id)

    def test_log_pagination_after_1000_and_error_location_and_secrets(self):
        run = self.runtime.create(USER, self.request, 'readonly-events-0001')
        with self.runtime.store.connect() as db:
            db.executemany('INSERT INTO runtime_stage_events(run_id,timestamp,stage,status,detail) VALUES(?,?,?,?,?)',
                           [(run['id'], i, 'code', 'active', 'api_key=DO_NOT_EXPOSE') for i in range(1005)])
            db.executemany('INSERT INTO runtime_stage_events(run_id,timestamp,stage,status,detail) VALUES(?,?,?,?,?)',
                           [(run['id'], 1006, 'build', 'started', ''), (run['id'], 1008, 'build', 'failed', 'JAVA_BUILD_FAILED')])
        after, count, pages = 0, 0, []
        while True:
            trace = self.read.trace(AUTHOR, run['id'], after=after, limit=100)
            pages.append(trace['events']); count += len(trace['events'])
            if trace['after'] is None: break
            after = trace['after']
        self.assertEqual(count, 1007)
        self.assertEqual(trace['nodes']['build']['error'], 'JAVA_BUILD_FAILED')
        self.assertEqual(trace['nodes']['build']['attempts'], [{'status': 'failed', 'seconds': 2}])
        self.assertNotIn('DO_NOT_EXPOSE', json.dumps(pages))

    def test_all_read_routes_have_no_writes_and_do_not_create_releases(self):
        app = FastAPI()
        app.include_router(build_router(self.read.engine, lambda: AUTHOR))
        app.exception_handler(SkillError)(lambda request, exc: JSONResponse({'code': exc.code}, status_code=exc.status))
        with self.skills.repository.transaction() as tx:
            before = [tuple(r) for r in tx.db.execute('SELECT * FROM skill_documents')]
            audits = tx.db.execute('SELECT count(*) FROM skill_audit').fetchone()[0]
        client = TestClient(app)
        for path in ('workflows', 'workflows/'+self.id, 'workflow-atoms', 'workflow-runs'):
            self.assertEqual(client.get('/api/v1/admin/'+path).status_code, 200)
            self.assertEqual(client.post('/api/v1/admin/'+path).status_code, 405)
        self.assertEqual(client.get('/api/v1/admin/workflow-runs?limit=101').status_code, 422)
        with self.skills.repository.transaction() as tx:
            self.assertEqual(before, [tuple(r) for r in tx.db.execute('SELECT * FROM skill_documents')])
            self.assertEqual(audits, tx.db.execute('SELECT count(*) FROM skill_audit').fetchone()[0])

    def test_atom_catalog_has_exact_version_references_and_real_system_types(self):
        catalog = self.read.atoms(AUTHOR)
        ao = next(a for a in catalog if a['ref'] == 'AO05@0.1.0')
        self.assertTrue(any(r['node'] == 'code' and r['workflow'] == self.id for r in ao['references']))
        system = next(a for a in catalog if a['ref'] == 'system:approval:design')
        self.assertIsNone(system['version'])
        self.assertEqual(safe({'credential_ref': 'cred-123', 'api_key': 'secret'}), {'credential_ref': 'cred-123', 'api_key': '[已隐藏]'})

    def test_nonempty_run_list_paginates_without_holding_read_cursor_during_acl(self):
        ids = [self.runtime.create(USER, self.request, 'readonly-list-'+str(i))['id'] for i in range(3)]
        first = self.read.runs(AUTHOR, limit=2)
        self.assertEqual([r['id'] for r in first['items']], ids[::-1][:2])
        self.assertIsNotNone(first['before'])
        last = self.read.runs(AUTHOR, limit=2, before=first['before'], workflow=self.id)
        self.assertEqual([r['id'] for r in last['items']], ids[:1])
        self.assertIsNone(last['before'])

    def test_expired_lease_is_exposed_without_rewriting_unknown_run(self):
        run = self.runtime.create(USER, self.request, 'readonly-expired-0001')
        self.runtime.store.mutate(run['id'], lambda r: r.update(status='running', lease_until=1))
        self.assertTrue(self.read.runs(AUTHOR)['items'][0]['lease_expired'])
        self.assertTrue(self.read.trace(AUTHOR, run['id'])['lease_expired'])
        self.assertEqual(self.runtime.store.get(run['id'])['status'], 'running')


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