tradingSystem/scripts/test_sim_reset_units.py

191 lines
11 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.

"""模拟仓重置:空仓证据、双账本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()