tradingSystem/scripts/test_trade_correction_servi...

437 lines
31 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 # 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_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)