tradingSystem/scripts/test_sim_reset_units.py

191 lines
11 KiB
Python
Raw Normal View History

"""模拟仓重置:空仓证据、双账本SQL事务、保护配置及失败回滚。"""
import unit_test_guard
import copy
import datetime as dt
import json
import os
from pathlib import Path
import sys
import tempfile
import unittest
from unittest.mock import patch
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
from sqlalchemy import create_engine, text, event
import reset_sim_baseline_20261102 as reset
from app.core import strategy_book as books, rotation_account
from app.db import session as db
from app.repo import rotation_repo as store, pms_repo
from app.services import publish_export
from config.settings import settings
NOW=dt.datetime(2026,11,2,10,0)
def healthy():
return {'channel':{'online':True,'last_seq':100,'acked_seq':100,'stat':{'seq_hwm':100}},
'positions':{'seq':98,'age_sec':2,'received_at':'2026-11-02 09:59:58','payload':{'kind':'positions','items':[]}},
'funds':{'seq':99,'age_sec':2,'received_at':'2026-11-02 09:59:58','payload':{'kind':'funds','data':{'available_cash':1967927.74,'total_asset':1967927.74,'frozen_cash':0.,'market_value':0.}}}}
class EmptyEvidenceTests(unittest.TestCase):
def test_complete_empty_account_is_accepted(self):
x=healthy()
self.assertEqual(reset.validate_empty(**x,pause_at='2026-11-02 09:00:00')['available_cash'],1967927.74)
def test_missing_stale_nonempty_or_inconsistent_account_is_blocked(self):
for mutate in (
lambda x:x.update(positions=None),
lambda x:x['positions'].update(age_sec=61),
lambda x:x['positions'].update(received_at='2026-11-02 08:50:00'),
lambda x:x['positions']['payload'].pop('items'),
lambda x:x['positions']['payload'].update(items=[{'ts_code':'600000.SH','total_qty':100}]),
lambda x:x['funds']['payload']['data'].update(frozen_cash=1),
lambda x:x['funds']['payload']['data'].update(total_asset=2000001),
lambda x:x['funds']['payload']['data'].update(available_cash=float('nan')),
lambda x:x['funds']['payload']['data'].update(available_cash=2000000.,total_asset=2000000.),
lambda x:x['channel'].update(acked_seq=99),
lambda x:x['channel'].update(resync_required=True),
lambda x:x['channel'].update(orphan_held=1),
lambda x:x['channel']['stat'].update(rejects=1),
):
x=healthy();mutate(x)
with self.subTest(x=x),self.assertRaises(ValueError):
reset.validate_empty(**x,pause_at='2026-11-02 09:00:00')
class ResetTransactionTests(unittest.TestCase):
def setUp(self):
self.tmp=tempfile.TemporaryDirectory();self.addCleanup(self.tmp.cleanup)
self.engine=create_engine('sqlite:///'+self.tmp.name+'/reset.sqlite');self.addCleanup(self.engine.dispose)
self.use(settings,'INFRA_STRATEGY_BOOK_SCHEMA',True)
self.use(db,'get_engine',lambda *a:self.engine);self.use(db,'_check_cooldown',lambda *a:None)
@event.listens_for(self.engine,'before_cursor_execute',retval=True)
def sqlite(conn,cursor,sql,params,ctx,many):
sql=sql.replace(' FOR UPDATE','')
if 'ON DUPLICATE KEY UPDATE' in sql:
a,b=sql.split('ON DUPLICATE KEY UPDATE',1)
if 'pms_rotation_document' in a:
sql=a+'ON CONFLICT(doc_id) DO NOTHING'
elif 'pms_runtime_param' in a:
sql=a+'ON CONFLICT(param_key) DO UPDATE SET '+b
else:
raise AssertionError('未覆盖的MySQL语句')
return sql,params
with self.engine.begin() as c:
for table in reset.TABLES:
if table in books.TABLES:
c.execute(text('CREATE TABLE '+table+'(id INTEGER PRIMARY KEY,book_id TEXT,created_at TEXT,issued_at TEXT,cmd_class TEXT)'))
for i,b in enumerate(('original','micro30'),1):
c.execute(text('INSERT INTO '+table+' VALUES(:id,:book,:at,:at,:cls)'),{'id':i,'book':b,'at':'2026-10-30 10:00:00','cls':'task'})
else:
c.execute(text('CREATE TABLE '+table+'(ymd INTEGER PRIMARY KEY,nav REAL)'))
c.execute(text('INSERT INTO '+table+' VALUES(20261030,1.1)'))
c.execute(text("INSERT INTO pms_command VALUES(3,'original','2026-10-30','2026-10-30','param')"))
c.execute(text('CREATE TABLE pms_runtime_param(param_key TEXT PRIMARY KEY,param_value TEXT,updated_by TEXT,updated_at TEXT)'))
c.execute(text("INSERT INTO pms_runtime_param VALUES('PMS_TOTAL_SCALE','2000000','user','2026-10-30')"))
c.execute(text('CREATE TABLE pms_rotation_document(doc_id TEXT PRIMARY KEY,kind TEXT,payload_json TEXT,revision INTEGER,updated_at TEXT)'))
oldcapital=rotation_account.seed(100.,{'original':0,'micro30':0});oldcapital['fills']={'old-seq':{'book':'original','amount':100,'side':'buy','fee':5}}
docs={'capital:live':('capital',oldcapital),'state:live':('state',{'rotation':{'cycle':4,'consumed_entry':'old-signal'}}),
'account-execution':('funds_reservation',{'orders':{}}),'live_day:2026-10-30':('live_day',{'profit':100}),
'snapshot:today':('snapshot',{'data':'preserve'})}
for key,(kind,body) in docs.items():
c.execute(text('INSERT INTO pms_rotation_document VALUES(:key,:kind,:body,1,:now)'),{'key':key,'kind':kind,'body':json.dumps(body),'now':str(NOW)})
c.execute(text('CREATE TABLE pms_qmt_order(id INTEGER PRIMARY KEY,status TEXT,created_at TEXT)'))
c.execute(text("INSERT INTO pms_qmt_order VALUES(1,'FILLED','2026-10-30 10:00:00')"))
c.execute(text('CREATE TABLE pms_qmt_inbox(seq INTEGER PRIMARY KEY,msg_type TEXT,processed INTEGER,payload_json TEXT)'))
c.execute(text("INSERT INTO pms_qmt_inbox VALUES(8,'trade',1,'old')"))
self.log=self.use(pms_repo,'insert_op_log',lambda **kw:1)
self.use(publish_export,'record_nav_snapshot',self.nav)
self.backup=reset.ledger_state()
self.funds=healthy();self.funds['parsed_funds']=reset.validate_empty(**self.funds,pause_at='2026-11-02 09:00:00')
self.cursor={'v':2,'t':str(NOW),'seen':{'old-order':'2026-11-02 09:00:00'}}
def use(self,obj,name,value):
p=patch.object(obj,name,value);p.start();self.addCleanup(p.stop);return value
def nav(self):
self.assertEqual(reset.read_table('pms_position'),[])
self.assertEqual(reset.read_table('pms_cash_flow'),[])
db.execute('INSERT INTO pms_nav_daily VALUES(20261102,1.0)')
return {'nav':1.,'pos_ratio':0.}
def run_reset(self):
with store.account_guard(),db.transaction():
return reset.reset_in_transaction(self.backup,'digest',self.funds,self.cursor,NOW)
def test_both_books_reset_preserving_user_config_channel_and_dedupe(self):
self.run_reset()
for table in reset.CLEAR:
if table not in ('pms_command','pms_nav_daily'):
self.assertEqual(reset.read_table(table),[],table)
self.assertEqual([r['cmd_class'] for r in reset.read_table('pms_command')],['param'])
self.assertEqual(float(pms_repo.get_param('PMS_TOTAL_SCALE')),1967927.74)
self.assertEqual(float(pms_repo.get_param('PMS_PUBLISH_NAV_SCALE')),0.)
current=reset.ledger_state()
for key in ('qmt_orders','trade_inbox'):
self.assertEqual(current[key],self.backup[key])
capital,_=store.get('capital:live')
self.assertEqual(capital['cash'],{'original':1967927.74,'micro30':0.})
self.assertIn('old-seq',capital['fills'])
metrics=rotation_account.metrics(capital,{'original':0.,'micro30':0.})
self.assertEqual(metrics['original']['nav'],1.)
self.assertEqual(metrics['account']['profit'],0.)
self.assertEqual(metrics['account']['fees'],0.)
self.assertIsNone(metrics['micro30']['nav'])
self.assertEqual(store.get('state:live')[0]['rotation']['consumed_entry'],'old-signal')
self.assertEqual(store.get('state:live')[0]['rotation']['cycle'],4)
self.assertEqual(store.get('snapshot:today')[0],{'data':'preserve'})
self.assertEqual(store.recent('live_day'),[])
self.assertIsNotNone(store.get('archive:'+reset.RESET_ID+':live_day:2026-10-30')[0])
def test_backup_drift_aborts_before_deletion(self):
with books.scope('micro30'):
db.execute("UPDATE pms_position SET created_at='changed'")
before=reset.ledger_state()
with self.assertRaisesRegex(RuntimeError,'备份后数据变化'):
self.run_reset()
self.assertEqual(reset.ledger_state(),before)
def test_late_nav_failure_rolls_back_every_table_and_document(self):
before=reset.ledger_state()
self.use(publish_export,'record_nav_snapshot',lambda:{'nav':1.1,'pos_ratio':0.})
with self.assertRaisesRegex(RuntimeError,'净值基线'):
self.run_reset()
self.assertEqual(reset.ledger_state(),before)
def test_trade_change_detected_and_rolls_back(self):
before=reset.ledger_state()
def changed():
result=self.nav();db.execute("UPDATE pms_qmt_inbox SET payload_json='changed' WHERE seq=8");return result
self.use(publish_export,'record_nav_snapshot',changed)
with self.assertRaisesRegex(RuntimeError,'新增成交'):
self.run_reset()
self.assertEqual(reset.ledger_state(),before)
def test_today_order_id_cannot_be_reused_after_reset(self):
db.execute('UPDATE pms_qmt_order SET created_at=:now',{'now':str(NOW)})
self.backup=reset.ledger_state()
with self.assertRaisesRegex(RuntimeError,'编号不复用'):
self.run_reset()
self.assertEqual(reset.ledger_state(),self.backup)
def test_apply_is_idempotent_and_does_not_touch_new_activity(self):
path=Path(self.tmp.name)/'backup.json';value={'reset_id':reset.RESET_ID};reset.save_new(path,value)
sha=reset.digest(value)
store.put_once('maintenance:'+reset.RESET_ID,'maintenance',{'backup_sha256':sha})
before=reset.ledger_state()
with patch.object(reset,'require_safe',side_effect=AssertionError('不能再次操作')):
result=reset.apply(path,sha)
self.assertTrue(result['already_applied'])
self.assertEqual(reset.ledger_state(),before)
with self.assertRaisesRegex(RuntimeError,'摘要不符'):
reset.apply(path,'bad')
def test_existing_transfers_require_explicit_numbering_migration(self):
old={'capital:live':{'transfers':{'allocation:1':{}},'fills':{}}}
with self.assertRaisesRegex(ValueError,'划拨编号'):
reset.baseline_documents(old,self.funds,NOW)
if __name__=='__main__':
unittest.main()