tradingSystem/scripts/test_user_stop.py

388 lines
22 KiB
Python
Raw Normal View History

"""人工止损命令、行情边界、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()