"""退出纪律:虚构事件、真实SQLite事务与双策略隔离,禁止联网。""" import unit_test_guard # noqa: F401 import copy import datetime as dt import json import sys import tempfile import unittest from pathlib import Path from unittest.mock import patch sys.path.insert(0, str(Path(__file__).resolve().parents[1])) from sqlalchemy import create_engine, event, text from app.core import risk_exit as core, signal_rules, strategy_book as books from app.db import session as db from app.repo import pms_repo, qmt_repo, rotation_repo as store from app.services import risk_exit as service, param_store, strategy_service, logic_state_service from app.services import executor, execution_orders, execution_conflicts, signal_service from config.settings import settings CODE = '600001.SH' NOW = dt.datetime(2026, 11, 5, 10, tzinfo=core.TZ) START = NOW-dt.timedelta(hours=1) def signal(n=1, *, at=None, source='intraday', reason='独立研判确认退出'): return {'ts_code': CODE, 'action': 'SELL', 'confidence': .95, 'reason': reason, 'source': source, 'producer_id': 'bionic_brain_intraday_v2.0', 'msg_id': str(n), 'signal_id': 'S'+str(n), 'event_time': (at or NOW).isoformat(), 'is_fallback': False} def review(grade='好', ref='a', days=2): return {'overall': grade, 'review_ref': ref*64, 'report_ran_at': (NOW-dt.timedelta(days=days)).isoformat(), 'qual': 'ok', 'brain_status': 'ok'} class CoreTests(unittest.TestCase): def parse(self, value): return core.signal_event(value, now=NOW, since=START) def test_valid_and_invalid_event_boundaries(self): self.assertIsNotNone(self.parse(signal())[0]) changes = [dict(ts_code='920001.BJ'), dict(confidence=.6), dict(confidence=float('nan')), dict(action='BUY'), dict(source='unknown'), dict(producer_id='smoketest'), dict(event_time=None), dict(msg_id=None), dict(reason=''), dict(is_fallback=True), dict(is_fallback='true'), dict(event_time=(NOW+dt.timedelta(seconds=1)).isoformat()), dict(event_time=(NOW-dt.timedelta(minutes=6)).isoformat()), dict(expires_at=(NOW-dt.timedelta(seconds=1)).isoformat()), dict(expires_at='bad')] for changeset in changes: with self.subTest(changeset=changeset): self.assertIsNone(self.parse({**signal(), **changeset})[0]) def test_cutover_does_not_replay_old_signals(self): self.assertIsNone(core.signal_event(signal(),now=NOW,since=NOW+dt.timedelta(seconds=1))[0]) self.assertIsNone(core.signal_event(signal(),now=NOW,since='')[0]) def test_replay_and_cross_stream_copy_do_not_count_twice(self): a=self.parse(signal())[0] self.assertTrue(core.duplicate([a],a)) copy_event=self.parse({**signal(2,source='risk_sell'), 'event_time':(NOW-dt.timedelta(seconds=1)).isoformat()})[0] self.assertTrue(core.duplicate([a],copy_event)) copy_event=self.parse(signal(3,source='risk_sell',reason='同一研判的另一份文字'))[0] self.assertTrue(core.duplicate([a],copy_event)) modified=self.parse({**signal(3), 'signal_id':'S1','reason':'重新包装的同一信号'})[0] self.assertTrue(core.duplicate([a],modified)) self.assertFalse(core.duplicate([a],self.parse(signal(4))[0])) def test_parser_preserves_upstream_identity_and_expiry(self): t=int(NOW.timestamp()*1000) a=signal_rules.parse_intraday({'ts_code':CODE,'action':'SELL','confidence':'.95', 'signal_id':'id','trigger_time':str(t),'producer_id':'bionic_brain_intraday_v2.0', 'signal_validity':json.dumps({'expires_at':t+300000}),'audit_reason':'退出'},msg_id='1') self.assertEqual(a['event_time'],str(t));self.assertEqual(a['expires_at'],t+300000) self.assertIsNotNone(self.parse(a)[0]) b=signal_rules.parse_risk_sell({'data':json.dumps({'ts_code':CODE,'action':'SELL', 'confidence':95,'timestamp':t,'is_fallback':False,'llm_reason':'退出'})},msg_id='2') self.assertIsNotNone(self.parse(b)[0]) def test_every_overall_downgrade_counts(self): for before,after in [('好','中'),('中','差'),('好','差')]: with self.subTest(before=before,after=after): a=core.review_snapshot(review(before),now=NOW) b=core.review_snapshot(review(after,'b',1),now=NOW) self.assertEqual(core.review_change(a,b),'downgrade') def test_missing_stale_incomplete_and_future_review_are_not_downgrades(self): for value in [None,{},review('未知'),{**review(),'qual':'off'}, {**review(),'brain_status':'timeout'},review(days=121),review(days=-1), {**review(),'review_ref':''}]: self.assertIsNone(core.review_snapshot(value,now=NOW)) def test_review_order_and_immutable_identity(self): a=core.review_snapshot(review(),now=NOW) self.assertEqual(core.review_change(a,a),'same') self.assertEqual(core.review_change(None,a),'baseline') self.assertEqual(core.review_change(a,None),'missing') self.assertEqual(core.review_change(a,core.review_snapshot(review('差','b',3),now=NOW)),'old') with self.assertRaises(ValueError):core.review_change(a,{**a,'grade':'中'}) class ServiceTests(unittest.TestCase): def setUp(self): self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup) self.engine=create_engine('sqlite:///'+self.tmp.name+'/risk.sqlite');self.addCleanup(self.engine.dispose) @event.listens_for(self.engine,'before_cursor_execute',retval=True) def dialect(conn,cursor,sql,params,context,many): db.assert_single_table(sql) sql=sql.replace(' FOR UPDATE','') if 'ON DUPLICATE KEY UPDATE' in sql: self.assertIn('pms_rotation_document',sql) sql=sql.split('ON DUPLICATE KEY UPDATE')[0]+'ON CONFLICT DO NOTHING' return sql,params self.params={'PMS_RISK_EXIT_ENABLED':True,'PMS_RISK_EXIT_START_AT':START.isoformat()} self.use(db,'get_engine',lambda *args:self.engine) self.use(db,'_check_cooldown',lambda *args:None) self.use(settings,'INFRA_STRATEGY_BOOK_SCHEMA',True) for name in ('get','get_bool','get_int','get_float'): self.use(param_store,name,lambda key,default=None:self.params.get(key,default)) self.use(logic_state_service,'entry_view',lambda code:{'company_review':review()}) self.reviews={CODE:{'company_review':review()}} self.use(logic_state_service,'state_map',lambda:self.reviews) self.use(execution_orders,'correction_blocker',lambda *a,**k:'') self.pending,self.orphans=0,0 self.use(qmt_repo,'inbox_pending_count',lambda:self.pending) self.use(qmt_repo,'inbox_orphan_count',lambda:self.orphans) self.use(strategy_service,'buypause_map',lambda:(store.get('test-pause')[0] or {})) def pause(code,reason='',source='signal'): with store.locked('test-pause','test',{}) as m: e=m.setdefault(code,{'sources':{}}) e['sources'][source]={'reason':reason,'at':NOW.isoformat()} return [] def clear(code,only_source=None): with store.locked('test-pause','test',{}) as m:m.pop(code,None) return {'ok':True,'cleared':True} self.use(strategy_service,'pause_buy',pause) self.use(strategy_service,'clear_buypause',clear) self.cancel_pending=False def cancel(iid,reason='',arbiter='user',**kwargs): self.assertEqual(arbiter,'system') if not self.cancel_pending:pms_repo.update_instruction(iid,status='CANCELLED') return {'ok':True,'pending':self.cancel_pending} self.use(executor,'cancel_instruction',cancel) schema={ 'pms_position':'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,total_qty INTEGER,avail_qty INTEGER,opened_date TEXT,status TEXT', 'pms_lot':'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,instruction_id TEXT,qty INTEGER,status TEXT,open_date TEXT', 'pms_instruction':'id INTEGER PRIMARY KEY,book_id TEXT,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 DEFAULT 0,exec_avg_price REAL,progress_json TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT', 'pms_action_ledger':'id INTEGER PRIMARY KEY,book_id TEXT,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', 'pms_proposal':'id INTEGER PRIMARY KEY,book_id TEXT,proposal_id TEXT,ts_code TEXT,action TEXT,qty INTEGER,hard_numbers_json TEXT,judge_verdict TEXT,judge_reason TEXT,status TEXT,expire_at TEXT,created_at TEXT,decided_at TEXT,archived_at TEXT', 'pms_strategy':'id INTEGER PRIMARY KEY,book_id TEXT,strategy_id TEXT,ts_code TEXT,type TEXT,status TEXT,params_json TEXT,state_json TEXT,autonomy TEXT,note TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT', 'pms_rotation_document':'doc_id TEXT PRIMARY KEY,kind TEXT,payload_json TEXT,revision INTEGER,updated_at TEXT', 'pms_plan':'id INTEGER PRIMARY KEY,book_id TEXT,plan_id TEXT,ts_code TEXT,action TEXT,status TEXT,priority INTEGER,created_at TEXT,updated_at TEXT', 'pms_qmt_order':'id INTEGER PRIMARY KEY,instruction_id TEXT,parent_id TEXT,ts_code TEXT,side TEXT,status TEXT', } with self.engine.begin() as conn: for table,cols in schema.items():conn.execute(text('CREATE TABLE '+table+' ('+cols+')')) self.insert('pms_position',dict(book_id='original',ts_code=CODE,total_qty=1600,avail_qty=1600,opened_date='2026-11-03',status='HOLDING')) self.insert('pms_lot',dict(id=1,book_id='original',ts_code=CODE,instruction_id='BASE',qty=1600,status='OPEN',open_date='2026-11-03')) def use(self,obj,name,value): p=patch.object(obj,name,value);p.start();self.addCleanup(p.stop) def insert(self,table,value): with self.engine.begin() as conn: conn.execute(text('INSERT INTO '+table+' ('+','.join(value)+') VALUES ('+','.join(':'+k for k in value)+')'),value) def change(self,sql): with self.engine.begin() as conn:conn.execute(text(sql)) def state(self):return store.get(service._key(CODE))[0] or {} def instructions(self):return pms_repo.list_instructions(ts_code=CODE,include_archived=True) def fire(self,n=1,**kwargs):return service.on_signal(signal(n,**kwargs),now=NOW) def test_first_stops_buys_second_creates_one_full_exit(self): self.assertEqual(self.fire()['count'],1) self.assertTrue(execution_conflicts.buy_blocker(CODE));self.assertEqual(self.instructions(),[]) self.assertEqual(self.fire(2)['count'],2) orders=self.instructions();self.assertEqual(len(orders),1) self.assertEqual((orders[0]['action'],orders[0]['qty']),('EXIT',1600)) self.assertTrue(orders[0]['progress']['urgent']) def test_duplicate_after_restart_does_not_count(self): self.fire();self.fire() self.assertEqual(self.state()['count'],1);self.assertEqual(self.instructions(),[]) self.fire(2);self.fire(2);service.scan(now=NOW) self.assertEqual(len(self.instructions()),1) def test_same_report_and_upgrade_no_exit_downgrade_exits(self): self.assertEqual(service.observe_review(CODE,review(),now=NOW),'same') service.drive(CODE,now=NOW);self.assertEqual(self.instructions(),[]) self.assertEqual(service.observe_review(CODE,review('中','b',1),now=NOW),'downgrade') service.drive(CODE,now=NOW) self.assertEqual(self.instructions()[0]['qty'],1600) self.assertEqual(self.state()['review_exit']['before']['grade'],'好') def test_missing_entry_review_starts_baseline_without_fabricated_decline(self): self.use(logic_state_service,'entry_view',lambda code:{}) self.assertEqual(service.observe_review(CODE,review('中'),now=NOW),'baseline') service.drive(CODE,now=NOW);self.assertEqual(self.instructions(),[]) def test_incomplete_review_keeps_last_valid_baseline(self): service.observe_review(CODE,review(),now=NOW) service.observe_review(CODE,{**review('差','b',1),'brain_status':'timeout'},now=NOW) self.assertEqual(self.state()['review']['grade'],'好');self.assertEqual(self.instructions(),[]) def test_stale_or_changed_same_version_does_not_exit(self): service.observe_review(CODE,review(),now=NOW) self.assertEqual(service.observe_review(CODE,review('差','b',3),now=NOW),'old') with self.assertRaises(ValueError):service.observe_review(CODE,review('差'),now=NOW) self.assertEqual(self.state()['review']['grade'],'好');self.assertEqual(self.instructions(),[]) def test_global_pause_records_intent_without_actions(self): self.params['PMS_GLOBAL_EXEC_HALT']=True self.fire();self.fire(2) self.assertEqual(self.state()['phase'],'EXIT_PENDING');self.assertEqual(self.instructions(),[]) self.params['PMS_GLOBAL_EXEC_HALT']=False service.scan(now=NOW);self.assertEqual(len(self.instructions()),1) def test_dry_run_writes_nothing(self): result=service.on_signal(signal(),now=NOW,dry_run=True) self.assertTrue(result['dry_run']);self.assertEqual(self.state(),{});self.assertEqual(self.instructions(),[]) def test_feature_off_keeps_legacy_path(self): self.params['PMS_RISK_EXIT_ENABLED']=False self.assertIsNone(self.fire());self.assertIsNone(service.buy_blocker(CODE)) def test_micro_book_untouched(self): self.insert('pms_position',dict(book_id='micro30',ts_code=CODE,total_qty=900,avail_qty=900,opened_date='2026-11-03')) self.insert('pms_lot',dict(id=2,book_id='micro30',ts_code=CODE,instruction_id='MICRO',qty=900,status='OPEN')) with books.scope('micro30'): self.assertIsNone(self.fire());self.assertIsNone(service.buy_blocker(CODE)) self.fire();self.fire(2) self.assertEqual(self.instructions()[0]['qty'],1600) with books.scope('micro30'): self.assertEqual(self.instructions(),[]);self.assertEqual(pms_repo.get_position(CODE)['total_qty'],900) def test_t1_retains_full_exit_quantity_until_available(self): self.change('UPDATE pms_position SET avail_qty=0') self.fire();self.fire(2) self.assertEqual(self.instructions()[0]['qty'],1600) service.scan(now=NOW);self.assertEqual(len(self.instructions()),1) def test_exit_insert_failure_does_not_consume_second_signal_twice(self): self.fire() with patch.object(pms_repo,'insert_instruction',return_value=0): with self.assertRaises(RuntimeError):self.fire(2) self.assertEqual(self.state()['count'],2);self.assertEqual(self.state()['phase'],'EXIT_PENDING') self.assertEqual(self.instructions(),[]) self.fire(2);self.assertEqual(len(self.instructions()),1);self.assertEqual(self.state()['count'],2) def test_audit_failure_rolls_back_signal_count(self): with patch.object(pms_repo,'insert_ledger',return_value=0): with self.assertRaises(RuntimeError):self.fire() self.assertEqual(self.state(),{}) self.fire();self.assertEqual(self.state()['count'],1) def test_first_cancels_buy_but_preserves_sell(self): pms_repo.insert_instruction(instruction_id='BUY',origin_type='proposal',origin_id=None,ts_code=CODE,action='ADD',side='buy',qty=100,status='PROPOSED') pms_repo.insert_instruction(instruction_id='SELL',origin_type='plan',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='PROPOSED') self.fire() self.assertEqual(pms_repo.get_instruction('BUY')['status'],'CANCELLED') self.assertEqual(pms_repo.get_instruction('SELL')['status'],'PROPOSED') self.assertIsNotNone(pms_repo.instruction_buy_stop('BUY')) def test_existing_sell_finishes_before_full_exit(self): pms_repo.insert_instruction(instruction_id='SELL',origin_type='plan',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='PROPOSED') self.fire();self.fire(2);self.assertEqual(len(self.instructions()),1) pms_repo.update_instruction('SELL',status='CONFIRMED') self.change('UPDATE pms_position SET total_qty=1500,avail_qty=1500') self.change('UPDATE pms_lot SET qty=1500') service.drive(CODE,now=NOW) self.assertEqual(self.instructions()[0]['qty'],1500) def test_pending_order_even_with_terminal_parent_prevents_double_sell(self): pms_repo.insert_instruction(instruction_id='OLD',origin_type='strategy',origin_id=None,ts_code=CODE,action='TRIM',side='sell',qty=100,status='CANCELLED') self.insert('pms_qmt_order',dict(instruction_id='CHILD',parent_id='OLD',ts_code=CODE,side='sell',status='ACCEPTED')) self.fire();self.fire(2) self.assertEqual(len(self.instructions()),1) def test_pending_ledger_and_correction_hold_wait(self): self.fire();self.pending=1;self.fire(2) self.assertEqual(self.instructions(),[]) self.pending=0 with patch.object(execution_orders,'correction_blocker',return_value='修正待核实'): with self.assertRaises(RuntimeError):service.drive(CODE,now=NOW) self.assertEqual(self.instructions(),[]) service.drive(CODE,now=NOW);self.assertEqual(len(self.instructions()),1) def test_cancelled_exit_is_not_reopened(self): self.fire();self.fire(2) pms_repo.update_instruction(self.instructions()[0]['instruction_id'],status='CANCELLED') service.drive(CODE,now=NOW) self.assertEqual(self.state()['phase'],'MANUAL');self.assertEqual(len(self.instructions()),1) service.resume_buy(CODE) self.assertEqual(self.state()['phase'],'WATCH') self.assertIsNone(service.buy_blocker(CODE)) def test_late_buy_after_flat_is_still_closed_out(self): self.fire();self.fire(2) iid=self.instructions()[0]['instruction_id'];pms_repo.update_instruction(iid,status='CONFIRMED',exec_qty=1600) self.change('UPDATE pms_position SET total_qty=0,avail_qty=0');self.change("UPDATE pms_lot SET qty=0,status='CLOSED'") service.scan(now=NOW);self.assertEqual(self.state()['phase'],'CLOSED') self.insert('pms_lot',dict(id=2,book_id='original',ts_code=CODE,instruction_id='BASE',qty=100,status='OPEN')) self.change('UPDATE pms_position SET total_qty=100,avail_qty=0') service.scan(now=NOW) self.assertEqual(len(self.instructions()),2);self.assertEqual(self.instructions()[0]['qty'],100) def test_new_holding_round_does_not_inherit_old_signal(self): self.fire();old=self.state()['round_id'] self.change("UPDATE pms_lot SET qty=0,status='CLOSED'") self.insert('pms_lot',dict(id=2,book_id='original',ts_code=CODE,instruction_id='NEW',qty=1600,status='OPEN')) service.observe_review(CODE,review(),now=NOW) self.assertNotEqual(self.state()['round_id'],old);self.assertEqual(self.state()['count'],0) self.assertEqual(self.instructions(),[]) def test_human_resume_resets_count_but_cannot_undo_started_exit(self): self.fire();service.resume_buy(CODE) self.assertIsNone(service.buy_blocker(CODE));self.assertEqual(self.state()['count'],0) self.fire();self.assertEqual(self.state()['count'],0) # 已处理的旧信号不得重算。 self.change("DELETE FROM pms_rotation_document WHERE doc_id LIKE 'risk-exit:%'") self.fire();self.fire(2) with self.assertRaises(ValueError):service.resume_buy(CODE) def test_legacy_pause_only_seeds_one_real_signal(self): reason='风控 SELL 置信度 95% ≥ 85%, 清仓 1600 股 —— 旧真实研判' strategy_service.pause_buy(CODE,reason=reason,source='intraday') pms_repo.insert_proposal(proposal_id='LEGACY',ts_code=CODE,action='EXIT',qty=1600, hard_numbers={'on_strategy':True,'confidence':.95,'signal_source':'intraday','reason':'策略暂停。 —— '+reason}, expire_at=NOW+dt.timedelta(days=1),judge_verdict='STRATEGY_RISK') self.change("UPDATE pms_proposal SET created_at='2026-11-05 10:00:00'") service.observe_review(CODE,review(),now=NOW) self.assertEqual(self.state()['count'],1);self.assertEqual(self.instructions(),[]) self.fire(2) self.assertEqual(len(self.instructions()),1) self.assertEqual(pms_repo.get_proposal('LEGACY')['status'],'EXPIRED') def test_signal_handler_bypasses_legacy_daily_dedup_and_pending_proposal(self): view={'positions':[{'ts_code':CODE,'total_qty':1600,'avail_qty':1600}]} prm={'sell_conf_min':.6,'auto_exit_conf':.85,'trim_ratio':.3333} seen={signal_rules.dedup_key(signal(),20261105):None} class Clock(dt.datetime): @classmethod def now(cls,tz=None):return NOW with patch.object(service,'datetime',Clock): out={'ignored':0} signal_service._handle(signal(),view,prm,seen,20261105,False,out,{CODE}) signal_service._handle(signal(2),view,prm,seen,20261105,False,out,{CODE}) self.assertEqual(len(self.instructions()),1) def test_independent_review_refresh_and_timeout_keep_baseline(self): from app.services import plan_feed with patch.object(plan_feed,'fetch_logic_states',return_value={CODE:{'company_review':review('中','b',1)}}) as fetch: out=service.refresh_reviews(now=NOW) self.assertTrue(out['ok']);self.assertEqual(out['reviews'][CODE],'downgrade') fetch.assert_called_once_with([CODE],timeout=3) self.assertEqual(self.instructions(),[]) # 刷新只记意图,委托留给执行任务。 service.refresh_reviews(now=NOW+dt.timedelta(seconds=60)) self.assertEqual(fetch.call_count,1) with patch.object(plan_feed,'fetch_logic_states',side_effect=TimeoutError): out=service.refresh_reviews(now=NOW+dt.timedelta(minutes=6)) self.assertFalse(out['ok']);self.assertEqual(self.state()['review']['grade'],'中') self.assertEqual(self.state()['phase'],'EXIT_PENDING') service.scan(now=NOW) self.assertEqual(len(self.instructions()),1) def test_refresh_missing_rows_and_disabled_do_not_manufacture_downgrade(self): from app.services import plan_feed with patch.object(plan_feed,'fetch_logic_states',return_value={}) as fetch: out=service.refresh_reviews(now=NOW) self.assertEqual(out['reviews'][CODE],'missing') self.assertEqual(self.state()['review']['grade'],'好') self.params['PMS_RISK_EXIT_ENABLED']=False service.refresh_reviews(now=NOW+dt.timedelta(minutes=6)) self.assertEqual(fetch.call_count,1) self.assertEqual(self.instructions(),[]) def test_failed_unfreeze_command_cannot_clear_risk_pause(self): from app.services import command_service self.fire() with patch.object(command_service,'active_commands',return_value=[]), \ patch.object(pms_repo,'next_command_seq',return_value=1), \ patch.object(pms_repo,'insert_command',return_value=1), \ patch.object(pms_repo,'update_command',return_value=1), \ patch.object(command_service,'_apply_param',return_value={'ok':False}): result=command_service.issue('UNFREEZE_STOCK',{'ts_code':CODE}) self.assertFalse(result['ok']) self.assertEqual(self.state()['phase'],'STOP_BUY') self.assertIn('risk_exit',strategy_service.buypause_map()[CODE]['sources']) def test_new_buy_command_does_not_silently_reset_stop(self): from app.services import command_service self.fire() with patch.object(command_service,'active_commands',return_value=[]), \ patch.object(pms_repo,'next_command_seq',return_value=1), \ patch.object(pms_repo,'insert_command',return_value=1), \ patch.object(pms_repo,'get_command',return_value={}), \ patch.object(command_service,'plan_command',return_value={'ok':False}): command_service.issue('OPEN_TARGET',{'ts_code':CODE,'target_ratio':.05}) self.assertEqual(self.state()['phase'],'STOP_BUY') def test_refresh_runs_independently_of_reprice_switch(self): from app import scheduler self.params['PMS_EXEC_REPRICE_ENABLED']=False fn=scheduler.execution_basis_refresh.run while hasattr(fn,'__wrapped__'):fn=fn.__wrapped__ with patch.object(service,'refresh_reviews',return_value={'ok':True,'reviews':{CODE:'same'}}) as fresh: result=fn() fresh.assert_called_once() self.assertEqual(result['risk_reviews']['reviews'],{CODE:'same'}) class DisplayTests(unittest.TestCase): def test_first_stop_without_strategy_is_visible(self): rows=[{'ts_code':CODE,'total_qty':100}] with patch.object(service,'enabled',return_value=True), patch.object(store,'get',return_value=({'phase':'STOP_BUY','reason':'第一次信号'},1)): service.decorate_positions(rows) self.assertEqual(rows[0]['exit_status_text'],'只卖不买') def test_exit_stages_are_not_mislabelled_as_add(self): for phase,text in [('EXIT_PENDING','等待清仓'),('EXITING','清仓中'),('MANUAL','退出待处理')]: rows=[{'ts_code':CODE,'total_qty':100}] with patch.object(service,'enabled',return_value=True), patch.object(store,'get',return_value=({'phase':phase},1)): service.decorate_positions(rows) self.assertEqual(rows[0]['exit_status_text'],text) def test_failure_is_visible_without_changing_trade_state(self): rows=[{'ts_code':CODE,'total_qty':100}] with patch.object(service,'enabled',return_value=True), patch.object(store,'get',side_effect=ValueError('unavailable')): service.decorate_positions(rows) self.assertEqual(rows[0]['exit_status_text'],'退出状态待核实') def test_disabled_and_empty_positions_do_not_read_state(self): with patch.object(service,'enabled',return_value=False), patch.object(store,'get') as get: service.decorate_positions([{'ts_code':CODE,'total_qty':100}]);get.assert_not_called() with patch.object(service,'enabled',return_value=True), patch.object(store,'get') as get: service.decorate_positions([{'ts_code':CODE,'total_qty':0}]);get.assert_not_called() if __name__=='__main__':unittest.main()