"""人工止损命令、行情边界、SQLite清仓收尾;全部隔离,不连接运行账户。""" import unit_test_guard import copy import datetime as dt import json import unittest import tempfile from concurrent.futures import ThreadPoolExecutor from unittest.mock import patch import test_risk_exit as base from app.core import risk_exit as core, strategy_book as books from app.repo import pms_repo, qmt_repo from app.services import risk_exit as service, market, executor, logic_state_service CODE, NOW = base.CODE, base.NOW def command(price=10, cid='STOP1', issued=None): return dict(command_id=cid, cmd_type='SET_STOP_PRICE', ts_code=CODE, status='EFFECTIVE', issued_at=issued or NOW-dt.timedelta(minutes=2), params={'price':price}) def quote(price=10, at=NOW): return dict(kind='minute', source='isolated-test', last=price, as_of=at.isoformat()) class CoreTests(unittest.TestCase): def test_simulation_cached_halt_read_also_rejects_invalid_old_value(self): from app.services import param_store from config.settings import settings key = 'PMS_GLOBAL_EXEC_HALT' with patch.object(settings, 'PMS_TABLE_PREFIX', ''), patch.object(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', True), \ patch.object(param_store, 'refresh', return_value={key:{'param_value':'unknown'}}): self.assertTrue(param_store.get_bool(key)) def test_equal_and_below_trigger_above_does_not(self): for price, trigger in [(9.99,True),(10,True),(10.01,False)]: self.assertEqual(bool(core.user_stop_event(command(),quote(price),now=NOW)[0]),trigger) def test_missing_disabled_invalid_command_never_triggers(self): for value in [None,0,-1,float('nan'),float('inf'),'bad']: self.assertIsNone(core.user_stop_event(command(value),quote(),now=NOW)[0]) for changes in [dict(command_id=None),dict(status='CANCELLED'),dict(ts_code='920001.BJ'), dict(issued_at=None),dict(issued_at=NOW+dt.timedelta(seconds=1))]: self.assertIsNone(core.user_stop_event({**command(),**changes},quote(),now=NOW)[0]) def test_quote_time_source_and_finite_price_required(self): changes=[dict(as_of=None),dict(as_of='2026-11-05T10:00:00'),dict(source=''), dict(kind='unknown'),dict(last=float('nan')),dict(last=float('inf')), dict(last=0),dict(as_of=(NOW-dt.timedelta(days=1)).isoformat()), dict(as_of=(NOW+dt.timedelta(seconds=1)).isoformat()), dict(as_of=(NOW-dt.timedelta(seconds=91)).isoformat())] for value in changes: with self.subTest(value=value): self.assertIsNone(core.user_stop_event(command(),{**quote(),**value},now=NOW)[0]) self.assertIsNotNone(core.user_stop_event(command(),quote(at=NOW-dt.timedelta(seconds=90)),now=NOW)[0]) def test_quote_must_follow_effective_command(self): self.assertIsNone(core.user_stop_event(command(issued=NOW),quote(at=NOW-dt.timedelta(seconds=1)),now=NOW)[0]) class ParamTransactionTests(unittest.TestCase): def setUp(self): from sqlalchemy import create_engine, event from app.db import session as db from app.services import param_store from config.settings import settings tmp = self.enterContext(tempfile.TemporaryDirectory()) engine = create_engine('sqlite:///' + tmp + '/params.sqlite') self.addCleanup(engine.dispose) self.enterContext(patch.object(db, 'get_engine', return_value=engine)) self.enterContext(patch.object(settings, 'PMS_TABLE_PREFIX', '')) self.enterContext(patch.object(settings, 'INFRA_ROTATION_DOCUMENT_SCHEMA', True)) self.enterContext(patch.object(param_store, '_cache', {'loaded':False, 'at':0, 'data':{}, 'error':None})) self.fail_state = False self.at_state_update = None @event.listens_for(engine, 'before_cursor_execute', retval=True) def dialect(conn, cursor, sql, params, context, many): sql = sql.replace(' FOR UPDATE', '') if 'ON DUPLICATE KEY UPDATE' in sql: if 'pms_runtime_param' in sql: sql = sql.replace('ON DUPLICATE KEY UPDATE', 'ON CONFLICT(param_key) DO UPDATE SET') else: sql = sql.partition('ON DUPLICATE KEY UPDATE')[0] + 'ON CONFLICT DO NOTHING' if sql.startswith('UPDATE pms_rotation_document SET payload_json=') and self.at_state_update: self.at_state_update() if self.fail_state: raise RuntimeError('模拟状态文档末笔写入失败') return sql, params with engine.begin() as conn: conn.exec_driver_sql('CREATE TABLE pms_runtime_param (param_key TEXT PRIMARY KEY, param_value TEXT, ' 'updated_by TEXT, updated_at TEXT)') conn.exec_driver_sql('CREATE TABLE pms_rotation_document (doc_id TEXT PRIMARY KEY, kind TEXT, ' 'payload_json TEXT, revision INTEGER, updated_at TEXT)') self.key = 'PMS_ROTATION_CONTROL' self.assertTrue(param_store.set_param('PMS_ROTATION_MODE', 'paper', 'isolated')['ok']) self.assertTrue(param_store.set_param(self.key, 'pause_all', 'isolated')['ok']) self.pool = self.enterContext(ThreadPoolExecutor(max_workers=1)) def test_real_control_and_document_publish_together_across_rollback_and_commit(self): from app.services import rotation_service, param_store def check_readers(): self.assertEqual(param_store.get(self.key), 'exit_disable') self.assertEqual(self.pool.submit(param_store.get, self.key).result(timeout=3), 'pause_all') def fresh_reader(): return param_store.refresh(force=True)[self.key]['param_value'] self.assertEqual(self.pool.submit(fresh_reader).result(timeout=3), 'pause_all') self.at_state_update = check_readers self.fail_state = True with self.assertRaisesRegex(RuntimeError, '末笔写入失败'): rotation_service._set_control('exit_disable', 'isolated') self.assertEqual(pms_repo.get_param(self.key), 'pause_all') self.assertEqual(param_store.get(self.key), 'pause_all') self.assertIsNone(rotation_service.store.get('state:paper')[0]) self.fail_state = False rotation_service._set_control('exit_disable', 'isolated') self.assertTrue(rotation_service.store.get('state:paper')[0]['rotation']['disabled']) self.assertEqual(self.pool.submit(param_store.get, self.key).result(timeout=3), 'exit_disable') def test_savepoint_rollback_and_release_preserve_outer_value_until_commit(self): from app.db import session as db from app.services import param_store with db.transaction(): self.assertTrue(param_store.set_param(self.key, 'pause_new')['ok']) with self.assertRaisesRegex(ValueError, '回滚'): with db.savepoint(): self.assertTrue(param_store.set_param(self.key, 'run')['ok']) self.assertEqual(param_store.get(self.key), 'run') raise ValueError('回滚') self.assertEqual(param_store.get(self.key), 'pause_new') with db.savepoint(): self.assertTrue(param_store.set_param(self.key, 'exit_disable')['ok']) self.assertEqual(param_store.get(self.key), 'exit_disable') self.assertEqual(param_store.get(self.key), 'exit_disable') self.assertEqual(self.pool.submit(param_store.get, self.key).result(timeout=3), 'pause_all') self.assertEqual(self.pool.submit(param_store.get, self.key).result(timeout=3), 'exit_disable') class ServiceTests(base.ServiceTests): def put_stop(self, price=10, cid='STOP1'): c=command(price,cid) self.insert('pms_command',dict(book_id='original',command_id=cid,cmd_class='param',cmd_type=c['cmd_type'], ts_code=CODE,status='EFFECTIVE',issued_at=c['issued_at'].isoformat(),params_json=json.dumps(c['params']))) def trigger(self): result=service.observe_user_stop(CODE,quote(),now=NOW) service.drive(CODE,now=NOW) return result def test_old_freeze_and_stop_survive_500_newer_effective_commands(self): from sqlalchemy import text from app.services import rotation_service self.insert('pms_command', dict(book_id='original', command_id='old-freeze', cmd_class='param', cmd_type='FREEZE_STOCK', ts_code=CODE, status='EFFECTIVE')) self.put_stop(cid='old-stop') other = '600002.SH' with self.engine.begin() as conn: sql = text("INSERT INTO pms_command (book_id,command_id,cmd_class,cmd_type,ts_code,status) " "VALUES ('original',:cid,'param',:kind,:code,'EFFECTIVE')") conn.execute(sql, [{'cid':kind+str(i), 'kind':kind, 'code':other} for kind in ('FREEZE_STOCK', 'SET_STOP_PRICE') for i in range(500)]) freeze = ('FREEZE_STOCK',) self.assertEqual(len(pms_repo.list_effective_stock_params(freeze)), 501) filtered = pms_repo.list_effective_stock_params(freeze, ts_code=CODE) self.assertEqual([row['command_id'] for row in filtered], ['old-freeze']) self.assertIn(CODE, rotation_service.micro_buy_restrictions()) self.assertEqual(set(rotation_service.micro_buy_restrictions(CODE)), {CODE}) self.assertEqual(service._stop_commands()[CODE]['command_id'], 'old-stop') self.assertTrue(service.observe_user_stop(CODE, quote(), now=NOW)['triggered']) def test_scan_generates_one_exit_without_model_or_second_signal(self): self.put_stop() with patch.object(market,'execution_quote',return_value=quote()) as fetch, \ patch.object(logic_state_service,'state_map',side_effect=RuntimeError('offline')): first=service.scan(now=NOW);service.scan(now=NOW) self.assertTrue(first['user_stops'][CODE]['triggered']) self.assertEqual(self.state()['count'],0) ins=self.instructions();self.assertEqual(len(ins),1);self.assertEqual(ins[0]['qty'],1600) self.assertTrue(ins[0]['progress']['is_command']);self.assertTrue(ins[0]['progress']['urgent']) self.assertFalse(ins[0]['progress']['from_signal']) self.assertEqual(ins[0]['progress']['risk_exit']['user_stop']['command_id'],'STOP1') self.assertEqual(fetch.call_args.kwargs['limits'],{}) def test_all_execution_halt_retains_intent_but_buy_halt_allows_exit(self): self.put_stop();self.params['PMS_GLOBAL_EXEC_HALT']=True self.trigger();self.assertEqual(self.instructions(),[]);self.assertEqual(self.state()['phase'],'EXIT_PENDING') self.params['PMS_GLOBAL_EXEC_HALT']=False;self.params['PMS_GLOBAL_BUY_HALT']=True service.drive(CODE,now=NOW);self.assertEqual(len(self.instructions()),1) def test_command_is_not_disabled_by_model_risk_switch(self): self.params['PMS_RISK_EXIT_ENABLED']=False;self.put_stop();self.trigger() self.assertEqual(len(self.instructions()),1);self.assertTrue(service.buy_blocker(CODE)) def existing_model_exit(self,pending): self.params['PMS_GLOBAL_EXEC_HALT']=pending self.fire();self.fire(2) self.params['PMS_GLOBAL_EXEC_HALT']=False self.params['PMS_RISK_EXIT_ENABLED']=False self.put_stop();self.trigger() self.assertEqual(len(self.instructions()),1) self.assertIn('user_stop',self.state()) service.drive(CODE,now=NOW);self.assertEqual(len(self.instructions()),1) def test_existing_model_pending_exit_continues_under_user_stop(self): self.existing_model_exit(True) def test_existing_model_exit_is_not_duplicated_by_user_stop(self): self.existing_model_exit(False) def test_latest_zero_price_disables_trigger_and_new_price_replaces_old(self): self.put_stop(11);self.put_stop(0,'STOP2') self.assertFalse(self.trigger()['triggered']);self.assertEqual(self.instructions(),[]) self.put_stop(10,'STOP3');self.assertTrue(self.trigger()['triggered']) self.assertEqual(self.state()['user_stop']['command_id'],'STOP3') def test_stale_quote_and_system_reference_do_not_trigger(self): self.put_stop(9) self.assertFalse(service.observe_user_stop(CODE,quote(),now=NOW)['triggered']) self.put_stop(11,'STOP2') self.assertFalse(service.observe_user_stop(CODE,quote(at=NOW-dt.timedelta(days=1)),now=NOW)['triggered']) self.assertEqual(self.instructions(),[]) def test_old_buy_cancel_and_pending_report_finish_before_full_exit(self): self.put_stop();self.cancel_pending=True pms_repo.insert_instruction(instruction_id='BUY',origin_type='proposal',origin_id=None, ts_code=CODE,action='ADD',side='buy',qty=100,status='DISPATCHED') self.insert('pms_qmt_order',dict(instruction_id='CHILD',parent_id='BUY',ts_code=CODE,side='buy',status='ACCEPTED')) self.trigger();self.assertEqual(len(self.instructions()),1) self.cancel_pending=False;self.change("UPDATE pms_qmt_order SET status='CANCELLED'") self.pending=1;service.drive(CODE,now=NOW);self.assertEqual(len(self.instructions()),1) self.pending=0;service.drive(CODE,now=NOW) self.assertEqual(self.instructions()[0]['action'],'EXIT');self.assertEqual(self.instructions()[0]['qty'],1600) def test_cancel_failure_keeps_intent_and_no_exit_then_retries(self): self.put_stop() pms_repo.insert_instruction(instruction_id='BUY',origin_type='proposal',origin_id=None, ts_code=CODE,action='ADD',side='buy',qty=100,status='PROPOSED') with patch.object(executor,'cancel_instruction',return_value={'ok':False}): with self.assertRaises(RuntimeError):self.trigger() self.assertEqual(self.state()['phase'],'EXIT_PENDING');self.assertEqual(len(self.instructions()),1) service.drive(CODE,now=NOW);self.assertEqual(self.instructions()[0]['action'],'EXIT') def test_old_grid_sell_and_strategy_are_cancelled_before_exit(self): self.put_stop() self.insert('pms_strategy',dict(book_id='original',strategy_id='GRID',ts_code=CODE,type='GRID',status='ACTIVE',params_json='{}',state_json='{}')) pms_repo.insert_instruction(instruction_id='SELL',origin_type='strategy',origin_id='GRID', ts_code=CODE,action='TRIM',side='sell',qty=100,status='DISPATCHED') self.insert('pms_qmt_order',dict(instruction_id='CHILD',parent_id='SELL',ts_code=CODE,side='sell',status='ACCEPTED')) self.trigger();self.assertEqual(len(self.instructions()),1) self.assertEqual(pms_repo.get_instruction('SELL')['status'],'CANCELLED') self.assertEqual(pms_repo.list_strategies(ts_code=CODE,statuses=['ACTIVE'],limit=1),[]) self.change("UPDATE pms_qmt_order SET status='CANCELLED'") service.drive(CODE,now=NOW);self.assertEqual(self.instructions()[0]['qty'],1600) def test_user_sell_finishes_then_exit_covers_actual_remainder(self): self.put_stop() 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.trigger();self.assertEqual(len(self.instructions()),1) pms_repo.update_instruction('SELL',status='CONFIRMED',exec_qty=100) 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_t1_partial_fill_and_late_buy_keep_full_remaining_exit(self): self.params['PMS_RISK_EXIT_ENABLED']=False self.put_stop();self.change('UPDATE pms_position SET avail_qty=0');self.trigger() ins=self.instructions()[0];self.assertEqual(ins['qty'],1600) pms_repo.update_instruction(ins['instruction_id'],status='DISPATCHED',exec_qty=600) self.change('UPDATE pms_position SET total_qty=1000,avail_qty=0');self.change('UPDATE pms_lot SET qty=1000') service.drive(CODE,now=NOW+dt.timedelta(days=1));self.assertEqual(len(self.instructions()),1) pms_repo.update_instruction(ins['instruction_id'],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.drive(CODE,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') with patch.object(market,'execution_quote',return_value=quote(11)): service.scan(now=NOW) self.assertEqual(self.instructions()[0]['qty'],100);self.assertEqual(len(self.instructions()),2) def test_clearing_price_does_not_undo_trigger_or_reopen_cancelled_exit(self): self.put_stop();self.trigger();iid=self.instructions()[0]['instruction_id'] self.put_stop(0,'STOP2');service.drive(CODE,now=NOW) self.assertEqual(self.state()['phase'],'EXITING') pms_repo.update_instruction(iid,status='CANCELLED');service.drive(CODE,now=NOW) self.assertEqual(self.state()['phase'],'MANUAL');self.put_stop(10,'STOP3');self.trigger() self.assertEqual(len(self.instructions()),1) def test_audit_or_instruction_failure_cannot_lose_intent(self): self.put_stop() with patch.object(pms_repo,'insert_ledger',return_value=0): with self.assertRaises(RuntimeError):service.observe_user_stop(CODE,quote(),now=NOW) self.assertEqual(self.state(),{}) with patch.object(pms_repo,'insert_instruction',return_value=0): with self.assertRaises(RuntimeError):self.trigger() self.assertEqual(self.state()['phase'],'EXIT_PENDING');self.assertEqual(self.instructions(),[]) service.drive(CODE,now=NOW);self.assertEqual(len(self.instructions()),1) def test_missing_pause_defaults_and_bad_input_cannot_release_pause(self): from app.services import param_store self.assertFalse(param_store.execution_halted()) self.change("INSERT INTO pms_runtime_param VALUES ('PMS_GLOBAL_EXEC_HALT','True')") for value in (None, 'ture', 2): with self.subTest(value=value): self.assertFalse(param_store.set_param('PMS_GLOBAL_EXEC_HALT', value)['ok']) self.assertTrue(param_store.execution_halted()) self.change("UPDATE pms_runtime_param SET param_value='unknown'") self.assertTrue(param_store.execution_halted()) with patch.object(pms_repo,'get_param',side_effect=RuntimeError('isolated')): self.assertTrue(param_store.execution_halted()) def test_pause_writer_uses_same_account_transaction_as_exit(self): from app.db import session as db from app.services import param_store def save_switch(key, value, by): self.assertIsNotNone(db._TRANSACTION.get()) self.assertEqual(key, 'PMS_GLOBAL_EXEC_HALT') db.execute('INSERT INTO pms_runtime_param VALUES (:key,:value)', {'key':key, 'value':str(value)}) return 1 with patch.object(pms_repo, 'set_param', side_effect=save_switch), patch.object(param_store, 'refresh', return_value={}): self.assertTrue(param_store.set_param('PMS_GLOBAL_EXEC_HALT', True)['ok']) self.assertTrue(param_store.execution_halted()) self.put_stop() service.observe_user_stop(CODE, quote(), now=NOW) service.drive(CODE, now=NOW) self.assertEqual(self.instructions(), []) def test_intraday_scheduler_observes_without_any_execution_while_halted(self): from app import scheduler from app.services import strategy_runner self.put_stop() self.change("INSERT INTO pms_runtime_param VALUES ('PMS_GLOBAL_EXEC_HALT','True')") self.change('UPDATE pms_position SET avail_qty=0') lease = {} original_read = pms_repo.get_param def read(key, **opts): return lease.get(key) if key.startswith('INFRA_LOCK_') else original_read(key, **opts) with patch.object(scheduler.td, 'is_trade_day', return_value=True), \ patch.object(scheduler, 'in_session', return_value=True), \ patch.object(pms_repo, 'get_param', side_effect=read), \ patch.object(pms_repo, 'set_param', side_effect=lambda k,v,*a: lease.update({k:v})), \ patch.object(service, 'datetime') as clock, patch.object(market, 'execution_quote', return_value=quote()), \ patch.object(service, 'drive') as drive, patch.object(executor, 'materialize_plans') as plans, \ patch.object(executor, 'run_tick') as orders, patch.object(strategy_runner, 'tick') as strategies: clock.now.return_value = NOW result = scheduler.intraday_exec.run() self.assertTrue(result['risk_exit']['user_stops'][CODE]['triggered'], result) self.assertFalse(scheduler.intraday_exec.run()['risk_exit']['user_stops'][CODE]['triggered']) for call in (drive, plans, orders, strategies): call.assert_not_called() self.assertEqual(self.instructions(), []) self.assertEqual(self.state()['phase'], 'EXIT_PENDING') # worker缓存仍读成未暂停时,退出事务重新锁定并读取真实开关。 with patch.object(service, '_stop_buys') as stop_buys: service.drive(CODE, now=NOW) stop_buys.assert_not_called() self.assertEqual(self.instructions(), []) self.change("UPDATE pms_runtime_param SET param_value='False'") with patch.object(market, 'execution_quote', return_value=quote(11)): service.scan(now=NOW) service.scan(now=NOW) self.assertEqual(len(self.instructions()), 1) self.assertEqual(self.instructions()[0]['qty'], 1600) self.assertEqual(self.state()['user_stop']['command_id'], 'STOP1') def test_other_book_and_no_holding_do_not_create_orders(self): self.put_stop() with books.scope('micro30'): self.assertIsNone(service.observe_user_stop(CODE,quote(),now=NOW)) self.change('UPDATE pms_position SET total_qty=0,avail_qty=0');self.change("UPDATE pms_lot SET qty=0,status='CLOSED'") self.assertFalse(self.trigger()['triggered']);self.assertEqual(self.instructions(),[]) for name in base.ServiceTests.__dict__: if name.startswith('test_') and name not in ServiceTests.__dict__: setattr(ServiceTests,name,None) if __name__=='__main__':unittest.main()