461 lines
32 KiB
Python
461 lines
32 KiB
Python
"""成交更正服务:虚构回执、双策略隔离和SQLite事务,禁止真实服务。"""
|
||
import unit_test_guard # noqa: F401
|
||
import copy
|
||
import datetime as dt
|
||
import json
|
||
from decimal import Decimal
|
||
from pathlib import Path
|
||
import sys
|
||
import tempfile
|
||
import unittest
|
||
from unittest.mock import patch
|
||
from types import SimpleNamespace
|
||
|
||
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
|
||
from sqlalchemy import create_engine, event, text
|
||
from app.core import strategy_book as books, ws_codec
|
||
from app.db import session as db
|
||
from app.repo import pms_repo, qmt_repo, rotation_repo as store
|
||
from app.services import trade_correction as service
|
||
from config.settings import settings
|
||
from test_trade_correction_units import fixture, economic, trade, lot
|
||
|
||
CODE = '600001.SH'
|
||
NOW = dt.datetime(2026, 11, 5, 12, tzinfo=service.TZ)
|
||
|
||
|
||
class ServiceTests(unittest.TestCase):
|
||
def setUp(self):
|
||
self.tmp = tempfile.TemporaryDirectory(); self.addCleanup(self.tmp.cleanup)
|
||
self.engine = create_engine('sqlite:///'+self.tmp.name+'/correction.sqlite'); self.addCleanup(self.engine.dispose)
|
||
class Clock(dt.datetime):
|
||
@classmethod
|
||
def now(cls, tz=None): return NOW if tz else NOW.replace(tzinfo=None)
|
||
self.use(service, 'dt', SimpleNamespace(datetime=Clock))
|
||
self.use(settings, 'INFRA_STRATEGY_BOOK_SCHEMA', True)
|
||
self.use(db, 'get_engine', lambda *args: self.engine)
|
||
self.use(db, '_check_cooldown', lambda *args: None)
|
||
@event.listens_for(self.engine, 'connect')
|
||
def funcs(conn, _):
|
||
def path(value, mode, key):
|
||
return int(key.lstrip('$.') in json.loads(value or '{}'))
|
||
conn.create_function('JSON_CONTAINS_PATH', 3, path)
|
||
@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, _ = sql.split('ON DUPLICATE KEY UPDATE', 1)
|
||
self.assertIn('pms_rotation_document', a)
|
||
sql = a+'ON CONFLICT(doc_id) DO NOTHING'
|
||
def serial(v):
|
||
return str(v) if isinstance(v, Decimal) else v.isoformat(' ') if isinstance(v, dt.datetime) else v
|
||
if isinstance(params, tuple): params = tuple(serial(v) for v in params)
|
||
return sql, params
|
||
schema = {
|
||
'pms_qmt_inbox': 'seq INTEGER PRIMARY KEY,msg_id TEXT,msg_type TEXT,corr_id TEXT,dedup_key TEXT,payload_json TEXT,msg_ts INTEGER,received_at TEXT,processed INTEGER,processed_at TEXT,process_note TEXT',
|
||
'pms_qmt_order': 'id INTEGER PRIMARY KEY,instruction_id TEXT,parent_id TEXT,ts_code TEXT,side TEXT,qty INTEGER,limit_price REAL,status TEXT,broker_order_id TEXT,cum_qty INTEGER,cum_avg_price REAL,leaves_qty INTEGER,updated_at TEXT,final_at TEXT',
|
||
'pms_instruction': 'id INTEGER PRIMARY KEY,book_id TEXT,instruction_id TEXT,origin_type TEXT,origin_id TEXT,ts_code TEXT,action TEXT,side TEXT,qty INTEGER,status TEXT,exec_qty INTEGER,exec_avg_price REAL,progress_json TEXT,archived_at TEXT,created_at TEXT,updated_at TEXT',
|
||
'pms_lot': 'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,instruction_id TEXT,lot_type TEXT,qty INTEGER,closed_qty INTEGER,open_price REAL,close_avg_price REAL,realized_pnl REAL,status TEXT,open_date TEXT,created_at TEXT,updated_at TEXT,archived_at TEXT',
|
||
'pms_position': 'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,total_qty INTEGER,avail_qty INTEGER,base_qty INTEGER,fill_qty INTEGER,add_qty INTEGER,dca_qty INTEGER,t0_qty INTEGER,avg_cost REAL,realized_t_profit REAL,cushion_pct REAL,cushion_state TEXT,cushion_peak REAL,pct_of_scale REAL,status TEXT,archived_at TEXT,updated_at TEXT',
|
||
'pms_rotation_document': 'doc_id TEXT PRIMARY KEY,kind TEXT,payload_json TEXT,revision INTEGER,updated_at TEXT',
|
||
'pms_strategy': 'id INTEGER PRIMARY KEY,book_id TEXT,ts_code TEXT,strategy_id TEXT,type TEXT,status TEXT,state_json TEXT,params_json TEXT,archived_at TEXT,updated_at TEXT',
|
||
'pms_plan': 'id INTEGER PRIMARY KEY,book_id TEXT,plan_id TEXT,ts_code TEXT,priority INTEGER,status TEXT,filled_qty INTEGER,updated_at TEXT',
|
||
}
|
||
with self.engine.begin() as conn:
|
||
for table, columns in schema.items(): conn.execute(text('CREATE TABLE '+table+'('+columns+')'))
|
||
self.use(qmt_repo, 'latest_snapshot', lambda kind: self.snapshot)
|
||
self.watermark = 1000
|
||
self.use(qmt_repo, 'get_state', lambda: {'last_seq': self.watermark})
|
||
self.snapshot = {'seq': 1000, 'age_sec': 1, 'received_at': NOW.isoformat(), 'payload': {'kind': 'positions', 'items': [{'ts_code': CODE, 'total_qty': 100, 'avail_qty': 0}]}}
|
||
# 费用配置从参数读取的路径本身不参与更正;隔离固定合法费率,禁止真实参数库。
|
||
from app.services import rotation_service
|
||
self.use(rotation_service, 'configuration', lambda: {'costs': {'rate': .0002, 'minimum': 5., 'sell_tax': .0005, 'transfer_rate': .00001}})
|
||
self.seed()
|
||
|
||
def use(self, obj, name, value):
|
||
patcher = patch.object(obj, name, value); patcher.start(); self.addCleanup(patcher.stop)
|
||
|
||
def insert(self, table, values):
|
||
with self.engine.begin() as conn:
|
||
conn.execute(text('INSERT INTO '+table+' ('+','.join(values)+') VALUES ('+','.join(':'+k for k in values)+')'), values)
|
||
|
||
def sql(self, sql, params=None):
|
||
with self.engine.begin() as conn: return conn.execute(text(sql), params or {})
|
||
|
||
def seed(self, sold=False, book='original'):
|
||
with self.engine.begin() as conn:
|
||
for table in ('pms_qmt_inbox','pms_qmt_order','pms_instruction','pms_lot','pms_position','pms_rotation_document','pms_strategy','pms_plan'):
|
||
conn.execute(text('DELETE FROM '+table))
|
||
data = fixture(sold)
|
||
fills = {}
|
||
for i, row in enumerate(data['trades'], 1):
|
||
payload = copy.deepcopy(row['payload']); payload.pop('parent_id')
|
||
pid = row['payload']['parent_id']; iid = payload['instruction_id']
|
||
self.insert('pms_qmt_inbox', dict(seq=row['seq'],msg_id='M'+str(i),msg_type='trade',corr_id=iid,dedup_key=ws_codec.dedup_key('trade',payload),payload_json=json.dumps(payload),msg_ts=1,received_at=row['processed_at'],processed=1,processed_at=row['processed_at'],process_note='原始成交'))
|
||
self.insert('pms_qmt_order',dict(id=i,instruction_id=iid,parent_id=pid,ts_code=CODE,side=payload['side'],qty=200,limit_price=20,status='FILLED',broker_order_id=payload['broker_order_id'],cum_qty=payload['qty'],cum_avg_price=float(payload['price']),leaves_qty=0))
|
||
self.insert('pms_instruction',dict(id=i,book_id=book,instruction_id=pid,origin_type='system',origin_id='other',ts_code=CODE,action='OPEN' if payload['side']=='buy' else 'EXIT',side=payload['side'],qty=200,status='CONFIRMED',exec_qty=payload['qty'],exec_avg_price=float(payload['price']),progress_json='{}',archived_at='2026-11-05 11:00:00'))
|
||
fills[str(row['seq'])] = dict(book=book,side=payload['side'],amount=float(payload['amount']),fee=0.)
|
||
for lot in data['lots']:
|
||
lot['book_id']=book
|
||
self.insert('pms_lot',lot)
|
||
self.insert('pms_position',dict(id=1,book_id=book,ts_code=CODE,total_qty=60 if sold else 100,avail_qty=60 if sold else 0,base_qty=60 if sold else 100,fill_qty=0,add_qty=0,dca_qty=0,t0_qty=0,avg_cost=8.667 if sold else 10.,realized_t_profit=0.,cushion_pct=.2,cushion_state='SOLID',cushion_peak=.3,pct_of_scale=.1,status='HOLDING'))
|
||
cash = {'original': 10000., 'micro30': 10000.}
|
||
capital = {'cash':cash,'fills':fills,'fees':{'original':0.,'micro30':0.},'units':{'original':20000.,'micro30':10000.},'net_capital':{'original':20000.,'micro30':10000.},'transfers':{}}
|
||
self.insert('pms_rotation_document',dict(doc_id='capital:live',kind='capital',payload_json=json.dumps(capital),revision=1))
|
||
self.snapshot['payload']['items'][0]['total_qty']=60 if sold else 100
|
||
self.after = economic(100, '11.000'); self.add_pair('C1', 'BUY', self.after)
|
||
|
||
def add_pair(self, cid, no, after, seq=10, before=None, amended=True):
|
||
original = service.repo.get_trade(no); p = original['payload']
|
||
before = before or {k:p[k] for k in service.ECONOMIC}
|
||
correction = {k:p[k] for k in service.IDENTITY}; correction.update(correction_id=cid,before=before,after=after,reason='券商成交事实更正',correct_time=int(NOW.timestamp()*1000))
|
||
am = {'instruction_id':p['instruction_id'],'broker_order_id':p['broker_order_id'],'correction_id':cid,'amended':amended,'reason':'trade_correction','status':'FILLED','final':True,'leaves_qty':0,'cum_qty':after['qty'],'cum_avg_price':after['price'] if after['qty'] else None}
|
||
for offset, kind, payload in ((0,'trade_correction',correction),(1,'order_update',am)):
|
||
self.insert('pms_qmt_inbox',dict(seq=seq+offset,msg_id='M'+str(seq+offset),msg_type=kind,corr_id=p['instruction_id'],dedup_key=None,payload_json=json.dumps(payload),msg_ts=1,received_at='2026-11-05T11:00:00+08:00',processed=0))
|
||
return correction, am
|
||
|
||
def modify_payload(self, seq, **change):
|
||
row=service.repo.get_inbox(seq);payload=row['payload'];payload.update(change)
|
||
self.sql('UPDATE pms_qmt_inbox SET payload_json=:p WHERE seq=:s',{'p':json.dumps(payload),'s':seq})
|
||
|
||
def state(self):
|
||
result={}
|
||
for table in ('pms_qmt_inbox','pms_qmt_order','pms_instruction','pms_lot','pms_position','pms_rotation_document','pms_strategy','pms_plan'):
|
||
with self.engine.connect() as conn: result[table]=[dict(x) for x in conn.execute(text('SELECT * FROM '+table+' ORDER BY 1')).mappings()]
|
||
return result
|
||
|
||
def assert_applied(self):
|
||
result=service.consume();self.assertEqual(result['applied'],1,result);self.assertTrue(result['ok'],result)
|
||
return result
|
||
|
||
def test_buy_price_delta_keeps_original_fees_and_parent_terminal(self):
|
||
before=self.state();self.assert_applied();after=self.state()
|
||
self.assertEqual(after['pms_qmt_inbox'][0],before['pms_qmt_inbox'][0])
|
||
self.assertEqual([r['processed'] for r in after['pms_qmt_inbox']], [1,1,1])
|
||
pos=pms_repo.get_position(CODE);self.assertEqual(pos['avg_cost'],11.);self.assertEqual(pos['cushion_peak'],0)
|
||
parent=pms_repo.get_instruction('P_BUY');self.assertEqual(parent['status'],'CONFIRMED');self.assertIsNotNone(parent['archived_at'])
|
||
capital=store.get('capital:live')[0];self.assertEqual(capital['cash']['original'],9900.)
|
||
for key in ('fills','fees','units','net_capital','transfers'): self.assertEqual(capital[key],json.loads(before['pms_rotation_document'][0]['payload_json'])[key])
|
||
audit=store.get(service._key('trade-correction:','C1'))[0]
|
||
self.assertIsNone(audit['original_fee']);self.assertEqual(audit['position_before']['cushion_peak'],.3)
|
||
|
||
def test_chain_uses_effective_before_and_persisted_lot_link(self):
|
||
self.assert_applied();self.add_pair('C2','BUY',economic(100,'12'),seq=20,before=self.after)
|
||
self.assert_applied();self.assertEqual(pms_repo.get_position(CODE)['avg_cost'],12.)
|
||
self.assertEqual(store.get('capital:live')[0]['cash']['original'],9800.)
|
||
self.assertEqual(service.repo.get_trade('BUY')['payload']['price'],'10.000')
|
||
|
||
def test_duplicate_same_id_is_not_applied_twice(self):
|
||
self.assert_applied();cash=store.get('capital:live')[0]
|
||
self.add_pair('C1','BUY',self.after,seq=20)
|
||
result=service.consume();self.assertEqual(result['applied'],0,result)
|
||
self.assertEqual(store.get('capital:live')[0],cash)
|
||
self.assertEqual([service.repo.get_inbox(i)['processed'] for i in (20,21)], [2,2])
|
||
|
||
def test_reused_id_changed_content_is_held(self):
|
||
self.assert_applied();self.add_pair('C1','BUY',economic(100,'12'),seq=20)
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.assertEqual(pms_repo.get_position(CODE)['avg_cost'],11.)
|
||
|
||
def test_missing_pair_or_unbooked_original_waits_without_blocking_original(self):
|
||
for missing in ('pair','original'):
|
||
self.seed()
|
||
if missing=='pair': self.sql('DELETE FROM pms_qmt_inbox WHERE seq=11')
|
||
else: self.sql('UPDATE pms_qmt_inbox SET processed=0 WHERE seq=1')
|
||
result=service.consume();self.assertEqual(result['waiting'],1,result)
|
||
self.assertEqual(service.repo.get_inbox(10)['processed'],0)
|
||
self.assertEqual(service.repo.get_inbox(1)['processed'],0 if missing=='original' else 1)
|
||
|
||
def test_before_pair_identity_average_and_original_cash_conflicts_hold(self):
|
||
changes=[lambda:self.modify_payload(10,before=economic(100,'9')),
|
||
lambda:self.modify_payload(11,broker_order_id='different'),
|
||
lambda:self.modify_payload(11,cum_avg_price='12'),
|
||
lambda:self.modify_payload(11,amended=False),
|
||
lambda:self.modify_payload(10,side='sell'),
|
||
lambda:self.sql("UPDATE pms_rotation_document SET payload_json=json_set(payload_json,'$.fills.1.amount',999) WHERE doc_id='capital:live'")]
|
||
for change in changes:
|
||
self.seed();change();before=self.state();result=service.consume()
|
||
self.assertEqual(result['held'],1,result)
|
||
after=self.state()
|
||
for table in ('pms_lot','pms_position','pms_instruction','pms_qmt_order'):self.assertEqual(after[table],before[table])
|
||
self.assertEqual(service.repo.get_inbox(10)['processed'],3)
|
||
|
||
def test_quantity_requires_fresh_later_snapshot_and_pauses_parent_remaining(self):
|
||
self.modify_payload(10,after=economic(150,'10'));self.modify_payload(11,cum_qty=150,cum_avg_price=10)
|
||
self.snapshot['payload']['items'][0]['total_qty']=150
|
||
self.assert_applied();pos=pms_repo.get_position(CODE)
|
||
self.assertEqual((pos['total_qty'],pos['avail_qty']),(150,0))
|
||
parent=pms_repo.get_instruction('P_BUY');self.assertIn('trade_correction_hold',parent['progress'])
|
||
self.assertEqual(parent['status'],'CONFIRMED')
|
||
self.assertEqual(qmt_repo.get_order('P_BUY_D01')['leaves_qty'],0)
|
||
|
||
def test_stale_missing_or_malformed_snapshot_does_not_guess_zero(self):
|
||
for snapshot in (None, {'age_sec':61,'received_at':NOW.isoformat(),'payload':{'items':[]}},
|
||
{'age_sec':1,'received_at':NOW.isoformat(),'payload':{}},
|
||
{'age_sec':1,'received_at':'2026-11-05T10:00:00+08:00','payload':{'items':[]}}):
|
||
self.seed();self.modify_payload(10,after=economic(0,'0'));self.modify_payload(11,cum_qty=0,cum_avg_price=None)
|
||
self.snapshot=snapshot
|
||
result=service.consume();expected='held' if snapshot and snapshot.get('payload')=={} else 'waiting'
|
||
self.assertEqual(result[expected],1,result)
|
||
self.assertEqual(pms_repo.get_position(CODE)['total_qty'],100)
|
||
self.snapshot={'seq':1000,'age_sec':1,'received_at':NOW.isoformat(),'payload':{'items':[{'ts_code':CODE,'total_qty':100}]}}
|
||
|
||
def test_zero_correction_accepts_explicit_empty_snapshot_and_none_average(self):
|
||
self.modify_payload(10,after=economic(0,'0'));self.modify_payload(11,cum_qty=0,cum_avg_price=None)
|
||
self.snapshot['payload']['items']=[]
|
||
self.assert_applied();self.assertEqual(pms_repo.get_position(CODE)['total_qty'],0)
|
||
self.assertEqual(store.get('capital:live')[0]['cash']['original'],11000.)
|
||
|
||
def test_after_sell_projection_reallocates_pnl_and_cash(self):
|
||
self.seed(sold=True);self.assert_applied()
|
||
lot=pms_repo.list_lots(CODE,status=None)[0]
|
||
self.assertEqual((lot['qty'],lot['realized_pnl']),(60,40.))
|
||
self.assertAlmostEqual(pms_repo.get_position(CODE)['avg_cost'],10.333)
|
||
|
||
def test_closed_recovery_excludes_only_unlinked_pre_cutover_terminal(self):
|
||
self.insert('pms_qmt_order',dict(id=90,instruction_id='PRE_D01',parent_id='PRE',ts_code=CODE,
|
||
side='buy',status='FILLED',final_at='2026-10-30T12:00:00+08:00'))
|
||
original=service.repo.get_trade('BUY')
|
||
order=qmt_repo.get_order('P_BUY_D01')
|
||
parent=pms_repo.get_instruction('P_BUY')
|
||
recovery={'cutover':NOW-dt.timedelta(days=3),'lot_parents':['P_BUY'],'balancing_sell':0}
|
||
with self.assertRaisesRegex(ValueError,'历史委托'):
|
||
service._load_evidence(original,order,parent)
|
||
rows, _, trades, _ = service._load_evidence(original,order,parent,recovery=recovery)
|
||
self.assertEqual([row['instruction_id'] for row in rows],['P_BUY_D01'])
|
||
self.assertEqual([row['seq'] for row in trades],[original['seq']])
|
||
with self.assertRaisesRegex(ValueError,'历史委托'):
|
||
service._load_evidence(original,order,parent,recovery=dict(recovery,lot_parents=['PRE']))
|
||
|
||
def test_balancing_sell_requires_final_actual_quantity(self):
|
||
self.snapshot['payload']['items']=[]
|
||
projection={'qty_before':0,'qty_after':70}
|
||
with self.assertRaisesRegex(ValueError,'实际持仓不一致'):
|
||
service._verify_physical(CODE,'original',projection,NOW)
|
||
service._verify_physical(CODE,'original',projection,NOW,balancing_sell=70)
|
||
with self.assertRaisesRegex(ValueError,'实际持仓不一致'):
|
||
service._verify_physical(CODE,'original',projection,NOW,balancing_sell=69)
|
||
|
||
def test_other_book_same_code_is_not_modified(self):
|
||
self.insert('pms_position',dict(id=2,book_id='micro30',ts_code=CODE,total_qty=50,avail_qty=50,status='HOLDING'))
|
||
self.modify_payload(10,after=economic(150,'10'));self.modify_payload(11,cum_qty=150,cum_avg_price=10)
|
||
self.snapshot['payload']['items'][0]['total_qty']=200
|
||
self.assert_applied()
|
||
with books.scope('micro30'): self.assertEqual(pms_repo.get_position(CODE)['total_qty'],50)
|
||
|
||
def test_cash_overdraft_and_reserved_budget_are_held(self):
|
||
self.sql("UPDATE pms_rotation_document SET payload_json=json_set(payload_json,'$.cash.original',50) WHERE doc_id='capital:live'")
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.seed()
|
||
self.insert('pms_qmt_order',dict(id=5,instruction_id='WAIT_D01',parent_id='P_BUY',ts_code=CODE,side='buy',qty=500,limit_price=20,status='SUBMITTED',cum_qty=0))
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
|
||
def grid(self, pending=False, type_='GRID'):
|
||
self.sql("UPDATE pms_instruction SET origin_id='GRID1',progress_json=:p WHERE instruction_id='P_BUY'",{'p':json.dumps({'leg':'grid_buy:2'})})
|
||
self.insert('pms_strategy',dict(id=1,book_id='original',ts_code=CODE,strategy_id='GRID1',type=type_,status='ACTIVE',state_json=json.dumps({'pending':{'iid':'x'} if pending else None,'filled_levels':{'2':{'qty':100,'price':10}},'invested':1000}),params_json='{}'))
|
||
|
||
def test_system_origin_grid_price_sync_and_quantity_pause(self):
|
||
self.grid();self.assert_applied();s=pms_repo.get_strategy('GRID1')
|
||
self.assertEqual(s['status'],'ACTIVE');self.assertEqual(s['state']['filled_levels']['2']['price'],11)
|
||
self.add_pair('C2','BUY',economic(100,'12'),seq=20,before=self.after)
|
||
self.assert_applied();s=pms_repo.get_strategy('GRID1')
|
||
self.assertEqual(s['state']['trade_correction']['correction_id'],'C2')
|
||
self.assertEqual(s['state']['filled_levels']['2']['price'],12)
|
||
self.seed();self.grid();self.modify_payload(10,after=economic(150,'10'));self.modify_payload(11,cum_qty=150,cum_avg_price=10)
|
||
self.snapshot['payload']['items'][0]['total_qty']=150
|
||
self.assert_applied();s=pms_repo.get_strategy('GRID1')
|
||
self.assertEqual(s['status'],'PAUSED');self.assertIn('correction_hold',s['state'])
|
||
self.assertEqual(s['state']['filled_levels']['2']['qty'],150)
|
||
|
||
def test_pending_or_unknown_strategy_holds_whole_correction(self):
|
||
for pending,type_ in ((True,'GRID'),(False,'T0')):
|
||
self.seed();self.grid(pending,type_);before=self.state();result=service.consume()
|
||
self.assertEqual(result['held'],1,result)
|
||
for table in ('pms_lot','pms_position','pms_strategy'):self.assertEqual(self.state()[table],before[table])
|
||
|
||
def test_final_write_failure_rolls_back_all_projection_and_documents(self):
|
||
# 账户锁哨兵预先存在,确保比较的不是建锁行副作用。
|
||
with store.account_guard(): pass
|
||
before=self.state()
|
||
original=qmt_repo.inbox_mark
|
||
def fail(seqs,processed=1,note=None):
|
||
if processed==qmt_repo.PROC_BOOKED: raise RuntimeError('injected final marker failure')
|
||
return original(seqs,processed=processed,note=note)
|
||
self.use(qmt_repo,'inbox_mark',fail)
|
||
result=service.consume();self.assertTrue(result['errors'],result)
|
||
self.assertEqual(self.state(),before)
|
||
|
||
def test_soft_zero_write_rolls_back_and_keeps_pending(self):
|
||
with store.account_guard(): pass
|
||
before=self.state();self.use(pms_repo,'update_position',lambda *a,**k:0)
|
||
result=service.consume();self.assertTrue(result['errors'],result);self.assertEqual(self.state(),before)
|
||
|
||
def test_plan_progress_changes_without_reviving_done_plan(self):
|
||
self.sql("UPDATE pms_instruction SET origin_type='plan',origin_id='PLAN1' WHERE instruction_id='P_BUY'")
|
||
self.insert('pms_plan',dict(id=1,book_id='original',plan_id='PLAN1',ts_code=CODE,priority=1,status='DONE',filled_qty=100))
|
||
self.assert_applied();self.assertEqual(pms_repo.list_plans()[0]['status'],'DONE')
|
||
|
||
def test_fresh_snapshot_arrival_retries_original_pending_correction(self):
|
||
self.modify_payload(10,after=economic(150,'10'));self.modify_payload(11,cum_qty=150,cum_avg_price=10)
|
||
self.snapshot['age_sec']=61
|
||
first=service.consume();self.assertEqual(first['waiting'],1,first)
|
||
self.assertEqual(service.repo.get_inbox(10)['processed'],0)
|
||
self.snapshot['age_sec']=1;self.snapshot['payload']['items'][0]['total_qty']=150
|
||
self.assert_applied()
|
||
|
||
def test_terminal_reclassification_preserves_old_terminal_and_final_time(self):
|
||
self.sql("UPDATE pms_qmt_order SET final_at='2026-11-05 10:00:00' WHERE id=1")
|
||
self.modify_payload(11,status='CANCELLED')
|
||
self.assert_applied();child=qmt_repo.get_order('P_BUY_D01')
|
||
self.assertEqual(child['status'],'FILLED');self.assertEqual(child['final_at'],'2026-11-05 10:00:00')
|
||
self.assertEqual(store.get(service._key('trade-correction:','C1'))[0]['qmt_amended_status'],'CANCELLED')
|
||
|
||
def test_terminal_cannot_become_active_or_regain_leaves(self):
|
||
self.modify_payload(11,status='PARTIAL',final=False,leaves_qty=100)
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.assertEqual(qmt_repo.get_order('P_BUY_D01')['status'],'FILLED')
|
||
|
||
def test_active_child_can_finish_without_reviving_parent(self):
|
||
self.sql("UPDATE pms_qmt_order SET status='PARTIAL',leaves_qty=100 WHERE id=1")
|
||
self.modify_payload(11,status='CANCELLED')
|
||
self.assert_applied();child=qmt_repo.get_order('P_BUY_D01')
|
||
self.assertEqual(child['status'],'CANCELLED');self.assertIsNotNone(child['final_at'])
|
||
self.assertEqual(pms_repo.get_instruction('P_BUY')['status'],'CONFIRMED')
|
||
|
||
def test_two_decimal_cumulative_average_never_replaces_true_trade_price(self):
|
||
self.modify_payload(10,after=economic(100,'10.125'));self.modify_payload(11,cum_avg_price='10.13')
|
||
self.assert_applied();self.assertEqual(pms_repo.get_position(CODE)['avg_cost'],10.125)
|
||
self.assertEqual(store.get('capital:live')[0]['cash']['original'],9987.5)
|
||
|
||
def test_malformed_economics_time_reason_and_nan_are_held_with_raw_audit(self):
|
||
for change in ({'before':[1,2]}, {'after':'bad'}, {'reason':''}, {'correct_time':True}, {'correct_time':'12'},
|
||
{'after':{'qty':100,'price':float('nan'),'amount':1000}}):
|
||
self.seed();self.modify_payload(10,**change)
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
audit=store.get(service._key('trade-correction-hold:', '10'))[0]
|
||
self.assertEqual(len(audit['raw_payload_fingerprint']),64)
|
||
|
||
def test_unproven_t_profit_and_disabled_book_schema_hold(self):
|
||
self.sql('UPDATE pms_position SET realized_t_profit=1 WHERE id=1')
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.seed();self.use(settings,'INFRA_STRATEGY_BOOK_SCHEMA',False)
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
|
||
def test_micro_book_price_correction_does_not_use_original_cash(self):
|
||
self.seed(book='micro30');self.assert_applied()
|
||
capital=store.get('capital:live')[0]
|
||
self.assertEqual(capital['cash'],{'original':10000.,'micro30':9900.})
|
||
|
||
def test_original_raw_principal_must_match_cash_ledger_not_rounded_guess(self):
|
||
self.modify_payload(1,qty=1,price='48.285',amount='48.29')
|
||
self.sql("UPDATE pms_qmt_order SET cum_qty=1 WHERE id=1")
|
||
self.sql("UPDATE pms_instruction SET exec_qty=1 WHERE id=1")
|
||
self.sql("UPDATE pms_lot SET qty=1,open_price=48.285 WHERE id=1")
|
||
self.sql("UPDATE pms_position SET total_qty=1,base_qty=1,avg_cost=48.285 WHERE id=1")
|
||
self.sql("UPDATE pms_rotation_document SET payload_json=json_set(payload_json,'$.fills.1.amount',48.285) WHERE doc_id='capital:live'")
|
||
self.modify_payload(10,before=economic(1,'48.285'),after=economic(1,'48.290'))
|
||
self.modify_payload(11,cum_qty=1,cum_avg_price='48.290')
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.assertIn('现金凭据',result['alerts'][0]['reason'])
|
||
|
||
def test_old_zeroed_cycle_cannot_change_new_position(self):
|
||
self.seed(sold=True)
|
||
self.modify_payload(2,qty=100,amount='1200.00')
|
||
self.sql('UPDATE pms_instruction SET exec_qty=100 WHERE id=2')
|
||
self.sql('UPDATE pms_qmt_order SET cum_qty=100 WHERE id=2')
|
||
self.sql("UPDATE pms_lot SET qty=0,closed_qty=100,realized_pnl=200,status='CLOSED' WHERE id=1")
|
||
row=trade('NEW',3,'buy',100,'20');raw=copy.deepcopy(row['payload']);raw.pop('parent_id')
|
||
self.insert('pms_qmt_inbox',dict(seq=3,msg_id='M3',msg_type='trade',corr_id=raw['instruction_id'],dedup_key=ws_codec.dedup_key('trade',raw),payload_json=json.dumps(raw),processed=1,processed_at=row['processed_at']))
|
||
self.insert('pms_qmt_order',dict(id=3,instruction_id=raw['instruction_id'],parent_id='P_NEW',ts_code=CODE,side='buy',qty=100,limit_price=20,status='FILLED',broker_order_id=raw['broker_order_id'],cum_qty=100,cum_avg_price=20,leaves_qty=0))
|
||
self.insert('pms_instruction',dict(id=3,book_id='original',instruction_id='P_NEW',origin_type='system',origin_id='other',ts_code=CODE,side='buy',qty=100,status='CONFIRMED',exec_qty=100,progress_json='{}'))
|
||
self.insert('pms_lot',lot(row,lid=2))
|
||
self.sql('UPDATE pms_position SET total_qty=100,avail_qty=0,avg_cost=20,base_qty=100 WHERE id=1')
|
||
before=self.state();result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.assertIn('轮',result['alerts'][0]['reason'])
|
||
self.assertEqual(self.state()['pms_lot'],before['pms_lot'])
|
||
|
||
def test_non_object_payload_is_held_without_blocking_next_valid_row(self):
|
||
self.sql("UPDATE pms_qmt_inbox SET payload_json='[]' WHERE seq=10")
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.assertEqual(service.repo.get_inbox(10)['processed'],3)
|
||
|
||
def test_contiguous_watermark_must_cover_both_correction_messages(self):
|
||
for mark in (9,10):
|
||
self.watermark=mark;result=service.consume()
|
||
self.assertEqual(result['waiting'],1,result)
|
||
self.assertEqual(service.repo.get_inbox(10)['processed'],0)
|
||
self.assertEqual(pms_repo.get_position(CODE)['avg_cost'],10.)
|
||
self.watermark=11;self.assert_applied()
|
||
|
||
def test_later_chained_pair_waits_for_earlier_unpaired_correction(self):
|
||
amendment=service.repo.get_inbox(11)
|
||
self.sql('DELETE FROM pms_qmt_inbox WHERE seq=11')
|
||
self.add_pair('C2','BUY',economic(100,'12'),seq=20,before=self.after)
|
||
result=service.consume();self.assertEqual(result['waiting'],2,result);self.assertEqual(result['held'],0,result)
|
||
self.assertEqual(pms_repo.get_position(CODE)['avg_cost'],10.)
|
||
amendment.pop('payload');self.insert('pms_qmt_inbox',amendment)
|
||
result=service.consume();self.assertEqual(result['applied'],2,result)
|
||
self.assertEqual(pms_repo.get_position(CODE)['avg_cost'],12.)
|
||
|
||
def test_decimal_physical_quantity_cannot_be_truncated_into_matching_fact(self):
|
||
self.modify_payload(10,after=economic(150,'10'));self.modify_payload(11,cum_qty=150,cum_avg_price=10)
|
||
self.snapshot['payload']['items'][0]['total_qty']='150.5'
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.assertEqual(pms_repo.get_position(CODE)['total_qty'],100)
|
||
|
||
def test_sell_price_and_quantity_use_cash_delta_and_actual_available_quantity(self):
|
||
for qty, price, expected_cash, expected_qty in ((40,'13',10040.,60),(50,'12',10120.,50)):
|
||
self.seed(sold=True);self.sql('DELETE FROM pms_qmt_inbox WHERE seq IN (10,11)')
|
||
self.add_pair('SELL-C','SELL',economic(qty,price))
|
||
self.snapshot['payload']['items'][0]['total_qty']=expected_qty
|
||
self.assert_applied();pos=pms_repo.get_position(CODE)
|
||
self.assertEqual((pos['total_qty'],pos['avail_qty']),(expected_qty,expected_qty))
|
||
self.assertEqual(store.get('capital:live')[0]['cash']['original'],expected_cash)
|
||
self.assertEqual(service.repo.get_trade('SELL')['payload']['qty'],40)
|
||
|
||
def test_child_cumulative_and_parent_all_children_are_distinct_aggregates(self):
|
||
row=trade('SECOND',2,'buy',50,'12',parent='P_BUY')
|
||
row['payload']['instruction_id']='P_BUY_D02';row['original_payload']=copy.deepcopy(row['payload'])
|
||
raw=copy.deepcopy(row['payload']);raw.pop('parent_id')
|
||
self.insert('pms_qmt_inbox',dict(seq=2,msg_id='M2',msg_type='trade',corr_id=raw['instruction_id'],dedup_key=ws_codec.dedup_key('trade',raw),payload_json=json.dumps(raw),processed=1,processed_at=row['processed_at']))
|
||
self.insert('pms_qmt_order',dict(id=2,instruction_id='P_BUY_D02',parent_id='P_BUY',ts_code=CODE,side='buy',qty=50,limit_price=12,status='FILLED',broker_order_id=raw['broker_order_id'],cum_qty=50,cum_avg_price=12,leaves_qty=0))
|
||
self.insert('pms_lot',lot(row,lid=2))
|
||
self.sql('UPDATE pms_instruction SET exec_qty=150 WHERE id=1')
|
||
self.sql('UPDATE pms_position SET total_qty=150,base_qty=150,avg_cost=10.667 WHERE id=1')
|
||
self.assert_applied()
|
||
self.assertEqual(qmt_repo.get_order('P_BUY_D01')['cum_qty'],100)
|
||
self.assertEqual(qmt_repo.get_order('P_BUY_D02')['cum_qty'],50)
|
||
parent=pms_repo.get_instruction('P_BUY')
|
||
self.assertEqual(parent['exec_qty'],150);self.assertAlmostEqual(parent['exec_avg_price'],1700/150)
|
||
self.assertEqual(pms_repo.get_position(CODE)['avg_cost'],11.333)
|
||
|
||
def test_parent_old_progress_or_new_capacity_conflict_holds(self):
|
||
self.sql('UPDATE pms_instruction SET exec_qty=99 WHERE id=1')
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.seed();self.sql('UPDATE pms_instruction SET qty=110 WHERE id=1')
|
||
self.modify_payload(10,after=economic(150,'10'));self.modify_payload(11,cum_qty=150,cum_avg_price=10)
|
||
self.snapshot['payload']['items'][0]['total_qty']=150
|
||
result=service.consume();self.assertEqual(result['held'],1,result)
|
||
self.assertEqual(pms_repo.get_position(CODE)['total_qty'],100)
|
||
|
||
def test_broken_amendment_original_is_held_not_retried_as_database_failure(self):
|
||
amendment = service.repo.get_inbox(11)['payload']
|
||
dedup = ws_codec.dedup_key('order_update', amendment)
|
||
self.sql('UPDATE pms_qmt_inbox SET payload_json=:body,dedup_key=:dedup WHERE seq=11',
|
||
{'body': '{broken original', 'dedup': dedup})
|
||
before = self.state()
|
||
result = service.consume()
|
||
self.assertEqual(result['held'], 1, result)
|
||
self.assertEqual(result['errors'], [])
|
||
self.assertIn('配套委托回报原文损坏', result['alerts'][0]['reason'])
|
||
self.assertEqual(service.repo.get_inbox(10)['processed'], 3)
|
||
for table in ('pms_lot', 'pms_position', 'pms_instruction', 'pms_qmt_order'):
|
||
self.assertEqual(self.state()[table], before[table])
|
||
|
||
def test_top_level_read_failure_is_not_a_healthy_empty_batch(self):
|
||
self.use(service.repo,'pending',lambda **k:(_ for _ in ()).throw(RuntimeError('offline')))
|
||
result=service.consume();self.assertFalse(result['ok']);self.assertTrue(result['errors'])
|
||
|
||
|
||
if __name__=='__main__': unittest.main(verbosity=2)
|