Spaces:
Sleeping
Sleeping
Download src/tests/runtime/test_local_web.py from dellweb3/VibeCoding: direct link, hf CLI and curl.
- Browser
- Download file 24 kB
-
https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/src/tests/runtime/test_local_web.py
- Command line
-
hf download hf://spaces/dellweb3/VibeCoding/src/tests/runtime/test_local_web.py
-
curl -L -o test_local_web.py https://huggingface.co/spaces/dellweb3/VibeCoding/resolve/main/src/tests/runtime/test_local_web.py
24 kB
| import io | |
| import json | |
| import unittest | |
| import zipfile | |
| import threading | |
| import queue | |
| from pathlib import Path | |
| from types import SimpleNamespace | |
| from fastapi.testclient import TestClient | |
| from src.adapters.persistence.local_identity import LocalIdentity | |
| from src.modules.knowledge.erp_assistant import ERPAssistant | |
| from src.modules.skill.domain.models import SkillError, Draft, digest | |
| from src.apps.workbench.web import create_web | |
| from src.apps.workbench.engine import LocalWorkbench | |
| from src.modules.governance.local_validation import LocalValidation | |
| from src.tests.runtime.fixtures import workspace, setup, AUTHOR, USER, REVIEWER | |
| class LocalWebTests(unittest.TestCase): | |
| def test_duplicate_budget_decision_preserves_running_and_verified_web_states(self): | |
| from src.adapters.persistence.runtime_sqlite import RuntimeStore | |
| store=RuntimeStore(self.folder/'budget-duplicate.sqlite') | |
| with store.connect() as db: | |
| db.execute('CREATE TABLE web_jobs(id TEXT PRIMARY KEY,state TEXT,error TEXT)') | |
| db.execute("INSERT INTO web_jobs VALUES('budget-case','working',NULL)") | |
| receipt={'digest':'a'*64,'approved':True} | |
| def job(actor,key): | |
| with store.connect() as db:state=db.execute('SELECT state FROM web_jobs WHERE id=?',(key,)).fetchone()['state'] | |
| return {'id':key,'scenario':'erp','status':state,'budget_authorizations':[receipt]} | |
| self.engine.store=store;self.engine.job=job;self.engine.lock=threading.RLock();self.engine.queue=queue.Queue() | |
| for web_state,runtime_state in [('working','running'),('verified','waiting_approval')]: | |
| with store.connect() as db:db.execute('UPDATE web_jobs SET state=? WHERE id=?',(web_state,'budget-case')) | |
| self.engine.runtimes={'erp':SimpleNamespace(decide_budget=lambda *args:{'status':runtime_state,'error':None,'budget_decision_applied':False})} | |
| response=self.client.post('/api/jobs/budget-case/budget',json={'digest':'a'*64,'revision':1,'accept':True}) | |
| self.assertEqual(response.status_code,200);self.assertEqual(response.json()['status'],web_state) | |
| self.assertEqual(self.engine.queue.qsize(),0) | |
| def test_queued_cancel_is_visible_immediately_without_waiting_for_worker(self): | |
| from src.adapters.persistence.runtime_sqlite import RuntimeStore | |
| store=RuntimeStore(self.folder/'cancel.sqlite') | |
| with store.connect() as db: | |
| db.execute('CREATE TABLE web_jobs(id TEXT PRIMARY KEY,state TEXT)') | |
| db.execute("INSERT INTO web_jobs VALUES('queued-cancel','queued')") | |
| def job(actor,key): | |
| with store.connect() as db:state=db.execute('SELECT state FROM web_jobs WHERE id=?',(key,)).fetchone()['state'] | |
| return {'id':key,'scenario':'erp','status':state} | |
| self.engine.store=store;self.engine.job=job | |
| self.engine.runtimes={'erp':SimpleNamespace(cancel=lambda *args:{'status':'cancelled'})} | |
| response=self.client.post('/api/jobs/queued-cancel/cancel') | |
| self.assertEqual(response.status_code,200) | |
| self.assertEqual(response.json()['status'],'cancelled') | |
| self.assertEqual(store.calls('queued-cancel'),[]) | |
| def test_preview_upload_is_lease_bound_and_only_pdf_accepts_body(self): | |
| calls=[] | |
| state={'id':'active-preview','scenario':'pdf'} | |
| self.engine.preview_state=lambda actor,preview_id=None:state | |
| self.engine.request_preview=lambda *a,**kw:calls.append((a,kw)) or {'status':200,'body':{},'source_digest':'fixture'} | |
| payload={'method':'POST','path':'/api/pdf/analyze','preview_id':'old-preview','body':{'base64':'AAAA'}} | |
| rejected=self.client.post('/api/preview/request',json=payload) | |
| self.assertEqual(rejected.status_code,409) | |
| self.assertEqual(rejected.json()['code'],'PREVIEW_REPLACED') | |
| self.assertFalse(calls) | |
| payload['preview_id']='active-preview';payload['body']['base64']='A'*120000 | |
| self.assertEqual(self.client.post('/api/preview/request',json=payload).status_code,200) | |
| self.assertEqual(calls[0][1]['body'],payload['body']) | |
| state['scenario']='erp';payload['path']='/api/purchase/quote' | |
| self.assertEqual(self.client.post('/api/preview/request',json=payload).status_code,422) | |
| self.assertEqual(len(calls),1) | |
| def setUp(self): | |
| self.folder=Path(self.enterContext(workspace())) | |
| self.identity=LocalIdentity(self.folder/'identity.sqlite');self.identity.seed_projects() | |
| self.erp=ERPAssistant(self.folder/'erp.sqlite',self.identity.project_access) | |
| self.engine=SimpleNamespace(identity=self.identity,erp=self.erp,shutdown=lambda:None) | |
| self.client=self.enterContext(TestClient(create_web(self.engine))) | |
| self.client.headers['Origin']='http://127.0.0.1:8789' | |
| self.client.post('/api/session/setup',json={'username':'localadmin','password':'safe-test-password-only'}) | |
| session=self.client.get('/api/session').json() | |
| self.client.headers['X-CSRF-Token']=session['csrf'] | |
| self.admin=self.identity.actor(session['actor']['user_id']) | |
| def test_first_setup_is_one_time_and_password_is_never_stored(self): | |
| self.assertEqual(self.client.post('/api/session/setup',json={'username':'secondadmin','password':'safe-test-password-only'}).status_code,409) | |
| with self.identity.connect() as db: | |
| row=db.execute('SELECT password FROM users WHERE enabled=1').fetchone() | |
| self.assertNotEqual(row['password'],'safe-test-password-only') | |
| self.assertNotIn('safe-test-password-only',(self.folder/'identity.sqlite').read_bytes().decode('utf-8',errors='ignore')) | |
| def test_csrf_origin_identity_spoof_and_logout(self): | |
| ask={'question':'最新完成的订单'} | |
| self.assertEqual(self.client.post('/api/erp/ask',json=ask,headers={'X-CSRF-Token':'bad'}).status_code,403) | |
| self.assertEqual(self.client.post('/api/erp/ask',json=ask,headers={'Origin':'https://untrusted.example'}).status_code,403) | |
| self.assertEqual(self.client.get('/api/session',headers={'X-User-Id':'admin'}).status_code,400) | |
| self.assertIn('HttpOnly',self.client.post('/api/session/login',json={'username':'localadmin','password':'safe-test-password-only'}).headers['set-cookie']) | |
| self.client.headers['X-CSRF-Token']=self.client.get('/api/session').json()['csrf'] | |
| self.assertEqual(self.client.post('/api/session/logout').status_code,200) | |
| self.assertEqual(self.client.post('/api/erp/ask',json=ask).status_code,401) | |
| def test_project_membership_not_implied_by_admin_and_revoked_immediately(self): | |
| uid=self.identity.create_user('otheradmin','other-test-password',['admin'],actor=self.admin) | |
| actor=self.identity.actor(uid) | |
| with self.assertRaises(SkillError):self.erp.ask(actor,'最新完成的订单') | |
| self.identity.set_member(self.admin,'erp-demo',uid,True) | |
| self.assertTrue(self.erp.ask(actor,'最新完成的订单')['orders']) | |
| self.identity.set_member(self.admin,'erp-demo',uid,False) | |
| with self.assertRaises(SkillError):self.erp.ask(actor,'最新完成的订单') | |
| def test_latest_is_ordered_filters_closed_and_reports_unpaid(self): | |
| result=self.client.post('/api/erp/ask',json={'question':'查询最新完成的3笔订单,哪些没有付款?'}).json() | |
| self.assertEqual([r['order_no'] for r in result['orders']],['PO-2026-1006','PO-2026-1002','PO-2026-1001']) | |
| self.assertEqual(result['orders'][-1]['outstanding_cents'],125000) | |
| self.assertIn('未付金额',result['diagnosis'][-1]['actions'][0]) | |
| self.assertTrue(result['read_only']);self.assertTrue(result['simulated_erp']) | |
| self.assertEqual(result['query']['parameters'],['erp-demo',3]) | |
| self.assertFalse(result['human_acceptance']) | |
| def test_order_gap_and_knowledge_citations(self): | |
| result=self.erp.ask(self.admin,'PO-2026-1004 为什么还未完成?') | |
| self.assertEqual(result['orders'][0]['status'],'TO_BILL') | |
| self.assertIn('已收数量大于已开票数量',result['diagnosis'][0]['actions'][0]) | |
| quality=self.erp.ask(self.admin,'来料质检不合格应当如何处理?') | |
| self.assertEqual(quality['citations'][0]['id'],'PO-QUALITY') | |
| self.assertEqual(quality['citations'][0]['quality_status'],'reference_not_enterprise_approved') | |
| self.assertTrue(all(c['url'].startswith('https://docs.frappe.io/') for c in quality['citations'])) | |
| def test_negation_and_order_embedded_in_chinese_are_not_misread(self): | |
| result=self.erp.ask(self.admin,'查询最新未完成的订单') | |
| self.assertEqual(result['intent'],'unfinished_orders') | |
| self.assertEqual({o['status'] for o in result['orders']},{'TO_BILL','TO_RECEIVE'}) | |
| self.assertEqual(len(self.erp.ask(self.admin,'采购订单PO-2026-1004为什么未完成')['orders']),1) | |
| def test_unsupported_knowledge_does_not_invent_and_database_not_mutated(self): | |
| before=self.erp.ask(self.admin,'查询最新完成的订单')['orders'] | |
| self.assertEqual(self.erp.ask(self.admin,'如何规划员工社保?')['intent'],'needs_clarification') | |
| self.assertEqual(self.erp.ask(self.admin,'删除所有订单 DROP TABLE demo_orders')['intent'],'unsupported_write') | |
| self.assertEqual(before,self.erp.ask(self.admin,'查询最新完成的订单')['orders']) | |
| self.assertEqual(self.client.post('/api/erp/ask',json={'question':'查询最新完成的999笔订单'}).status_code,422) | |
| self.assertEqual(self.client.post('/api/erp/ask',json={'question':'订单状态','sql':'DELETE FROM demo_orders'}).status_code,422) | |
| def test_login_lockout_persists_and_no_static_bearer_accepted(self): | |
| for _ in range(5): | |
| with self.assertRaises(SkillError): self.identity.login('localadmin','bad') | |
| with self.assertRaises(SkillError) as exc:self.identity.login('localadmin','safe-test-password-only') | |
| self.assertEqual(exc.exception.code,'LOGIN_RATE_LIMITED') | |
| self.assertEqual(self.client.get('/api/erp/knowledge',headers={'Authorization':'Bearer developer-demo'}).status_code,400) | |
| def test_body_limit_and_no_secret_static_routes(self): | |
| self.assertEqual(self.client.post('/api/erp/ask',content='x'*33000).status_code,413) | |
| self.assertEqual(self.client.get('/assets/identity.sqlite').status_code,404) | |
| response=self.client.get('/') | |
| self.assertEqual(response.status_code,200) | |
| self.assertIn("frame-ancestors 'none'",response.headers['content-security-policy']) | |
| class LocalReleaseTests(unittest.TestCase): | |
| def test_owner_bound_snapshot_allows_independent_reviewer_but_not_creation(self): | |
| runtime,request,_,_=setup(self.enterContext(workspace())) | |
| doc=runtime.skills.read_draft(AUTHOR,'erp-java-development') | |
| body={k:v for k,v in doc['body'].items() if k not in {'owner_id','last_editor_id'}} | |
| runtime.skills.save_draft(AUTHOR,Draft.model_validate(body).model_copy(update={'project_id':'fixture-project'}),doc['revision']) | |
| release=runtime.skills.stage_local_validation(AUTHOR,'erp-java-development','local-test',validation_owner=USER.user_id) | |
| request=dict(request,release_ref=release['key']) | |
| with self.assertRaises(SkillError):runtime.create(REVIEWER,request,'reviewer-create') | |
| run=runtime.create(USER,request,'owner-creates') | |
| for _ in range(5):run=LocalValidation(runtime,USER,'local-test').step(run['id']) | |
| self.assertEqual(run['pending_approval']['scope'],'acceptance') | |
| with self.assertRaises(SkillError):runtime.approve(USER,run['id'],run['pending_approval']['digest']) | |
| runtime.approve(REVIEWER,run['id'],run['pending_approval']['digest']) | |
| self.assertEqual(runtime.advance(USER,run['id'])['status'],'succeeded') | |
| def test_export_binds_source_and_requires_evidence_without_credentials(self): | |
| runtime,request,_,_=setup(self.enterContext(workspace())) | |
| from src.tests.runtime.fixtures import through_execution | |
| run=through_execution(runtime,request);evidence=runtime.validation_evidence(USER,run['id']) | |
| engine=LocalWorkbench.__new__(LocalWorkbench) | |
| engine.runtimes={'erp':runtime};engine.evidence=lambda *args:('erp',run['id'],evidence) | |
| from unittest.mock import patch | |
| from src.apps.workbench.deliverables import _file | |
| source=evidence['manifest']['source']['files'] | |
| with patch('src.apps.workbench.deliverables.get_delivery',return_value={'files':[_file(k,v,'model-generated') for k,v in source.items()]}): | |
| bundle=engine.export(USER,'run',run['id']) | |
| with zipfile.ZipFile(io.BytesIO(bundle)) as z: | |
| manifest=json.loads(z.read('validation-manifest.json')) | |
| self.assertFalse(manifest['deployment_approved']) | |
| self.assertEqual(manifest['source_digest'],digest(evidence['manifest']['source']['files'])) | |
| self.assertEqual(set(z.namelist()),{'src/main/java/demo/App.java','validation-manifest.json','delivery-manifest.json','evidence/validation.json','acceptance-checklist.txt'}) | |
| evidence['manifest']['source']['files']['../../escape.java']='x' | |
| with self.assertRaises(SkillError):engine.export(USER,'run',run['id']) | |
| class WorkQueueTests(unittest.TestCase): | |
| def test_limited_mode_does_not_spend_an_extra_vm_on_unrequested_prewarm(self): | |
| from unittest.mock import Mock | |
| from src.modules.governance.resource_limits import configured | |
| e=self.engine;e.resource_limits=configured();e.preview_pool=Mock() | |
| job=e.submit(USER,'erp','Fixed bounded Java requirement','limited-no-prewarm') | |
| e.process(job['id']) | |
| self.assertEqual(e.job(USER,job['id'])['status'],'verified') | |
| e.preview_pool.start.assert_not_called() | |
| def test_opted_in_failure_continues_once_with_original_source_and_diagnostics(self): | |
| e=self.engine | |
| old=e.submit(USER,'erp','Original Java requirement','automatic-recovery-old',auto_recover=True) | |
| e.runtimes['erp'].sandbox.fail='build' | |
| e.process(e.queue.get_nowait()) | |
| failed=e.job(USER,old['id']);next_id=failed['auto_recovery']['next_run_id'] | |
| self.assertEqual(failed['status'],'failed');self.assertTrue(next_id) | |
| self.assertEqual(e.auto_recover(USER,old['id']),next_id) | |
| self.assertEqual(e.queue.qsize(),1) | |
| request=e.store.get(next_id)['request'] | |
| self.assertEqual(request['baseline']['source_digest'],failed['source']['source_digest']) | |
| self.assertEqual(request['recovery_of'],old['id']);self.assertIn('observed',request['recovery_diagnostics']) | |
| e.process(e.queue.get_nowait()) | |
| last=e.job(USER,next_id) | |
| self.assertEqual(last['status'],'failed');self.assertEqual(last['auto_recovery']['attempt'],1) | |
| self.assertFalse(last['auto_recovery']['next_run_id']);self.assertTrue(e.queue.empty()) | |
| self.assertIsNone(e.auto_recover(USER,next_id)) | |
| self.assertEqual(e.store.get(old['id'])['budget'],e.store.get(next_id)['budget']) | |
| def test_failure_without_opt_in_never_creates_a_paid_continuation(self): | |
| e=self.engine;old=e.submit(USER,'erp','Original Java requirement','no-auto-recovery') | |
| e.runtimes['erp'].sandbox.fail='build';e.process(e.queue.get_nowait()) | |
| self.assertFalse(e.job(USER,old['id'])['followups']);self.assertTrue(e.queue.empty()) | |
| def test_unknown_or_unsettled_failure_cannot_auto_replay(self): | |
| e=self.engine;old=e.submit(USER,'erp','Original Java requirement','unknown-auto-recovery',auto_recover=True) | |
| rid=e.queue.get_nowait() | |
| e.store.mutate(rid,lambda r:r.update(status='unknown',error='MODEL_RESULT_UNKNOWN')) | |
| self.assertIsNone(e.auto_recover(USER,rid));self.assertTrue(e.queue.empty()) | |
| e.store.mutate(rid,lambda r:r.update(status='running',error=None)) | |
| call=e.store.reserve(rid,'fixture',{},1) | |
| e.store.mutate(rid,lambda r:r.update(status='failed',error='JAVA_TEST_FAILED')) | |
| self.assertIsNone(e.auto_recover(USER,rid));self.assertTrue(e.queue.empty()) | |
| self.assertEqual(e.store.calls(rid)[0]['state'],'reserved') | |
| def test_auto_recovery_cannot_cross_owner_or_restart_a_cancelled_task(self): | |
| from src.tests.runtime.fixtures import OTHER | |
| e=self.engine;old=e.submit(USER,'erp','Original Java requirement','cancel-auto-recovery',auto_recover=True) | |
| rid=e.queue.get_nowait() | |
| e.store.mutate(rid,lambda r:r.update(status='failed',error='JAVA_TEST_FAILED',cancel_requested=True)) | |
| self.assertIsNone(e.auto_recover(USER,rid));self.assertIsNone(e.auto_recover(OTHER,rid)) | |
| self.assertTrue(e.queue.empty()) | |
| def setUp(self): | |
| runtime,_,model,sandbox=setup(self.enterContext(workspace())) | |
| sandbox.preflight=lambda:None | |
| doc=runtime.skills.read_draft(AUTHOR,'erp-java-development') | |
| body={k:v for k,v in doc['body'].items() if k not in {'owner_id','last_editor_id'}} | |
| runtime.skills.save_draft(AUTHOR,Draft.model_validate(body).model_copy(update={'project_id':'erp-demo'}),doc['revision']) | |
| engine=LocalWorkbench.__new__(LocalWorkbench) | |
| engine.author=AUTHOR;engine.store=runtime.store;engine.skills=runtime.skills;engine.runtimes={'erp':runtime} | |
| engine.root=runtime.store.path.parent | |
| engine.identity=SimpleNamespace(project_access=lambda *a:None,actor=lambda user:USER) | |
| engine.queue=queue.Queue(maxsize=1);engine.lock=threading.RLock();engine.preview=None;engine.busy=False | |
| engine.stopped=threading.Event() | |
| engine.initialize_jobs();self.engine=engine;self.model=model | |
| def test_submit_idempotence_and_atomic_budgeted_worker_completion(self): | |
| e=self.engine | |
| first=e.submit(USER,'erp','Test Java requirement','web-test-request') | |
| second=e.submit(USER,'erp','Test Java requirement','web-test-request') | |
| self.assertEqual(first['id'],second['id']);self.assertEqual(e.queue.qsize(),1) | |
| self.assertEqual(self.model.count,0) | |
| e.process(e.queue.get_nowait()) | |
| job=e.job(USER,first['id']) | |
| self.assertEqual(job['status'],'verified');self.assertEqual(len(job['model_calls']),2) | |
| self.assertFalse(job['evidence']['manifest']['human_acceptance']) | |
| self.assertEqual(e.submit(USER,'erp','Test Java requirement','web-test-request')['status'],'verified') | |
| self.assertTrue(e.queue.empty()) | |
| def test_conflicting_key_and_full_queue_do_not_call_model(self): | |
| e=self.engine;e.submit(USER,'erp','Test Java requirement','web-test-request') | |
| with self.assertRaises(SkillError) as err:e.submit(USER,'erp','Different requirement','web-test-request') | |
| self.assertEqual(err.exception.code,'IDEMPOTENCY_CONFLICT') | |
| with self.assertRaises(SkillError) as err:e.submit(USER,'erp','Test Java requirement','web-other-request') | |
| self.assertEqual(err.exception.code,'QUEUE_FULL');self.assertEqual(self.model.count,0) | |
| def test_restart_marks_unknown_and_same_request_is_not_replayed(self): | |
| e=self.engine;e.submit(USER,'erp','Test Java requirement','web-test-request') | |
| e.queue.get_nowait();e.initialize_jobs() | |
| job=e.submit(USER,'erp','Test Java requirement','web-test-request') | |
| self.assertEqual(job['status'],'unknown');self.assertEqual(job['error'],'SERVER_RESTART_RESULT_UNKNOWN') | |
| self.assertEqual(self.model.count,0);self.assertTrue(e.queue.empty()) | |
| def test_explicit_new_recovery_links_history_without_replaying_original(self): | |
| e=self.engine | |
| old=e.submit(USER,'erp','Original Java requirement','old-recovery-request') | |
| e.queue.get_nowait();e.initialize_jobs() | |
| with self.assertRaises(SkillError) as error:e.submit(USER,'erp','Original Java requirement','new-recovery-request',recovery_of=old['id']) | |
| self.assertEqual(error.exception.code,'NEW_CALL_CONFIRMATION_REQUIRED') | |
| new=e.submit(USER,'erp','Original Java requirement','new-recovery-request',recovery_of=old['id'],acknowledge_new_cost=True) | |
| self.assertNotEqual(new['id'],old['id']) | |
| self.assertEqual(new['recovery_of'],old['id']) | |
| self.assertEqual(e.job(USER,old['id'])['status'],'unknown') | |
| self.assertEqual(e.job(USER,old['id'])['followups'],[{'id':new['id'],'status':'queued'}]) | |
| self.assertEqual(e.submit(USER,'erp','Original Java requirement','new-recovery-request',recovery_of=old['id'],acknowledge_new_cost=True)['id'],new['id']) | |
| self.assertEqual(self.model.count,0) | |
| def test_business_recovery_rejects_changed_requirement(self): | |
| e=self.engine;e.runtimes['business-app']=e.runtimes['erp'] | |
| original_spec=e.spec;e.spec=lambda actor,scenario:original_spec(actor,'erp' if scenario=='business-app' else scenario) | |
| old=e.submit(USER,'business-app','物流单检索','business-original-request') | |
| e.queue.get_nowait();e.initialize_jobs() | |
| with self.assertRaises(SkillError) as err: | |
| e.submit(USER,'business-app','采购退货','business-recovery-request',recovery_of=old['id']) | |
| self.assertEqual(err.exception.code,'RECOVERY_REQUIREMENT_CHANGED') | |
| self.assertEqual(self.model.count,0) | |
| def test_operator_schema_open_does_not_mark_an_active_queue_unknown(self): | |
| e=self.engine;job=e.submit(USER,'erp','Original Java requirement','operator-open-test') | |
| e.initialize_jobs(recover_incomplete=False) | |
| self.assertEqual(e.job(USER,job['id'])['status'],'queued') | |
| self.assertEqual(e.queue.qsize(),1);self.assertEqual(self.model.count,0) | |
| def test_recovery_rejects_another_owner_even_when_admin_can_inspect(self): | |
| e=self.engine | |
| old=e.submit(USER,'erp','Original Java requirement','old-recovery-request') | |
| e.queue.get_nowait();e.initialize_jobs() | |
| other=USER.model_copy(update={'user_id':'other-developer','roles':['admin']}) | |
| with self.assertRaises(SkillError) as err: | |
| e.submit(other,'erp','Original Java requirement','new-recovery-request',recovery_of=old['id']) | |
| self.assertEqual(err.exception.status,404) | |
| self.assertTrue(e.queue.empty());self.assertEqual(self.model.count,0) | |
| def test_known_failed_candidate_is_an_unverified_reference_for_a_new_repair(self): | |
| e=self.engine;old=e.submit(USER,'erp','Original Java requirement','failed-baseline-old') | |
| e.runtimes['erp'].sandbox.fail='build';e.process(e.queue.get_nowait()) | |
| before=e.job(USER,old['id']);self.assertEqual(before['status'],'failed') | |
| previous_calls=self.model.count | |
| new=e.submit(USER,'erp','Original Java requirement','failed-baseline-new',recovery_of=old['id']) | |
| request=e.store.get(new['id'])['request'] | |
| self.assertEqual(request['baseline_origin'],'unverified-failed-candidate') | |
| self.assertEqual(request['baseline']['source_digest'],before['source']['source_digest']) | |
| self.assertIn('observed',request['recovery_diagnostics']) | |
| self.assertEqual(e.job(USER,old['id'])['status'],'failed') | |
| self.assertEqual(self.model.count,previous_calls) | |
| def test_member_revocation_stops_queued_execution(self): | |
| e=self.engine;e.submit(USER,'erp','Test Java requirement','web-test-request');rid=e.queue.get_nowait() | |
| def denied(*args):raise SkillError('PROJECT_NOT_FOUND','revoked',404) | |
| e.identity.project_access=denied;e.process(rid) | |
| self.assertEqual(self.model.count,0) | |
| with e.store.connect() as db: | |
| row=db.execute('SELECT state,error FROM web_jobs').fetchone() | |
| self.assertEqual(row['state'],'unknown');self.assertEqual(row['error'],'PROJECT_NOT_FOUND') | |