"""跨日复核:真实单表SQL事务、决策重走、委托回报与人工确认并发。""" import unit_test_guard import copy import os, sys sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) import json import tempfile import unittest from datetime import datetime, timedelta from unittest.mock import patch from sqlalchemy import create_engine, text, event from app.db import session from app.repo import pms_repo, qmt_repo, execution_repo from app.services import daily_buy_review as dr, proposal_service as ps, dispatcher, execution_conflicts, executor NOW = datetime(2026, 10, 30, 10, 0) CODE = '300693.SZ' class DailyReviewTests(unittest.TestCase): def test_stale_execution_write_cannot_change_approved_budget(self): from app.core import buy_budget value={'version':1,'ts_code':CODE,'amount':'10000.00','scale':'1000000', 'target_pct':'.01','quantity_limit':300,'tier':'试探仓'} value['revision']=buy_budget.identity(value) original=pms_repo.get_instruction('P')['progress'] self.assertEqual(pms_repo.update_instruction('P',progress=dict(original,buy_budget=value)),1) self.assertEqual(pms_repo.update_instruction('P',progress=original),1) changed=dict(value,amount='60000.00',tier='标准仓') changed['revision']=buy_budget.identity(changed) self.assertEqual(pms_repo.update_instruction('P',progress=dict(original,buy_budget=changed)),1) self.assertEqual(pms_repo.get_instruction('P')['progress']['buy_budget'],value) def setUp(self): self.tmp = tempfile.TemporaryDirectory(); self.addCleanup(self.tmp.cleanup) self.engine = create_engine('sqlite:///' + self.tmp.name + '/state.sqlite') self.addCleanup(self.engine.dispose) def register_json_functions(connection, _): # 生产用 MariaDB;这里精确补齐仓储所用的单个顶层路径存在性语义。 # 键存在且值为 null 仍返回 1,不能用 value is not None 代替。 def contains_path(document, mode, path): if document is None or mode is None or path is None: return None if mode != 'one' or not path.startswith('$.') or '.' in path[2:] or '[' in path: raise ValueError('测试 JSON_CONTAINS_PATH 不支持该路径形状') value = json.loads(document) return int(isinstance(value, dict) and path[2:] in value) connection.create_function('JSON_CONTAINS_PATH', 3, contains_path) event.listen(self.engine, 'connect', register_json_functions) @event.listens_for(self.engine, 'before_cursor_execute', retval=True) def sqlite_lock_syntax(conn, cursor, statement, parameters, context, executemany): return statement.removesuffix(' FOR UPDATE'), parameters self.use(session, 'get_engine', return_value=self.engine) self.use(session, '_check_cooldown') self.use(execution_repo, 'pending_corrections', return_value=0) self.params = {'PMS_DAILY_BUY_REVIEW': True} self.use(dr.param_store, 'get_bool', side_effect=lambda k, d=False: self.params.get(k, d)) self.orders = [] self.use(qmt_repo, 'orders_for_parent', side_effect=lambda _: copy.deepcopy(self.orders)) self.cancel = self.use(dispatcher, 'cancel', return_value={'ok': True}) self.fresh = {'candidate': {'ts_code': CODE, 'action': 'OPEN', 'side': 'buy', 'qty': 400, 'hard_numbers': {'plan_basis': {'research': 'today'}, 'scan_params_hash': 'p', 'portfolio_context_hash': 'a'}}, 'verdict': {'verdict': 'PASS', 'reason': 'today', 'degraded': False}, 'auto_exec': True} self.scan = self.use(ps, 'scan_and_route', side_effect=lambda **kw: {'ok': True, 'review': copy.deepcopy(self.fresh)}) ddl = [ 'CREATE TABLE pms_ws_state(id INTEGER PRIMARY KEY)', 'INSERT INTO pms_ws_state VALUES(1)', 'CREATE TABLE pms_runtime_param(param_key TEXT PRIMARY KEY,param_value TEXT)', "INSERT INTO pms_runtime_param VALUES ('PMS_SELF_DECIDE','full')", 'CREATE TABLE pms_proposal(id INTEGER PRIMARY KEY,proposal_id TEXT UNIQUE,ts_code TEXT,action TEXT,qty INTEGER,hard_numbers_json TEXT,status TEXT,expire_at TEXT,decided_at TEXT,judge_verdict TEXT,judge_reason TEXT,archived_at TEXT,created_at TEXT)', 'CREATE TABLE pms_action_ledger(id INTEGER PRIMARY KEY,ts_code TEXT,decided_at TEXT,action TEXT,arbiter TEXT,verdict TEXT,price_at REAL,hard_numbers_json TEXT,failed_checks_json TEXT,reason TEXT,ref_id TEXT,outcome_scored INTEGER)', 'CREATE TABLE pms_instruction(id INTEGER PRIMARY KEY,instruction_id TEXT UNIQUE,origin_type TEXT,origin_id TEXT,ts_code TEXT,action TEXT,side TEXT,qty INTEGER,limit_price REAL,window_tdays INTEGER,status TEXT,exec_qty INTEGER,progress_json TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT)'] with self.engine.begin() as c: for sql in ddl: c.execute(text(sql)) pms_repo.insert_instruction(instruction_id='P', origin_type='plan', origin_id='PLAN', ts_code=CODE, action='OPEN', side='buy', qty=600, limit_price=29, window_tdays=3, status='DISPATCHED', progress={'deadline': '2026-11-02', 'exec_advice': {'ymd': 20261029, 'buy_band': [28, 29]}, 'ref_lock': {'ymd': 20261029}, 'is_command': True}) session.execute('UPDATE pms_instruction SET created_at=:t, exec_qty=0', {'t': '2026-10-29 10:00:00'}) def use(self, obj, name, **kw): p = patch.object(obj, name, **kw); result = p.start(); self.addCleanup(p.stop); return result def parent(self): return pms_repo.get_instruction('P') def run_review(self): return dr.process(now=NOW) def child(self, state='ACCEPTED', qty=600, done=0): self.orders = [{'instruction_id': 'P_D01', 'status': state, 'qty': qty, 'cum_qty': done}] def prop(self): return pms_repo.get_proposal(self.parent()['progress']['daily_review']['proposal_id']) def accept(self, p=None): p = p or self.prop() return dr.decide_confirmation(p, 'ACCEPTED', '交易员确认', p['hard_numbers']['proposal_revision'], now=NOW) def test_each_waiting_parent_gets_a_turn_after_pending_or_failure(self): for iid in ('Q', 'R'): pms_repo.insert_instruction(instruction_id=iid, origin_type='plan', origin_id=iid, ts_code=CODE, action='OPEN', side='buy', qty=600, limit_price=None, window_tdays=3, status='PROPOSED', progress={'decision_ymd': 20261029}) seen = [] def decide(**kwargs): iid = kwargs['review_instruction']['instruction_id'] seen.append(iid) if iid == 'P': return {'ok': False, 'errors': ['资料暂不可用']} if iid == 'Q': return {'ok': True, 'skipped': [{'by': 'judge_pending'}]} return {'ok': True, 'review': None} self.scan.side_effect = decide for minute in range(4): dr.process(now=NOW + timedelta(minutes=minute)) self.assertEqual(seen, ['P', 'Q', 'R', 'P']) self.assertEqual(pms_repo.get_instruction('R')['status'], 'EXPIRED') self.assertEqual(self.parent()['progress']['daily_review']['attempts'], 2) def test_concurrent_review_skips_an_active_request_and_recovers_after_worker_loss(self): calls = [] def decide(**kwargs): calls.append(kwargs['review_instruction']['instruction_id']) if len(calls) == 1: dr.process(now=NOW + timedelta(seconds=1)) return {'ok': True, 'skipped': [{'by': 'judge_pending'}]} self.scan.side_effect = decide self.run_review() self.assertEqual(calls, ['P']) old = self.parent() self.assertIsNotNone(dr._claim_review(old, NOW)) self.assertIsNone(dr._claim_review(old, NOW)) dr.process(now=NOW + timedelta(seconds=5)) self.assertEqual(len(calls), 1) dr.process(now=NOW + timedelta(minutes=5)) self.assertEqual(len(calls), 2) def test_waiting_parent_beyond_newest_500_is_serviced(self): with session.transaction(): for index in range(500): pms_repo.insert_instruction(instruction_id=f'held-{index}', origin_type='plan', origin_id='plan', ts_code=CODE, action='OPEN', side='buy', qty=100, limit_price=None, window_tdays=3, status='WAIT_REVIEW', progress={ 'daily_review': {'ymd': 20261030, 'status': 'pending'}, 'trade_correction_hold': True}) self.scan.side_effect = lambda **kwargs: {'ok': True, 'review': None} result = self.run_review() self.assertEqual(result['ended'], ['P']) self.assertEqual(len(result['waiting']), 500) self.assertEqual(result['errors'], []) def test_async_pending_keeps_parent_for_later_result(self): self.scan.side_effect=None self.scan.return_value={'ok':True,'review':None, 'skipped':[{'ts_code':CODE,'by':'judge_pending','why':'waiting'}]} result=self.run_review() self.assertEqual(result['waiting'],['P']) self.assertEqual(result['ended'],[]) self.assertEqual(self.parent()['status'],'WAIT_REVIEW') self.scan.return_value={'ok':True,'review':copy.deepcopy(self.fresh)} self.assertEqual(self.run_review()['approved'],['P']) def test_old_day_is_blocked_even_with_refreshed_execution_advice(self): row = self.parent(); row['progress']['exec_advice']['ymd'] = 20261030 self.assertTrue(dr.blocker(row, now=NOW)) def test_today_new_decision_passes_and_missing_date_fails_closed(self): row = self.parent(); row['created_at'] = NOW self.assertIsNone(dr.blocker(row, now=NOW)) row['created_at'] = None self.assertTrue(dr.blocker(row, now=NOW)) def test_old_plan_materialized_today_still_requires_review(self): row = self.parent(); row['created_at'] = NOW; row['progress']['decision_ymd'] = 20261029 self.assertTrue(dr.blocker(row, now=NOW)) def test_rotation_and_sell_keep_existing_daily_process(self): row = self.parent(); row['progress']['execution_profile'] = 'rotation' self.assertIsNone(dr.blocker(row, now=NOW)) row = self.parent(); row['side'] = 'sell' self.assertIsNone(dr.blocker(row, now=NOW)) def test_maintenance_hold_stays_blocked_even_when_switch_off(self): self.params['PMS_DAILY_BUY_REVIEW'] = False row = self.parent(); row['status'] = 'WAIT_REVIEW' self.assertTrue(dr.blocker(row, now=NOW)) def test_active_child_cancel_request_does_not_reopen_parent(self): self.child() r = self.run_review() self.assertEqual(self.parent()['status'], 'WAIT_REVIEW'); self.assertEqual(r['waiting'], ['P']) self.scan.assert_not_called(); self.cancel.assert_called_once() def test_cancel_failure_remains_pending(self): self.child(); self.cancel.return_value = {'ok': False} self.assertTrue(self.run_review()['errors']); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW') def test_late_partial_fill_waits_for_bookkeeping_before_review(self): self.child('CANCELLED', done=100) self.run_review(); self.scan.assert_not_called() pms_repo.update_instruction('P', exec_qty=100) self.assertEqual(self.run_review()['approved'], ['P']) self.assertEqual(self.parent()['progress']['daily_review']['start_filled'], 100) self.assertEqual(self.parent()['exec_qty'], 100) def test_approval_uses_current_quantity_and_clears_old_price_cache(self): self.child('EXPIRED') r = self.run_review(); row = self.parent() self.assertEqual(r['approved'], ['P']); self.assertEqual(row['status'], 'PROPOSED') self.assertEqual(row['qty'], 600); self.assertEqual(row['progress']['daily_review']['qty'], 400) self.assertNotIn('exec_advice', row['progress']); self.assertNotIn('ref_lock', row['progress']) self.assertIsNone(row['limit_price']); self.assertEqual(self.scan.call_count, 2) self.assertIsNone(dr.blocker(row, now=NOW)); self.assertTrue(dr.blocker(row, now=NOW + timedelta(days=1))) def test_approval_does_not_expand_prior_authorization(self): self.fresh['candidate']['qty'] = 1000 self.run_review() self.assertEqual(self.parent()['progress']['daily_review']['qty'], 600) def test_allowance_counts_fills_and_reservations_once(self): self.run_review(); self.child('ACCEPTED', qty=300, done=100) pms_repo.update_instruction('P', exec_qty=100) self.assertEqual(dr.allowance(self.parent(), now=NOW), 100) self.orders[0]['status'] = 'CANCELLED' self.assertEqual(dr.allowance(self.parent(), now=NOW), 300) def test_source_failure_keeps_pending_and_never_reuses_yesterday(self): self.scan.side_effect = lambda **kw: {'ok': False, 'errors': ['上游失败']} self.assertTrue(self.run_review()['errors']); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW') def test_source_changed_during_model_response_requires_new_preparation(self): changed = copy.deepcopy(self.fresh); changed['candidate']['hard_numbers']['plan_basis'] = {'research': 'new'} self.scan.side_effect = [{'ok': True, 'review': self.fresh}, {'ok': True, 'review': changed}] self.assertEqual(self.run_review()['waiting'], ['P']); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW') def test_disqualified_parent_ends_without_erasing_existing_fill(self): self.child('CANCELLED', done=100); pms_repo.update_instruction('P', exec_qty=100) self.scan.side_effect = lambda **kw: {'ok': True, 'review': None, 'skipped': [{'ts_code': CODE, 'why': '排名已不入选'}]} self.assertEqual(self.run_review()['ended'], ['P']); self.assertEqual(self.parent()['exec_qty'], 100) self.assertIn('排名', self.parent()['progress']['daily_review']['reason']) def test_source_command_cancelled_during_review_cannot_resume(self): row = self.parent(); row['progress']['command_id'] = 'CMD' pms_repo.update_instruction('P', progress=row['progress']) self.use(pms_repo, 'get_command', return_value={'status': 'CANCELLED'}) self.assertEqual(self.run_review()['ended'], ['P']); self.scan.assert_not_called() def test_expired_command_does_not_keep_buying_as_partial(self): row = self.parent(); row['progress']['deadline'] = '2026-10-29' pms_repo.update_instruction('P', progress=row['progress']) self.assertEqual(self.run_review()['ended'], ['P']); self.scan.assert_not_called() def test_global_pause_prevents_decision_and_resume(self): self.params['PMS_GLOBAL_BUY_HALT'] = True self.run_review(); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW'); self.scan.assert_not_called() def test_no_remaining_auto_places_queues_existing_parent(self): session.execute("INSERT INTO pms_runtime_param VALUES ('PMS_SELF_DECIDE_DAILY_MAX','1')") pms_repo.insert_ledger(ts_code='600000.SH', action='OPEN', arbiter='judge', verdict='PASS', price_at=10, ref_id='recent_open', reason='系统采纳:原新建仓') self.fresh['self_decide'] = {'decision': 'accept'} result = self.run_review() self.assertEqual(result['queued'], ['P']) self.assertEqual(self.parent()['status'], 'WAIT_REVIEW') self.assertIn('上限', self.prop()['hard_numbers']['reason']) self.assertEqual(pms_repo.system_pass_count_today('2000-01-01'), 1) self.assertTrue(self.accept()['ok']) self.assertEqual(pms_repo.system_pass_count_today('2000-01-01'), 1) def test_auto_accept_is_counted_in_existing_daily_limit(self): self.fresh['self_decide'] = {'decision': 'accept'} self.run_review() self.assertEqual(pms_repo.system_pass_count_today('2000-01-01'), 1) self.run_review() self.assertEqual(pms_repo.system_pass_count_today('2000-01-01'), 1) def test_restart_reuses_today_approval(self): self.run_review(); n = self.scan.call_count self.run_review(); self.assertEqual(self.scan.call_count, n) def test_manual_route_requires_fresh_confirmation(self): self.fresh['auto_exec'] = False self.assertEqual(self.run_review()['queued'], ['P']); p = self.prop() self.assertEqual(p['qty'], 400); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW') self.assertTrue(self.accept(p)['ok']); self.assertEqual(self.parent()['status'], 'PROPOSED') self.assertTrue(self.accept(pms_repo.get_proposal(p['proposal_id']))['already_accepted']) self.assertEqual(len(pms_repo.list_instructions()), 1) def test_manual_decline_never_resumes(self): self.fresh['auto_exec'] = False; self.run_review(); p = self.prop() r = dr.decide_confirmation(p, 'DECLINED', '不买', p['hard_numbers']['proposal_revision'], now=NOW) self.assertTrue(r['ok']); self.assertEqual(self.parent()['status'], 'EXPIRED') def test_changed_manual_basis_invalidates_and_background_reprepares(self): self.fresh['auto_exec'] = False; self.run_review(); p = self.prop() self.fresh['candidate']['qty'] = 200 r = self.accept(p); self.assertFalse(r['ok']); self.assertTrue(r['pending']) self.assertEqual(pms_repo.get_proposal(p['proposal_id'])['status'], 'EXPIRED') self.assertEqual(self.run_review()['queued'], ['P']); self.assertEqual(self.prop()['qty'], 200) def test_cancel_during_model_response_cannot_revive_parent(self): def cancelled(**kw): pms_repo.update_instruction('P', status='CANCELLED') return {'ok': True, 'review': self.fresh} self.scan.side_effect = cancelled self.run_review(); self.assertEqual(self.parent()['status'], 'CANCELLED') def test_fill_during_model_response_cannot_overwrite_bookkeeping(self): def filled(**kw): pms_repo.update_instruction('P', exec_qty=100) return {'ok': True, 'review': self.fresh} self.scan.side_effect = filled self.run_review(); self.assertEqual(self.parent()['status'], 'WAIT_REVIEW') self.assertEqual(self.parent()['exec_qty'], 100) def test_sql_audit_failure_rolls_back_status_and_manual_decision(self): self.fresh['auto_exec'] = False; self.run_review(); p = self.prop() def fail(conn, cursor, statement, *args): if statement.startswith('INSERT INTO pms_action_ledger'): raise RuntimeError('audit failure') event.listen(self.engine, 'before_cursor_execute', fail) try: with self.assertRaises(RuntimeError): self.accept(p) finally: event.remove(self.engine, 'before_cursor_execute', fail) self.assertEqual(self.parent()['status'], 'WAIT_REVIEW') self.assertEqual(pms_repo.get_proposal(p['proposal_id'])['status'], 'WAIT_USER') def test_direct_dispatch_and_queued_sender_both_block_old_day(self): self.use(dispatcher, 'mode', return_value='ws') self.use(execution_conflicts, 'buy_blocker', return_value=None) sent = self.use(dispatcher, '_ws') r = dispatcher.dispatch(instruction_id='P_D01', ts_code=CODE, side='buy', qty=100, limit_price=30, valid_until=NOW, parent_id='P') self.assertFalse(r['ok']); sent.assert_not_called() self.assertTrue(execution_conflicts._queued_parent_check({'parent_id': 'P', 'ts_code': CODE}, self.parent())) def test_quantity_read_failure_blocks_instead_of_assuming_zero(self): self.run_review() self.use(qmt_repo, 'orders_for_parent', side_effect=RuntimeError('db down')) with self.assertRaises(RuntimeError): dr.allowance(self.parent(), now=NOW) class ScanIntegrationTests(unittest.TestCase): def setUp(self): from test_wiring import install_fakes from app.services import plan_feed, judge self.feed, self.judge = plan_feed, judge self.fake = install_fakes(prices={CODE: 30, '600001.SH': 10}, params={ 'PMS_TOTAL_SCALE': 2000000, 'PMS_AUTONOMY': 'full', 'PMS_OPEN_AUTONOMY': 'full', 'PMS_OPEN_REQUIRE_WS_CASH': False, 'PMS_EXEC_WINDOW_TDAYS': 3, 'PMS_CONSENSUS_ROUTE': False, 'PMS_PLAN_TOP_N': 1, 'PMS_CANDIDATE_SOURCE': 'plan_api', 'PMS_PLAN_THEME_CAP': 0}) self.fake.insert_instruction(instruction_id='P', origin_type='plan', origin_id='plan', ts_code=CODE, action='OPEN', side='buy', qty=600, status='WAIT_REVIEW', progress={'deadline': '2026-11-02'}) self.parent = self.fake.get_instruction('P') self.raw = {'date': '2026-10-30', 'rank_axis': 'quality', 'decision': {'id': 'today'}, 'main': [{'code': 'SZ300693', 'rank': 1, 'score': 230, 'tier': '强传导', 'upside': .3, 'heat': .2, 'verdict': '候选', 'risk': []}]} patch.object(plan_feed, 'get_plan', side_effect=lambda **kw: plan_feed.parse_plan(self.raw)).start() fp = dict(top_n=1, tiers=['强传导'], include_observe=False, min_score=0, min_sources=0, min_upside=0, theme_cap_local=0, exclude_st=False, rank_by_quality=True, rank_by_upstream=True, observe_if_fund_bull=False) patch.object(plan_feed, '_params', return_value=fp).start() self.request = patch.object(judge, 'request', return_value={'verdict': 'PASS', 'reason': '当日研究', 'confidence': 90, 'degraded': False, 'raw': {'verdict': 'PASS'}}).start() self.addCleanup(patch.stopall) def scan(self): return ps.scan_and_route(now=NOW, review_instruction=copy.deepcopy(self.parent)) def test_real_full_scan_excludes_self_and_requests_fresh_judgement(self): r = self.scan(); self.assertFalse(r['errors'], r); self.assertIsNotNone(r['review'], r) self.assertTrue(self.request.call_args.kwargs['force']) self.assertLessEqual(r['review']['candidate']['qty'], 600) self.assertEqual(len(self.fake.instructions), 1) def test_rank_cutoff_is_reapplied_not_bypassed_by_old_choice(self): self.raw['main'].insert(0, dict(self.raw['main'][0], code='SH600001', rank=1, score=250)) self.raw['main'][1]['rank'] = 2 r = self.scan(); self.assertIsNone(r['review'], r); self.request.assert_not_called() def test_other_inflight_kept_while_self_and_linked_confirmation_excluded(self): self.fake.insert_instruction(instruction_id='OTHER', origin_type='plan', origin_id='o', ts_code='600001.SH', action='OPEN', side='buy', qty=100, status='PROPOSED', progress={}) self.fake.insert_proposal(proposal_id='REVIEW', ts_code=CODE, action='OPEN', qty=200, hard_numbers={'daily_parent': 'P'}, expire_at=NOW) keys = ps._inflight_keys(exclude_instruction='P') self.assertNotIn((CODE, 'OPEN'), keys); self.assertIn(('600001.SH', 'OPEN'), keys) c = ps._inflight_open_commitments({'held': []}, exclude_instruction='P', strict=True) self.assertEqual(c['names'], {'600001.SH'}); self.assertEqual(c['amount'], 1000) def test_nonautomatic_verdict_retains_manual_route(self): self.request.return_value = {'verdict': 'UNAVAILABLE', 'reason': '待人工确认', 'degraded': True} r = self.scan(); self.assertIsNotNone(r['review'], r); self.assertFalse(r['review']['auto_exec']) def test_missing_current_source_waits_instead_of_approving(self): with patch.object(self.feed, 'get_plan', side_effect=self.feed.PlanFeedError('missing')): r = self.scan() self.assertTrue(r['errors']); self.assertIsNone(r['review']) def test_separate_manual_source_is_preserved_and_never_upgraded(self): from app.services import dividend_feed self.parent['progress']['plan'] = {'candidate_source': 'dividend'} selected = self.feed.candidates(record=False) with patch.object(dividend_feed, 'candidates', return_value=selected) as separate: r = self.scan() self.assertIsNotNone(r['review'], r); self.assertFalse(r['review']['auto_exec']) self.assertTrue(separate.called) def test_cancel_entire_command_also_cancels_review_waiting_child(self): from app.services import command_service self.fake.commands['CMD'] = {'command_id': 'CMD', 'cmd_class': 'task', 'status': 'EXECUTING'} self.fake.insert_plans([{'command_id': 'CMD', 'plan_id': 'plan', 'status': 'EXECUTING', 'qty': 600}]) with patch.object(dispatcher, 'cancel', return_value={'ok': True}): r = command_service.cancel('CMD') self.assertTrue(r['ok'], r); self.assertEqual(r['cancelled'], ['P']) self.assertEqual(self.fake.get_instruction('P')['status'], 'CANCELLED') def test_strategy_and_rotation_continue_tracking_review_waits(self): from app.services import rotation_service, strategy_runner, strategy_advisor self.assertIn('WAIT_REVIEW', rotation_service.LIVE) self.assertIn('WAIT_REVIEW', strategy_runner.LIVE_INS) self.assertTrue(strategy_advisor._has_pending({'state': {'pending': {'iid': 'P'}}})) def test_prepared_verdict_path_does_not_call_model(self): r = ps.scan_and_route(now=NOW, review_instruction=copy.deepcopy(self.parent), prepared_verdict={'verdict': 'PASS', 'reason': '今日已准备', 'degraded': False}) self.assertIsNotNone(r['review'], r); self.request.assert_not_called() if __name__ == '__main__': unittest.main()