tradingSystem/scripts/test_user_stop.py

388 lines
22 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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